glove-foundry 0.0.0

package/dist/chunk-UNHGCCSA.js

@@ -0,0 +1,4211 @@
+import {
+  DEFAULT_FOUNDRY_CONFIG
+} from "./chunk-ZFNMFE3T.js";
+import {
+  EMPTY_CAPABILITY_REGISTRY,
+  EMPTY_FOUNDRY_APPLICATION,
+  EMPTY_NATIVE_REGISTRY,
+  FOUNDRY_AGENT_APPLICATION_BRAND,
+  FOUNDRY_AGENT_FILE_ENV,
+  FOUNDRY_AGENT_ROUTE_ENV,
+  FOUNDRY_APPLICATION_ENV,
+  FOUNDRY_CORE_COMMAND_EVENT,
+  FOUNDRY_EVENT_PREFIX,
+  FOUNDRY_EXECUTION_MARKER,
+  FOUNDRY_LAYER_BRAND,
+  FOUNDRY_MCP_BRAND,
+  FOUNDRY_MEMORY_BRAND,
+  FOUNDRY_SHARED_TOOL_BRAND,
+  FOUNDRY_SUBSCRIBER_BRAND,
+  MemoryFoundryDataAdapter,
+  bindFileIdentity,
+  compileAgentDefinition,
+  createAgentInstance,
+  createConversation,
+  createManifest,
+  definePlaybookSubscription,
+  defineSharedTool,
+  discoverAgents,
+  fileDefinitionKey,
+  fileDefinitionLabel,
+  id,
+  installationKey,
+  normalizeAgentInstallations,
+  reconstructPlaybook,
+  reconstructPlaybookSubscription,
+  routeFromInternalAgentName,
+  transmissionPredicate
+} from "./chunk-CRWY7M66.js";
+
+// src/codegen.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, relative, resolve, sep } from "node:path";
+function moduleSpecifier(fromFile, targetFile) {
+  let specifier = relative(dirname(fromFile), targetFile).split(sep).join("/");
+  if (!specifier.startsWith(".")) specifier = `./${specifier}`;
+  return specifier.replace(/\.(?:tsx?|mts|mjs|js)$/, ".js");
+}
+async function writeGeneratedTypes(options) {
+  const generatedDir = resolve(options.rootDir, ".foundry");
+  const routesFile = resolve(generatedDir, "routes.d.ts");
+  const manifestFile = resolve(generatedDir, "manifest.json");
+  await mkdir(generatedDir, { recursive: true });
+  const routes = options.agents.map(
+    ({ route, filePath }) => `  readonly ${JSON.stringify(route)}: typeof import(${JSON.stringify(moduleSpecifier(routesFile, filePath))});`
+  ).join("\n");
+  const source = `// Generated by Glove Foundry. Do not edit.
+export type FoundryRoutes = {
+${routes}
+};
+`;
+  await writeFile(routesFile, source, "utf8");
+  await writeFile(manifestFile, `${JSON.stringify(options.manifest, null, 2)}
+`, "utf8");
+  return { routesFile, manifestFile };
+}
+
+// src/composition.ts
+function addUnique(values, value, kind) {
+  const key = fileDefinitionKey(value);
+  if (values.some((candidate) => fileDefinitionKey(candidate) === key)) {
+    throw new Error(`Duplicate agent-local ${kind} "${fileDefinitionLabel(value)}".`);
+  }
+  values.push(value);
+}
+function composeAgent(...sources) {
+  const capabilities = {
+    tools: [...EMPTY_CAPABILITY_REGISTRY.tools],
+    applications: [...EMPTY_CAPABILITY_REGISTRY.applications],
+    mcp: [...EMPTY_CAPABILITY_REGISTRY.mcp],
+    memory: [...EMPTY_CAPABILITY_REGISTRY.memory]
+  };
+  const native = {
+    layers: [...EMPTY_NATIVE_REGISTRY.layers],
+    subscribers: [...EMPTY_NATIVE_REGISTRY.subscribers]
+  };
+  const visit = (source) => {
+    if (!source) return;
+    if (typeof source === "function") {
+      visit(source());
+      return;
+    }
+    if (Array.isArray(source)) {
+      for (const child of source) visit(child);
+      return;
+    }
+    if ("capabilities" in source && "native" in source) {
+      visit([
+        ...source.capabilities.tools,
+        ...source.capabilities.applications,
+        ...source.capabilities.mcp,
+        ...source.capabilities.memory,
+        ...source.native.layers,
+        ...source.native.subscribers
+      ]);
+      return;
+    }
+    const branded = source;
+    if (branded[FOUNDRY_SHARED_TOOL_BRAND] === true) {
+      addUnique(capabilities.tools, branded, "tool");
+    } else if (branded[FOUNDRY_AGENT_APPLICATION_BRAND] === true) {
+      addUnique(
+        capabilities.applications,
+        branded,
+        "application"
+      );
+    } else if (branded[FOUNDRY_MCP_BRAND] === true) {
+      addUnique(capabilities.mcp, branded, "MCP");
+    } else if (branded[FOUNDRY_MEMORY_BRAND] === true) {
+      addUnique(
+        capabilities.memory,
+        branded,
+        "memory"
+      );
+    } else if (branded[FOUNDRY_LAYER_BRAND] === true) {
+      addUnique(native.layers, branded, "layer");
+    } else if (branded[FOUNDRY_SUBSCRIBER_BRAND] === true) {
+      addUnique(native.subscribers, branded, "subscriber");
+    } else {
+      throw new Error("composeAgent received an unrecognized Foundry definition.");
+    }
+  };
+  for (const source of sources) visit(source);
+  return Object.freeze({
+    capabilities: Object.freeze({
+      tools: Object.freeze(capabilities.tools),
+      applications: Object.freeze(capabilities.applications),
+      mcp: Object.freeze(capabilities.mcp),
+      memory: Object.freeze(capabilities.memory)
+    }),
+    native: Object.freeze({
+      layers: Object.freeze(native.layers),
+      subscribers: Object.freeze(native.subscribers)
+    })
+  });
+}
+var EMPTY_AGENT_COMPOSITION = composeAgent();
+
+// src/domain.ts
+import { Schema } from "effect";
+var Slug = Schema.String.pipe(
+  Schema.pattern(/^[a-z][a-z0-9-]*$/),
+  Schema.annotations({
+    description: "A lowercase, hyphen-delimited Foundry identifier"
+  })
+);
+var RoutePath = Schema.String.pipe(
+  Schema.pattern(/^[a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)*$/),
+  Schema.annotations({ description: "A file-routed Foundry agent identifier" })
+);
+var TransmissionId = Slug.pipe(Schema.brand("FoundryTransmissionId"));
+var AgentDefinitionId = RoutePath.pipe(
+  Schema.brand("FoundryAgentDefinitionId")
+);
+var AgentId = Schema.NonEmptyTrimmedString.pipe(Schema.brand("FoundryAgentId"));
+var AccountId = Schema.NonEmptyTrimmedString.pipe(
+  Schema.brand("FoundryAccountId")
+);
+var RouteId = Schema.NonEmptyTrimmedString.pipe(
+  Schema.brand("FoundryRouteId")
+);
+var BindingId = Schema.NonEmptyTrimmedString.pipe(
+  Schema.brand("FoundryBindingId")
+);
+var EventId = Schema.NonEmptyTrimmedString.pipe(
+  Schema.brand("FoundryEventId")
+);
+var RunId = Schema.NonEmptyTrimmedString.pipe(
+  Schema.brand("FoundryRunId")
+);
+var CapabilityId = Schema.String.pipe(
+  Schema.pattern(/^[a-z][a-z0-9-]*(?::[a-z][a-z0-9-]*)?$/),
+  Schema.brand("FoundryCapabilityId")
+);
+var StringRecord = Schema.Record({
+  key: Schema.String,
+  value: Schema.Unknown
+});
+var AccountReference = Schema.Struct({
+  id: AccountId,
+  transmissionId: TransmissionId,
+  externalAccountId: Schema.NonEmptyTrimmedString,
+  label: Schema.optional(Schema.NonEmptyTrimmedString),
+  accessRef: Schema.NonEmptyTrimmedString,
+  metadata: StringRecord
+});
+var AccountSummary = Schema.Struct({
+  id: AccountId,
+  transmissionId: TransmissionId,
+  externalAccountId: Schema.NonEmptyTrimmedString,
+  label: Schema.optional(Schema.NonEmptyTrimmedString),
+  metadata: StringRecord
+});
+var RouteFields = {
+  id: RouteId,
+  transmissionId: TransmissionId,
+  accountId: Schema.optional(AccountId),
+  visibility: Schema.Literal("private", "workspace"),
+  enabled: Schema.Boolean,
+  config: StringRecord
+};
+var InboundRoute = Schema.Struct({
+  ...RouteFields,
+  direction: Schema.Literal("inbound")
+});
+var OutboundRoute = Schema.Struct({
+  ...RouteFields,
+  direction: Schema.Literal("outbound")
+});
+var Route = Schema.Union(InboundRoute, OutboundRoute);
+var ReplyPolicy = Schema.Union(
+  Schema.Struct({ mode: Schema.Literal("none") }),
+  Schema.Struct({ mode: Schema.Literal("origin") }),
+  Schema.Struct({ mode: Schema.Literal("route"), routeId: RouteId })
+);
+var AgentBinding = Schema.Struct({
+  id: BindingId,
+  agentId: AgentId,
+  transmissionId: TransmissionId,
+  accountId: Schema.optional(AccountId),
+  routeId: Schema.optional(RouteId),
+  capabilities: Schema.Array(CapabilityId),
+  reply: Schema.optional(ReplyPolicy),
+  enabled: Schema.Boolean
+});
+var RunGrant = Schema.Struct({
+  runId: RunId,
+  agentId: AgentId,
+  accountIds: Schema.Array(AccountId),
+  outboundRouteIds: Schema.Array(RouteId),
+  capabilities: Schema.Array(CapabilityId),
+  reply: ReplyPolicy
+});
+var EventReference = Schema.Struct({
+  id: EventId,
+  transmissionId: TransmissionId,
+  routeId: RouteId,
+  accountId: Schema.optional(AccountId),
+  externalEventId: Schema.NonEmptyTrimmedString,
+  threadKey: Schema.NonEmptyTrimmedString,
+  emittedAt: Schema.NonEmptyTrimmedString,
+  payloadRef: Schema.NonEmptyTrimmedString
+});
+var AccountNotFound = class extends Schema.TaggedError(
+  "AccountNotFound"
+)("AccountNotFound", { accountId: AccountId }) {
+  get message() {
+    return `Foundry account "${this.accountId}" was not found.`;
+  }
+};
+var RouteNotFound = class extends Schema.TaggedError(
+  "RouteNotFound"
+)("RouteNotFound", { routeId: RouteId }) {
+  get message() {
+    return `Foundry route "${this.routeId}" was not found.`;
+  }
+};
+var BindingNotFound = class extends Schema.TaggedError(
+  "BindingNotFound"
+)("BindingNotFound", { bindingId: BindingId }) {
+  get message() {
+    return `Foundry binding "${this.bindingId}" was not found.`;
+  }
+};
+var EventNotFound = class extends Schema.TaggedError(
+  "EventNotFound"
+)("EventNotFound", { eventId: EventId }) {
+  get message() {
+    return `Foundry event "${this.eventId}" was not found.`;
+  }
+};
+var TopologyConflict = class extends Schema.TaggedError(
+  "TopologyConflict"
+)("TopologyConflict", {
+  resource: Schema.Literal("route", "binding"),
+  id: Schema.NonEmptyTrimmedString,
+  reason: Schema.NonEmptyTrimmedString
+}) {
+};
+var AccountSessionUnavailable = class extends Schema.TaggedError(
+  "AccountSessionUnavailable"
+)("AccountSessionUnavailable", {
+  accountId: AccountId,
+  operation: Schema.NonEmptyTrimmedString,
+  reason: Schema.NonEmptyTrimmedString
+}) {
+  get message() {
+    return `Account session for "${this.accountId}" is unavailable during ${this.operation}: ${this.reason}`;
+  }
+};
+var GrantResolutionError = class extends Schema.TaggedError(
+  "GrantResolutionError"
+)("GrantResolutionError", {
+  runId: RunId,
+  agentId: AgentId,
+  reason: Schema.NonEmptyTrimmedString
+}) {
+};
+
+// src/services.ts
+import { Context, Effect, Layer, Option, Ref } from "effect";
+var AccountDirectory = class extends Context.Tag(
+  "@glove-foundry/AccountDirectory"
+)() {
+};
+var TopologyStore = class extends Context.Tag("@glove-foundry/TopologyStore")() {
+};
+var EventStore = class extends Context.Tag("@glove-foundry/EventStore")() {
+};
+function routeMatches(route, filter) {
+  return (filter.transmissionId === void 0 || route.transmissionId === filter.transmissionId) && (filter.accountId === void 0 || route.accountId === filter.accountId) && (filter.direction === void 0 || route.direction === filter.direction) && (filter.enabled === void 0 || route.enabled === filter.enabled);
+}
+function bindingMatches(binding, filter) {
+  return (filter.agentId === void 0 || binding.agentId === filter.agentId) && (filter.transmissionId === void 0 || binding.transmissionId === filter.transmissionId) && (filter.accountId === void 0 || binding.accountId === filter.accountId) && (filter.routeId === void 0 || binding.routeId === filter.routeId) && (filter.enabled === void 0 || binding.enabled === filter.enabled);
+}
+function memoryAccountDirectory(accounts) {
+  return Layer.succeed(AccountDirectory, {
+    get: (id2) => {
+      const account = accounts.find((candidate) => candidate.id === id2);
+      return account ? Effect.succeed(account) : Effect.fail(new AccountNotFound({ accountId: id2 }));
+    },
+    list: (filter = {}) => Effect.succeed(
+      accounts.filter(
+        (account) => filter.transmissionId === void 0 || account.transmissionId === filter.transmissionId
+      )
+    )
+  });
+}
+var memoryTopologyStore = Layer.effect(
+  TopologyStore,
+  Effect.gen(function* () {
+    const routes = yield* Ref.make(/* @__PURE__ */ new Map());
+    const bindings = yield* Ref.make(/* @__PURE__ */ new Map());
+    return {
+      getRoute: (id2) => Ref.get(routes).pipe(
+        Effect.flatMap(
+          (state) => Option.fromNullable(state.get(id2)).pipe(
+            Option.match({
+              onNone: () => Effect.fail(new RouteNotFound({ routeId: id2 })),
+              onSome: Effect.succeed
+            })
+          )
+        )
+      ),
+      listRoutes: (filter = {}) => Ref.get(routes).pipe(
+        Effect.map(
+          (state) => [...state.values()].filter((route) => routeMatches(route, filter))
+        )
+      ),
+      putRoute: (route) => Ref.update(routes, (state) => {
+        const next = new Map(state);
+        next.set(route.id, route);
+        return next;
+      }).pipe(Effect.as(route)),
+      removeRoute: (id2) => Ref.modify(routes, (state) => {
+        if (!state.has(id2)) {
+          return [false, state];
+        }
+        const next = new Map(state);
+        next.delete(id2);
+        return [true, next];
+      }).pipe(
+        Effect.flatMap(
+          (removed) => removed ? Effect.void : Effect.fail(new RouteNotFound({ routeId: id2 }))
+        )
+      ),
+      getBinding: (id2) => Ref.get(bindings).pipe(
+        Effect.flatMap(
+          (state) => Option.fromNullable(state.get(id2)).pipe(
+            Option.match({
+              onNone: () => Effect.fail(new BindingNotFound({ bindingId: id2 })),
+              onSome: Effect.succeed
+            })
+          )
+        )
+      ),
+      listBindings: (filter = {}) => Ref.get(bindings).pipe(
+        Effect.map(
+          (state) => [...state.values()].filter(
+            (binding) => bindingMatches(binding, filter)
+          )
+        )
+      ),
+      putBinding: (binding) => Ref.update(bindings, (state) => {
+        const next = new Map(state);
+        next.set(binding.id, binding);
+        return next;
+      }).pipe(Effect.as(binding)),
+      removeBinding: (id2) => Ref.modify(bindings, (state) => {
+        if (!state.has(id2)) {
+          return [false, state];
+        }
+        const next = new Map(state);
+        next.delete(id2);
+        return [true, next];
+      }).pipe(
+        Effect.flatMap(
+          (removed) => removed ? Effect.void : Effect.fail(new BindingNotFound({ bindingId: id2 }))
+        )
+      )
+    };
+  })
+);
+var memoryEventStore = Layer.effect(
+  EventStore,
+  Effect.gen(function* () {
+    const references = yield* Ref.make(/* @__PURE__ */ new Map());
+    const payloads = yield* Ref.make(/* @__PURE__ */ new Map());
+    return {
+      put: (reference, payload) => Ref.update(references, (state) => {
+        const next = new Map(state);
+        next.set(reference.id, reference);
+        return next;
+      }).pipe(
+        Effect.andThen(
+          Ref.update(payloads, (state) => {
+            const next = new Map(state);
+            next.set(reference.id, payload);
+            return next;
+          })
+        )
+      ),
+      getReference: (id2) => Ref.get(references).pipe(
+        Effect.flatMap((state) => {
+          const reference = state.get(id2);
+          return reference ? Effect.succeed(reference) : Effect.fail(new EventNotFound({ eventId: id2 }));
+        })
+      ),
+      getPayload: (id2) => Ref.get(payloads).pipe(
+        Effect.flatMap(
+          (state) => state.has(id2) ? Effect.succeed(state.get(id2)) : Effect.fail(new EventNotFound({ eventId: id2 }))
+        )
+      )
+    };
+  })
+);
+
+// src/grants.ts
+import { Context as Context2, Effect as Effect2, Layer as Layer2 } from "effect";
+var GrantResolver = class extends Context2.Tag("@glove-foundry/GrantResolver")() {
+};
+var replyKey = (policy) => policy.mode === "route" ? `route:${policy.routeId}` : policy.mode;
+var grantResolverLive = Layer2.effect(
+  GrantResolver,
+  Effect2.gen(function* () {
+    const topology = yield* TopologyStore;
+    return {
+      resolve: (request) => Effect2.gen(function* () {
+        const bindings = yield* topology.listBindings({
+          agentId: request.agentId,
+          enabled: true
+        });
+        if (bindings.length === 0) {
+          return yield* Effect2.fail(
+            new GrantResolutionError({
+              runId: request.runId,
+              agentId: request.agentId,
+              reason: "agent has no enabled bindings"
+            })
+          );
+        }
+        const routes = yield* topology.listRoutes({ enabled: true });
+        const routeById = new Map(
+          routes.map((route) => [route.id, route])
+        );
+        const accountIds = /* @__PURE__ */ new Set();
+        const capabilities = /* @__PURE__ */ new Set();
+        const outboundRouteIds = /* @__PURE__ */ new Set();
+        const replyPolicies = /* @__PURE__ */ new Map();
+        for (const binding of bindings) {
+          if (binding.accountId) accountIds.add(binding.accountId);
+          binding.capabilities.forEach(
+            (capability) => capabilities.add(capability)
+          );
+          if (binding.routeId) {
+            const route = routeById.get(binding.routeId);
+            if (!route) {
+              return yield* Effect2.fail(
+                new GrantResolutionError({
+                  runId: request.runId,
+                  agentId: request.agentId,
+                  reason: `binding "${binding.id}" references a missing or disabled route`
+                })
+              );
+            }
+            if (route.accountId) accountIds.add(route.accountId);
+            if (route.direction === "outbound") {
+              outboundRouteIds.add(route.id);
+            }
+          }
+          if (binding.reply) {
+            replyPolicies.set(replyKey(binding.reply), binding.reply);
+          }
+        }
+        if (replyPolicies.size > 1) {
+          return yield* Effect2.fail(
+            new GrantResolutionError({
+              runId: request.runId,
+              agentId: request.agentId,
+              reason: "enabled bindings declare conflicting reply policies"
+            })
+          );
+        }
+        const explicitReply = replyPolicies.values().next().value;
+        const reply = explicitReply ?? (request.originRouteId ? { mode: "origin" } : { mode: "none" });
+        if (reply.mode === "route") {
+          const route = routeById.get(reply.routeId);
+          if (!route || route.direction !== "outbound") {
+            return yield* Effect2.fail(
+              new GrantResolutionError({
+                runId: request.runId,
+                agentId: request.agentId,
+                reason: `reply route "${reply.routeId}" is missing, disabled, or not outbound`
+              })
+            );
+          }
+          outboundRouteIds.add(route.id);
+          if (route.accountId) accountIds.add(route.accountId);
+        }
+        return {
+          runId: request.runId,
+          agentId: request.agentId,
+          accountIds: [...accountIds].sort(),
+          outboundRouteIds: [...outboundRouteIds].sort(),
+          capabilities: [...capabilities].sort(),
+          reply
+        };
+      }).pipe(
+        Effect2.withSpan("foundry.grant.resolve", {
+          attributes: {
+            "foundry.run.id": request.runId,
+            "foundry.agent.id": request.agentId
+          }
+        })
+      )
+    };
+  })
+);
+
+// src/manifest.ts
+import { Effect as Effect3, JSONSchema, Schema as Schema2 } from "effect";
+var JsonSchemaDocument = Schema2.Record({
+  key: Schema2.String,
+  value: Schema2.Unknown
+});
+var FoundryManifestCapability = Schema2.Struct({
+  id: Schema2.String,
+  description: Schema2.String,
+  account: Schema2.Literal("none", "optional", "required"),
+  effect: Schema2.Literal("read", "write")
+});
+var FoundryManifestTransmission = Schema2.Struct({
+  id: Schema2.String,
+  name: Schema2.String,
+  description: Schema2.String,
+  shape: Schema2.Literal(
+    "capability-only",
+    "inbound-only",
+    "outbound-only",
+    "bidirectional"
+  ),
+  account: Schema2.optional(
+    Schema2.Struct({
+      required: Schema2.Boolean,
+      metadataSchema: JsonSchemaDocument
+    })
+  ),
+  capabilities: Schema2.Array(FoundryManifestCapability),
+  inbound: Schema2.optional(
+    Schema2.Struct({
+      configSchema: JsonSchemaDocument,
+      eventSchema: JsonSchemaDocument
+    })
+  ),
+  outbound: Schema2.optional(
+    Schema2.Struct({
+      configSchema: JsonSchemaDocument,
+      inputSchema: JsonSchemaDocument,
+      outputSchema: JsonSchemaDocument
+    })
+  )
+});
+var FoundryApplicationManifest = Schema2.Struct({
+  schemaVersion: Schema2.Literal(2),
+  generatedAt: Schema2.String,
+  transmissions: Schema2.Array(FoundryManifestTransmission)
+});
+var ManifestCompilationError = class extends Schema2.TaggedError(
+  "ManifestCompilationError"
+)("ManifestCompilationError", {
+  message: Schema2.String
+}) {
+};
+function shapeOf(definition) {
+  if (definition.inbound && definition.outbound) return "bidirectional";
+  if (definition.inbound) return "inbound-only";
+  if (definition.outbound) return "outbound-only";
+  return "capability-only";
+}
+function jsonSchema(schema) {
+  return JSONSchema.make(schema);
+}
+function compileApplicationManifest(transmissions) {
+  return Effect3.try({
+    try: () => {
+      const seen = /* @__PURE__ */ new Set();
+      const compiled = [...transmissions].sort((left, right) => left.id.localeCompare(right.id)).map((definition) => {
+        if (seen.has(definition.id)) {
+          throw new Error(`Duplicate integration id "${definition.id}".`);
+        }
+        seen.add(definition.id);
+        return {
+          id: definition.id,
+          name: definition.name,
+          description: definition.description,
+          shape: shapeOf(definition),
+          ...definition.account ? {
+            account: {
+              required: definition.account.required,
+              metadataSchema: jsonSchema(definition.account.metadata)
+            }
+          } : {},
+          capabilities: [...definition.capabilities ?? []],
+          ...definition.inbound ? {
+            inbound: {
+              configSchema: jsonSchema(definition.inbound.config),
+              eventSchema: jsonSchema(definition.inbound.event)
+            }
+          } : {},
+          ...definition.outbound ? {
+            outbound: {
+              configSchema: jsonSchema(definition.outbound.config),
+              inputSchema: jsonSchema(definition.outbound.input),
+              outputSchema: jsonSchema(definition.outbound.output)
+            }
+          } : {}
+        };
+      });
+      return Schema2.decodeUnknownSync(FoundryApplicationManifest)({
+        schemaVersion: 2,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        transmissions: compiled
+      });
+    },
+    catch: (cause) => new ManifestCompilationError({
+      message: cause instanceof Error ? cause.message : String(cause)
+    })
+  }).pipe(
+    Effect3.withSpan("foundry.manifest.compile", {
+      attributes: { "foundry.transmission.count": transmissions.length }
+    })
+  );
+}
+
+// src/transmission.ts
+function escapeXml(value) {
+  return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function stable(value) {
+  if (Array.isArray(value)) return value.map(stable);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, stable(item)])
+    );
+  }
+  return value;
+}
+function data(value) {
+  return escapeXml(JSON.stringify(stable(value)) ?? "null");
+}
+function serializeInboundTransmissionXml(input) {
+  const playbooks = input.playbooks.map((playbook) => {
+    const directives = playbook.directives.map(
+      (directive) => `      <directive action="${escapeXml(directive.action)}">
+        <instruction>${escapeXml(directive.instruction)}</instruction>` + (directive.parameters ? `
+        <parameters format="json">${data(directive.parameters)}</parameters>` : "") + `
+      </directive>`
+    ).join("\n");
+    const outbound = (playbook.outbound ?? []).map(
+      (target) => `      <outbound route="${escapeXml(target.routeId)}"` + (target.applicationId ? ` application="${escapeXml(target.applicationId)}"` : "") + (target.event ? ` event="${escapeXml(target.event)}"` : "") + (target.accountId ? ` account="${escapeXml(target.accountId)}"` : "") + (target.applicationAccountId ? ` application-account="${escapeXml(target.applicationAccountId)}"` : "") + `>` + (target.instruction ? escapeXml(target.instruction) : "") + `</outbound>`
+    ).join("\n");
+    return `  <playbook id="${escapeXml(playbook.id)}">
+${directives}` + (outbound ? `
+${outbound}` : "") + (playbook.serialization ? `
+      <serialization format="json">${data(playbook.serialization)}</serialization>` : "") + `
+  </playbook>`;
+  }).join("\n");
+  return `<transmission direction="inbound" definition="${escapeXml(input.transmissionId)}" route="${escapeXml(input.routeId)}" event="${escapeXml(input.eventName)}" event-id="${escapeXml(input.eventId)}" thread="${escapeXml(input.threadKey)}">
+  <payload format="json">${data(input.event)}</payload>
+${playbooks}
+</transmission>`;
+}
+
+// src/observability.ts
+import { randomUUID } from "node:crypto";
+var MemoryObservabilityAdapter = class {
+  maxEvents;
+  events = [];
+  listeners = /* @__PURE__ */ new Set();
+  sequence = 0;
+  constructor(options) {
+    this.maxEvents = options?.maxEvents ?? 1e4;
+    if (!Number.isInteger(this.maxEvents) || this.maxEvents < 1) {
+      throw new Error("maxEvents must be an integer >= 1");
+    }
+  }
+  append(input) {
+    const event = Object.freeze({
+      id: randomUUID(),
+      sequence: ++this.sequence,
+      timestamp: input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      type: input.type,
+      category: input.category,
+      ...input.agent ? { agent: input.agent } : {},
+      ...input.runId ? { runId: input.runId } : {},
+      data: input.data
+    });
+    this.events.push(event);
+    if (this.events.length > this.maxEvents) {
+      this.events.splice(0, this.events.length - this.maxEvents);
+    }
+    for (const listener of this.listeners) listener(event);
+    return event;
+  }
+  list(filter = {}) {
+    const matched = this.events.filter((event) => {
+      if (filter.after !== void 0 && event.sequence <= filter.after) {
+        return false;
+      }
+      if (filter.agent && event.agent !== filter.agent) return false;
+      if (filter.runId && event.runId !== filter.runId) return false;
+      if (filter.category && event.category !== filter.category) return false;
+      return true;
+    });
+    const limit = Math.max(1, Math.min(filter.limit ?? 500, 5e3));
+    return matched.slice(-limit);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  clear() {
+    this.events.length = 0;
+  }
+};
+function categoryForAgentEvent(type) {
+  if (type.startsWith("tool_")) return "tool";
+  if (type.startsWith("foundry.installation")) return "application";
+  if (type.startsWith("foundry.layer") || type.startsWith("foundry.subscriber")) {
+    return "extension";
+  }
+  if (type.startsWith("glove_memory") || type.startsWith("glove_context")) {
+    return "memory";
+  }
+  if (type.startsWith("mcp") || type.includes("discovermcp")) return "mcp";
+  if (type.startsWith("inbox")) return "inbox";
+  if (type.startsWith("hook_") || type.startsWith("skill_") || type.startsWith("subagent_")) {
+    return "extension";
+  }
+  if (type === "text_delta" || type.startsWith("model_") || type === "token_consumption") {
+    return "model";
+  }
+  return "system";
+}
+function encodedAgentEvent(message) {
+  const start = message.indexOf(FOUNDRY_EVENT_PREFIX);
+  if (start < 0) return null;
+  const json2 = message.slice(start + FOUNDRY_EVENT_PREFIX.length).trim();
+  try {
+    const parsed = JSON.parse(json2);
+    return typeof parsed.type === "string" ? { type: parsed.type, data: parsed.data, timestamp: parsed.timestamp } : null;
+  } catch {
+    return null;
+  }
+}
+var FoundryObserver = class {
+  constructor(adapter, routeForSignalName, onAgentEvent) {
+    this.adapter = adapter;
+    this.routeForSignalName = routeForSignalName;
+    this.onAgentEvent = onAgentEvent;
+  }
+  logBuffers = /* @__PURE__ */ new Map();
+  route(name) {
+    return this.routeForSignalName(name);
+  }
+  runEvent(type, run, data2 = {}) {
+    this.adapter.append({
+      type,
+      category: "run",
+      agent: this.route(run.signalName),
+      runId: run.id,
+      data: data2
+    });
+  }
+  onSignalDiscovered(event) {
+    this.adapter.append({
+      type: "agent.discovered",
+      category: "agent",
+      agent: this.route(event.signalName),
+      data: { runtime: "foundry-execution", filePath: event.filePath }
+    });
+  }
+  onRunDispatched({ run }) {
+    this.runEvent("run.dispatched", run);
+  }
+  onRunStarted({ run }) {
+    this.runEvent("run.started", run);
+  }
+  onRunCompleted(event) {
+    this.flushRunLogs(event.run);
+    this.runEvent("run.completed", event.run, { output: event.output });
+  }
+  onRunTimeout({ run }) {
+    this.runEvent("run.timeout", run);
+  }
+  onRunRetry(event) {
+    this.runEvent("run.retry", event.run, {
+      attempt: event.attempt,
+      maxAttempts: event.maxAttempts
+    });
+  }
+  onRunFailed(event) {
+    this.flushRunLogs(event.run);
+    this.runEvent("run.failed", event.run, { error: event.error });
+  }
+  onRunCancelled({ run }) {
+    this.flushRunLogs(run);
+    this.runEvent("run.cancelled", run);
+  }
+  onRunSkipped(event) {
+    this.runEvent("run.skipped", event.run, { reason: event.reason });
+  }
+  onRunRescheduled(event) {
+    this.runEvent("run.rescheduled", event.run, {
+      nextRunAt: event.nextRunAt.toISOString()
+    });
+  }
+  onCompleteError(event) {
+    this.runEvent("run.on-complete-error", event.run, { error: event.error });
+  }
+  onLogOutput(event) {
+    const key = `${event.run.id}:${event.level}`;
+    const combined = `${this.logBuffers.get(key) ?? ""}${event.message}`;
+    const lines = combined.split(/\r?\n/);
+    const complete = combined.endsWith("\n") ? lines : lines.slice(0, -1);
+    const remainder = combined.endsWith("\n") ? "" : lines.at(-1) ?? "";
+    if (remainder) this.logBuffers.set(key, remainder);
+    else this.logBuffers.delete(key);
+    for (const line of complete) {
+      if (line) this.appendLogLine(event.run, event.level, line);
+    }
+  }
+  appendLogLine(run, level, message) {
+    const encoded = encodedAgentEvent(message);
+    if (encoded) {
+      this.onAgentEvent?.({
+        route: this.route(run.signalName),
+        run,
+        type: encoded.type,
+        data: encoded.data
+      });
+      this.adapter.append({
+        type: `agent.${encoded.type}`,
+        category: categoryForAgentEvent(encoded.type),
+        agent: this.route(run.signalName),
+        runId: run.id,
+        ...encoded.timestamp ? { timestamp: encoded.timestamp } : {},
+        data: encoded.data
+      });
+      return;
+    }
+    this.adapter.append({
+      type: `log.${level}`,
+      category: "log",
+      agent: this.route(run.signalName),
+      runId: run.id,
+      data: { message }
+    });
+  }
+  flushRunLogs(run) {
+    for (const level of ["stdout", "stderr"]) {
+      const key = `${run.id}:${level}`;
+      const remainder = this.logBuffers.get(key);
+      if (!remainder) continue;
+      this.logBuffers.delete(key);
+      this.appendLogLine(run, level, remainder);
+    }
+  }
+};
+
+// src/runtime.ts
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import {
+  Effect as Effect5,
+  Layer as Layer3,
+  ManagedRuntime as EffectManagedRuntime,
+  Schema as Schema3
+} from "effect";
+import { EnvStore, MemoryEnvStorage } from "station-env";
+import {
+  MemoryAdapter,
+  parseInterval,
+  SignalRunner
+} from "station-signal";
+import {
+  ScheduleMemoryAdapter,
+  ScheduleReconciler,
+  nextCronOccurrence
+} from "station-schedules";
+
+// src/connection-supervisor.ts
+import { Effect as Effect4 } from "effect";
+function safeError(cause) {
+  return cause instanceof Error ? cause.message : String(cause);
+}
+function routeSignature(routes) {
+  return routes.map((route) => route.id).sort().join("\0");
+}
+var ApplicationConnectionSupervisor = class {
+  constructor(options) {
+    this.options = options;
+  }
+  running = /* @__PURE__ */ new Map();
+  states = /* @__PURE__ */ new Map();
+  list() {
+    return [...this.states.values()].map((state) => ({
+      ...state,
+      routeIds: [...state.routeIds]
+    }));
+  }
+  async reconcile(desired) {
+    const wanted = new Map(desired.map((item) => [item.id, item]));
+    for (const [id2, running] of this.running) {
+      const next = wanted.get(id2);
+      if (!next || routeSignature(next.routes) !== routeSignature(running.desired.routes)) {
+        await this.stop(id2);
+        if (!next) this.states.delete(id2);
+      }
+    }
+    for (const item of desired) {
+      if (!this.running.has(item.id)) this.start(item);
+    }
+  }
+  async reconnect(id2) {
+    const current = this.running.get(id2)?.desired;
+    if (!current) throw new Error(`Application connection "${id2}" was not found.`);
+    await this.stop(id2);
+    this.start(current);
+  }
+  async stopAll() {
+    await Promise.all([...this.running.keys()].map((id2) => this.stop(id2)));
+  }
+  start(desired) {
+    const controller = new AbortController();
+    const task = this.run(desired, controller.signal).finally(() => {
+      const current = this.running.get(desired.id);
+      if (current?.controller === controller) this.running.delete(desired.id);
+    });
+    this.running.set(desired.id, { desired, controller, task });
+  }
+  async stop(id2) {
+    const running = this.running.get(id2);
+    if (!running) return;
+    running.controller.abort();
+    await running.task.catch(() => void 0);
+    this.running.delete(id2);
+    this.update(running.desired, {
+      status: "disconnected",
+      disconnectedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async run(desired, signal) {
+    let attempts = 0;
+    while (!signal.aborted) {
+      attempts += 1;
+      this.update(desired, {
+        status: attempts === 1 ? "connecting" : "reconnecting",
+        attempts
+      });
+      let ready = false;
+      try {
+        const program = desired.connection.connect({
+          applicationId: desired.application.id,
+          connectionId: desired.connection.id,
+          definitionId: desired.definitionId,
+          workspaceId: desired.workspaceId,
+          ...desired.account ? { account: desired.account } : {},
+          routes: desired.routes,
+          signal,
+          ready: () => Effect4.sync(() => {
+            if (ready) return;
+            ready = true;
+            this.update(desired, {
+              status: "connected",
+              attempts,
+              connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              error: ""
+            });
+          }),
+          receive: (input) => Effect4.tryPromise({
+            try: async () => {
+              if (!desired.routes.some((route) => route.id === input.route.id)) {
+                throw new Error(
+                  `Connection "${desired.id}" emitted through inactive route "${input.route.id}".`
+                );
+              }
+              this.update(desired, {
+                status: ready ? "connected" : "connecting",
+                attempts,
+                lastEventAt: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              await this.options.receive({
+                routeId: input.route.id,
+                eventId: input.eventId,
+                threadKey: input.threadKey,
+                raw: input.raw
+              });
+            },
+            catch: (cause) => cause
+          }).pipe(Effect4.orDie),
+          ...desired.account && desired.accountSessions ? {
+            withAccountSession: (operation, use) => desired.accountSessions.withSession({
+              accountId: desired.account.id,
+              operation,
+              agentId: `connection:${desired.id}`,
+              conversationId: `connection:${desired.id}`,
+              workspaceId: desired.workspaceId
+            }, use)
+          } : {}
+        });
+        await Effect4.runPromise(program, { signal });
+        if (signal.aborted) break;
+        throw new Error("Provider connection ended.");
+      } catch (cause) {
+        if (signal.aborted) break;
+        this.update(desired, {
+          status: "failed",
+          attempts,
+          disconnectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          error: safeError(cause)
+        });
+      }
+      const backoffMs = Math.min(3e4, 250 * 2 ** Math.min(attempts - 1, 7));
+      await new Promise((resolve3) => {
+        const timer = setTimeout(resolve3, backoffMs);
+        signal.addEventListener("abort", () => {
+          clearTimeout(timer);
+          resolve3();
+        }, { once: true });
+      });
+    }
+  }
+  update(desired, patch) {
+    const prior = this.states.get(desired.id);
+    const state = Object.freeze({
+      id: desired.id,
+      applicationId: desired.application.id,
+      connectionId: desired.connection.id,
+      definitionId: desired.definitionId,
+      workspaceId: desired.workspaceId,
+      ...desired.account ? { accountId: desired.account.id } : {},
+      routeIds: Object.freeze(desired.routes.map((route) => route.id).sort()),
+      status: patch.status ?? prior?.status ?? "disconnected",
+      attempts: patch.attempts ?? prior?.attempts ?? 0,
+      ...patch.connectedAt ?? prior?.connectedAt ? { connectedAt: patch.connectedAt ?? prior?.connectedAt } : {},
+      ...patch.disconnectedAt ?? prior?.disconnectedAt ? { disconnectedAt: patch.disconnectedAt ?? prior?.disconnectedAt } : {},
+      ...patch.lastEventAt ?? prior?.lastEventAt ? { lastEventAt: patch.lastEventAt ?? prior?.lastEventAt } : {},
+      ...patch.error !== void 0 ? patch.error ? { error: patch.error } : {} : prior?.error ? { error: prior.error } : {}
+    });
+    this.states.set(desired.id, state);
+    this.options.emit({
+      type: `application.connection.${state.status}`,
+      data: state
+    });
+  }
+};
+
+// src/registry.ts
+import { readdir } from "node:fs/promises";
+import { extname, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+import { pathToFileURL } from "node:url";
+var MODULE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".js", ".mjs"]);
+var DEFAULT_REGISTRY_DIRECTORIES = Object.freeze({
+  tools: "tools",
+  applications: "applications",
+  mcp: "mcp",
+  memory: "memory",
+  layers: "layers",
+  subscribers: "subscribers"
+});
+var KINDS = [
+  {
+    kind: "tool",
+    directory: "tools",
+    suffix: ".tool",
+    brand: FOUNDRY_SHARED_TOOL_BRAND
+  },
+  {
+    kind: "application",
+    directory: "applications",
+    suffix: ".application",
+    brand: FOUNDRY_AGENT_APPLICATION_BRAND
+  },
+  { kind: "mcp", directory: "mcp", suffix: ".mcp", brand: FOUNDRY_MCP_BRAND },
+  {
+    kind: "memory",
+    directory: "memory",
+    suffix: ".memory",
+    brand: FOUNDRY_MEMORY_BRAND
+  }
+];
+function normalizePath(path) {
+  return path.split(sep2).join("/");
+}
+async function moduleFiles(directory, suffix) {
+  let entries;
+  try {
+    entries = await readdir(directory, { recursive: true });
+  } catch (cause) {
+    const code = cause.code;
+    if (code === "ENOENT") return [];
+    throw cause;
+  }
+  return entries.filter((entry) => {
+    if (entry.endsWith(".d.ts")) return false;
+    const extension = extname(entry);
+    return MODULE_EXTENSIONS.has(extension) && entry.slice(0, -extension.length).endsWith(suffix);
+  }).map((entry) => resolve2(directory, entry)).sort();
+}
+function routeFromModule(directory, filePath, suffix) {
+  const rel = normalizePath(relative2(directory, filePath));
+  const extension = extname(rel);
+  return rel.slice(0, -extension.length - suffix.length);
+}
+async function importDefault(filePath, cacheBust) {
+  const url = pathToFileURL(filePath);
+  if (cacheBust) url.searchParams.set("t", String(Date.now()));
+  const imported = await import(url.href);
+  return imported.default;
+}
+async function importModule(filePath, cacheBust) {
+  const url = pathToFileURL(filePath);
+  if (cacheBust) url.searchParams.set("t", String(Date.now()));
+  return await import(url.href);
+}
+function isToolBody(value) {
+  if (!value || typeof value !== "object") return false;
+  const body = value;
+  return typeof body.description === "string" && typeof body.do === "function" && (body.inputSchema !== void 0 || body.jsonSchema !== void 0);
+}
+function assembleToolModule(route, module) {
+  const branded = module.default;
+  if (branded && typeof branded === "object" && branded[FOUNDRY_SHARED_TOOL_BRAND] === true) {
+    return branded;
+  }
+  const body = isToolBody(module.default) ? module.default : isToolBody(module.tool) ? module.tool : isToolBody(module) ? module : null;
+  if (!body) {
+    throw new Error(`Tool route "${route}" must export a Glove tool body as default, as \`tool\`, or as named description/inputSchema/do constants.`);
+  }
+  const name = route.replaceAll("/", "__").replaceAll("-", "_");
+  return defineSharedTool({
+    id: route,
+    description: typeof module.summary === "string" ? module.summary : body.description,
+    tool: { ...body, name }
+  });
+}
+function addUnique2(target, values, label) {
+  const ids = new Set(target.map((value) => value.id));
+  for (const value of values) {
+    if (ids.has(value.id)) {
+      throw new Error(`Duplicate Foundry ${label} id "${value.id}".`);
+    }
+    ids.add(value.id);
+    target.push(value);
+  }
+}
+async function discoverFoundryRegistry(options) {
+  const directories = {
+    ...DEFAULT_REGISTRY_DIRECTORIES,
+    ...options.directories
+  };
+  const registry = {
+    tools: [...EMPTY_CAPABILITY_REGISTRY.tools],
+    applications: [...EMPTY_CAPABILITY_REGISTRY.applications],
+    mcp: [...EMPTY_CAPABILITY_REGISTRY.mcp],
+    memory: [...EMPTY_CAPABILITY_REGISTRY.memory]
+  };
+  const files = [];
+  const native = {
+    layers: [...EMPTY_NATIVE_REGISTRY.layers],
+    subscribers: [...EMPTY_NATIVE_REGISTRY.subscribers]
+  };
+  const nativeFiles = [];
+  for (const config of options.capabilities === false ? [] : KINDS) {
+    const directory = resolve2(options.rootDir, directories[config.directory]);
+    for (const filePath of await moduleFiles(directory, config.suffix)) {
+      const route = routeFromModule(directory, filePath, config.suffix);
+      const imported = await importModule(filePath, options.cacheBust ?? false);
+      const value = config.kind === "tool" ? assembleToolModule(route, imported) : imported.default;
+      if (!value || typeof value !== "object" || value[config.brand] !== true) {
+        throw new Error(
+          `${normalizePath(relative2(options.rootDir, filePath))} must default-export a Foundry ${config.kind} definition.`
+        );
+      }
+      const definition = value;
+      bindFileIdentity(value, route, config.kind);
+      if ((options.strictFileRoutes ?? true) && definition.id !== route) {
+        throw new Error(
+          `Foundry ${config.kind} route mismatch in ${filePath}: file resolves to "${route}" but declares "${definition.id}".`
+        );
+      }
+      if (config.kind === "tool") {
+        addUnique2(registry.tools, [value], "shared tool");
+      } else if (config.kind === "application") {
+        addUnique2(
+          registry.applications,
+          [value],
+          "agent application"
+        );
+      } else if (config.kind === "mcp") {
+        addUnique2(registry.mcp, [value], "MCP");
+      } else if (config.kind === "memory") {
+        addUnique2(
+          registry.memory,
+          [value],
+          "memory profile"
+        );
+      }
+      files.push({
+        kind: config.kind,
+        id: definition.id,
+        filePath,
+        relativePath: normalizePath(relative2(options.rootDir, filePath))
+      });
+    }
+  }
+  for (const config of options.native === false ? [] : [
+    {
+      kind: "layer",
+      directory: "layers",
+      suffix: ".layer",
+      brand: FOUNDRY_LAYER_BRAND
+    },
+    {
+      kind: "subscriber",
+      directory: "subscribers",
+      suffix: ".subscriber",
+      brand: FOUNDRY_SUBSCRIBER_BRAND
+    }
+  ]) {
+    const directory = resolve2(options.rootDir, directories[config.directory]);
+    for (const filePath of await moduleFiles(directory, config.suffix)) {
+      const route = routeFromModule(directory, filePath, config.suffix);
+      const value = await importDefault(filePath, options.cacheBust ?? false);
+      if (!value || typeof value !== "object" || value[config.brand] !== true) {
+        throw new Error(
+          `${normalizePath(relative2(options.rootDir, filePath))} must default-export a Foundry ${config.kind} definition.`
+        );
+      }
+      const definition = value;
+      bindFileIdentity(value, route, config.kind);
+      if ((options.strictFileRoutes ?? true) && definition.id !== route) {
+        throw new Error(
+          `Foundry ${config.kind} route mismatch in ${filePath}: file resolves to "${route}" but declares "${definition.id}".`
+        );
+      }
+      if (config.kind === "layer") {
+        addUnique2(native.layers, [value], "layer");
+      } else {
+        addUnique2(
+          native.subscribers,
+          [value],
+          "subscriber"
+        );
+      }
+      nativeFiles.push({
+        kind: config.kind,
+        id: definition.id,
+        filePath,
+        relativePath: normalizePath(relative2(options.rootDir, filePath))
+      });
+    }
+  }
+  return {
+    capabilities: Object.freeze({
+      tools: Object.freeze(registry.tools),
+      applications: Object.freeze(registry.applications),
+      mcp: Object.freeze(registry.mcp),
+      memory: Object.freeze(registry.memory)
+    }),
+    native: Object.freeze({
+      layers: Object.freeze(native.layers),
+      subscribers: Object.freeze(native.subscribers)
+    }),
+    files: Object.freeze(files),
+    nativeFiles: Object.freeze(nativeFiles)
+  };
+}
+
+// src/runtime.ts
+var FoundryRuntimeError = class extends Schema3.TaggedError(
+  "FoundryRuntimeError"
+)("FoundryRuntimeError", {
+  operation: Schema3.String,
+  message: Schema3.String
+}) {
+};
+function parseJson(value) {
+  if (value === void 0) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function runtimeFailure(operation, cause) {
+  return new FoundryRuntimeError({
+    operation,
+    message: cause instanceof Error ? cause.message : String(cause)
+  });
+}
+function promiseEffect(operation, evaluate) {
+  return Effect5.tryPromise({
+    try: evaluate,
+    catch: (cause) => runtimeFailure(operation, cause)
+  }).pipe(Effect5.withSpan(`foundry.${operation}`));
+}
+function executionAgentEntrypoint() {
+  const built = fileURLToPath(new URL("./execution-agent.js", import.meta.url));
+  if (existsSync(built)) return built;
+  return fileURLToPath(new URL("./execution-agent.ts", import.meta.url));
+}
+var FoundryRuntime = class _FoundryRuntime {
+  rootDir;
+  agents;
+  application;
+  applicationFilePath;
+  registry;
+  manifest;
+  applicationManifest;
+  observability;
+  data;
+  byRoute = /* @__PURE__ */ new Map();
+  routeBySignalName = /* @__PURE__ */ new Map();
+  transmissionById = /* @__PURE__ */ new Map();
+  /** Stable topology view used by synchronous playbook validation. */
+  topologyRoutes = /* @__PURE__ */ new Map();
+  compositionByDefinition = /* @__PURE__ */ new Map();
+  connectionSupervisor;
+  execution;
+  observer;
+  signalRunner;
+  envStore;
+  envProvider;
+  scheduleAdapter;
+  services;
+  runnerLoops = [];
+  materializedActivations = /* @__PURE__ */ new Set();
+  started = false;
+  disposed = false;
+  constructor(options) {
+    this.rootDir = options.rootDir;
+    this.agents = Object.freeze([...options.agents]);
+    this.application = options.application ?? EMPTY_FOUNDRY_APPLICATION;
+    this.applicationFilePath = options.applicationFilePath;
+    for (const route of this.application.routes ?? []) {
+      this.topologyRoutes.set(route.id, route);
+    }
+    const capabilities = { tools: [], applications: [], mcp: [], memory: [] };
+    const native = { layers: [], subscribers: [] };
+    for (const discovered of this.agents) {
+      const composition = discovered.definition.components ?? EMPTY_AGENT_COMPOSITION;
+      this.compositionByDefinition.set(discovered.route, composition);
+      capabilities.tools.push(...composition.capabilities.tools);
+      capabilities.applications.push(...composition.capabilities.applications);
+      capabilities.mcp.push(...composition.capabilities.mcp);
+      capabilities.memory.push(...composition.capabilities.memory);
+      native.layers.push(...composition.native.layers);
+      native.subscribers.push(...composition.native.subscribers);
+      for (const application of composition.capabilities.applications) {
+        for (const transmission of application.transmissions ?? []) {
+          const existing = this.transmissionById.get(transmission.id);
+          if (existing && existing !== transmission) {
+            throw new Error(
+              `Transmission "${transmission.id}" is defined by more than one agent-local application. Share one application definition instead.`
+            );
+          }
+          this.transmissionById.set(transmission.id, transmission);
+        }
+      }
+    }
+    this.registry = Object.freeze({
+      capabilities: Object.freeze({
+        tools: Object.freeze(capabilities.tools),
+        applications: Object.freeze(capabilities.applications),
+        mcp: Object.freeze(capabilities.mcp),
+        memory: Object.freeze(capabilities.memory)
+      }),
+      native: Object.freeze({
+        layers: Object.freeze(native.layers),
+        subscribers: Object.freeze(native.subscribers)
+      }),
+      files: Object.freeze([]),
+      nativeFiles: Object.freeze([])
+    });
+    this.manifest = createManifest(this.agents);
+    this.applicationManifest = Effect5.runSync(
+      compileApplicationManifest([...this.transmissionById.values()])
+    );
+    this.observability = options.observability ?? new MemoryObservabilityAdapter({
+      maxEvents: options.config?.observability?.maxEvents
+    });
+    this.data = this.application.data ?? new MemoryFoundryDataAdapter();
+    for (const discovered of this.agents) {
+      this.byRoute.set(discovered.route, discovered);
+      this.routeBySignalName.set(discovered.executionName, discovered.route);
+    }
+    this.observer = new FoundryObserver(
+      this.observability,
+      (name) => this.routeBySignalName.get(name) ?? name,
+      (event) => {
+        if (event.type === FOUNDRY_CORE_COMMAND_EVENT) {
+          void this.executeCoreCommand(event.data, event.run.id).catch((cause) => {
+            this.observability.append({
+              type: "core.command.failed",
+              category: "system",
+              agent: event.route,
+              runId: event.run.id,
+              data: { error: cause instanceof Error ? cause.message : String(cause), command: event.data }
+            });
+          });
+        }
+      }
+    );
+    this.connectionSupervisor = new ApplicationConnectionSupervisor({
+      receive: async (input) => {
+        await this.dispatchInbound(input);
+      },
+      emit: (event) => {
+        this.observability.append({
+          type: event.type,
+          category: "application",
+          data: event.data
+        });
+      }
+    });
+    const configured = options.config?.execution;
+    const defaults = DEFAULT_FOUNDRY_CONFIG.execution;
+    this.execution = {
+      maxConcurrent: configured?.maxConcurrent ?? defaults.maxConcurrent,
+      maxAttempts: configured?.maxAttempts ?? defaults.maxAttempts,
+      retryBackoffMs: configured?.retryBackoffMs ?? defaults.retryBackoffMs,
+      pollIntervalMs: configured?.pollIntervalMs ?? defaults.pollIntervalMs,
+      idlePollIntervalMs: configured?.idlePollIntervalMs ?? defaults.idlePollIntervalMs
+    };
+    this.envStore = new EnvStore(new MemoryEnvStorage());
+    this.envProvider = {
+      resolveFor: async (target) => {
+        const resolvedEnvironment = await this.envStore.resolveFor(target);
+        if (target.kind === "signal") {
+          const route = routeFromInternalAgentName(target.name);
+          resolvedEnvironment[FOUNDRY_AGENT_ROUTE_ENV] = route;
+          const discovered = this.byRoute.get(route);
+          if (discovered) {
+            resolvedEnvironment[FOUNDRY_AGENT_FILE_ENV] = discovered.filePath;
+          }
+        }
+        if (this.applicationFilePath) {
+          resolvedEnvironment[FOUNDRY_APPLICATION_ENV] = this.applicationFilePath;
+        }
+        return resolvedEnvironment;
+      }
+    };
+    this.scheduleAdapter = new ScheduleMemoryAdapter();
+    const signalAdapter = new MemoryAdapter();
+    const signalScheduleReconciler = new ScheduleReconciler({
+      adapter: this.scheduleAdapter,
+      kinds: ["signal"],
+      triggerFn: (schedule, scheduledFor) => this.signalRunner.triggerSignal(
+        schedule.target,
+        schedule.input,
+        { id: schedule.id, scheduledFor }
+      ),
+      hasPendingOrRunning: (schedule) => this.signalRunner.hasPendingOrRunningForSignal(schedule.target),
+      parseInterval,
+      onError: (error, schedule) => this.observability.append({
+        type: "schedule.error",
+        category: "activation",
+        data: { scheduleId: schedule?.id, error: error.message }
+      })
+    });
+    this.signalRunner = new SignalRunner({
+      adapter: signalAdapter,
+      pollIntervalMs: this.execution.pollIntervalMs,
+      idlePollIntervalMs: this.execution.idlePollIntervalMs,
+      maxConcurrent: this.execution.maxConcurrent,
+      maxAttempts: this.execution.maxAttempts,
+      retryBackoffMs: this.execution.retryBackoffMs,
+      subscribers: [this.observer],
+      scheduleReconciler: signalScheduleReconciler,
+      envProvider: this.envProvider,
+      stationId: "foundry-local",
+      failUnknownSignals: true
+    });
+    for (const discovered of this.agents) {
+      this.signalRunner.registerSignal(
+        this.executionSignal(discovered),
+        executionAgentEntrypoint()
+      );
+    }
+    const topologyLayer = memoryTopologyStore;
+    const defaultServices = Layer3.mergeAll(
+      memoryAccountDirectory(this.application.accounts ?? []),
+      topologyLayer,
+      memoryEventStore
+    );
+    const serviceBase = this.application.services ?? defaultServices;
+    const resolver = grantResolverLive.pipe(Layer3.provide(serviceBase));
+    this.services = EffectManagedRuntime.make(
+      Layer3.merge(serviceBase, resolver)
+    );
+  }
+  static async discover(options) {
+    const agents = await discoverAgents({
+      agentsDir: options.agentsDir,
+      strictFileRoutes: options.config?.strictFileRoutes
+    });
+    const registry = await discoverFoundryRegistry({
+      rootDir: options.rootDir,
+      capabilities: false,
+      native: false,
+      strictFileRoutes: options.config?.strictFileRoutes
+    });
+    return new _FoundryRuntime({
+      rootDir: options.rootDir,
+      agents,
+      application: options.application,
+      applicationFilePath: options.applicationFilePath,
+      registry,
+      config: options.config,
+      observability: options.observability
+    });
+  }
+  startEffect() {
+    return promiseEffect("runtime.start", async () => {
+      if (this.started) throw new Error("Foundry runtime is already started.");
+      if (this.disposed) {
+        throw new Error("Foundry runtime has been stopped and cannot be restarted.");
+      }
+      if (this.agents.length === 0) {
+        throw new Error("Foundry did not discover any agents.");
+      }
+      this.started = true;
+      try {
+        await this.seedTopology();
+        for (const instance of await this.listAgentInstances()) {
+          if (!this.byRoute.has(instance.definitionId)) {
+            throw new Error(
+              `Agent instance "${instance.id}" references unknown definition "${instance.definitionId}".`
+            );
+          }
+          for (const installation of instance.installations) {
+            this.assertRegisteredInstallation(instance.definitionId, installation);
+          }
+          this.validatePlaybooks(
+            instance.definitionId,
+            instance.playbooks,
+            instance.installations
+          );
+        }
+        for (const subscription of await this.listPlaybookSubscriptions()) {
+          await this.validatePlaybookSubscription(subscription);
+        }
+        await this.signalRunner.initialize();
+        await this.reconstructActivations();
+        this.runInBackground("signal", this.signalRunner.start());
+        await this.reconcileApplicationConnections();
+      } catch (cause) {
+        try {
+          await this.stop();
+        } catch {
+        }
+        throw cause;
+      }
+    });
+  }
+  start() {
+    return Effect5.runPromise(this.startEffect());
+  }
+  stopEffect() {
+    return promiseEffect("runtime.stop", async () => {
+      if (this.disposed) return;
+      if (!this.started) {
+        await this.services.dispose();
+        this.disposed = true;
+        return;
+      }
+      await this.connectionSupervisor.stopAll();
+      this.observability.append({ type: "runtime.stop.signals", category: "system", data: {} });
+      await this.signalRunner.stop({ graceful: true, timeoutMs: 1e4 });
+      this.observability.append({ type: "runtime.stop.loops", category: "system", data: {} });
+      await this.settleRunnerLoops(1e3);
+      this.runnerLoops.length = 0;
+      await this.envStore.close();
+      await this.scheduleAdapter.close?.();
+      await this.services.dispose();
+      this.started = false;
+      this.disposed = true;
+      this.observability.append({ type: "runtime.stopped", category: "system", data: {} });
+    });
+  }
+  stop() {
+    return Effect5.runPromise(this.stopEffect());
+  }
+  requestEffect(route, request) {
+    return promiseEffect("agent.request", async () => {
+      if (!this.started) throw new Error("Foundry runtime is not started.");
+      const discovered = this.byRoute.get(route);
+      if (!discovered) throw new Error(`Foundry agent "${route}" was not found.`);
+      const agent = await Effect5.runPromise(this.data.getAgent(request.agentId));
+      if (!agent) throw new Error(`Foundry agent instance "${request.agentId}" was not found.`);
+      if (agent.definitionId !== route) {
+        throw new Error(`Agent instance "${request.agentId}" uses definition "${agent.definitionId}", not "${route}".`);
+      }
+      const conversation = await Effect5.runPromise(this.data.getConversation(request.conversationId));
+      if (!conversation || conversation.agentId !== agent.id) {
+        throw new Error(`Conversation "${request.conversationId}" does not belong to agent instance "${agent.id}".`);
+      }
+      if (request.workspaceId !== agent.workspaceId || request.workspaceId !== conversation.workspaceId) {
+        throw new Error("The request, agent instance, and conversation must share a workspace.");
+      }
+      const runId = await this.signalRunner.triggerSignal(
+        discovered.executionName,
+        await this.executionEnvelope(request)
+      );
+      const run = await this.signalRunner.getRun(runId);
+      if (!run) throw new Error(`Foundry failed to create run "${runId}".`);
+      return this.toFoundryRun(run);
+    }).pipe(
+      Effect5.withSpan("foundry.agent.request", {
+        attributes: { "foundry.agent.id": route }
+      })
+    );
+  }
+  request(route, request) {
+    return Effect5.runPromise(this.requestEffect(route, request));
+  }
+  async createAgent(definitionId, options = {}) {
+    if (!this.byRoute.has(definitionId)) {
+      throw new Error(`Foundry agent definition "${definitionId}" was not found.`);
+    }
+    const agent = createAgentInstance(definitionId, options);
+    for (const installation of agent.installations) {
+      this.assertRegisteredInstallation(definitionId, installation);
+    }
+    this.validatePlaybooks(definitionId, agent.playbooks, agent.installations);
+    if (await Effect5.runPromise(this.data.getAgent(agent.id))) {
+      throw new Error(`Foundry agent instance "${agent.id}" already exists.`);
+    }
+    await Effect5.runPromise(this.data.putAgent(agent));
+    this.observability.append({ type: "agent.instance.created", category: "agent", agent: definitionId, data: agent });
+    if (this.started) await this.reconcileApplicationConnections();
+    return agent;
+  }
+  async createConversation(agentId, options = {}) {
+    const agent = await Effect5.runPromise(this.data.getAgent(agentId));
+    if (!agent) throw new Error(`Foundry agent instance "${agentId}" was not found.`);
+    const conversation = createConversation(agent, options);
+    if (await Effect5.runPromise(this.data.getConversation(conversation.id))) {
+      throw new Error(`Foundry conversation "${conversation.id}" already exists.`);
+    }
+    await Effect5.runPromise(this.data.putConversation(conversation));
+    this.observability.append({ type: "conversation.created", category: "agent", agent: agent.definitionId, data: conversation });
+    return conversation;
+  }
+  listAgentInstances(definitionId) {
+    return Effect5.runPromise(this.data.listAgents(definitionId));
+  }
+  async setAgentPlaybooks(agentId, playbooks) {
+    const agent = await this.configureAgent(agentId, { playbooks });
+    this.observability.append({
+      type: "agent.playbooks.updated",
+      category: "agent",
+      agent: agent.definitionId,
+      data: { agentId, playbookIds: agent.playbooks.map((playbook) => playbook.id) }
+    });
+    return agent;
+  }
+  listPlaybookSubscriptions(workspaceId) {
+    return Effect5.runPromise(this.data.listPlaybookSubscriptions(workspaceId));
+  }
+  /** List persisted future activations created by schedules or sleeping runs. */
+  listActivations(workspaceId) {
+    return Effect5.runPromise(this.data.listActivations(workspaceId));
+  }
+  async putPlaybookSubscription(input) {
+    const firstTarget = input.targets[0];
+    const subscription = firstTarget && "definitionId" in firstTarget ? reconstructPlaybookSubscription(input) : definePlaybookSubscription(input);
+    await this.validatePlaybookSubscription(subscription);
+    await Effect5.runPromise(this.data.putPlaybookSubscription(subscription));
+    this.observability.append({
+      type: "playbook.subscription.updated",
+      category: "application",
+      data: {
+        subscriptionId: subscription.id,
+        playbookId: subscription.playbook.id,
+        targetDefinitions: subscription.targets.map((target) => target.definitionId)
+      }
+    });
+    if (this.started) await this.reconcileApplicationConnections();
+    return subscription;
+  }
+  async deletePlaybookSubscription(id2) {
+    const removed = await Effect5.runPromise(this.data.deletePlaybookSubscription(id2));
+    if (removed) {
+      this.observability.append({
+        type: "playbook.subscription.deleted",
+        category: "application",
+        data: { subscriptionId: id2 }
+      });
+      if (this.started) await this.reconcileApplicationConnections();
+    }
+    return removed;
+  }
+  listApplicationConnections() {
+    return this.connectionSupervisor.list();
+  }
+  reconnectApplicationConnection(id2) {
+    return this.connectionSupervisor.reconnect(id2);
+  }
+  /** Atomically replace the persisted, frontend-editable instance configuration. */
+  async configureAgent(agentId, options) {
+    const current = await Effect5.runPromise(this.data.getAgent(agentId));
+    if (!current) throw new Error(`Foundry agent instance "${agentId}" was not found.`);
+    const installations = options.installations ? normalizeAgentInstallations(options.installations) : current.installations;
+    for (const installation of installations) {
+      this.assertRegisteredInstallation(current.definitionId, installation);
+    }
+    const playbooks = options.playbooks ? Object.freeze(options.playbooks.map(reconstructPlaybook)) : current.playbooks;
+    this.validatePlaybooks(current.definitionId, playbooks, installations);
+    const agent = Object.freeze({
+      ...current,
+      ...options.context ? { context: Object.freeze(structuredClone(options.context)) } : {},
+      installations,
+      playbooks,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await Effect5.runPromise(this.data.putAgent(agent));
+    this.observability.append({
+      type: "agent.instance.configured",
+      category: "agent",
+      agent: current.definitionId,
+      data: {
+        agentId,
+        installations: installations.map(installationKey),
+        playbookIds: playbooks.map((playbook) => playbook.id)
+      }
+    });
+    if (this.started) await this.reconcileApplicationConnections();
+    return agent;
+  }
+  listConversations(agentId) {
+    return Effect5.runPromise(this.data.listConversations(agentId));
+  }
+  listWorkspaceEntries(workspaceId) {
+    return Effect5.runPromise(this.data.listWorkspaceEntries(workspaceId));
+  }
+  async putWorkspaceEntry(workspaceId, key, value) {
+    const entry = { workspaceId, key, value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await Effect5.runPromise(this.data.putWorkspaceEntry(entry));
+    return entry;
+  }
+  listSharedInbox(workspaceId) {
+    return Effect5.runPromise(this.data.listInboxItems(workspaceId));
+  }
+  async postSharedInbox(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const item = { ...input, id: id("inbox"), createdAt: now, updatedAt: now };
+    await Effect5.runPromise(this.data.putInboxItem(item));
+    return item;
+  }
+  async updateSharedInbox(workspaceId, itemId, status) {
+    const current = (await this.listSharedInbox(workspaceId)).find((item2) => item2.id === itemId);
+    if (!current) throw new Error(`Shared inbox item "${itemId}" was not found in workspace "${workspaceId}".`);
+    const item = { ...current, status, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await Effect5.runPromise(this.data.putInboxItem(item));
+    return item;
+  }
+  listTasks(workspaceId) {
+    return Effect5.runPromise(this.data.listTasks(workspaceId));
+  }
+  async createTask(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task = { ...input, id: id("task"), createdAt: now, updatedAt: now };
+    await Effect5.runPromise(this.data.putTask(task));
+    return task;
+  }
+  async updateTask(workspaceId, taskId, status) {
+    const current = (await this.listTasks(workspaceId)).find((task2) => task2.id === taskId);
+    if (!current) throw new Error(`Task "${taskId}" was not found in workspace "${workspaceId}".`);
+    const task = { ...current, status, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await Effect5.runPromise(this.data.putTask(task));
+    return task;
+  }
+  listDataEnvironment(scope) {
+    return Effect5.runPromise(this.data.listEnvironment(scope));
+  }
+  async send(agentId, conversationId, message, options = {}) {
+    const agent = await Effect5.runPromise(this.data.getAgent(agentId));
+    if (!agent) throw new Error(`Foundry agent instance "${agentId}" was not found.`);
+    return this.request(agent.definitionId, {
+      agentId,
+      conversationId,
+      workspaceId: agent.workspaceId,
+      message,
+      ...options.payload !== void 0 ? { payload: options.payload } : {},
+      ...options.context ? { context: options.context } : {},
+      source: { kind: "direct" }
+    });
+  }
+  async getRun(runId) {
+    const run = await this.signalRunner.getRun(runId);
+    return run ? this.toFoundryRun(run) : null;
+  }
+  async listRuns(route) {
+    const signalName = route ? this.byRoute.get(route)?.executionName : void 0;
+    if (route && !signalName) return [];
+    const runs = await this.signalRunner.listAllRuns({ signalName });
+    return runs.map((run) => this.toFoundryRun(run));
+  }
+  async waitForRun(runId, options) {
+    const run = await this.signalRunner.waitForRun(runId, options);
+    return run ? this.toFoundryRun(run) : null;
+  }
+  cancel(runId) {
+    return this.signalRunner.cancel(runId);
+  }
+  capabilityManifest(definitionId) {
+    if (!this.compositionByDefinition.has(definitionId)) {
+      throw new Error(`Foundry agent definition "${definitionId}" was not found.`);
+    }
+    const capabilities = this.compositionByDefinition.get(definitionId).capabilities;
+    const fileByKey = new Map(
+      this.registry.files.map((file) => [`${file.kind}:${file.id}`, file])
+    );
+    const map = (kind, values, ownership) => values.map((value) => ({
+      id: value.id,
+      kind,
+      description: value.description ?? "",
+      ownership,
+      file: fileByKey.get(`${kind}:${value.id}`)?.relativePath
+    }));
+    return {
+      tools: map("tool", capabilities.tools, "instance"),
+      applications: map(
+        "application",
+        capabilities.applications,
+        "instance"
+      ),
+      mcp: map("mcp", capabilities.mcp, "instance"),
+      memory: map("memory", capabilities.memory, "definition")
+    };
+  }
+  nativeManifest(definitionId) {
+    if (!this.compositionByDefinition.has(definitionId)) {
+      throw new Error(`Foundry agent definition "${definitionId}" was not found.`);
+    }
+    const native = this.compositionByDefinition.get(definitionId).native;
+    const fileByKey = new Map(
+      this.registry.nativeFiles.map((file) => [`${file.kind}:${file.id}`, file])
+    );
+    const map = (kind, values) => values.map((value) => ({
+      id: value.id,
+      kind,
+      description: value.description,
+      file: fileByKey.get(`${kind}:${value.id}`)?.relativePath
+    }));
+    return {
+      layers: map("layer", native.layers),
+      subscribers: map("subscriber", native.subscribers)
+    };
+  }
+  async listInstallations(agentId) {
+    const agent = await Effect5.runPromise(this.data.getAgent(agentId));
+    if (!agent) {
+      throw new Error(`Foundry agent instance "${agentId}" was not found.`);
+    }
+    return agent.installations;
+  }
+  async installCapability(agentId, installation) {
+    const agent = await Effect5.runPromise(this.data.getAgent(agentId));
+    if (!agent) {
+      throw new Error(`Foundry agent instance "${agentId}" was not found.`);
+    }
+    this.assertRegisteredInstallation(agent.definitionId, installation);
+    const installations = normalizeAgentInstallations([
+      ...agent.installations,
+      installation
+    ]);
+    const updated = Object.freeze({
+      ...agent,
+      installations,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await Effect5.runPromise(this.data.putAgent(updated));
+    this.observability.append({
+      type: "installation.installed",
+      category: "application",
+      agent: agentId,
+      data: installation
+    });
+    if (this.started) await this.reconcileApplicationConnections();
+    return updated;
+  }
+  async uninstallCapability(agentId, installation) {
+    const agent = await Effect5.runPromise(this.data.getAgent(agentId));
+    if (!agent) throw new Error(`Foundry agent instance "${agentId}" was not found.`);
+    const installations = normalizeAgentInstallations(
+      agent.installations.filter(
+        (candidate) => installationKey(candidate) !== installationKey(installation)
+      )
+    );
+    this.validatePlaybooks(agent.definitionId, agent.playbooks, installations);
+    const updated = Object.freeze({
+      ...agent,
+      installations,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await Effect5.runPromise(this.data.putAgent(updated));
+    this.observability.append({
+      type: "installation.uninstalled",
+      category: "application",
+      agent: agentId,
+      data: installation
+    });
+    if (this.started) await this.reconcileApplicationConnections();
+    return updated;
+  }
+  listAccounts() {
+    return this.services.runPromise(
+      Effect5.gen(function* () {
+        const accounts = yield* (yield* AccountDirectory).list();
+        return accounts.map(
+          ({ accessRef: _accessRef, ...account }) => account
+        );
+      })
+    );
+  }
+  listRoutes() {
+    return this.services.runPromise(
+      Effect5.gen(function* () {
+        return yield* (yield* TopologyStore).listRoutes();
+      })
+    );
+  }
+  async putRoute(route) {
+    await this.validateRoute(route);
+    const stored = await this.services.runPromise(
+      Effect5.gen(function* () {
+        return yield* (yield* TopologyStore).putRoute(route);
+      })
+    );
+    this.topologyRoutes.set(stored.id, stored);
+    return stored;
+  }
+  async removeRoute(id2) {
+    await this.services.runPromise(
+      Effect5.gen(function* () {
+        return yield* (yield* TopologyStore).removeRoute(id2);
+      })
+    );
+    this.topologyRoutes.delete(id2);
+  }
+  listBindings() {
+    return this.services.runPromise(
+      Effect5.gen(function* () {
+        return yield* (yield* TopologyStore).listBindings();
+      })
+    );
+  }
+  async putBinding(binding) {
+    await this.validateBinding(binding);
+    return this.services.runPromise(
+      Effect5.gen(function* () {
+        return yield* (yield* TopologyStore).putBinding(binding);
+      })
+    );
+  }
+  removeBinding(id2) {
+    return this.services.runPromise(
+      Effect5.gen(function* () {
+        return yield* (yield* TopologyStore).removeBinding(id2);
+      })
+    );
+  }
+  resolveGrant(request) {
+    return this.services.runPromise(
+      Effect5.gen(function* () {
+        return yield* (yield* GrantResolver).resolve(request);
+      })
+    );
+  }
+  putEvent(reference, payload) {
+    return this.services.runPromise(
+      Effect5.gen(function* () {
+        return yield* (yield* EventStore).put(reference, payload);
+      })
+    );
+  }
+  async dispatchInbound(input) {
+    const route = (await this.listRoutes()).find((item) => item.id === input.routeId);
+    if (!route || route.direction !== "inbound" || !route.enabled) {
+      throw new Error(`Inbound route "${input.routeId}" is missing or disabled.`);
+    }
+    const claim = `${route.id}:${input.eventId}`;
+    const prior = await Effect5.runPromise(this.data.getInboundDelivery(claim));
+    if (prior?.status === "completed") {
+      return this.runsFromIds(prior.runIds);
+    }
+    const acquired = await Effect5.runPromise(this.data.claimInboundDelivery(claim));
+    if (!acquired) return this.waitForInboundDelivery(claim);
+    try {
+      const integration = this.transmissionById.get(route.transmissionId);
+      if (!integration?.inbound) throw new Error(`Transmission "${route.transmissionId}" has no inbound contract.`);
+      const account = route.accountId ? await this.services.runPromise(Effect5.gen(function* () {
+        return yield* (yield* AccountDirectory).get(route.accountId);
+      })) : void 0;
+      const ingressContext = { route, ...account ? { account } : {} };
+      if (integration.inbound.adapter) {
+        const authenticated = await Effect5.runPromise(integration.inbound.adapter.authenticate(input.raw, ingressContext));
+        if (!authenticated) throw new Error(`Inbound event for route "${route.id}" was not authenticated.`);
+      }
+      const event = integration.inbound.adapter ? await Effect5.runPromise(integration.inbound.adapter.normalize(input.raw, ingressContext)) : await Schema3.decodeUnknownPromise(integration.inbound.event)(input.raw);
+      const inferredEventName = event && typeof event === "object" ? ["type", "kind", "event"].map((key) => event[key]).find((value) => typeof value === "string" && value.length > 0) : void 0;
+      const classifiedEvent = integration.inbound.classify ? await Effect5.runPromise(integration.inbound.classify(event, ingressContext)) : void 0;
+      if (classifiedEvent && !integration.events?.some((candidate) => candidate.id === classifiedEvent.id)) {
+        throw new Error(
+          `Transmission "${integration.id}" classified an event it does not declare. Add the imported event definition to its events array.`
+        );
+      }
+      const eventName = classifiedEvent?.id ?? inferredEventName ?? "event";
+      const instances = await this.listAgentInstances();
+      const runs = [];
+      const deliveries = [];
+      const matchedByAgent = /* @__PURE__ */ new Map();
+      for (const agent of instances) {
+        const installedApplications = new Set(
+          agent.installations.filter((installation) => installation.kind === "application").map((installation) => installation.id)
+        );
+        const hasInstalledOwner = (this.compositionByDefinition.get(agent.definitionId)?.capabilities.applications ?? []).some(
+          (application) => installedApplications.has(application.id) && application.transmissions?.some(
+            (candidate) => candidate.id === integration.id && candidate.inbound
+          )
+        );
+        if (!hasInstalledOwner) continue;
+        const matched = [];
+        for (const playbook of agent.playbooks) {
+          if (await this.playbookMatches(
+            playbook,
+            integration,
+            route,
+            eventName,
+            event,
+            ingressContext
+          )) matched.push(playbook);
+        }
+        if (matched.length === 0) continue;
+        matchedByAgent.set(agent.id, { agent, playbooks: matched });
+      }
+      for (const subscription of await this.listPlaybookSubscriptions()) {
+        if (!subscription.enabled || subscription.workspaceId.length === 0) continue;
+        if (!await this.playbookMatches(
+          subscription.playbook,
+          integration,
+          route,
+          eventName,
+          event,
+          ingressContext
+        )) continue;
+        for (const [targetIndex, target] of subscription.targets.entries()) {
+          const resolved = await this.resolveSubscriptionTarget(
+            subscription,
+            target,
+            targetIndex,
+            {
+              route,
+              eventId: input.eventId,
+              eventName,
+              threadKey: input.threadKey,
+              event
+            }
+          );
+          for (const agent of resolved) {
+            const prior2 = matchedByAgent.get(agent.id);
+            if (prior2) {
+              if (!prior2.playbooks.some((playbook) => playbook.id === subscription.playbook.id)) {
+                prior2.playbooks.push(subscription.playbook);
+              }
+            } else {
+              matchedByAgent.set(agent.id, {
+                agent,
+                playbooks: [subscription.playbook]
+              });
+            }
+          }
+        }
+      }
+      for (const { agent, playbooks: matched } of matchedByAgent.values()) {
+        const conversationId = `transmission:${route.id}:${agent.id}:${input.threadKey}`;
+        let conversation = await Effect5.runPromise(this.data.getConversation(conversationId));
+        if (!conversation) {
+          conversation = await this.createConversation(agent.id, {
+            id: conversationId,
+            context: { routeId: route.id, threadKey: input.threadKey }
+          });
+        }
+        const serializationContext = {
+          ...ingressContext,
+          eventId: input.eventId,
+          eventName,
+          threadKey: input.threadKey,
+          playbooks: matched
+        };
+        const eventMessage = integration.inbound.serialize ? await Effect5.runPromise(integration.inbound.serialize(event, serializationContext)) : serializeInboundTransmissionXml({
+          transmissionId: integration.id,
+          routeId: route.id,
+          eventId: input.eventId,
+          eventName,
+          threadKey: input.threadKey,
+          event,
+          playbooks: matched
+        });
+        const run = await this.request(agent.definitionId, {
+          agentId: agent.id,
+          conversationId: conversation.id,
+          workspaceId: agent.workspaceId,
+          message: eventMessage,
+          payload: event,
+          context: {
+            playbookIds: matched.map((playbook) => playbook.id),
+            outbound: matched.flatMap((playbook) => playbook.outbound ?? [])
+          },
+          source: {
+            kind: "transmission",
+            id: route.id,
+            provider: route.transmissionId,
+            eventId: input.eventId,
+            threadKey: input.threadKey
+          }
+        });
+        runs.push(run);
+        deliveries.push({
+          agentId: agent.id,
+          playbookIds: matched.map((playbook) => playbook.id),
+          runId: run.id
+        });
+      }
+      await Effect5.runPromise(
+        this.data.completeInboundDelivery(claim, runs.map((run) => run.id))
+      );
+      this.observability.append({
+        type: "transmission.dispatched",
+        category: "application",
+        data: { routeId: route.id, eventId: input.eventId, eventName, deliveries }
+      });
+      return runs;
+    } catch (cause) {
+      await Effect5.runPromise(this.data.releaseInboundDelivery(claim));
+      throw cause;
+    }
+  }
+  async dispatchOutbound(input) {
+    const route = (await this.listRoutes()).find((item) => item.id === input.routeId);
+    if (!route || route.direction !== "outbound" || !route.enabled) {
+      throw new Error(`Outbound route "${input.routeId}" is missing or disabled.`);
+    }
+    if (input.transmissionId && route.transmissionId !== input.transmissionId) {
+      throw new Error(
+        `Outbound route "${route.id}" does not belong to transmission "${input.transmissionId}".`
+      );
+    }
+    if (input.applicationId) {
+      const agent = await Effect5.runPromise(this.data.getAgent(input.agentId));
+      const application = agent ? this.compositionByDefinition.get(agent.definitionId)?.capabilities.applications.find(
+        (candidate) => candidate.id === input.applicationId
+      ) : void 0;
+      if (!application || !agent?.installations.some(
+        (installation) => installation.kind === "application" && installation.id === input.applicationId
+      ) || !application.transmissions?.some(
+        (candidate) => candidate.id === route.transmissionId
+      )) {
+        throw new Error(
+          `Application "${input.applicationId}" does not own outbound transmission "${route.transmissionId}" for agent "${input.agentId}".`
+        );
+      }
+    }
+    const grant = await this.resolveGrant({
+      runId: input.runId,
+      agentId: input.agentId
+    });
+    if (!grant.outboundRouteIds.includes(route.id)) {
+      throw new Error(`Run "${input.runId}" is not authorized for outbound route "${route.id}".`);
+    }
+    const transmission = this.transmissionById.get(route.transmissionId);
+    if (!transmission?.outbound?.adapter) {
+      throw new Error(`Transmission "${route.transmissionId}" has no outbound delivery adapter.`);
+    }
+    const account = route.accountId ? await this.services.runPromise(Effect5.gen(function* () {
+      return yield* (yield* AccountDirectory).get(route.accountId);
+    })) : void 0;
+    const payload = await Schema3.decodeUnknownPromise(transmission.outbound.input)(input.payload);
+    const output = await Effect5.runPromise(transmission.outbound.adapter.deliver(payload, {
+      route,
+      ...account ? { account } : {},
+      grant
+    }));
+    const validated = await Schema3.decodeUnknownPromise(transmission.outbound.output)(output);
+    this.observability.append({
+      type: "transmission.outbound.delivered",
+      category: "application",
+      runId: input.runId,
+      data: {
+        ...input.commandId ? { commandId: input.commandId } : {},
+        ...input.applicationId ? { applicationId: input.applicationId } : {},
+        ...input.transmissionId ? { transmissionId: input.transmissionId } : {},
+        routeId: route.id,
+        output: validated
+      }
+    });
+    return validated;
+  }
+  async health() {
+    const [execution, environment, activations] = await Promise.all([
+      this.signalRunner.getAdapter().ping(),
+      this.envStore.ping(),
+      this.scheduleAdapter.ping()
+    ]);
+    return {
+      ok: execution && environment && activations,
+      execution,
+      environment,
+      activations,
+      agents: this.agents.length,
+      capabilities: this.registry.files.length,
+      surfaces: this.registry.nativeFiles.length
+    };
+  }
+  async runsFromIds(runIds) {
+    return (await Promise.all(runIds.map((id2) => this.getRun(id2)))).filter(
+      (run) => run !== null
+    );
+  }
+  async waitForInboundDelivery(key) {
+    const deadline = Date.now() + 3e4;
+    while (Date.now() < deadline) {
+      const claim = await Effect5.runPromise(this.data.getInboundDelivery(key));
+      if (!claim) {
+        throw new Error(`Inbound delivery "${key}" was released before completion.`);
+      }
+      if (claim.status === "completed") return this.runsFromIds(claim.runIds);
+      await new Promise((resolveWait) => setTimeout(resolveWait, 25));
+    }
+    throw new Error(`Timed out waiting for inbound delivery "${key}".`);
+  }
+  async validatePlaybookSubscription(subscription) {
+    for (const target of subscription.targets) {
+      if (!this.byRoute.has(target.definitionId)) {
+        throw new Error(
+          `Playbook subscription "${subscription.id}" targets unknown agent definition "${target.definitionId}".`
+        );
+      }
+      for (const installation of target.installations) {
+        this.assertRegisteredInstallation(target.definitionId, installation);
+      }
+      if (target.provisioning.mode === "existing") {
+        for (const agentId of target.provisioning.agentIds) {
+          const agent = await Effect5.runPromise(this.data.getAgent(agentId));
+          if (!agent || agent.definitionId !== target.definitionId) {
+            throw new Error(
+              `Playbook subscription "${subscription.id}" references missing or incompatible agent instance "${agentId}".`
+            );
+          }
+          this.validatePlaybooks(
+            agent.definitionId,
+            [subscription.playbook],
+            agent.installations
+          );
+        }
+      } else {
+        this.validatePlaybooks(
+          target.definitionId,
+          [subscription.playbook],
+          target.installations
+        );
+      }
+    }
+  }
+  async playbookMatches(playbook, transmission, route, eventName, event, ingressContext) {
+    if (playbook.enabled === false || playbook.transmissionId !== transmission.id) return false;
+    if (playbook.match?.routeIds && !playbook.match.routeIds.includes(route.id)) return false;
+    if (playbook.match?.event && playbook.match.event !== eventName) return false;
+    const predicateRef = playbook.match?.predicate;
+    if (!predicateRef) return true;
+    const predicate = transmissionPredicate(transmission, predicateRef.name);
+    if (!predicate) {
+      throw new Error(
+        `Playbook "${playbook.id}" references unknown predicate "${predicateRef.name}" on transmission "${transmission.id}".`
+      );
+    }
+    return Effect5.runPromise(
+      predicate.match(event, predicateRef.parameters ?? {}, ingressContext)
+    );
+  }
+  async resolveSubscriptionTarget(subscription, target, targetIndex, input) {
+    const policy = target.provisioning;
+    if (policy.mode === "existing") {
+      return Promise.all(policy.agentIds.map(async (agentId) => {
+        const agent = await Effect5.runPromise(this.data.getAgent(agentId));
+        if (!agent) throw new Error(`Subscribed agent instance "${agentId}" was not found.`);
+        return this.attachSubscriptionPlaybook(agent, subscription, target);
+      }));
+    }
+    const seeds = policy.mode === "custom" ? await Effect5.runPromise(
+      this.application.provisioner?.provision(policy.adapter, {
+        subscription,
+        target,
+        route: input.route,
+        eventId: input.eventId,
+        eventName: input.eventName,
+        threadKey: input.threadKey,
+        event: input.event
+      }) ?? Effect5.fail(
+        new Error(
+          `Playbook subscription "${subscription.id}" requires custom provisioner "${policy.adapter}", but the Foundry application does not define one.`
+        )
+      )
+    ) : [{
+      provisioningKey: [
+        "subscription",
+        subscription.workspaceId,
+        subscription.id,
+        String(targetIndex),
+        policy.mode,
+        ...policy.mode === "per-thread" ? [input.route.id, input.threadKey] : policy.mode === "per-event" ? [input.route.id, input.eventId] : [policy.key ?? "default"]
+      ].join(":")
+    }];
+    const agents = [];
+    for (const seed of seeds) {
+      const agent = await Effect5.runPromise(this.data.provisionAgent({
+        definitionId: target.definitionId,
+        provisioningKey: seed.provisioningKey,
+        workspaceId: seed.workspaceId ?? subscription.workspaceId,
+        context: seed.context ?? target.context,
+        installations: seed.installations ?? target.installations,
+        playbooks: seed.playbooks ?? [subscription.playbook],
+        ...seed.id ? { id: seed.id } : {}
+      }));
+      const attached = await this.attachSubscriptionPlaybook(agent, subscription, target);
+      agents.push(attached);
+      this.observability.append({
+        type: "playbook.subscription.agent-resolved",
+        category: "agent",
+        agent: target.definitionId,
+        data: {
+          subscriptionId: subscription.id,
+          agentId: attached.id,
+          provisioningKey: seed.provisioningKey
+        }
+      });
+    }
+    return agents;
+  }
+  async attachSubscriptionPlaybook(agent, subscription, target) {
+    const playbooks = [
+      ...agent.playbooks.filter((playbook) => playbook.id !== subscription.playbook.id),
+      subscription.playbook
+    ];
+    const installations = normalizeAgentInstallations([
+      ...agent.installations,
+      ...target.installations
+    ]);
+    this.validatePlaybooks(agent.definitionId, playbooks, installations);
+    const changed = JSON.stringify(agent.playbooks) !== JSON.stringify(playbooks) || JSON.stringify(agent.installations) !== JSON.stringify(installations);
+    if (!changed) return agent;
+    const updated = Object.freeze({
+      ...agent,
+      playbooks: Object.freeze(playbooks),
+      installations,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await Effect5.runPromise(this.data.putAgent(updated));
+    return updated;
+  }
+  async reconcileApplicationConnections() {
+    const requirements = [];
+    for (const subscription of await this.listPlaybookSubscriptions()) {
+      if (!subscription.enabled || subscription.playbook.enabled === false) continue;
+      for (const target of subscription.targets) {
+        requirements.push({
+          definitionId: target.definitionId,
+          workspaceId: subscription.workspaceId,
+          playbook: subscription.playbook,
+          installedApplications: new Set(
+            target.installations.filter((installation) => installation.kind === "application").map((installation) => installation.id)
+          )
+        });
+      }
+    }
+    for (const agent of await this.listAgentInstances()) {
+      const installedApplications = new Set(
+        agent.installations.filter((installation) => installation.kind === "application").map((installation) => installation.id)
+      );
+      for (const playbook of agent.playbooks) {
+        if (playbook.enabled === false) continue;
+        requirements.push({
+          definitionId: agent.definitionId,
+          workspaceId: agent.workspaceId,
+          playbook,
+          installedApplications
+        });
+      }
+    }
+    const routes = (await this.listRoutes()).filter(
+      (route) => route.direction === "inbound" && route.enabled
+    );
+    const grouped = /* @__PURE__ */ new Map();
+    for (const requirement of requirements) {
+      const composition = this.compositionByDefinition.get(requirement.definitionId);
+      if (!composition) continue;
+      for (const application of composition.capabilities.applications) {
+        if (requirement.installedApplications && !requirement.installedApplications.has(application.id)) continue;
+        if (!application.transmissions?.some(
+          (transmission) => transmission.id === requirement.playbook.transmissionId
+        )) continue;
+        for (const connection of application.connections ?? []) {
+          if (!connection.transmissions.some(
+            (transmission) => transmission.id === requirement.playbook.transmissionId
+          )) continue;
+          const matchingRoutes = routes.filter(
+            (route) => route.transmissionId === requirement.playbook.transmissionId && (!requirement.playbook.match?.routeIds || requirement.playbook.match.routeIds.includes(route.id))
+          );
+          for (const route of matchingRoutes) {
+            const account = route.accountId ? this.application.accounts?.find((candidate) => candidate.id === route.accountId) : void 0;
+            const id2 = [
+              requirement.definitionId,
+              requirement.workspaceId,
+              application.id,
+              connection.id,
+              account?.id ?? "no-account"
+            ].join(":");
+            const prior = grouped.get(id2);
+            if (prior) {
+              if (!prior.routes.some((candidate) => candidate.id === route.id)) prior.routes.push(route);
+            } else {
+              grouped.set(id2, {
+                id: id2,
+                application,
+                connection,
+                definitionId: requirement.definitionId,
+                workspaceId: requirement.workspaceId,
+                ...account ? { account } : {},
+                routes: [route],
+                accountSessions: this.byRoute.get(requirement.definitionId)?.definition.accountSessions
+              });
+            }
+          }
+        }
+      }
+    }
+    await this.connectionSupervisor.reconcile([...grouped.values()]);
+  }
+  assertRegisteredInstallation(definitionId, installation) {
+    const registry = this.compositionByDefinition.get(definitionId)?.capabilities ?? EMPTY_CAPABILITY_REGISTRY;
+    const values = installation.kind === "tool" ? registry.tools : installation.kind === "application" ? registry.applications : registry.mcp;
+    if (!values.some((value) => value.id === installation.id)) {
+      throw new Error(
+        `Unknown Foundry ${installation.kind} capability "${installation.id}".`
+      );
+    }
+  }
+  validatePlaybooks(definitionId, playbooks, installations) {
+    const routes = this.topologyRoutes;
+    const applicationDefinitions = this.compositionByDefinition.get(definitionId)?.capabilities.applications ?? [];
+    const applications = new Map(
+      applicationDefinitions.map((application) => [application.id, application])
+    );
+    const installedApplications = new Set(
+      installations.filter((installation) => installation.kind === "application").map((installation) => installation.id)
+    );
+    const localTransmissions = new Map(
+      (this.compositionByDefinition.get(definitionId)?.capabilities.applications ?? []).flatMap(
+        (application) => (application.transmissions ?? []).map((transmission) => [
+          transmission.id,
+          transmission
+        ])
+      )
+    );
+    for (const playbook of playbooks) {
+      const transmission = localTransmissions.get(playbook.transmissionId);
+      if (!transmission?.inbound) {
+        throw new Error(
+          `Playbook "${playbook.id}" references transmission "${playbook.transmissionId}" without an inbound definition.`
+        );
+      }
+      const inboundOwners = applicationDefinitions.filter(
+        (application) => application.transmissions?.some(
+          (candidate) => candidate.id === playbook.transmissionId && candidate.inbound
+        )
+      );
+      if (!inboundOwners.some((application) => installedApplications.has(application.id))) {
+        throw new Error(
+          `Playbook "${playbook.id}" requires an installed application that owns inbound transmission "${playbook.transmissionId}".`
+        );
+      }
+      const predicate = playbook.match?.predicate?.name;
+      if (predicate && !transmissionPredicate(transmission, predicate)) {
+        throw new Error(
+          `Playbook "${playbook.id}" references unknown predicate "${predicate}" on transmission "${playbook.transmissionId}".`
+        );
+      }
+      for (const routeId of playbook.match?.routeIds ?? []) {
+        const route = routes.get(routeId);
+        if (!route || route.direction !== "inbound" || route.transmissionId !== playbook.transmissionId) {
+          throw new Error(`Playbook "${playbook.id}" references invalid inbound route "${routeId}".`);
+        }
+      }
+      for (const outbound of playbook.outbound ?? []) {
+        const route = routes.get(outbound.routeId);
+        if (!route || route.direction !== "outbound") {
+          throw new Error(`Playbook "${playbook.id}" references invalid outbound route "${outbound.routeId}".`);
+        }
+        if (outbound.accountId && route.accountId !== outbound.accountId) {
+          throw new Error(
+            `Playbook "${playbook.id}" selects account "${outbound.accountId}" outside outbound route "${outbound.routeId}".`
+          );
+        }
+        if (outbound.applicationId) {
+          const application = applications.get(outbound.applicationId);
+          if (!application) {
+            throw new Error(
+              `Playbook "${playbook.id}" references unknown application "${outbound.applicationId}".`
+            );
+          }
+          if (!installedApplications.has(outbound.applicationId)) {
+            throw new Error(
+              `Playbook "${playbook.id}" references uninstalled application "${outbound.applicationId}".`
+            );
+          }
+          if (!application.transmissions?.some(
+            (candidate) => candidate.id === route.transmissionId && candidate.outbound
+          )) {
+            throw new Error(
+              `Application "${outbound.applicationId}" does not own outbound route "${outbound.routeId}".`
+            );
+          }
+        } else {
+          const hasInstalledOwner = applicationDefinitions.some(
+            (application) => installedApplications.has(application.id) && application.transmissions?.some(
+              (candidate) => candidate.id === route.transmissionId && candidate.outbound
+            )
+          );
+          if (!hasInstalledOwner) {
+            throw new Error(
+              `Playbook "${playbook.id}" outbound route "${outbound.routeId}" has no installed owning application.`
+            );
+          }
+        }
+      }
+      for (const applicationId of playbook.applications ?? []) {
+        if (!applications.has(applicationId)) {
+          throw new Error(`Playbook "${playbook.id}" references unknown application "${applicationId}".`);
+        }
+        if (!installedApplications.has(applicationId)) {
+          throw new Error(`Playbook "${playbook.id}" references uninstalled application "${applicationId}".`);
+        }
+      }
+    }
+  }
+  async validateRoute(route) {
+    const integration = this.transmissionById.get(route.transmissionId);
+    if (!integration) {
+      throw new Error(
+        `Route "${route.id}" references unknown transmission "${route.transmissionId}".`
+      );
+    }
+    const contract = route.direction === "inbound" ? integration.inbound : integration.outbound;
+    if (!contract) {
+      throw new Error(
+        `Integration "${integration.id}" does not support ${route.direction} routes.`
+      );
+    }
+    if (integration.account?.required && !route.accountId) {
+      throw new Error(`Route "${route.id}" requires an account.`);
+    }
+    if (route.accountId) {
+      const account = await this.services.runPromise(
+        Effect5.gen(function* () {
+          return yield* (yield* AccountDirectory).get(route.accountId);
+        })
+      );
+      if (account.transmissionId !== route.transmissionId) {
+        throw new Error(
+          `Route "${route.id}" has an account outside transmission "${route.transmissionId}".`
+        );
+      }
+    }
+    await Schema3.decodeUnknownPromise(contract.config)(route.config);
+  }
+  async validateBinding(binding) {
+    if (!await Effect5.runPromise(this.data.getAgent(binding.agentId))) {
+      throw new Error(
+        `Binding "${binding.id}" references unknown agent instance "${binding.agentId}".`
+      );
+    }
+    const integration = this.transmissionById.get(binding.transmissionId);
+    if (!integration) {
+      throw new Error(
+        `Binding "${binding.id}" references unknown transmission "${binding.transmissionId}".`
+      );
+    }
+    if (integration.account?.required && !binding.accountId) {
+      throw new Error(`Binding "${binding.id}" requires an account.`);
+    }
+    if (binding.accountId) {
+      const account = await this.services.runPromise(
+        Effect5.gen(function* () {
+          return yield* (yield* AccountDirectory).get(binding.accountId);
+        })
+      );
+      if (account.transmissionId !== binding.transmissionId) {
+        throw new Error(
+          `Binding "${binding.id}" has an account outside transmission "${binding.transmissionId}".`
+        );
+      }
+    }
+    const declared = new Set(
+      (integration.capabilities ?? []).map((capability) => capability.id)
+    );
+    const unknown = binding.capabilities.filter(
+      (capability) => !declared.has(capability)
+    );
+    if (unknown.length > 0) {
+      throw new Error(
+        `Binding "${binding.id}" requests undeclared capabilities: ${unknown.join(", ")}.`
+      );
+    }
+    const referencedRoutes = [
+      ...binding.routeId ? [binding.routeId] : [],
+      ...binding.reply?.mode === "route" ? [binding.reply.routeId] : []
+    ];
+    for (const routeId of referencedRoutes) {
+      const route = await this.services.runPromise(
+        Effect5.gen(function* () {
+          return yield* (yield* TopologyStore).getRoute(routeId);
+        })
+      );
+      if (route.transmissionId !== binding.transmissionId) {
+        throw new Error(
+          `Binding "${binding.id}" has a route outside transmission "${binding.transmissionId}".`
+        );
+      }
+      if (binding.reply?.mode === "route" && binding.reply.routeId === routeId) {
+        if (route.direction !== "outbound") {
+          throw new Error(
+            `Binding "${binding.id}" reply route must be outbound.`
+          );
+        }
+      }
+    }
+  }
+  executionSignal(discovered) {
+    return compileAgentDefinition(
+      discovered.definition,
+      discovered.route
+    );
+  }
+  async seedTopology() {
+    for (const route of this.application.routes ?? []) {
+      await this.putRoute(route);
+    }
+    for (const binding of this.application.bindings ?? []) {
+      await this.putBinding(binding);
+    }
+  }
+  runInBackground(kind, loop) {
+    const observed = loop.catch((cause) => {
+      this.observability.append({
+        type: `runtime.${kind}.failed`,
+        category: "system",
+        data: { error: cause instanceof Error ? cause.message : String(cause) }
+      });
+    });
+    this.runnerLoops.push(observed);
+  }
+  async settleRunnerLoops(timeoutMs) {
+    if (this.runnerLoops.length === 0) return;
+    let timeout;
+    const settled = await Promise.race([
+      Promise.allSettled(this.runnerLoops).then(() => true),
+      new Promise((resolveTimeout) => {
+        timeout = setTimeout(() => resolveTimeout(false), timeoutMs);
+      })
+    ]);
+    if (timeout) clearTimeout(timeout);
+    if (!settled) {
+      this.observability.append({
+        type: "runtime.stop.loop-drain-timeout",
+        category: "system",
+        data: { timeoutMs, loops: this.runnerLoops.length }
+      });
+    }
+  }
+  async enqueueCoreRequest(definitionId, request, runAt) {
+    const discovered = this.byRoute.get(definitionId);
+    if (!discovered) throw new Error(`Foundry agent definition "${definitionId}" was not found.`);
+    const agent = await Effect5.runPromise(this.data.getAgent(request.agentId));
+    const conversation = await Effect5.runPromise(this.data.getConversation(request.conversationId));
+    if (!agent || !conversation) throw new Error("Core command references an unknown agent instance or conversation.");
+    const runId = await this.signalRunner.triggerSignal(
+      discovered.executionName,
+      await this.executionEnvelope(request)
+    );
+    if (runAt) {
+      const date = new Date(runAt);
+      if (Number.isNaN(date.getTime())) throw new Error(`Invalid future run date "${runAt}".`);
+      await this.signalRunner.getAdapter().updateRun(runId, { nextRunAt: date });
+    }
+    return runId;
+  }
+  async executeCoreCommand(command, parentRunId) {
+    if (command.type === "transmit") {
+      await this.deliverOutbound(command, parentRunId);
+      return;
+    }
+    if (command.type === "playbook.sync") {
+      await this.syncAgentPlaybooks(command, parentRunId);
+      return;
+    }
+    if (command.type === "schedule.sync") {
+      await this.syncDefinitionSchedules(command, parentRunId);
+      return;
+    }
+    if (command.type === "schedule.update") {
+      await this.updateScheduledActivation(command, parentRunId);
+      return;
+    }
+    if (command.type === "schedule.cancel") {
+      await this.cancelScheduledActivation(command, parentRunId);
+      return;
+    }
+    let agent = command.agentId ? await Effect5.runPromise(this.data.getAgent(command.agentId)) : null;
+    if (!agent) {
+      agent = await this.createAgent(command.definitionId, {
+        ...command.agentId ? { id: command.agentId } : {},
+        workspaceId: command.workspaceId,
+        context: { spawnedByRunId: parentRunId }
+      });
+    }
+    let conversation = command.conversationId ? await Effect5.runPromise(this.data.getConversation(command.conversationId)) : null;
+    if (!conversation) {
+      conversation = await this.createConversation(agent.id, {
+        ...command.conversationId ? { id: command.conversationId } : {},
+        workspaceId: command.workspaceId,
+        context: { spawnedByRunId: parentRunId }
+      });
+    }
+    const request = {
+      agentId: agent.id,
+      conversationId: conversation.id,
+      workspaceId: command.workspaceId,
+      message: command.message,
+      ..."payload" in command && command.payload !== void 0 ? { payload: command.payload } : {},
+      source: {
+        kind: command.type === "sleep" || command.type === "schedule" ? "activation" : command.type,
+        id: command.id
+      }
+    };
+    if (command.type === "schedule" || command.type === "sleep") {
+      const now = /* @__PURE__ */ new Date();
+      const activation = {
+        id: command.id,
+        kind: command.type === "sleep" ? "sleep" : "scheduled",
+        definitionId: command.definitionId,
+        agentId: agent.id,
+        conversationId: conversation.id,
+        workspaceId: command.workspaceId,
+        message: command.message,
+        ...command.type === "schedule" && command.payload !== void 0 ? { payload: command.payload } : {},
+        timing: command.type === "sleep" ? { kind: "at", at: command.wakeAt } : command.timing,
+        origin: "agent-tool",
+        status: "pending",
+        createdByRunId: parentRunId,
+        createdAt: now.toISOString(),
+        updatedAt: now.toISOString()
+      };
+      await Effect5.runPromise(this.data.putActivation(activation));
+      await this.materializeActivation(activation);
+      return;
+    }
+    const runId = await this.enqueueCoreRequest(
+      command.definitionId,
+      request,
+      void 0
+    );
+    this.observability.append({
+      type: "core.command.accepted",
+      category: "system",
+      agent: command.definitionId,
+      runId: parentRunId,
+      data: { commandId: command.id, childRunId: runId, type: command.type }
+    });
+    if (command.type === "background" && command.reconvene) {
+      void this.waitForRun(runId).then(async (run) => {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const item = {
+          id: id("inbox"),
+          workspaceId: command.workspaceId,
+          agentId: command.agentId,
+          conversationId: command.conversationId,
+          topic: "background.reconvene",
+          payload: { commandId: command.id, run },
+          status: "resolved",
+          createdAt: now,
+          updatedAt: now
+        };
+        await Effect5.runPromise(this.data.putInboxItem(item));
+      });
+    }
+  }
+  async syncAgentPlaybooks(command, parentRunId) {
+    const agent = await Effect5.runPromise(this.data.getAgent(command.agentId));
+    if (!agent || agent.definitionId !== command.definitionId || agent.workspaceId !== command.workspaceId) {
+      throw new Error("Playbook synchronization references an invalid agent instance.");
+    }
+    const currentById = new Map(agent.playbooks.map((item) => [item.id, item]));
+    const instancePlaybooks = agent.playbooks.filter(
+      (item) => item.origin !== "agent-definition"
+    );
+    const reconciled = command.playbooks.map((desired) => {
+      const current = currentById.get(desired.id);
+      return current && current.definitionRevision === desired.definitionRevision ? current : desired;
+    });
+    const updated = {
+      ...agent,
+      playbooks: Object.freeze([...instancePlaybooks, ...reconciled]),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.validatePlaybooks(command.definitionId, updated.playbooks, updated.installations);
+    await Effect5.runPromise(this.data.putAgent(updated));
+    await this.reconcileApplicationConnections();
+    this.observability.append({
+      type: "agent.playbooks.composed",
+      category: "agent",
+      agent: command.definitionId,
+      runId: parentRunId,
+      data: {
+        agentId: command.agentId,
+        playbookIds: reconciled.map((item) => item.id)
+      }
+    });
+  }
+  assertActivationOwnership(activation, command) {
+    if (activation.kind !== "scheduled" || activation.agentId !== command.agentId || activation.workspaceId !== command.workspaceId) {
+      throw new Error(`Scheduled activation "${activation.id}" is not owned by this agent instance.`);
+    }
+  }
+  backendScheduleId(activationId) {
+    return `activation/${activationId.replaceAll("_", "-")}`;
+  }
+  async disarmActivation(activation) {
+    if (activation.timing.kind === "every" || activation.timing.kind === "cron") {
+      await this.scheduleAdapter.delete(this.backendScheduleId(activation.id));
+    } else if (activation.lastRunId) {
+      await this.signalRunner.cancel(activation.lastRunId);
+    }
+    this.materializedActivations.delete(activation.id);
+  }
+  async syncDefinitionSchedules(command, parentRunId) {
+    const current = (await Effect5.runPromise(this.data.listActivations(command.workspaceId))).filter(
+      (item) => item.agentId === command.agentId && item.kind === "scheduled" && item.origin === "agent-definition"
+    );
+    const desiredIds = new Set(command.schedules.map((item) => item.id));
+    for (const stale of current.filter((item) => !desiredIds.has(item.id))) {
+      await this.disarmActivation(stale);
+      await Effect5.runPromise(this.data.putActivation({
+        ...stale,
+        status: "cancelled",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+    }
+    for (const desired of command.schedules) {
+      const existing = await Effect5.runPromise(this.data.getActivation(desired.id));
+      if (existing) this.assertActivationOwnership(existing, command);
+      if (!desired.enabled) {
+        if (existing && existing.status !== "cancelled") {
+          await this.disarmActivation(existing);
+          await Effect5.runPromise(this.data.putActivation({
+            ...existing,
+            status: "cancelled",
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }));
+        }
+        continue;
+      }
+      const unchanged = existing?.definitionRevision === desired.revision;
+      if (unchanged || existing?.status === "cancelled") continue;
+      if (existing) await this.disarmActivation(existing);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const activation = {
+        id: desired.id,
+        kind: "scheduled",
+        definitionId: command.definitionId,
+        agentId: command.agentId,
+        conversationId: command.conversationId,
+        workspaceId: command.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: parentRunId,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now
+      };
+      await Effect5.runPromise(this.data.putActivation(activation));
+      await this.materializeActivation(activation);
+    }
+  }
+  async updateScheduledActivation(command, parentRunId) {
+    const existing = await Effect5.runPromise(this.data.getActivation(command.activationId));
+    if (!existing) throw new Error(`Scheduled activation "${command.activationId}" was not found.`);
+    this.assertActivationOwnership(existing, command);
+    await this.disarmActivation(existing);
+    const updated = {
+      ...existing,
+      ...command.patch,
+      status: "pending",
+      createdByRunId: parentRunId,
+      lastRunId: void 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await Effect5.runPromise(this.data.putActivation(updated));
+    await this.materializeActivation(updated);
+    this.observability.append({
+      type: "scheduled-action.updated",
+      category: "activation",
+      agent: command.definitionId,
+      runId: parentRunId,
+      data: { commandId: command.id, activationId: updated.id }
+    });
+  }
+  async cancelScheduledActivation(command, parentRunId) {
+    const existing = await Effect5.runPromise(this.data.getActivation(command.activationId));
+    if (!existing) throw new Error(`Scheduled activation "${command.activationId}" was not found.`);
+    this.assertActivationOwnership(existing, command);
+    await this.disarmActivation(existing);
+    await Effect5.runPromise(this.data.putActivation({
+      ...existing,
+      status: "cancelled",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    this.observability.append({
+      type: "scheduled-action.cancelled",
+      category: "activation",
+      agent: command.definitionId,
+      runId: parentRunId,
+      data: { commandId: command.id, activationId: existing.id }
+    });
+  }
+  async reconstructActivations() {
+    for (const activation of await Effect5.runPromise(this.data.listActivations())) {
+      if (activation.status === "completed" || activation.status === "cancelled") continue;
+      await this.materializeActivation(activation);
+    }
+  }
+  async materializeActivation(activation) {
+    if (this.materializedActivations.has(activation.id)) return;
+    this.materializedActivations.add(activation.id);
+    try {
+      const discovered = this.byRoute.get(activation.definitionId);
+      if (!discovered) {
+        throw new Error(
+          `Activation "${activation.id}" references unknown agent definition "${activation.definitionId}".`
+        );
+      }
+      const storedAgent = await Effect5.runPromise(this.data.getAgent(activation.agentId));
+      const storedConversation = await Effect5.runPromise(
+        this.data.getConversation(activation.conversationId)
+      );
+      if (!storedAgent || storedAgent.definitionId !== activation.definitionId) {
+        throw new Error(`Activation "${activation.id}" references an invalid agent instance.`);
+      }
+      if (!storedConversation || storedConversation.agentId !== activation.agentId) {
+        throw new Error(`Activation "${activation.id}" references an invalid conversation.`);
+      }
+      if (activation.timing.kind === "every" && (!Number.isFinite(activation.timing.intervalMs) || activation.timing.intervalMs <= 0)) {
+        throw new Error(`Activation "${activation.id}" has an invalid recurrence interval.`);
+      }
+      if (activation.timing.kind === "at" && Number.isNaN(new Date(activation.timing.at).getTime())) {
+        throw new Error(`Activation "${activation.id}" has an invalid wake time.`);
+      }
+      const request = {
+        agentId: activation.agentId,
+        conversationId: activation.conversationId,
+        workspaceId: activation.workspaceId,
+        message: activation.message,
+        ...activation.payload !== void 0 ? { payload: activation.payload } : {},
+        source: { kind: "activation", id: activation.id }
+      };
+      if (activation.timing.kind === "every" || activation.timing.kind === "cron") {
+        const now = /* @__PURE__ */ new Date();
+        const schedule = {
+          id: this.backendScheduleId(activation.id),
+          kind: "signal",
+          target: discovered.executionName,
+          ...activation.timing.kind === "every" ? { interval: `${activation.timing.intervalMs}ms` } : { cron: activation.timing.expression, timezone: activation.timing.timezone },
+          overlapPolicy: "skip",
+          misfirePolicy: "fire-once",
+          misfireGraceMs: 6e4,
+          input: await this.executionEnvelope(request),
+          enabled: true,
+          nextRunAt: activation.timing.kind === "every" ? new Date(now.getTime() + activation.timing.intervalMs) : nextCronOccurrence(
+            activation.timing.expression,
+            activation.timing.timezone,
+            now
+          ),
+          createdAt: now,
+          updatedAt: now,
+          createdBy: `core:${activation.createdByRunId}`
+        };
+        await this.scheduleAdapter.add(schedule);
+        await Effect5.runPromise(this.data.putActivation({
+          ...activation,
+          status: "active",
+          updatedAt: now.toISOString()
+        }));
+        this.observability.append({
+          type: "scheduled-action.created",
+          category: "activation",
+          agent: activation.definitionId,
+          runId: activation.createdByRunId,
+          data: { commandId: activation.id, recurring: true, nextRunAt: schedule.nextRunAt }
+        });
+        return;
+      }
+      const runId = await this.enqueueCoreRequest(
+        activation.definitionId,
+        request,
+        activation.timing.at
+      );
+      const active = {
+        ...activation,
+        status: "active",
+        lastRunId: runId,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await Effect5.runPromise(this.data.putActivation(active));
+      this.observability.append({
+        type: "core.command.accepted",
+        category: "system",
+        agent: activation.definitionId,
+        runId: activation.createdByRunId,
+        data: { commandId: activation.id, childRunId: runId, type: activation.kind }
+      });
+      void this.waitForRun(runId).then(async (run) => {
+        if (!run || run.status !== "completed" && run.status !== "failed" && run.status !== "cancelled") return;
+        await Effect5.runPromise(this.data.putActivation({
+          ...active,
+          status: run.status === "cancelled" ? "cancelled" : "completed",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+      }).catch((cause) => {
+        this.observability.append({
+          type: "activation.persistence.error",
+          category: "activation",
+          agent: activation.definitionId,
+          runId,
+          data: { error: cause instanceof Error ? cause.message : String(cause) }
+        });
+      });
+    } catch (cause) {
+      this.materializedActivations.delete(activation.id);
+      throw cause;
+    }
+  }
+  async deliverOutbound(command, parentRunId) {
+    await this.dispatchOutbound({
+      routeId: command.routeId,
+      agentId: command.agentId,
+      runId: parentRunId,
+      payload: command.payload,
+      commandId: command.id,
+      ...command.applicationId ? { applicationId: command.applicationId } : {},
+      ...command.transmissionId ? { transmissionId: command.transmissionId } : {}
+    });
+  }
+  async executionEnvelope(request) {
+    const agent = await Effect5.runPromise(this.data.getAgent(request.agentId));
+    const conversation = await Effect5.runPromise(this.data.getConversation(request.conversationId));
+    if (!agent || !conversation) throw new Error("Cannot schedule an unknown agent instance or conversation.");
+    const activations = (await Effect5.runPromise(this.data.listActivations(request.workspaceId))).filter((activation) => activation.agentId === request.agentId);
+    return { [FOUNDRY_EXECUTION_MARKER]: true, request, agent, conversation, activations };
+  }
+  toFoundryRun(run) {
+    const storedInput = parseJson(run.input);
+    const input = storedInput && typeof storedInput === "object" && storedInput[FOUNDRY_EXECUTION_MARKER] === true ? storedInput.request : storedInput;
+    const request = input && typeof input === "object" ? input : void 0;
+    return {
+      id: run.id,
+      agent: this.routeBySignalName.get(run.signalName) ?? run.signalName,
+      kind: run.kind,
+      status: run.status,
+      input,
+      ...request?.agentId ? { agentId: request.agentId } : {},
+      ...request?.conversationId ? { conversationId: request.conversationId } : {},
+      ...request?.workspaceId ? { workspaceId: request.workspaceId } : {},
+      ...run.output !== void 0 ? { output: parseJson(run.output) } : {},
+      ...run.error ? { error: run.error } : {},
+      attempts: run.attempts,
+      maxAttempts: run.maxAttempts,
+      timeoutMs: run.timeout,
+      createdAt: run.createdAt.toISOString(),
+      ...run.startedAt ? { startedAt: run.startedAt.toISOString() } : {},
+      ...run.completedAt ? { completedAt: run.completedAt.toISOString() } : {}
+    };
+  }
+};
+
+// src/server.ts
+import {
+  createServer
+} from "node:http";
+import { Schema as Schema4 } from "effect";
+
+// src/dashboard-icons.ts
+var PHOSPHOR_ICON_PATHS = {
+  overview: "M104,40H56A16,16,0,0,0,40,56v48a16,16,0,0,0,16,16h48a16,16,0,0,0,16-16V56A16,16,0,0,0,104,40Zm0,64H56V56h48v48Zm96-64H152a16,16,0,0,0-16,16v48a16,16,0,0,0,16,16h48a16,16,0,0,0,16-16V56A16,16,0,0,0,200,40Zm0,64H152V56h48v48Zm-96,32H56a16,16,0,0,0-16,16v48a16,16,0,0,0,16,16h48a16,16,0,0,0,16-16V152A16,16,0,0,0,104,136Zm0,64H56V152h48v48Zm96-64H152a16,16,0,0,0-16,16v48a16,16,0,0,0,16,16h48a16,16,0,0,0,16-16V152A16,16,0,0,0,200,136Zm0,64H152V152h48v48Z",
+  agent: "M200,48H136V16a8,8,0,0,0-16,0V48H56A32,32,0,0,0,24,80V192a32,32,0,0,0,32,32H200a32,32,0,0,0,32-32V80A32,32,0,0,0,200,48Zm16,144a16,16,0,0,1-16,16H56a16,16,0,0,1-16-16V80A16,16,0,0,1,56,64H200a16,16,0,0,1,16,16Zm-52-56H92a28,28,0,0,0,0,56h72a28,28,0,0,0,0-56Zm-24,16v24H116V152ZM80,164a12,12,0,0,1,12-12h8v24H92A12,12,0,0,1,80,164Zm84,12h-8V152h8a12,12,0,0,1,0,24ZM72,108a12,12,0,1,1,12,12A12,12,0,0,1,72,108Zm88,0a12,12,0,1,1,12,12A12,12,0,0,1,160,108Z",
+  runs: "M128,24A104,104,0,1,0,232,128,104.11,104.11,0,0,0,128,24Zm0,192a88,88,0,1,1,88-88A88.1,88.1,0,0,1,128,216Zm48.24-94.78-64-40A8,8,0,0,0,100,88v80a8,8,0,0,0,12.24,6.78l64-40a8,8,0,0,0,0-13.56ZM116,153.57V102.43L156.91,128Z",
+  automations: "M232,136.66A104.12,104.12,0,1,1,119.34,24,8,8,0,0,1,120.66,40,88.12,88.12,0,1,0,216,135.34,8,8,0,0,1,232,136.66ZM120,72v56a8,8,0,0,0,8,8h56a8,8,0,0,0,0-16H136V72a8,8,0,0,0-16,0Zm40-24a12,12,0,1,0-12-12A12,12,0,0,0,160,48Zm36,24a12,12,0,1,0-12-12A12,12,0,0,0,196,72Zm24,36a12,12,0,1,0-12-12A12,12,0,0,0,220,108Z",
+  integrations: "M237.66,18.34a8,8,0,0,0-11.32,0l-52.4,52.41-5.37-5.38a32.05,32.05,0,0,0-45.26,0L100,88.69l-6.34-6.35A8,8,0,0,0,82.34,93.66L88.69,100,65.37,123.31a32,32,0,0,0,0,45.26l5.38,5.37-52.41,52.4a8,8,0,0,0,11.32,11.32l52.4-52.41,5.37,5.38a32,32,0,0,0,45.26,0L156,167.31l6.34,6.35a8,8,0,0,0,11.32-11.32L167.31,156l23.32-23.31a32,32,0,0,0,0-45.26l-5.38-5.37,52.41-52.4A8,8,0,0,0,237.66,18.34Zm-116.29,161a16,16,0,0,1-22.62,0L76.69,157.25a16,16,0,0,1,0-22.62L100,111.31,144.69,156Zm57.94-57.94L156,144.69,111.31,100l23.32-23.31a16,16,0,0,1,22.62,0l22.06,22A16,16,0,0,1,179.31,121.37ZM88.57,35A8,8,0,0,1,103.43,29l8,20A8,8,0,0,1,96.57,55ZM24.57,93A8,8,0,0,1,35,88.57l20,8A8,8,0,0,1,49,111.43l-20-8A8,8,0,0,1,24.57,93ZM231.43,163a8,8,0,0,1-10.4,4.46l-20-8A8,8,0,1,1,207,144.57l20,8A8,8,0,0,1,231.43,163Zm-64,58.06A8,8,0,0,1,152.57,227l-8-20A8,8,0,0,1,159.43,201Z",
+  workspaces: "M224,64H154.67L126.93,43.2a16.12,16.12,0,0,0-9.6-3.2H72A16,16,0,0,0,56,56V72H40A16,16,0,0,0,24,88V200a16,16,0,0,0,16,16H192.89A15.13,15.13,0,0,0,208,200.89V184h16.89A15.13,15.13,0,0,0,240,168.89V80A16,16,0,0,0,224,64ZM192,200H40V88H85.33l29.87,22.4A8,8,0,0,0,120,112h72Zm32-32H208V112a16,16,0,0,0-16-16H122.67L94.93,75.2a16.12,16.12,0,0,0-9.6-3.2H72V56h45.33L147.2,78.4A8,8,0,0,0,152,80h72Z",
+  menu: "M224,128a8,8,0,0,1-8,8H40a8,8,0,0,1,0-16H216A8,8,0,0,1,224,128ZM40,72H216a8,8,0,0,0,0-16H40a8,8,0,0,0,0,16ZM216,184H40a8,8,0,0,0,0,16H216a8,8,0,0,0,0-16Z",
+  plus: "M224,128a8,8,0,0,1-8,8H136v80a8,8,0,0,1-16,0V136H40a8,8,0,0,1,0-16h80V40a8,8,0,0,1,16,0v80h80A8,8,0,0,1,224,128Z",
+  close: "M205.66,194.34a8,8,0,0,1-11.32,11.32L128,139.31,61.66,205.66a8,8,0,0,1-11.32-11.32L116.69,128,50.34,61.66A8,8,0,0,1,61.66,50.34L128,116.69l66.34-66.35a8,8,0,0,1,11.32,11.32L139.31,128Z",
+  caretRight: "M181.66,133.66l-80,80a8,8,0,0,1-11.32-11.32L164.69,128,90.34,53.66a8,8,0,0,1,11.32-11.32l80,80A8,8,0,0,1,181.66,133.66Z",
+  search: "M229.66,218.34l-50.07-50.06a88.11,88.11,0,1,0-11.31,11.31l50.06,50.07a8,8,0,0,0,11.32-11.32ZM40,112a72,72,0,1,1,72,72A72.08,72.08,0,0,1,40,112Z",
+  definitions: "M229.66,189.66l-32,32a8,8,0,0,1-11.32,0l-32-32a8,8,0,0,1,11.32-11.32L184,196.69V139.31l-56-56-56,56v57.38l18.34-18.35a8,8,0,0,1,11.32,11.32l-32,32a8,8,0,0,1-11.32,0l-32-32a8,8,0,0,1,11.32-11.32L56,196.69V136a8,8,0,0,1,2.34-5.66L120,68.69V24a8,8,0,0,1,16,0V68.69l61.66,61.65A8,8,0,0,1,200,136v60.69l18.34-18.35a8,8,0,0,1,11.32,11.32Z",
+  secure: "M208,40H48A16,16,0,0,0,32,56v56c0,52.72,25.52,84.67,46.93,102.19,23.06,18.86,46,25.26,47,25.53a8,8,0,0,0,4.2,0c1-.27,23.91-6.67,47-25.53C198.48,196.67,224,164.72,224,112V56A16,16,0,0,0,208,40Zm0,72c0,37.07-13.66,67.16-40.6,89.42A129.3,129.3,0,0,1,128,223.62a128.25,128.25,0,0,1-38.92-21.81C61.82,179.51,48,149.3,48,112l0-56,160,0ZM82.34,141.66a8,8,0,0,1,11.32-11.32L112,148.69l50.34-50.35a8,8,0,0,1,11.32,11.32l-56,56a8,8,0,0,1-11.32,0Z",
+  external: "M200,64V168a8,8,0,0,1-16,0V83.31L69.66,197.66a8,8,0,0,1-11.32-11.32L172.69,72H88a8,8,0,0,1,0-16H192A8,8,0,0,1,200,64Z"
+};
+function renderPhosphorIcon(name, className = "icon") {
+  return `<svg class="${className}" data-phosphor="${name}" viewBox="0 0 256 256" fill="currentColor" aria-hidden="true"><path d="${PHOSPHOR_ICON_PATHS[name]}"/></svg>`;
+}
+var GLOVE_HAND_PATH = "M410.08 393.32C410.08 393.447 410.105 393.573 410.153 393.69C410.202 393.807 410.273 393.913 410.362 394.002C410.451 394.092 410.557 394.162 410.673 394.21C410.79 394.257 410.914 394.281 411.04 394.28L422.48 394.22C422.626 394.22 422.766 394.162 422.869 394.059C422.972 393.956 423.03 393.816 423.03 393.67L422.1 203.44C422.099 203.381 422.109 203.323 422.131 203.269C422.153 203.214 422.186 203.164 422.228 203.122C422.27 203.081 422.32 203.047 422.375 203.024C422.431 203.002 422.49 202.99 422.55 202.99L479.35 202.88C479.631 202.88 479.901 202.992 480.1 203.19C480.298 203.389 480.41 203.659 480.41 203.94L480.76 393.79C480.76 393.904 480.805 394.013 480.886 394.094C480.967 394.175 481.076 394.22 481.19 394.22L493.3 394.16C493.449 394.157 493.592 394.096 493.697 393.99C493.801 393.883 493.86 393.739 493.86 393.59L493.45 172.81C493.45 172.593 493.536 172.384 493.69 172.23C493.844 172.076 494.053 171.99 494.27 171.99L546.6 171.73C546.674 171.73 546.745 171.759 546.798 171.812C546.85 171.865 546.88 171.936 546.88 172.01L547.29 394C547.29 394.217 547.376 394.426 547.53 394.58C547.684 394.734 547.893 394.82 548.11 394.82L559.31 394.8C559.543 394.8 559.767 394.706 559.932 394.539C560.097 394.372 560.19 394.146 560.19 393.91L559.84 203.7C559.84 203.498 559.921 203.305 560.066 203.163C560.21 203.02 560.406 202.94 560.61 202.94L617.16 202.83C617.36 202.83 617.552 202.91 617.694 203.052C617.836 203.194 617.917 203.388 617.92 203.59L618.46 497.93C618.459 498.009 618.48 498.087 618.523 498.153C618.565 498.22 618.627 498.273 618.699 498.305C618.772 498.338 618.854 498.349 618.934 498.338C619.013 498.326 619.089 498.292 619.15 498.24L710.7 416.63C710.966 416.396 711.296 416.256 711.64 416.23C712.093 416.197 713.19 416.98 714.93 418.58C726.357 429.047 738.423 439.817 751.13 450.89C752.057 451.697 752.843 452.367 753.49 452.9C753.881 453.221 754.13 453.685 754.183 454.19C754.235 454.695 754.087 455.201 753.77 455.6C748.957 461.66 744.16 467.85 739.38 474.17C730.767 485.563 722.277 496.827 713.91 507.96C704.103 521.013 694.037 534.443 683.71 548.25C682.31 550.123 681.463 551.257 681.17 551.65C651.197 591.923 635.867 612.51 635.18 613.41C633.727 615.303 626.6 624.933 613.8 642.3C612.853 643.587 611.92 644.223 611 644.21C593.94 643.94 576.01 644.48 560.67 644.48C557.17 644.48 507.53 644.427 411.75 644.32C410.983 644.32 410.13 644.353 409.19 644.42C408.676 644.453 408.163 644.342 407.709 644.1C407.255 643.858 406.878 643.494 406.62 643.05C403.013 636.843 400.117 631.393 397.93 626.7C394.94 620.29 392.01 614.85 389 608.75C382.72 595.99 376.747 583.813 371.08 572.22C368.85 567.67 364.77 560.45 362.06 554.23C362.014 554.138 361.99 554.035 361.99 553.93L362 269.83C362 269.637 362.039 269.445 362.115 269.267C362.192 269.09 362.303 268.929 362.444 268.797C362.584 268.664 362.75 268.561 362.932 268.494C363.114 268.428 363.307 268.399 363.5 268.41C378.36 269.18 393.79 268.85 408.23 268.58C408.441 268.575 408.651 268.612 408.847 268.689C409.043 268.766 409.222 268.881 409.373 269.028C409.524 269.176 409.644 269.352 409.726 269.546C409.808 269.74 409.85 269.949 409.85 270.16L410.08 393.32Z";
+var GLOVE_CUFF_PATH = "M406.91 658.31C406.91 658.22 406.946 658.133 407.01 658.07C407.073 658.006 407.16 657.97 407.25 657.97C462.983 657.857 503.02 657.817 527.36 657.85C559.72 657.9 574.5 657.57 611.92 657.12C612.178 657.117 612.435 657.166 612.674 657.263C612.913 657.36 613.131 657.504 613.315 657.686C613.499 657.869 613.646 658.085 613.746 658.325C613.846 658.564 613.899 658.82 613.9 659.08L614.06 747.46C614.06 747.776 613.946 748.08 613.738 748.318C613.53 748.555 613.243 748.709 612.93 748.75C612.257 748.837 610.613 748.88 608 748.88C574.107 748.9 508.023 748.873 409.75 748.8C407.817 748.8 406.85 747.943 406.85 746.23C406.903 718.95 406.923 689.643 406.91 658.31Z";
+function renderGloveMark() {
+  return `<svg class="brand-mark" data-brand="glove" viewBox="0 0 1024 1024" fill="none" aria-hidden="true"><path d="${GLOVE_HAND_PATH}" fill="currentColor"/><path d="${GLOVE_CUFF_PATH}" fill="currentColor"/></svg>`;
+}
+
+// src/dashboard-script.ts
+var ICON_PATHS_JSON = JSON.stringify(PHOSPHOR_ICON_PATHS);
+var DASHBOARD_SCRIPT = String.raw`
+const ICON_PATHS=${ICON_PATHS_JSON};
+const state={manifest:null,instances:[],subscriptions:[],connections:[],runs:[],events:[],health:null,transmissions:[],accounts:[],routes:[],bindings:[],activations:[],conversations:{},workspaces:{},filters:{runs:"all"},workspaceTab:"entries",showAllEvents:false};
+const $=id=>document.getElementById(id);
+const esc=value=>String(value??"").replace(/[&<>"']/g,c=>({"&":"&amp;","<":"&lt;",">":"&gt;","\"":"&quot;","'":"&#39;"}[c]));
+const attr=value=>esc(value).replace(/\x60/g,"&#96;");
+const fmtDate=iso=>iso?new Date(iso).toLocaleString([],{month:"short",day:"numeric",hour:"2-digit",minute:"2-digit"}):"—";
+const fmtTime=iso=>iso?new Date(iso).toLocaleTimeString([],{hour:"2-digit",minute:"2-digit",second:"2-digit"}):"—";
+const short=value=>{const text=String(value??"");return text.length>22?text.slice(0,10)+"…"+text.slice(-7):text};
+const jsonText=value=>JSON.stringify(value,null,2);
+const count=(n,word)=>n+" "+word+(n===1?"":"s");
+const icon=(name,className)=>'<svg class="'+(className||"icon")+'" data-phosphor="'+name+'" viewBox="0 0 256 256" fill="currentColor" aria-hidden="true"><path d="'+ICON_PATHS[name]+'"/></svg>';
+
+async function api(url,options){
+  const response=await fetch(url,options);let body;
+  try{body=await response.json()}catch{body={error:"The runtime returned an unreadable response."}}
+  if(!response.ok)throw new Error(body.error||("Request failed ("+response.status+")"));return body;
+}
+function toast(message){const node=$("toast");node.textContent=message;node.classList.add("show");setTimeout(()=>node.classList.remove("show"),2400)}
+function route(){const parts=location.pathname.split("/").filter(Boolean).map(decodeURIComponent);return{parts,section:parts[0]||"overview",id:parts.slice(1).join("/")}}
+function go(path){history.pushState({},"",path);void navigate()}
+function status(value){return '<span class="status '+attr(value)+'">'+esc(value)+'</span>'}
+function tags(values){return(values||[]).map(value=>'<span class="tag">'+esc(value)+'</span>').join("")}
+function empty(title,detail){return'<div class="empty"><strong>'+esc(title)+'</strong>'+esc(detail)+'</div>'}
+function pageHead(eyebrow,title,detail,actions){return'<div class="page-head"><div><div class="page-rule"></div><div class="eyebrow">'+esc(eyebrow)+'</div><h1>'+esc(title)+'</h1><p>'+esc(detail)+'</p></div>'+(actions?'<div class="actions">'+actions+'</div>':"")+'</div>'}
+function card(title,body,meta,classes){return'<section class="card '+(classes||"")+'"><div class="card-head"><h2>'+esc(title)+'</h2>'+(meta?'<span class="meta">'+esc(meta)+'</span>':"")+'</div>'+body+'</section>'}
+function metric(label,value,note,accent){return'<section class="card metric '+(accent?"accent":"")+'"><label>'+esc(label)+'</label><strong>'+esc(value)+'</strong><small>'+esc(note)+'</small></section>'}
+function dataLinks(){
+  document.querySelectorAll("[data-link]").forEach(node=>node.onclick=event=>{if(event.metaKey||event.ctrlKey||event.shiftKey||event.altKey)return;event.preventDefault();go(node.getAttribute("href"))});
+  document.querySelectorAll("[data-go]").forEach(node=>node.onclick=event=>{if(event.target.closest("a,button"))return;go(node.dataset.go)});
+}
+function workspaceIds(){const ids=new Set();state.instances.forEach(x=>ids.add(x.workspaceId));state.subscriptions.forEach(x=>ids.add(x.workspaceId));state.connections.forEach(x=>ids.add(x.workspaceId));state.runs.forEach(x=>{if(x.workspaceId)ids.add(x.workspaceId)});return[...ids].filter(Boolean).sort()}
+function definition(id){return state.manifest?.agents?.agents?.find(x=>x.id===id)}
+function eventsFor(runId){return state.events.filter(event=>event.runId===runId)}
+function isKeyRunEvent(event){
+  const type=event.type;
+  if(/^run\./.test(type)||/^scheduled-action\./.test(type))return true;
+  return /(?:playbooks\.composed|definition\.schedules\.loaded|application\.transmission-tools\.mounted|working-environment\.(?:mounted|snapshot\.saved)|repl\.mounted|subscriber\.mounted|layer\.mounted|installation\.(?:started|completed|failed)|definition\.memory\.mounted|definition\.inboxes\.loaded|tool_use(?:_result)?|model_response_complete)$/.test(type);
+}
+function activeRuns(){return state.runs.filter(run=>run.status==="pending"||run.status==="running")}
+function failureRuns(){return state.runs.filter(run=>run.status==="failed")}
+function recent(array){return[...array].sort((a,b)=>String(b.createdAt||b.timestamp||b.updatedAt).localeCompare(String(a.createdAt||a.timestamp||a.updatedAt)))}
+function explainRun(run){
+  if(run.status==="failed")return run.error||"The runtime could not complete this run.";
+  const source=run.input?.source?.kind;
+  if(source==="transmission")return"Started by an inbound transmission.";
+  if(source==="activation")return"Started by a scheduled activation or wake-up.";
+  if(source==="spawn")return"Spawned by another agent run.";
+  if(source==="background")return"Continued as background work.";
+  if(run.status==="completed")return"The agent completed the requested work.";
+  return"The agent is processing a direct message.";
+}
+function navState(section){const key=section==="overview"?"overview":section;document.querySelectorAll("[data-nav]").forEach(node=>node.classList.toggle("active",node.dataset.nav===key));$("sidebar").classList.remove("open")}
+function crumbs(items){$("breadcrumbs").innerHTML=items.map((item,index)=>index===items.length-1?'<span>'+esc(item.label)+'</span>':'<a href="'+attr(item.href)+'" data-link>'+esc(item.label)+'</a><span class="crumb-separator">'+icon("caretRight")+'</span>').join("")}
+
+function renderOverview(){
+  crumbs([{label:"Overview"}]);
+  const recentRuns=recent(state.runs).slice(0,6);const definitions=state.manifest?.agents?.agents||[];const live=activeRuns();
+  let html=pageHead("Runtime at a glance","What is happening now","Start here. Foundry separates code-defined agents from their runtime instances, then records every invocation as a run.",'<a class="button" href="/agents" data-link>Browse agents</a><button class="button primary" data-new-run>Start a run</button>');
+  html+='<div class="grid cols-4">'+metric("Agent definitions",definitions.length,"Discovered from the agents folder",true)+metric("Runtime instances",state.instances.length,"Persisted agent identities")+metric("Active work",live.length,live.length?"Runs currently pending or running":"No work in flight")+metric("Attention needed",failureRuns().length,"Failed runs in retained history")+'</div>';
+  html+='<div class="grid cols-2" style="margin-top:16px">';
+  const activity=recentRuns.map(run=>'<tr class="clickable" data-go="/runs/'+attr(run.id)+'"><td><span class="primary-cell">'+esc(run.agent)+'</span><span class="secondary">'+esc(short(run.id))+'</span></td><td>'+status(run.status)+'</td><td>'+esc(explainRun(run))+'</td><td>'+esc(fmtDate(run.createdAt))+'</td></tr>').join("");
+  html+=card("Recent runs",'<div class="table-wrap"><table class="table"><thead><tr><th>Agent</th><th>Status</th><th>Why it ran</th><th>Started</th></tr></thead><tbody>'+activity+'</tbody></table></div>'+(activity?"":empty("No runs yet","Start a run to see its progress and trace here.")),count(state.runs.length,"run"),"span-2");
+  const map=definitions.slice(0,6).map(def=>{const instances=state.instances.filter(x=>x.definitionId===def.id);return'<tr class="clickable" data-go="/agents/'+attr(def.id)+'"><td><span class="primary-cell">'+esc(def.id)+'</span><span class="secondary">'+esc(def.description)+'</span></td><td>'+instances.length+'</td><td>'+esc((def.workingEnvironment?"Working environment · ":"")+(def.repl?def.repl+" REPL":"No REPL"))+'</td></tr>'}).join("");
+  html+=card("Agent map",'<div class="table-wrap"><table class="table"><thead><tr><th>Definition</th><th>Instances</th><th>Mounted surface</th></tr></thead><tbody>'+map+'</tbody></table></div>',count(definitions.length,"definition"));
+  const automationCount=state.activations.length+state.subscriptions.length+state.connections.length;
+  html+=card("Background activity",'<div class="card-body">'+(automationCount?'<div class="summary-box"><dl><dt>Scheduled wake-ups</dt><dd>'+state.activations.length+'</dd><dt>Playbook listeners</dt><dd>'+state.subscriptions.length+'</dd><dt>Inbound connections</dt><dd>'+state.connections.length+'</dd></dl><p><a class="link inline-icon" href="/automations" data-link>Inspect automation state '+icon("external")+'</a></p></div>':empty("Nothing is listening yet","Schedules, sleeping runs, playbooks, and app connections appear here."))+'</div>');
+  html+='</div>';$("content").innerHTML=html;document.querySelectorAll("[data-new-run]").forEach(x=>x.onclick=openRunDrawer);dataLinks();
+}
+
+function renderAgents(){
+  crumbs([{label:"Agents"}]);const definitions=state.manifest?.agents?.agents||[];
+  let html=pageHead("Code and runtime","Agents","A definition is the code-discovered recipe. An instance is persisted runtime data with its own context, apps, playbooks, and conversations.",'<button class="button primary" data-new-run>Start a run</button>');
+  html+='<div class="callout"><span class="symbol">'+icon("definitions")+'</span><div><b>Definitions and instances are intentionally separate.</b><p>Editing a file changes what can be assembled. Updating an instance changes what one runtime identity actually has installed.</p></div></div>';
+  html+='<div class="definition-grid">'+definitions.map(def=>{const instances=state.instances.filter(x=>x.definitionId===def.id);const features=[def.workingEnvironment?"VFS":null,def.repl?def.repl+" repl":null,def.mesh?"mesh":null].filter(Boolean);return'<a class="definition-card" href="/agents/'+attr(def.id)+'" data-link><span class="definition-icon">'+icon("agent")+'</span><span class="definition-open">'+icon("external")+'</span><h3>'+esc(def.id)+'</h3><p>'+esc(def.description)+'</p><div>'+tags(features)+'</div><div class="definition-meta"><b>'+count(instances.length,"instance")+'</b><span class="muted mono" style="font-size:9px">'+esc(def.file)+'</span></div></a>'}).join("")+'</div>';
+  const rows=recent(state.instances).map(instance=>'<tr class="clickable" data-go="/instances/'+attr(instance.id)+'"><td><span class="primary-cell">'+esc(short(instance.id))+'</span><span class="secondary">'+esc(instance.workspaceId)+'</span></td><td><a class="link" href="/agents/'+attr(instance.definitionId)+'" data-link>'+esc(instance.definitionId)+'</a></td><td>'+instance.installations.length+'</td><td>'+instance.playbooks.length+'</td><td>'+esc(fmtDate(instance.updatedAt))+'</td></tr>').join("");
+  html+=card("Runtime instances",'<div class="table-wrap"><table class="table"><thead><tr><th>Instance</th><th>Definition</th><th>Installed</th><th>Playbooks</th><th>Updated</th></tr></thead><tbody>'+rows+'</tbody></table></div>'+(rows?"":empty("No runtime instances","Start a run or create an instance from a definition.")),count(state.instances.length,"instance"));
+  $("content").innerHTML=html;document.querySelectorAll("[data-new-run]").forEach(x=>x.onclick=openRunDrawer);dataLinks();
+}
+
+function renderDefinition(id){
+  const def=definition(id);if(!def)return renderNotFound("Agent definition");
+  crumbs([{label:"Agents",href:"/agents"},{label:id}]);
+  const instances=state.instances.filter(x=>x.definitionId===id);const caps=state.manifest?.definitions?.[id]?.capabilities||{tools:[],applications:[],mcp:[],memory:[]};const surfaces=state.manifest?.definitions?.[id]?.surfaces||{layers:[],subscribers:[]};
+  let html=pageHead("Agent definition",id,def.description,'<button class="button" data-create-instance="'+attr(id)+'">Create instance</button><button class="button primary" data-new-run="'+attr(id)+'">Start a run</button>');
+  html+='<div class="detail-strip"><div><label>File route</label><strong class="mono">'+esc(def.file)+'</strong></div><div><label>Assembly</label><strong>'+esc(def.assembly)+" · "+esc(def.handler)+' handler</strong></div><div><label>Runtime surfaces</label><strong>'+(def.workingEnvironment?"Working environment":"No working environment")+(def.repl?" · "+esc(def.repl)+" REPL":"")+'</strong></div><div><label>Lazy fields</label><strong>'+esc(def.lazy.length?def.lazy.join(", "):"None")+'</strong></div></div>';
+  const rows=instances.map(x=>'<tr class="clickable" data-go="/instances/'+attr(x.id)+'"><td><span class="primary-cell">'+esc(short(x.id))+'</span><span class="secondary">'+esc(x.workspaceId)+'</span></td><td>'+x.installations.length+'</td><td>'+x.playbooks.length+'</td><td>'+esc(fmtDate(x.updatedAt))+'</td></tr>').join("");
+  html+=card("Runtime instances",'<div class="table-wrap"><table class="table"><thead><tr><th>Instance</th><th>Installed</th><th>Playbooks</th><th>Updated</th></tr></thead><tbody>'+rows+'</tbody></table></div>'+(rows?"":empty("No instance exists","Create one now or let a playbook provision one when an inbound event matches.")),count(instances.length,"instance"));
+  html+='<div class="grid cols-2">';
+  const groups=[["Shared tools",caps.tools],["Applications",caps.applications],["MCP",caps.mcp],["Memory",caps.memory]];
+  html+=card("Capability catalogue",'<div class="card-body">'+groups.map(group=>'<div style="margin-bottom:14px"><span class="secondary">'+esc(group[0])+'</span><div class="cap-list">'+(group[1].length?group[1].map(x=>'<span class="cap">'+esc(x.id)+'</span>').join(""):'<span class="muted" style="font-size:11px">None discovered</span>')+'</div></div>').join("")+'</div>',"Available to instances");
+  html+=card("Native composition",'<div class="card-body"><div class="summary-box"><dl><dt>Layers</dt><dd>'+esc((surfaces.layers||[]).map(x=>x.id).join(", ")||"None")+'</dd><dt>Subscribers</dt><dd>'+esc((surfaces.subscribers||[]).map(x=>x.id).join(", ")||"None")+'</dd><dt>Calls</dt><dd>'+esc(def.calls.join(", ")||"None")+'</dd><dt>Subagents</dt><dd>'+esc(def.subagents.join(", ")||"None")+'</dd><dt>Schedules</dt><dd>'+esc(def.schedules.join(", ")||"None")+'</dd><dt>Playbooks</dt><dd>'+esc(def.playbooks.join(", ")||"None")+'</dd></dl></div></div>',"Code-defined");
+  html+='</div>';$("content").innerHTML=html;document.querySelectorAll("[data-new-run]").forEach(x=>x.onclick=()=>openRunDrawer(id));document.querySelectorAll("[data-create-instance]").forEach(x=>x.onclick=()=>void createInstance(id));dataLinks();
+}
+
+async function ensureConversations(agentId){if(!state.conversations[agentId])state.conversations[agentId]=await api("/api/conversations?agent="+encodeURIComponent(agentId))}
+function renderInstance(id){
+  const instance=state.instances.find(x=>x.id===id);if(!instance)return renderNotFound("Agent instance");
+  crumbs([{label:"Agents",href:"/agents"},{label:instance.definitionId,href:"/agents/"+instance.definitionId},{label:short(id)}]);
+  const conversations=state.conversations[id]||[];const runs=recent(state.runs.filter(x=>x.agentId===id));
+  let html=pageHead("Runtime instance",short(id),"Persisted runtime data assembled from "+instance.definitionId+". This identity can be updated without changing the code definition.",'<button class="button primary" data-instance-run>Send message</button>');
+  html+='<div class="detail-strip"><div><label>Definition</label><strong><a class="link" href="/agents/'+attr(instance.definitionId)+'" data-link>'+esc(instance.definitionId)+'</a></strong></div><div><label>Workspace</label><strong><a class="link mono" href="/workspaces/'+attr(instance.workspaceId)+'" data-link>'+esc(instance.workspaceId)+'</a></strong></div><div><label>Conversations</label><strong>'+conversations.length+'</strong></div><div><label>Last updated</label><strong>'+esc(fmtDate(instance.updatedAt))+'</strong></div></div>';
+  html+='<div class="grid cols-2">';
+  const convRows=recent(conversations).map(c=>'<tr><td><span class="primary-cell">'+esc(c.title||"Untitled conversation")+'</span><span class="secondary">'+esc(short(c.id))+'</span></td><td>'+esc(fmtDate(c.updatedAt))+'</td></tr>').join("");
+  html+=card("Conversations",'<div class="table-wrap"><table class="table"><thead><tr><th>Conversation</th><th>Updated</th></tr></thead><tbody>'+convRows+'</tbody></table></div>'+(convRows?"":empty("No conversations","The first message creates a conversation for this instance.")),count(conversations.length,"conversation"));
+  const runRows=runs.slice(0,8).map(run=>'<tr class="clickable" data-go="/runs/'+attr(run.id)+'"><td><span class="primary-cell">'+esc(short(run.id))+'</span><span class="secondary">'+esc(explainRun(run))+'</span></td><td>'+status(run.status)+'</td><td>'+esc(fmtDate(run.createdAt))+'</td></tr>').join("");
+  html+=card("Recent runs",'<div class="table-wrap"><table class="table"><thead><tr><th>Run</th><th>Status</th><th>Started</th></tr></thead><tbody>'+runRows+'</tbody></table></div>'+(runRows?"":empty("No runs","Send this instance a message to begin.")),count(runs.length,"run"));
+  html+=card("Installed capabilities",'<div class="card-body">'+(instance.installations.length?instance.installations.map(x=>'<div class="cap">'+esc(x.kind)+" · "+esc(x.id)+(x.accountId?" · account "+esc(x.accountId):"")+'</div>').join(""):empty("Nothing installed","Applications, MCP servers, and shared tools are instance data."))+'</div>',count(instance.installations.length,"installation"));
+  html+=card("Playbooks and context",'<div class="card-body"><div class="summary-box"><dl><dt>Playbooks</dt><dd>'+esc(instance.playbooks.map(x=>x.name||x.id).join(", ")||"None")+'</dd><dt>Context keys</dt><dd>'+esc(Object.keys(instance.context||{}).join(", ")||"None")+'</dd><dt>Provisioning key</dt><dd class="mono">'+esc(instance.provisioningKey||"Directly provisioned")+'</dd></dl></div><details><summary class="link">View stored instance data</summary><pre class="json">'+esc(jsonText(instance))+'</pre></details></div>',"Persisted data");
+  html+='</div>';$("content").innerHTML=html;document.querySelector("[data-instance-run]").onclick=()=>openRunDrawer(instance.definitionId,id);dataLinks();
+}
+
+function renderRuns(){
+  crumbs([{label:"Runs"}]);let runs=recent(state.runs);if(state.filters.runs!=="all")runs=runs.filter(x=>x.status===state.filters.runs);
+  let html=pageHead("Execution history","Runs","Each invocation has one status, one result, and a chronological trace. Open a run to follow assembly, model work, tools, and completion.",'<button class="button primary" data-new-run>Start a run</button>');
+  html+='<div class="filters"><input id="run-search" placeholder="Search agent, run id, or input…"><select id="run-filter"><option value="all">All statuses</option><option value="running">Running</option><option value="completed">Completed</option><option value="failed">Failed</option><option value="cancelled">Cancelled</option></select></div>';
+  const rows=runs.map(run=>'<tr class="clickable run-search-row" data-search="'+attr((run.agent+" "+run.id+" "+jsonText(run.input)).toLowerCase())+'" data-go="/runs/'+attr(run.id)+'"><td><span class="primary-cell">'+esc(run.agent)+'</span><span class="secondary">'+esc(short(run.id))+'</span></td><td>'+status(run.status)+'</td><td>'+esc(run.input?.source?.kind||"direct")+'</td><td>'+run.attempts+" / "+run.maxAttempts+'</td><td>'+esc(fmtDate(run.createdAt))+'</td></tr>').join("");
+  html+=card("All runs",'<div class="table-wrap"><table class="table"><thead><tr><th>Agent / run</th><th>Status</th><th>Source</th><th>Attempts</th><th>Started</th></tr></thead><tbody>'+rows+'</tbody></table></div>'+(rows?"":empty("No matching runs","Change the filter or start a new run.")),count(runs.length,"run"));
+  $("content").innerHTML=html;$("run-filter").value=state.filters.runs;$("run-filter").onchange=e=>{state.filters.runs=e.target.value;renderRuns()};$("run-search").oninput=e=>{const term=e.target.value.toLowerCase();document.querySelectorAll(".run-search-row").forEach(row=>row.classList.toggle("hidden",!row.dataset.search.includes(term)))};document.querySelector("[data-new-run]").onclick=openRunDrawer;dataLinks();
+}
+
+function phaseData(run,events){
+  const has=pattern=>events.some(e=>pattern.test(e.type));const time=pattern=>events.find(e=>pattern.test(e.type))?.timestamp;
+  return[
+    {name:"Accepted",detail:"The runtime recorded the invocation and its source.",state:"complete",time:run.createdAt},
+    {name:"Assembled",detail:"Foundry resolved context-dependent tools, memory, apps, layers, and working surfaces.",state:has(/assembly.*complete|agent\.started|run\.started/)?"complete":run.status==="failed"?"error":"active",time:time(/assembly.*complete|run\.started/)},
+    {name:"Agent work",detail:has(/tool_/)?"The model used one or more mounted tools.":"The model processed the request with its assembled context.",state:run.status==="running"?"active":run.status==="failed"?"error":"complete",time:time(/model_|text_delta|tool_/)},
+    {name:run.status==="failed"?"Failed":run.status==="cancelled"?"Cancelled":run.status==="completed"?"Completed":"In progress",detail:explainRun(run),state:run.status==="failed"||run.status==="cancelled"?"error":run.status==="completed"?"complete":"active",time:run.completedAt||time(/run\.(completed|failed|cancelled)/)}
+  ];
+}
+function renderRun(id){
+  const run=state.runs.find(x=>x.id===id);if(!run)return renderNotFound("Run");const events=eventsFor(id);
+  const visibleEvents=state.showAllEvents?events:events.filter(isKeyRunEvent);
+  crumbs([{label:"Runs",href:"/runs"},{label:short(id)}]);
+  let html=pageHead("Run detail",run.agent+" · "+short(id),"Follow the high-level phases first. Expand individual events only when you need raw adapter or model evidence.",run.status==="running"||run.status==="pending"?'<button class="button" data-cancel>Cancel run</button>':"");
+  html+='<div class="detail-strip"><div><label>Status</label><strong>'+status(run.status)+'</strong></div><div><label>Source</label><strong>'+esc(run.input?.source?.kind||"direct")+'</strong></div><div><label>Agent instance</label><strong>'+(run.agentId?'<a class="link mono" href="/instances/'+attr(run.agentId)+'" data-link>'+esc(short(run.agentId))+'</a>':"Not recorded")+'</strong></div><div><label>Attempts</label><strong>'+run.attempts+" of "+run.maxAttempts+'</strong></div></div>';
+  html+='<div class="grid cols-3"><section class="card span-2"><div class="card-head"><h2>Run spine</h2><span class="meta">'+count(events.length,"event")+'</span></div><div class="card-body"><div class="trace-note">This shows observable work intent and outcomes. It does not expose private hidden chain-of-thought.</div><div class="run-spine">'+phaseData(run,events).map(p=>'<div class="phase '+p.state+'"><span class="phase-dot"></span><div><strong>'+esc(p.name)+'</strong><p>'+esc(p.detail)+'</p></div><time>'+esc(fmtTime(p.time))+'</time></div>').join("")+'</div></div></section>';
+  html+=card("Result",'<div class="card-body"><div class="summary-box"><dl><dt>Created</dt><dd>'+esc(fmtDate(run.createdAt))+'</dd><dt>Started</dt><dd>'+esc(fmtDate(run.startedAt))+'</dd><dt>Finished</dt><dd>'+esc(fmtDate(run.completedAt))+'</dd><dt>Timeout</dt><dd>'+Math.round(run.timeoutMs/1000)+' seconds</dd></dl></div><details open><summary class="link">Output</summary><pre class="json">'+esc(jsonText(run.output??run.error??null))+'</pre></details><details><summary class="link">Input</summary><pre class="json">'+esc(jsonText(run.input))+'</pre></details></div>',"Recorded outcome");html+='</div>';
+  const eventRows=visibleEvents.map(event=>'<div class="event-row"><button class="event-toggle"><span class="event-time">'+esc(fmtTime(event.timestamp))+'</span><span class="event-category">'+esc(event.category)+'</span><span class="event-type">'+esc(event.type)+'</span><span>⌄</span></button><div class="event-detail"><pre class="json">'+esc(jsonText(event.data))+'</pre></div></div>').join("");
+  const eventControl='<div class="card-body" style="display:flex;align-items:center;gap:12px;padding-top:11px;padding-bottom:11px"><span class="muted" style="font-size:11px">'+(state.showAllEvents?"Showing every retained event, including assembly and process detail.":"Showing the lifecycle events that explain this run. Expand one for raw evidence.")+'</span><button class="button" style="margin-left:auto" data-toggle-events>'+(state.showAllEvents?"Show key events":"Show all "+events.length+" events")+'</button></div>';
+  html+=card("Observable event trace",eventControl+(eventRows||empty("No key events retained","Show all events to inspect runtime logs.")),count(visibleEvents.length,"event"));
+  $("content").innerHTML=html;document.querySelectorAll(".event-toggle").forEach(x=>x.onclick=()=>x.parentElement.classList.toggle("open"));document.querySelector("[data-toggle-events]").onclick=()=>{state.showAllEvents=!state.showAllEvents;renderRun(id)};const cancel=document.querySelector("[data-cancel]");if(cancel)cancel.onclick=()=>void cancelRun(id);dataLinks();
+}
+
+function renderAutomations(){
+  crumbs([{label:"Automations"}]);let html=pageHead("Background work","Automations","Schedules and sleeps create future activations. Playbook subscriptions listen for inbound transmissions and can provision one or many agent instances.","");
+  html+='<div class="grid cols-3">'+metric("Scheduled activations",state.activations.length,"Future triggers and sleeping runs",true)+metric("Playbook subscriptions",state.subscriptions.length,"Inbound event policies")+metric("Application connections",state.connections.length,"Long-lived inbound workers")+'</div>';
+  const actRows=recent(state.activations).map(x=>'<tr><td><span class="primary-cell">'+esc(x.kind==="sleep"?"Sleeping run":x.scheduleName||"Scheduled activation")+'</span><span class="secondary">'+esc(short(x.id))+'</span></td><td><a class="link" href="/instances/'+attr(x.agentId)+'" data-link>'+esc(short(x.agentId))+'</a></td><td>'+status(x.status)+'</td><td>'+esc(x.timing?.at||x.timing?.cron||x.timing?.everyMs||"Configured timing")+'</td><td>'+esc(x.origin)+'</td></tr>').join("");
+  html+=card("Schedules and sleeps",'<div class="table-wrap"><table class="table"><thead><tr><th>Activation</th><th>Agent</th><th>Status</th><th>Timing</th><th>Origin</th></tr></thead><tbody>'+actRows+'</tbody></table></div>'+(actRows?"":empty("No future activations","Agents create schedules and sleeps through Foundry utility tools.")),count(state.activations.length,"activation"));
+  const subRows=state.subscriptions.map(x=>'<tr><td><span class="primary-cell">'+esc(x.playbook?.name||x.playbook?.id||x.id)+'</span><span class="secondary">'+esc(short(x.id))+'</span></td><td>'+status(x.enabled?"enabled":"disabled")+'</td><td>'+esc(x.targets.map(t=>t.definitionId+" · "+t.provisioning.mode).join(", "))+'</td><td>'+esc(x.workspaceId)+'</td></tr>').join("");
+  html+=card("Playbook listeners",'<div class="table-wrap"><table class="table"><thead><tr><th>Playbook</th><th>State</th><th>Targets / provisioning</th><th>Workspace</th></tr></thead><tbody>'+subRows+'</tbody></table></div>'+(subRows?"":empty("No playbook subscriptions","Runtime-defined subscriptions appear when a frontend or adapter installs them.")),count(state.subscriptions.length,"subscription"));
+  const connRows=state.connections.map(x=>'<tr><td><span class="primary-cell">'+esc(x.applicationId)+'</span><span class="secondary">'+esc(x.connectionId)+'</span></td><td>'+status(x.status)+'</td><td>'+esc(x.definitionId)+'</td><td>'+x.routeIds.length+'</td><td>'+esc(fmtDate(x.lastEventAt))+'</td></tr>').join("");
+  html+=card("Inbound application workers",'<div class="table-wrap"><table class="table"><thead><tr><th>Application / connection</th><th>Status</th><th>Definition</th><th>Routes</th><th>Last event</th></tr></thead><tbody>'+connRows+'</tbody></table></div>'+(connRows?"":empty("No inbound workers","A connection starts only when an installed app has an active inbound playbook.")),count(state.connections.length,"connection"));
+  $("content").innerHTML=html;dataLinks();
+}
+
+function renderIntegrations(){
+  crumbs([{label:"Integrations"}]);let html=pageHead("External boundaries","Integrations","Inspect application transmissions and the runtime data that binds accounts, routes, and agent instances. Credential acquisition and refresh remain adapter-owned.","");
+  html+='<div class="callout"><span class="symbol">'+icon("secure")+'</span><div><b>Foundry stores references, never credential material.</b><p>Accounts expose safe metadata and opaque adapter ownership. Routes and bindings determine what an instance can receive and send.</p></div></div>';
+  const txRows=state.transmissions.map(x=>'<tr><td><span class="primary-cell">'+esc(x.name)+'</span><span class="secondary">'+esc(x.id)+'</span></td><td><span class="tag">'+esc(x.shape)+'</span></td><td>'+x.capabilities.length+'</td><td>'+esc(x.description)+'</td></tr>').join("");
+  html+=card("Transmission catalogue",'<div class="table-wrap"><table class="table"><thead><tr><th>Transmission</th><th>Shape</th><th>Capabilities</th><th>Purpose</th></tr></thead><tbody>'+txRows+'</tbody></table></div>'+(txRows?"":empty("No transmissions discovered","Install an agent-local application definition to add inbound or outbound behavior.")),count(state.transmissions.length,"transmission"));
+  html+='<div class="grid cols-3">';
+  html+=card("Accounts",'<div class="card-body">'+(state.accounts.length?state.accounts.map(x=>'<div class="kv-item"><strong>'+esc(x.label||x.externalAccountId)+'</strong><small>'+esc(x.transmissionId)+" · "+esc(short(x.id))+'</small></div>').join(""):empty("No accounts","Account references are supplied by the application adapter."))+'</div>',count(state.accounts.length,"account"));
+  html+=card("Routes",'<div class="card-body">'+(state.routes.length?state.routes.map(x=>'<div class="kv-item"><strong>'+esc(x.id)+'</strong><small>'+esc(x.direction)+" · "+esc(x.transmissionId)+'</small><div>'+status(x.enabled?"enabled":"disabled")+'</div></div>').join(""):empty("No routes","Routes are runtime data for transmission paths."))+'</div>',count(state.routes.length,"route"));
+  html+=card("Agent bindings",'<div class="card-body">'+(state.bindings.length?state.bindings.map(x=>'<div class="kv-item"><strong>'+esc(short(x.agentId))+'</strong><small>'+esc(x.transmissionId)+" · "+x.capabilities.length+' capabilities</small><div>'+status(x.enabled?"enabled":"disabled")+'</div></div>').join(""):empty("No bindings","Bindings grant an instance access to routes and capabilities."))+'</div>',count(state.bindings.length,"binding"));
+  html+='</div>';$("content").innerHTML=html;dataLinks();
+}
+
+async function ensureWorkspace(id){if(!id)return;const values=await Promise.all(["entries","inbox","tasks","environment"].map(surface=>api("/api/workspaces/"+encodeURIComponent(id)+"/"+surface)));state.workspaces[id]={entries:values[0],inbox:values[1],tasks:values[2],environment:values[3]}}
+function renderWorkspaces(id){
+  const ids=workspaceIds();if(!id&&ids.length){go("/workspaces/"+encodeURIComponent(ids[0]));return}
+  crumbs(id?[{label:"Workspaces",href:"/workspaces"},{label:id}]:[{label:"Workspaces"}]);
+  if(!id){$("content").innerHTML=pageHead("Shared data","Workspaces","Workspaces hold shared entries, an inbox, tasks, and safe environment values across agent instances.","")+empty("No workspaces yet","Create an agent instance with a workspace id to begin.");return}
+  const data=state.workspaces[id]||{entries:[],inbox:[],tasks:[],environment:[]};const localInstances=state.instances.filter(x=>x.workspaceId===id);
+  let html=pageHead("Shared data","Workspace · "+id,"Inspect collaboration state shared by this workspace. Secret environment values are intentionally never exposed.",'<select class="button" id="workspace-select">'+ids.map(x=>'<option value="'+attr(x)+'" '+(x===id?"selected":"")+'>'+esc(x)+'</option>').join("")+'</select>');
+  html+='<div class="grid cols-4">'+metric("Agent instances",localInstances.length,"Runtime identities in this workspace",true)+metric("Shared entries",data.entries.length,"Documents and structured values")+metric("Inbox items",data.inbox.length,"Cross-agent and external handoffs")+metric("Open tasks",data.tasks.filter(x=>x.status==="open"||x.status==="in-progress").length,"Work still requiring action")+'</div>';
+  html+='<div class="workspace-tabs"><button data-tab="entries">Entries</button><button data-tab="inbox">Inbox</button><button data-tab="tasks">Tasks</button><button data-tab="environment">Environment</button></div><div id="workspace-panel"></div>';
+  $("content").innerHTML=html;$("workspace-select").onchange=e=>go("/workspaces/"+encodeURIComponent(e.target.value));document.querySelectorAll("[data-tab]").forEach(x=>x.onclick=()=>{state.workspaceTab=x.dataset.tab;renderWorkspacePanel(data)});renderWorkspacePanel(data);dataLinks();
+}
+function renderWorkspacePanel(data){
+  document.querySelectorAll("[data-tab]").forEach(x=>x.classList.toggle("active",x.dataset.tab===state.workspaceTab));const values=data[state.workspaceTab]||[];let body="";
+  if(state.workspaceTab==="entries")body=values.length?'<div class="kv">'+values.map(x=>'<div class="kv-item"><strong>'+esc(x.key)+'</strong><small>Updated '+esc(fmtDate(x.updatedAt))+'</small><div class="kv-value">'+esc(typeof x.value==="string"?x.value:jsonText(x.value))+'</div></div>').join("")+'</div>':empty("No shared entries","Agents can place documents and structured data into this workspace.");
+  if(state.workspaceTab==="inbox")body=values.length?'<div class="table-wrap"><table class="table"><thead><tr><th>Topic</th><th>Agent</th><th>Status</th><th>Updated</th></tr></thead><tbody>'+recent(values).map(x=>'<tr><td><span class="primary-cell">'+esc(x.topic)+'</span><span class="secondary">'+esc(short(x.id))+'</span></td><td>'+esc(short(x.agentId||"shared"))+'</td><td>'+status(x.status)+'</td><td>'+esc(fmtDate(x.updatedAt))+'</td></tr>').join("")+'</tbody></table></div>':empty("Inbox is clear","Shared handoffs and external requests will appear here.");
+  if(state.workspaceTab==="tasks")body=values.length?'<div class="table-wrap"><table class="table"><thead><tr><th>Task</th><th>Owner</th><th>Status</th><th>Updated</th></tr></thead><tbody>'+recent(values).map(x=>'<tr><td><span class="primary-cell">'+esc(x.title)+'</span><span class="secondary">'+esc(x.detail||short(x.id))+'</span></td><td>'+esc(short(x.agentId||"workspace"))+'</td><td>'+status(x.status)+'</td><td>'+esc(fmtDate(x.updatedAt))+'</td></tr>').join("")+'</tbody></table></div>':empty("No tasks","Agents can create shared tasks for work that spans conversations.");
+  if(state.workspaceTab==="environment")body='<div class="callout"><span class="symbol">'+icon("secure")+'</span><div><b>Only safe values are visible.</b><p>Credential material remains inside user-owned adapters and is never returned by this endpoint.</p></div></div>'+(values.length?'<div class="kv">'+values.map(x=>'<div class="kv-item"><strong>'+esc(x.key)+'</strong><small>'+esc(x.scope)+'</small><div class="kv-value">'+esc(typeof x.value==="string"?x.value:jsonText(x.value))+'</div></div>').join("")+'</div>':empty("No public environment values","Mount an environment adapter to expose non-secret context."));
+  $("workspace-panel").innerHTML=card(state.workspaceTab[0].toUpperCase()+state.workspaceTab.slice(1),'<div class="card-body">'+body+'</div>',count(values.length,"item"));
+}
+
+function renderNotFound(label){crumbs([{label:"Not found"}]);$("content").innerHTML=pageHead("Inspector",label+" not found","The requested runtime record does not exist or is no longer retained.",'<a class="button" href="/" data-link>Return to overview</a>');dataLinks()}
+async function loadBase(){
+  const endpoints=["/api/manifest","/api/agent-instances","/api/playbook-subscriptions","/api/application-connections","/api/runs","/api/events","/health","/api/transmissions","/api/accounts","/api/routes","/api/bindings","/api/activations"];
+  const results=await Promise.all(endpoints.map(url=>api(url)));[state.manifest,state.instances,state.subscriptions,state.connections,state.runs,state.events,state.health,state.transmissions,state.accounts,state.routes,state.bindings,state.activations]=results;renderHealth();
+}
+async function refreshActivity(){
+  try{const endpoints=["/api/agent-instances","/api/playbook-subscriptions","/api/application-connections","/api/runs","/api/events","/api/activations","/health"];const values=await Promise.all(endpoints.map(url=>api(url)));[state.instances,state.subscriptions,state.connections,state.runs,state.events,state.activations,state.health]=values;renderHealth();await navigate(false)}catch{$("event-state").textContent="Refresh paused"}
+}
+function renderHealth(){const ok=Boolean(state.health?.ok);$("runtime-state").classList.toggle("bad",!ok);$("runtime-state").querySelector("span").textContent=ok?"Runtime healthy":"Runtime needs attention"}
+async function navigate(load=true){
+  const current=route();navState(current.section);
+  try{
+    if(load&&current.section==="instances"&&current.id)await ensureConversations(current.id);
+    if(load&&current.section==="workspaces"&&current.id)await ensureWorkspace(current.id);
+    if(current.section==="overview")renderOverview();else if(current.section==="agents"&&!current.id)renderAgents();else if(current.section==="agents")renderDefinition(current.id);else if(current.section==="instances")renderInstance(current.id);else if(current.section==="runs"&&!current.id)renderRuns();else if(current.section==="runs")renderRun(current.id);else if(current.section==="automations")renderAutomations();else if(current.section==="integrations")renderIntegrations();else if(current.section==="workspaces")renderWorkspaces(current.id);else renderNotFound("Page");
+  }catch(error){$("content").innerHTML='<div class="form-error">'+esc(error.message)+'</div>';console.error(error)}
+}
+
+function openRunDrawer(definitionId,instanceId){
+  const definitions=state.manifest?.agents?.agents||[];$("run-definition").innerHTML=definitions.map(x=>'<option value="'+attr(x.id)+'">'+esc(x.id)+'</option>').join("");
+  if(typeof definitionId==="string"&&definition(definitionId))$("run-definition").value=definitionId;updateInstanceOptions(instanceId);$("run-message").value="";$("run-form-error").classList.add("hidden");$("drawer").classList.add("open");setTimeout(()=>$("run-message").focus(),20);
+}
+function closeRunDrawer(){$("drawer").classList.remove("open")}
+function updateInstanceOptions(selected){const definitionId=$("run-definition").value;const instances=state.instances.filter(x=>x.definitionId===definitionId);$("run-instance").innerHTML='<option value="">Create a new instance</option>'+instances.map(x=>'<option value="'+attr(x.id)+'">'+esc(short(x.id))+" · "+esc(x.workspaceId)+'</option>').join("");if(selected&&instances.some(x=>x.id===selected))$("run-instance").value=selected}
+async function createInstance(definitionId){try{const workspace=workspaceIds()[0]||"foundry-dashboard";const instance=await api("/api/agent-instances",{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({definitionId,workspaceId:workspace})});state.instances=[...state.instances,instance];toast("Instance created");go("/instances/"+encodeURIComponent(instance.id))}catch(error){toast(error.message)}}
+async function startRun(event){
+  event.preventDefault();const errorNode=$("run-form-error");errorNode.classList.add("hidden");
+  try{
+    const definitionId=$("run-definition").value;let instance=state.instances.find(x=>x.id===$("run-instance").value);
+    if(!instance){instance=await api("/api/agent-instances",{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({definitionId,workspaceId:workspaceIds()[0]||"foundry-dashboard"})});state.instances=[...state.instances,instance]}
+    await ensureConversations(instance.id);let conversation=state.conversations[instance.id][0];
+    if(!conversation){conversation=await api("/api/conversations",{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({agentId:instance.id,title:"Foundry inspector"})});state.conversations[instance.id]=[conversation]}
+    const run=await api("/api/conversations/"+encodeURIComponent(conversation.id)+"/messages",{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({agentId:instance.id,message:$("run-message").value})});state.runs=[...state.runs,run];closeRunDrawer();toast("Run accepted");go("/runs/"+encodeURIComponent(run.id));
+  }catch(error){errorNode.textContent=error.message;errorNode.classList.remove("hidden")}
+}
+async function cancelRun(id){try{await api("/api/runs/"+encodeURIComponent(id)+"/cancel",{method:"POST"});toast("Cancellation requested");await refreshActivity()}catch(error){toast(error.message)}}
+
+function searchItems(){
+  const items=[{label:"Overview",detail:"Runtime health and recent activity",path:"/"},{label:"Agents",detail:"Definitions and runtime instances",path:"/agents"},{label:"Runs",detail:"Execution history and traces",path:"/runs"},{label:"Automations",detail:"Schedules, sleeps, playbooks, and connections",path:"/automations"},{label:"Integrations",detail:"Transmissions, routes, accounts, and bindings",path:"/integrations"},{label:"Workspaces",detail:"Shared entries, inbox, tasks, and environment",path:"/workspaces"}];
+  (state.manifest?.agents?.agents||[]).forEach(x=>items.push({label:x.id,detail:"Agent definition · "+x.description,path:"/agents/"+x.id}));state.instances.forEach(x=>items.push({label:short(x.id),detail:"Agent instance · "+x.definitionId,path:"/instances/"+x.id}));recent(state.runs).slice(0,100).forEach(x=>items.push({label:short(x.id),detail:"Run · "+x.agent+" · "+x.status,path:"/runs/"+x.id}));return items;
+}
+function renderSearch(){const term=$("search-input").value.trim().toLowerCase();const matches=searchItems().filter(x=>!term||(x.label+" "+x.detail).toLowerCase().includes(term)).slice(0,12);$("search-results").innerHTML=matches.map(x=>'<a class="search-result" href="'+attr(x.path)+'" data-search-link><strong>'+esc(x.label)+'</strong><small>'+esc(x.detail)+'</small></a>').join("")||empty("No matches","Try an agent id, instance id, run id, or page name.");document.querySelectorAll("[data-search-link]").forEach(x=>x.onclick=e=>{e.preventDefault();closeSearch();go(x.getAttribute("href"))})}
+function openSearch(){$("search-modal").classList.add("open");$("search-input").value="";renderSearch();setTimeout(()=>$("search-input").focus(),20)}function closeSearch(){$("search-modal").classList.remove("open")}
+
+$("new-run").onclick=()=>openRunDrawer();$("close-drawer").onclick=closeRunDrawer;$("cancel-run").onclick=closeRunDrawer;$("drawer").onclick=e=>{if(e.target===$("drawer"))closeRunDrawer()};$("run-definition").onchange=()=>updateInstanceOptions();$("run-form").onsubmit=startRun;$("open-search").onclick=openSearch;$("search-input").oninput=renderSearch;$("search-modal").onclick=e=>{if(e.target===$("search-modal"))closeSearch()};$("mobile-toggle").onclick=()=>$("sidebar").classList.toggle("open");window.onpopstate=()=>void navigate();document.addEventListener("keydown",e=>{if((e.metaKey||e.ctrlKey)&&e.key.toLowerCase()==="k"){e.preventDefault();openSearch()}if(e.key==="Escape"){closeSearch();closeRunDrawer()}});
+loadBase().then(async()=>{await navigate();const stream=new EventSource("/api/events");stream.onopen=()=>{$("event-state").textContent="Live updates"};stream.onmessage=()=>void refreshActivity();stream.onerror=()=>{$("event-state").textContent="Reconnecting…"};setInterval(()=>void refreshActivity(),10000)}).catch(error=>{$("content").innerHTML='<div class="form-error"><strong>Could not open Foundry.</strong><br>'+esc(error.message)+'</div>';$("runtime-state").classList.add("bad");$("runtime-state").querySelector("span").textContent="Runtime unavailable"});
+`;
+
+// src/dashboard-styles.ts
+var DASHBOARD_STYLES = String.raw`
+@import url('https://fonts.googleapis.com/css2?family=DM+Sans:ital,wght@0,300;0,400;0,500;0,600;1,400&family=JetBrains+Mono:wght@400;500&display=swap');
+:root{
+  --bg:#080B0A;--bg-elevated:#0F1613;--bg-surface:#141D18;--bg-surface-2:#19241F;
+  --border:#243029;--border-subtle:#18211C;--border-strong:#32453B;
+  --text-primary:#E7EEEA;--text-secondary:#93A399;--text-tertiary:#5C6F64;
+  --accent:#9ED4B8;--accent-soft:#7BBFA0;--accent-strong:#BEE7D0;
+  --accent-dim:rgba(158,212,184,.08);--accent-glow:rgba(158,212,184,.045);--accent-line:rgba(158,212,184,.16);
+  --interface:#E4B879;--network:#83B3E2;--deploy:#B8A7E8;--media:#E29BA8;
+  --success:#8CC494;--warn:#E4B879;--danger:#E29BA8;
+  --sans:'DM Sans',-apple-system,BlinkMacSystemFont,sans-serif;--mono:'JetBrains Mono',monospace;
+  --sidebar:248px;--radius:10px;--radius-lg:14px;--shadow:0 24px 64px rgba(0,0,0,.34);
+  font-family:var(--sans);color:var(--text-primary);background:var(--bg);color-scheme:dark;
+}
+*{box-sizing:border-box}html,body{margin:0;min-height:100%;background:var(--bg)}html{scroll-behavior:smooth}body{font-family:var(--sans);color:var(--text-primary);-webkit-font-smoothing:antialiased;overflow-x:hidden}
+body:before{content:"";position:fixed;inset:0 0 auto 0;height:100vh;background:radial-gradient(60% 40% at 55% -5%,rgba(158,212,184,.06),transparent 70%);pointer-events:none;z-index:0}
+button,input,textarea,select{font:inherit;color:inherit}button,a{touch-action:manipulation}button:focus-visible,a:focus-visible,input:focus-visible,textarea:focus-visible,select:focus-visible{outline:2px solid var(--accent-soft);outline-offset:2px;border-radius:5px}
+::selection{background:rgba(158,212,184,.22);color:var(--text-primary)}.mono{font-family:var(--mono)}.muted{color:var(--text-secondary)}.hidden{display:none!important}
+.icon{display:block;width:1em;height:1em;flex:0 0 auto;fill:currentColor}.icon-button{padding:8px;aspect-ratio:1}.icon-button .icon{width:17px;height:17px}
+.app{min-height:100vh;position:relative;z-index:1}.sidebar{position:fixed;inset:0 auto 0 0;width:var(--sidebar);background:rgba(8,11,10,.92);backdrop-filter:blur(20px) saturate(140%);border-right:1px solid var(--border-subtle);z-index:20;display:flex;flex-direction:column}
+.brand{height:72px;display:flex;align-items:center;gap:11px;padding:0 20px;border-bottom:1px solid var(--border-subtle);color:inherit;text-decoration:none}.brand-mark{width:26px;height:26px;color:var(--accent);filter:drop-shadow(0 3px 12px rgba(158,212,184,.2));transition:transform .25s ease}.brand:hover .brand-mark{transform:rotate(-7deg) scale(1.05)}.brand strong{display:block;font-size:14px;font-weight:600;letter-spacing:-.015em}.brand small{display:block;color:var(--text-tertiary);font:9px/1.4 var(--mono);text-transform:uppercase;letter-spacing:.13em;margin-top:3px}
+.nav{padding:20px 12px}.nav-label{padding:0 11px 9px;color:var(--text-tertiary);font:9px var(--mono);text-transform:uppercase;letter-spacing:.15em}.nav a{position:relative;color:var(--text-secondary);text-decoration:none;display:flex;align-items:center;gap:11px;padding:9px 11px;border-radius:7px;margin:2px 0;font-size:13px;transition:color .18s,background .18s}.nav a:hover{background:var(--accent-glow);color:var(--text-primary)}.nav a.active{background:var(--accent-dim);color:var(--accent)}.nav a.active:before{content:"";position:absolute;left:-12px;width:2px;height:22px;background:var(--accent)}.nav-icon{width:18px;height:18px;color:var(--text-tertiary);display:grid;place-items:center}.nav-icon svg{width:17px;height:17px;fill:currentColor}.nav a.active .nav-icon{color:var(--accent)}
+.sidebar-foot{margin-top:auto;padding:18px;border-top:1px solid var(--border-subtle)}.runtime-state{display:flex;align-items:center;gap:9px;font-size:11px;color:var(--text-secondary)}.runtime-state i{width:7px;height:7px;border-radius:50%;background:var(--success);box-shadow:0 0 8px rgba(140,196,148,.55)}.runtime-state.bad i{background:var(--danger)}.shortcut{margin-top:12px;width:100%;border:1px solid var(--border);background:var(--bg-elevated);color:var(--text-secondary);border-radius:7px;padding:8px 10px;text-align:left;font-size:11px;cursor:pointer;display:flex;align-items:center;justify-content:space-between}.shortcut:hover{border-color:var(--border-strong);color:var(--text-primary)}.shortcut-label{display:flex;align-items:center;gap:7px}.shortcut-label .icon{width:14px;height:14px}.shortcut kbd{color:var(--text-tertiary);font:9px var(--mono);border:0;background:transparent;padding:0}
+.main{margin-left:var(--sidebar);min-height:100vh}.topbar{height:72px;background:rgba(8,11,10,.72);backdrop-filter:blur(20px) saturate(140%);border-bottom:1px solid var(--border-subtle);display:flex;align-items:center;padding:0 32px;position:sticky;top:0;z-index:10}.breadcrumbs{display:flex;align-items:center;gap:8px;font:11px var(--mono);color:var(--text-tertiary)}.breadcrumbs a{color:var(--text-tertiary);text-decoration:none}.breadcrumbs a:hover{color:var(--accent)}.crumb-separator{display:grid;place-items:center;color:var(--text-tertiary)}.crumb-separator .icon{width:10px;height:10px}.top-actions{margin-left:auto;display:flex;align-items:center;gap:9px}.live-chip{display:flex;align-items:center;gap:7px;border:1px solid var(--border);background:var(--bg-elevated);padding:8px 10px;border-radius:7px;font:9px var(--mono);text-transform:uppercase;letter-spacing:.07em;color:var(--text-secondary)}.live-chip i{width:6px;height:6px;border-radius:50%;background:var(--success);box-shadow:0 0 8px rgba(140,196,148,.45)}
+.button{border:1px solid var(--border);background:var(--bg-elevated);color:var(--text-secondary);border-radius:7px;padding:9px 13px;font-weight:500;font-size:12px;cursor:pointer;text-decoration:none;display:inline-flex;align-items:center;justify-content:center;gap:7px;transition:border-color .18s,background .18s,color .18s,transform .18s}.button>.icon{width:15px;height:15px}.button:hover{border-color:var(--border-strong);background:var(--bg-surface);color:var(--text-primary)}.button.primary{border-color:var(--accent);background:var(--accent);color:var(--bg);font-weight:600;box-shadow:0 2px 18px rgba(158,212,184,.12)}.button.primary:hover{background:var(--accent-strong);transform:translateY(-1px)}.mobile-toggle{display:none}.content{max-width:1480px;margin:0 auto;padding:36px 36px 72px;position:relative}
+.content:before{content:"";position:absolute;inset:0;z-index:-1;pointer-events:none;background-image:linear-gradient(var(--border-subtle) 1px,transparent 1px),linear-gradient(90deg,var(--border-subtle) 1px,transparent 1px);background-size:56px 56px;mask-image:linear-gradient(to bottom,rgba(0,0,0,.25),transparent 300px);opacity:.34}
+.page-head{display:flex;align-items:flex-end;gap:24px;margin-bottom:28px}.eyebrow{display:flex;align-items:center;gap:8px;font:10px var(--mono);color:var(--accent-soft);text-transform:uppercase;letter-spacing:.14em;margin-bottom:12px}.eyebrow:before{content:"";width:18px;height:1px;background:var(--accent-line)}.page-head h1{font-size:34px;font-weight:400;line-height:1.08;letter-spacing:-.035em;margin:0}.page-head p{margin:9px 0 0;color:var(--text-secondary);max-width:690px;font-size:14px;font-weight:300;line-height:1.6}.page-head .actions{margin-left:auto;display:flex;gap:8px;align-items:center}.page-rule{width:42px;height:2px;background:var(--accent);margin-bottom:16px}
+.grid{display:grid;gap:14px}.cols-4{grid-template-columns:repeat(4,1fr)}.cols-3{grid-template-columns:repeat(3,1fr)}.cols-2{grid-template-columns:repeat(2,1fr)}.span-2{grid-column:span 2}.card{background:rgba(15,22,19,.92);border:1px solid var(--border-subtle);border-radius:var(--radius);min-width:0;margin-bottom:14px;overflow:hidden}.card-head{padding:14px 16px;border-bottom:1px solid var(--border-subtle);display:flex;align-items:center;gap:12px;background:rgba(20,29,24,.3)}.card-head h2{font-size:13px;font-weight:500;margin:0}.card-head .meta{margin-left:auto;color:var(--text-tertiary);font:9px var(--mono)}.card-body{padding:16px}.metric{padding:18px;min-height:124px;margin-bottom:0}.metric label{display:block;color:var(--text-tertiary);font:9px var(--mono);text-transform:uppercase;letter-spacing:.12em}.metric strong{display:block;font-size:30px;font-weight:400;letter-spacing:-.035em;margin-top:15px}.metric small{display:block;color:var(--text-secondary);font-size:11px;font-weight:300;margin-top:6px}.metric.accent{border-top:2px solid var(--accent)}
+.table-wrap{overflow:auto}.table{width:100%;border-collapse:collapse;min-width:650px}.table th{padding:11px 15px;text-align:left;color:var(--text-tertiary);font:9px var(--mono);text-transform:uppercase;letter-spacing:.1em;border-bottom:1px solid var(--border-subtle);white-space:nowrap}.table td{padding:13px 15px;border-bottom:1px solid var(--border-subtle);font-size:12px;vertical-align:top}.table tr:last-child td{border-bottom:0}.table tbody tr.clickable{cursor:pointer}.table tbody tr.clickable:hover{background:var(--accent-glow)}.primary-cell{font-weight:500;color:var(--text-primary)}.secondary{display:block;color:var(--text-tertiary);font:9px/1.55 var(--mono);margin-top:4px;overflow-wrap:anywhere}
+.status{display:inline-flex;align-items:center;gap:6px;border-radius:999px;padding:4px 8px;background:var(--bg-surface-2);color:var(--text-secondary);font:8px var(--mono);text-transform:uppercase;letter-spacing:.06em;white-space:nowrap;border:1px solid var(--border)}.status:before{content:"";width:5px;height:5px;border-radius:50%;background:var(--text-tertiary)}.status.completed,.status.connected,.status.active,.status.enabled,.status.resolved{background:rgba(140,196,148,.08);color:var(--success);border-color:rgba(140,196,148,.18)}.status.completed:before,.status.connected:before,.status.active:before,.status.enabled:before,.status.resolved:before{background:var(--success)}.status.running,.status.pending,.status.connecting,.status.reconnecting,.status.in-progress{background:rgba(131,179,226,.08);color:var(--network);border-color:rgba(131,179,226,.18)}.status.running:before,.status.pending:before,.status.connecting:before,.status.reconnecting:before,.status.in-progress:before{background:var(--network)}.status.failed,.status.cancelled,.status.disconnected,.status.dismissed{background:rgba(226,155,168,.08);color:var(--danger);border-color:rgba(226,155,168,.18)}.status.failed:before,.status.cancelled:before,.status.disconnected:before,.status.dismissed:before{background:var(--danger)}
+.tag{display:inline-block;border:1px solid var(--border);border-radius:4px;padding:3px 6px;font:8px var(--mono);color:var(--text-secondary);margin:2px 4px 2px 0;background:var(--bg-surface)}.link{color:var(--accent);text-decoration:none;font-weight:500}.link:hover{text-decoration:underline;text-decoration-color:var(--accent-line)}.inline-icon{display:inline-flex;align-items:center;gap:5px}.inline-icon .icon{width:12px;height:12px}.empty{padding:38px 22px;text-align:center;color:var(--text-secondary);font-size:12px;line-height:1.6}.empty strong{display:block;color:var(--text-primary);font-size:14px;font-weight:500;margin-bottom:5px}.filters{display:flex;gap:8px;margin-bottom:14px}.filters input,.filters select{background:var(--bg-elevated);border:1px solid var(--border);border-radius:7px;padding:10px 12px;font-size:12px}.filters input{min-width:280px}
+.definition-grid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:14px;margin-bottom:16px}.definition-card{display:block;color:inherit;text-decoration:none;background:var(--bg-elevated);border:1px solid var(--border-subtle);border-radius:var(--radius-lg);padding:19px;min-height:196px;position:relative;overflow:hidden;transition:transform .2s ease,border-color .2s ease,background .2s}.definition-card:before{content:"";position:absolute;inset:0;opacity:0;background:radial-gradient(110% 80% at 100% 0%,var(--accent-dim),transparent 60%);transition:opacity .2s}.definition-card:hover{transform:translateY(-2px);border-color:var(--accent-line);background:var(--bg-surface)}.definition-card:hover:before{opacity:1}.definition-icon{width:31px;height:31px;display:grid;place-items:center;border:1px solid var(--accent-line);border-radius:8px;color:var(--accent);background:var(--accent-dim);margin-bottom:15px;position:relative}.definition-icon .icon{width:17px;height:17px}.definition-open{position:absolute;right:17px;top:17px;color:var(--text-tertiary);transition:color .18s,transform .18s}.definition-open .icon{width:14px;height:14px}.definition-card:hover .definition-open{color:var(--accent);transform:translate(1px,-1px)}.definition-card h3{margin:0;font-size:17px;font-weight:500;position:relative}.definition-card p{color:var(--text-secondary);font-size:12px;font-weight:300;line-height:1.6;margin:9px 0 18px;position:relative}.definition-meta{position:absolute;left:19px;right:19px;bottom:17px;display:flex;justify-content:space-between;align-items:end}.definition-meta b{font:9px var(--mono);color:var(--accent-soft)}
+.cap-list{display:flex;flex-wrap:wrap;gap:6px}.cap{border:1px solid var(--border);background:var(--bg-surface);border-radius:5px;padding:7px 9px;font:9px var(--mono);margin-bottom:6px;color:var(--text-secondary)}.detail-strip{display:grid;grid-template-columns:repeat(4,1fr);border:1px solid var(--border-subtle);border-radius:var(--radius);background:var(--bg-elevated);margin-bottom:14px;overflow:hidden}.detail-strip>div{padding:15px;border-right:1px solid var(--border-subtle);min-width:0}.detail-strip>div:last-child{border-right:0}.detail-strip label{display:block;color:var(--text-tertiary);font:8px var(--mono);text-transform:uppercase;letter-spacing:.1em}.detail-strip strong{display:block;margin-top:8px;font-size:12px;font-weight:500;overflow-wrap:anywhere}.json{margin:0;background:#070A09;color:var(--text-secondary);border:1px solid var(--border-subtle);border-radius:7px;padding:14px;font:9px/1.65 var(--mono);white-space:pre-wrap;overflow:auto;max-height:360px}.summary-box{font-size:12px;line-height:1.65;overflow-wrap:anywhere}.summary-box dl{display:grid;grid-template-columns:130px 1fr;gap:9px 14px;margin:0}.summary-box dt{color:var(--text-tertiary);font:8px var(--mono);text-transform:uppercase;letter-spacing:.08em}.summary-box dd{margin:0;color:var(--text-secondary)}
+.run-spine{position:relative;padding:4px 0}.run-spine:before{content:"";position:absolute;left:19px;top:14px;bottom:14px;width:1px;background:var(--border)}.phase{position:relative;display:grid;grid-template-columns:40px 1fr auto;gap:12px;padding:11px 4px}.phase-dot{width:12px;height:12px;border-radius:50%;background:var(--bg-elevated);border:2px solid var(--text-tertiary);margin:2px 0 0 13px;z-index:1}.phase.complete .phase-dot{border-color:var(--success);box-shadow:0 0 8px rgba(140,196,148,.2)}.phase.active .phase-dot{border-color:var(--network);box-shadow:0 0 0 5px rgba(131,179,226,.09)}.phase.error .phase-dot{border-color:var(--danger)}.phase strong{font-size:12px;font-weight:500}.phase p{margin:4px 0 0;color:var(--text-secondary);font-size:11px;font-weight:300;line-height:1.5}.phase time{font:8px var(--mono);color:var(--text-tertiary)}
+.event-row{border-top:1px solid var(--border-subtle)}.event-toggle{width:100%;border:0;background:transparent;padding:12px 15px;display:grid;grid-template-columns:82px 110px minmax(0,1fr) auto;gap:11px;text-align:left;align-items:center;cursor:pointer}.event-toggle:hover,.event-row.open .event-toggle{background:var(--accent-glow)}.event-time,.event-category{font:8px var(--mono);color:var(--text-tertiary)}.event-type{font:9px var(--mono);overflow:hidden;text-overflow:ellipsis}.event-detail{display:none;padding:0 15px 14px}.event-row.open .event-detail{display:block}.trace-note{border-left:2px solid var(--accent);padding:10px 12px;background:var(--accent-dim);font-size:11px;line-height:1.5;color:var(--text-secondary);margin-bottom:14px}
+.workspace-tabs{display:flex;gap:2px;border-bottom:1px solid var(--border-subtle);margin:20px 0 14px}.workspace-tabs button{border:0;background:transparent;padding:11px 13px;color:var(--text-secondary);font-size:11px;cursor:pointer;border-bottom:2px solid transparent}.workspace-tabs button.active{color:var(--accent);border-color:var(--accent);font-weight:500}.kv{display:grid;grid-template-columns:repeat(3,1fr);gap:10px}.kv-item{border:1px solid var(--border-subtle);border-radius:7px;padding:13px;background:var(--bg-surface)}.kv-item strong{font:10px var(--mono)}.kv-item small{display:block;color:var(--text-tertiary);margin-top:6px}.kv-value{margin-top:12px;color:var(--text-secondary);font-size:11px;line-height:1.5;overflow-wrap:anywhere}.callout{border:1px solid var(--accent-line);background:var(--accent-glow);border-radius:8px;padding:15px 17px;display:flex;align-items:flex-start;gap:12px;margin-bottom:14px}.callout b{font-size:12px;font-weight:500}.callout p{margin:4px 0 0;color:var(--text-secondary);font-size:11px;line-height:1.5}.callout .symbol{width:31px;height:31px;display:grid;place-items:center;flex:0 0 auto;border:1px solid var(--accent-line);border-radius:7px;color:var(--accent);background:var(--accent-dim)}.callout .symbol .icon{width:16px;height:16px}
+.drawer-backdrop{position:fixed;inset:0;background:rgba(0,0,0,.62);backdrop-filter:blur(3px);z-index:40;display:none}.drawer-backdrop.open{display:block}.drawer{position:absolute;right:0;top:0;bottom:0;width:min(520px,100%);background:var(--bg-elevated);border-left:1px solid var(--border);box-shadow:-20px 0 60px rgba(0,0,0,.35);padding:26px;overflow:auto}.drawer-head{display:flex;align-items:flex-start;margin-bottom:28px}.drawer h2{margin:0;font-size:23px;font-weight:400;letter-spacing:-.025em}.drawer-head button{margin-left:auto;border:0;background:transparent;color:var(--text-secondary);cursor:pointer}.drawer-head button:hover{color:var(--text-primary);background:var(--bg-surface)}.field{margin-bottom:17px}.field label{display:block;font:8px var(--mono);text-transform:uppercase;letter-spacing:.12em;color:var(--text-tertiary);margin-bottom:7px}.field input,.field textarea,.field select{width:100%;border:1px solid var(--border);background:var(--bg);border-radius:7px;padding:11px 12px;font-size:12px}.field textarea{min-height:120px;resize:vertical}.form-error{background:rgba(226,155,168,.08);color:var(--danger);border:1px solid rgba(226,155,168,.18);border-radius:7px;padding:10px 12px;font-size:11px;margin-bottom:13px}.drawer-actions{display:flex;justify-content:flex-end;gap:8px;margin-top:22px}
+.search-modal{position:fixed;inset:0;background:rgba(0,0,0,.64);backdrop-filter:blur(4px);z-index:50;display:none;padding:12vh 20px}.search-modal.open{display:block}.search-box{max-width:650px;margin:auto;background:var(--bg-elevated);border:1px solid var(--border);border-radius:10px;box-shadow:var(--shadow);overflow:hidden}.search-input-wrap{display:flex;align-items:center;gap:12px;padding:0 20px;border-bottom:1px solid var(--border);color:var(--text-tertiary)}.search-input-wrap>.icon{width:19px;height:19px}.search-box input{width:100%;border:0;background:var(--bg-elevated);padding:18px 0;font-size:15px}.search-results{max-height:420px;overflow:auto;padding:8px}.search-result{display:block;padding:11px 12px;border-radius:6px;text-decoration:none;color:inherit}.search-result:hover{background:var(--accent-glow)}.search-result strong{font-size:12px;font-weight:500}.search-result small{display:block;color:var(--text-tertiary);margin-top:3px}.toast{position:fixed;right:24px;bottom:24px;background:var(--accent);color:var(--bg);border-radius:7px;padding:12px 15px;font-size:11px;font-weight:600;box-shadow:var(--shadow);z-index:60;transform:translateY(20px);opacity:0;pointer-events:none;transition:.2s}.toast.show{transform:none;opacity:1}
+@media(max-width:1100px){.cols-4{grid-template-columns:repeat(2,1fr)}.definition-grid{grid-template-columns:repeat(2,1fr)}.cols-3{grid-template-columns:1fr 1fr}.detail-strip{grid-template-columns:1fr 1fr}.detail-strip>div:nth-child(2){border-right:0}.detail-strip>div:nth-child(-n+2){border-bottom:1px solid var(--border-subtle)}}
+@media(max-width:760px){:root{--sidebar:0px}.sidebar{transform:translateX(-248px);width:248px;transition:transform .2s ease}.sidebar.open{transform:none}.mobile-toggle{display:inline-flex}.topbar{padding:0 16px}.live-chip{display:none}.content{padding:24px 16px 55px}.page-head{display:block}.page-head .actions{margin:18px 0 0}.cols-4,.cols-3,.cols-2,.definition-grid,.kv{grid-template-columns:1fr}.span-2{grid-column:auto}.detail-strip{display:block}.detail-strip>div{border-right:0;border-bottom:1px solid var(--border-subtle)}.filters{flex-wrap:wrap}.filters input{min-width:100%;width:100%}.event-toggle{grid-template-columns:70px 90px 1fr}.event-toggle span:last-child{display:none}.top-actions .button.primary span{display:none}}
+@media(prefers-reduced-motion:reduce){*{scroll-behavior:auto!important;transition:none!important}}
+`;
+
+// src/dashboard.ts
+var NAV_ICONS = {
+  overview: renderPhosphorIcon("overview"),
+  agents: renderPhosphorIcon("agent"),
+  runs: renderPhosphorIcon("runs"),
+  automations: renderPhosphorIcon("automations"),
+  integrations: renderPhosphorIcon("integrations"),
+  workspaces: renderPhosphorIcon("workspaces")
+};
+function renderDashboard() {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width,initial-scale=1" />
+  <meta name="color-scheme" content="dark" />
+  <title>Glove Foundry \xB7 Inspector</title>
+  <style>${DASHBOARD_STYLES}</style>
+</head>
+<body>
+  <div class="app">
+    <aside class="sidebar" id="sidebar">
+      <a class="brand" href="/" data-link>
+        ${renderGloveMark()}
+        <span><strong>Glove Foundry</strong><small>Runtime inspector</small></span>
+      </a>
+      <nav class="nav">
+        <div class="nav-label">Inspect</div>
+        <a href="/" data-link data-nav="overview"><span class="nav-icon">${NAV_ICONS.overview}</span>Overview</a>
+        <a href="/agents" data-link data-nav="agents"><span class="nav-icon">${NAV_ICONS.agents}</span>Agents</a>
+        <a href="/runs" data-link data-nav="runs"><span class="nav-icon">${NAV_ICONS.runs}</span>Runs</a>
+        <a href="/automations" data-link data-nav="automations"><span class="nav-icon">${NAV_ICONS.automations}</span>Automations</a>
+        <a href="/integrations" data-link data-nav="integrations"><span class="nav-icon">${NAV_ICONS.integrations}</span>Integrations</a>
+        <a href="/workspaces" data-link data-nav="workspaces"><span class="nav-icon">${NAV_ICONS.workspaces}</span>Workspaces</a>
+      </nav>
+      <div class="sidebar-foot">
+        <div class="runtime-state" id="runtime-state"><i></i><span>Connecting to runtime\u2026</span></div>
+        <button class="shortcut" id="open-search"><span class="shortcut-label">${renderPhosphorIcon("search")}Search Foundry</span><kbd>\u2318K</kbd></button>
+      </div>
+    </aside>
+    <section class="main">
+      <header class="topbar">
+        <button class="button icon-button mobile-toggle" id="mobile-toggle" aria-label="Open navigation">${renderPhosphorIcon("menu")}</button>
+        <div class="breadcrumbs" id="breadcrumbs"></div>
+        <div class="top-actions">
+          <span class="live-chip"><i></i><span id="event-state">Live updates</span></span>
+          <button class="button primary" id="new-run">${renderPhosphorIcon("plus")} <span>New run</span></button>
+        </div>
+      </header>
+      <main class="content" id="content">
+        <div class="empty"><strong>Opening the Foundry\u2026</strong>Reading definitions, instances, and runtime activity.</div>
+      </main>
+    </section>
+  </div>
+
+  <div class="drawer-backdrop" id="drawer">
+    <section class="drawer" role="dialog" aria-modal="true" aria-labelledby="drawer-title">
+      <div class="drawer-head">
+        <div><div class="eyebrow">Direct invocation</div><h2 id="drawer-title">Start a run</h2></div>
+        <button class="icon-button" id="close-drawer" aria-label="Close">${renderPhosphorIcon("close")}</button>
+      </div>
+      <div id="run-form-error" class="form-error hidden"></div>
+      <form id="run-form">
+        <div class="field"><label for="run-definition">Agent definition</label><select id="run-definition"></select></div>
+        <div class="field"><label for="run-instance">Runtime instance</label><select id="run-instance"></select><small class="muted">Choose \u201CCreate a new instance\u201D to provision one.</small></div>
+        <div class="field"><label for="run-message">Message</label><textarea id="run-message" required placeholder="What should this agent work on?"></textarea></div>
+        <div class="drawer-actions"><button type="button" class="button" id="cancel-run">Cancel</button><button type="submit" class="button primary">Start run</button></div>
+      </form>
+    </section>
+  </div>
+
+  <div class="search-modal" id="search-modal">
+    <div class="search-box" role="dialog" aria-modal="true">
+      <div class="search-input-wrap">${renderPhosphorIcon("search")}<input id="search-input" aria-label="Search Foundry" placeholder="Search pages, agents, instances, and runs\u2026" autocomplete="off" /></div>
+      <div class="search-results" id="search-results"></div>
+    </div>
+  </div>
+  <div class="toast" id="toast"></div>
+  <script>${DASHBOARD_SCRIPT}</script>
+</body>
+</html>`;
+}
+
+// src/server.ts
+var MAX_BODY_BYTES = 1024 * 1024;
+function isFoundryMessageInput(value) {
+  if (typeof value === "string") return true;
+  if (!Array.isArray(value)) return false;
+  return value.every((part) => {
+    if (!part || typeof part !== "object") return false;
+    const candidate = part;
+    if (!["text", "image", "video", "document"].includes(String(candidate.type))) {
+      return false;
+    }
+    if (candidate.text !== void 0 && typeof candidate.text !== "string") return false;
+    if (candidate.source === void 0) return true;
+    if (!candidate.source || typeof candidate.source !== "object") return false;
+    const source = candidate.source;
+    return (source.type === "base64" || source.type === "url") && typeof source.media_type === "string" && (source.data === void 0 || typeof source.data === "string") && (source.url === void 0 || typeof source.url === "string");
+  });
+}
+var RequestError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+};
+function json(response, status, value) {
+  response.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store",
+    "x-content-type-options": "nosniff"
+  });
+  response.end(JSON.stringify(value));
+}
+async function readJson(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    if (size > MAX_BODY_BYTES) {
+      throw new RequestError(413, "Request body exceeds the 1 MB limit.");
+    }
+    chunks.push(buffer);
+  }
+  if (chunks.length === 0) return {};
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new RequestError(400, "Request body must be valid JSON.");
+  }
+}
+function eventFilter(url) {
+  const afterValue = url.searchParams.get("after");
+  const limitValue = url.searchParams.get("limit");
+  const after = afterValue === null ? void 0 : Number(afterValue);
+  const limit = limitValue === null ? void 0 : Number(limitValue);
+  return {
+    ...after !== void 0 && Number.isFinite(after) ? { after } : {},
+    ...limit !== void 0 && Number.isFinite(limit) ? { limit } : {},
+    ...url.searchParams.get("agent") ? { agent: url.searchParams.get("agent") } : {},
+    ...url.searchParams.get("runId") ? { runId: url.searchParams.get("runId") } : {},
+    ...url.searchParams.get("category") ? {
+      category: url.searchParams.get(
+        "category"
+      )
+    } : {}
+  };
+}
+function matches(event, filter) {
+  if (filter.after !== void 0 && event.sequence <= filter.after) return false;
+  if (filter.agent && event.agent !== filter.agent) return false;
+  if (filter.runId && event.runId !== filter.runId) return false;
+  if (filter.category && event.category !== filter.category) return false;
+  return true;
+}
+function agentRoute(pathname) {
+  const prefix = "/api/agents/";
+  const suffix = "/runs";
+  if (!pathname.startsWith(prefix) || !pathname.endsWith(suffix)) return null;
+  const encoded = pathname.slice(prefix.length, -suffix.length);
+  if (!encoded) return null;
+  try {
+    return encoded.split("/").map(decodeURIComponent).join("/");
+  } catch {
+    return null;
+  }
+}
+function installationFrom(value) {
+  if (!value || typeof value !== "object") {
+    throw new RequestError(400, "Installation body must be an object.");
+  }
+  const body = value;
+  const kinds = /* @__PURE__ */ new Set([
+    "tool",
+    "application",
+    "mcp"
+  ]);
+  if (typeof body.agentId !== "string" || !body.agentId) {
+    throw new RequestError(400, "agentId is required.");
+  }
+  if (typeof body.kind !== "string" || !kinds.has(body.kind)) {
+    throw new RequestError(400, "kind is invalid.");
+  }
+  if (typeof body.id !== "string" || !body.id) {
+    throw new RequestError(400, "id is required.");
+  }
+  return {
+    agentId: body.agentId,
+    installation: {
+      kind: body.kind,
+      id: body.id,
+      ...body.config !== void 0 ? { config: body.config } : {}
+    }
+  };
+}
+function foundryRequestFrom(value) {
+  if (!value || typeof value !== "object") {
+    throw new RequestError(400, "Foundry request body must be an object.");
+  }
+  const body = value;
+  for (const key of ["agentId", "conversationId", "workspaceId", "message"]) {
+    if (typeof body[key] !== "string" || !body[key]) {
+      throw new RequestError(400, `${key} is required.`);
+    }
+  }
+  return body;
+}
+var FoundryServer = class {
+  constructor(runtime, options = {}) {
+    this.runtime = runtime;
+    this.options = options;
+    this.server = createServer((request, response) => {
+      void this.handle(request, response);
+    });
+  }
+  server;
+  eventStreams = /* @__PURE__ */ new Set();
+  addressInfo = null;
+  async listen() {
+    const host = this.options.host ?? "127.0.0.1";
+    const port = this.options.port ?? 4141;
+    await new Promise((resolve3, reject) => {
+      this.server.once("error", reject);
+      this.server.listen(port, host, () => {
+        this.server.removeListener("error", reject);
+        resolve3();
+      });
+    });
+    const address = this.server.address();
+    if (!address || typeof address === "string") {
+      throw new Error("Foundry server did not receive a TCP address.");
+    }
+    this.addressInfo = address;
+    return { host, port: address.port, url: `http://${host}:${address.port}` };
+  }
+  async close() {
+    if (!this.server.listening) return;
+    for (const stream of this.eventStreams) stream.end();
+    this.eventStreams.clear();
+    await new Promise(
+      (resolve3, reject) => this.server.close((error) => error ? reject(error) : resolve3())
+    );
+    this.addressInfo = null;
+  }
+  address() {
+    return this.addressInfo;
+  }
+  async handle(request, response) {
+    try {
+      const url = new URL(request.url ?? "/", "http://foundry.local");
+      const method = request.method ?? "GET";
+      if (method === "GET" && !url.pathname.startsWith("/api/") && url.pathname !== "/health") {
+        response.writeHead(200, {
+          "content-type": "text/html; charset=utf-8",
+          "cache-control": "no-store",
+          "content-security-policy": "default-src 'self'; script-src 'unsafe-inline' 'self'; style-src 'unsafe-inline' 'self'; connect-src 'self'",
+          "x-content-type-options": "nosniff",
+          "x-frame-options": "DENY"
+        });
+        response.end(renderDashboard());
+        return;
+      }
+      if (method === "GET" && url.pathname === "/health") {
+        json(response, 200, await this.runtime.health());
+        return;
+      }
+      if (method === "GET" && url.pathname === "/api/manifest") {
+        const definitions = Object.fromEntries(
+          this.runtime.agents.map((agent) => [
+            agent.route,
+            {
+              capabilities: this.runtime.capabilityManifest(agent.route),
+              surfaces: this.runtime.nativeManifest(agent.route)
+            }
+          ])
+        );
+        json(response, 200, {
+          agents: this.runtime.manifest,
+          application: this.runtime.applicationManifest,
+          definitions
+        });
+        return;
+      }
+      if (method === "GET" && url.pathname === "/api/agents") {
+        json(response, 200, this.runtime.manifest.agents);
+        return;
+      }
+      if (url.pathname === "/api/agent-instances" && method === "GET") {
+        json(response, 200, await this.runtime.listAgentInstances(url.searchParams.get("definition") ?? void 0));
+        return;
+      }
+      if (url.pathname === "/api/agent-instances" && method === "POST") {
+        const body = await readJson(request);
+        if (typeof body.definitionId !== "string") throw new RequestError(400, "definitionId is required.");
+        json(response, 201, await this.runtime.createAgent(body.definitionId, {
+          ...typeof body.id === "string" ? { id: body.id } : {},
+          ...typeof body.workspaceId === "string" ? { workspaceId: body.workspaceId } : {},
+          ...body.context && typeof body.context === "object" ? { context: body.context } : {},
+          ...Array.isArray(body.installations) ? { installations: body.installations } : {},
+          ...Array.isArray(body.playbooks) ? { playbooks: body.playbooks } : {}
+        }));
+        return;
+      }
+      const instanceConfiguration = url.pathname.match(/^\/api\/agent-instances\/([^/]+)$/);
+      if (instanceConfiguration && method === "PATCH") {
+        const body = await readJson(request);
+        json(response, 200, await this.runtime.configureAgent(
+          decodeURIComponent(instanceConfiguration[1]),
+          {
+            ...body.context && typeof body.context === "object" ? { context: body.context } : {},
+            ...Array.isArray(body.installations) ? { installations: body.installations } : {},
+            ...Array.isArray(body.playbooks) ? { playbooks: body.playbooks } : {}
+          }
+        ));
+        return;
+      }
+      const instancePlaybooks = url.pathname.match(/^\/api\/agent-instances\/([^/]+)\/playbooks$/);
+      if (instancePlaybooks && method === "PUT") {
+        const body = await readJson(request);
+        if (!Array.isArray(body.playbooks)) throw new RequestError(400, "playbooks must be an array.");
+        json(response, 200, await this.runtime.setAgentPlaybooks(
+          decodeURIComponent(instancePlaybooks[1]),
+          body.playbooks
+        ));
+        return;
+      }
+      if (url.pathname === "/api/playbook-subscriptions" && method === "GET") {
+        json(
+          response,
+          200,
+          await this.runtime.listPlaybookSubscriptions(
+            url.searchParams.get("workspace") ?? void 0
+          )
+        );
+        return;
+      }
+      if (url.pathname === "/api/activations" && method === "GET") {
+        json(
+          response,
+          200,
+          await this.runtime.listActivations(
+            url.searchParams.get("workspace") ?? void 0
+          )
+        );
+        return;
+      }
+      if (url.pathname === "/api/playbook-subscriptions" && method === "PUT") {
+        json(
+          response,
+          200,
+          await this.runtime.putPlaybookSubscription(
+            await readJson(request)
+          )
+        );
+        return;
+      }
+      const subscriptionDelete = url.pathname.match(
+        /^\/api\/playbook-subscriptions\/([^/]+)$/
+      );
+      if (subscriptionDelete && method === "DELETE") {
+        json(response, 200, {
+          removed: await this.runtime.deletePlaybookSubscription(
+            decodeURIComponent(subscriptionDelete[1])
+          )
+        });
+        return;
+      }
+      if (url.pathname === "/api/conversations" && method === "GET") {
+        const agentId = url.searchParams.get("agent");
+        if (!agentId) throw new RequestError(400, "agent query is required.");
+        json(response, 200, await this.runtime.listConversations(agentId));
+        return;
+      }
+      if (url.pathname === "/api/conversations" && method === "POST") {
+        const body = await readJson(request);
+        if (typeof body.agentId !== "string") throw new RequestError(400, "agentId is required.");
+        json(response, 201, await this.runtime.createConversation(body.agentId, {
+          ...typeof body.id === "string" ? { id: body.id } : {},
+          ...typeof body.workspaceId === "string" ? { workspaceId: body.workspaceId } : {},
+          ...typeof body.title === "string" ? { title: body.title } : {},
+          ...body.context && typeof body.context === "object" ? { context: body.context } : {}
+        }));
+        return;
+      }
+      const conversationMessage = url.pathname.match(/^\/api\/conversations\/([^/]+)\/messages$/);
+      if (conversationMessage && method === "POST") {
+        const body = await readJson(request);
+        if (typeof body.agentId !== "string" || !isFoundryMessageInput(body.message)) {
+          throw new RequestError(400, "agentId and message are required.");
+        }
+        json(response, 202, await this.runtime.send(
+          body.agentId,
+          decodeURIComponent(conversationMessage[1]),
+          body.message,
+          {
+            ...body.payload !== void 0 ? { payload: body.payload } : {},
+            ...body.context && typeof body.context === "object" ? { context: body.context } : {}
+          }
+        ));
+        return;
+      }
+      const workspaceItem = url.pathname.match(/^\/api\/workspaces\/([^/]+)\/(inbox|tasks)\/([^/]+)$/);
+      if (workspaceItem && method === "PATCH") {
+        const workspaceId = decodeURIComponent(workspaceItem[1]);
+        const surface = workspaceItem[2];
+        const itemId = decodeURIComponent(workspaceItem[3]);
+        const body = await readJson(request);
+        if (typeof body.status !== "string") throw new RequestError(400, "status is required.");
+        if (surface === "inbox") {
+          if (!["pending", "resolved", "dismissed"].includes(body.status)) {
+            throw new RequestError(400, "Invalid shared inbox status.");
+          }
+          json(response, 200, await this.runtime.updateSharedInbox(
+            workspaceId,
+            itemId,
+            body.status
+          ));
+          return;
+        }
+        if (!["open", "in-progress", "completed", "cancelled"].includes(body.status)) {
+          throw new RequestError(400, "Invalid task status.");
+        }
+        json(response, 200, await this.runtime.updateTask(
+          workspaceId,
+          itemId,
+          body.status
+        ));
+        return;
+      }
+      const workspaceSurface = url.pathname.match(/^\/api\/workspaces\/([^/]+)\/(entries|inbox|tasks|environment)$/);
+      if (workspaceSurface) {
+        const workspaceId = decodeURIComponent(workspaceSurface[1]);
+        const surface = workspaceSurface[2];
+        if (method === "GET" && surface === "entries") {
+          json(response, 200, await this.runtime.listWorkspaceEntries(workspaceId));
+          return;
+        }
+        if (method === "PUT" && surface === "entries") {
+          const body = await readJson(request);
+          if (typeof body.key !== "string") throw new RequestError(400, "key is required.");
+          json(response, 200, await this.runtime.putWorkspaceEntry(workspaceId, body.key, body.value));
+          return;
+        }
+        if (method === "GET" && surface === "inbox") {
+          json(response, 200, await this.runtime.listSharedInbox(workspaceId));
+          return;
+        }
+        if (method === "POST" && surface === "inbox") {
+          const body = await readJson(request);
+          if (typeof body.topic !== "string") throw new RequestError(400, "topic is required.");
+          json(response, 201, await this.runtime.postSharedInbox({
+            workspaceId,
+            ...typeof body.agentId === "string" ? { agentId: body.agentId } : {},
+            ...typeof body.conversationId === "string" ? { conversationId: body.conversationId } : {},
+            topic: body.topic,
+            payload: body.payload,
+            status: "pending"
+          }));
+          return;
+        }
+        if (method === "GET" && surface === "tasks") {
+          json(response, 200, await this.runtime.listTasks(workspaceId));
+          return;
+        }
+        if (method === "POST" && surface === "tasks") {
+          const body = await readJson(request);
+          if (typeof body.title !== "string") throw new RequestError(400, "title is required.");
+          json(response, 201, await this.runtime.createTask({
+            workspaceId,
+            ...typeof body.agentId === "string" ? { agentId: body.agentId } : {},
+            ...typeof body.conversationId === "string" ? { conversationId: body.conversationId } : {},
+            title: body.title,
+            ...typeof body.detail === "string" ? { detail: body.detail } : {},
+            status: "open"
+          }));
+          return;
+        }
+        if (method === "GET" && surface === "environment") {
+          json(response, 200, await this.runtime.listDataEnvironment({
+            workspaceId,
+            ...url.searchParams.get("agent") ? { agentId: url.searchParams.get("agent") } : {},
+            ...url.searchParams.get("conversation") ? { conversationId: url.searchParams.get("conversation") } : {}
+          }));
+          return;
+        }
+      }
+      if (method === "GET" && url.pathname === "/api/capabilities") {
+        const definition = url.searchParams.get("definition");
+        if (!definition) throw new Error("definition is required");
+        json(response, 200, this.runtime.capabilityManifest(definition));
+        return;
+      }
+      if (method === "GET" && url.pathname === "/api/surfaces") {
+        const definition = url.searchParams.get("definition");
+        if (!definition) throw new Error("definition is required");
+        json(response, 200, this.runtime.nativeManifest(definition));
+        return;
+      }
+      if (url.pathname === "/api/installations" && method === "GET") {
+        const agentId = url.searchParams.get("agent");
+        if (!agentId) throw new RequestError(400, "agent query is required.");
+        json(response, 200, await this.runtime.listInstallations(agentId));
+        return;
+      }
+      if (url.pathname === "/api/installations" && method === "PUT") {
+        const parsed = installationFrom(await readJson(request));
+        const agent = await this.runtime.installCapability(
+          parsed.agentId,
+          parsed.installation
+        );
+        json(response, 200, agent);
+        return;
+      }
+      if (url.pathname === "/api/installations" && method === "DELETE") {
+        const parsed = installationFrom(await readJson(request));
+        const agent = await this.runtime.uninstallCapability(
+          parsed.agentId,
+          parsed.installation
+        );
+        json(response, 200, agent);
+        return;
+      }
+      if (method === "GET" && url.pathname === "/api/runs") {
+        json(response, 200, await this.runtime.listRuns(url.searchParams.get("agent") ?? void 0));
+        return;
+      }
+      if (method === "GET" && url.pathname === "/api/transmissions") {
+        json(response, 200, this.runtime.applicationManifest.transmissions);
+        return;
+      }
+      if (method === "GET" && url.pathname === "/api/accounts") {
+        json(response, 200, await this.runtime.listAccounts());
+        return;
+      }
+      if (url.pathname === "/api/routes" && method === "GET") {
+        json(response, 200, await this.runtime.listRoutes());
+        return;
+      }
+      if (url.pathname === "/api/routes" && method === "PUT") {
+        const route2 = Schema4.decodeUnknownSync(Route)(await readJson(request));
+        json(response, 200, await this.runtime.putRoute(route2));
+        return;
+      }
+      const routeDelete = url.pathname.match(/^\/api\/routes\/([^/]+)$/);
+      if (routeDelete && method === "DELETE") {
+        const id2 = Schema4.decodeUnknownSync(RouteId)(
+          decodeURIComponent(routeDelete[1])
+        );
+        await this.runtime.removeRoute(id2);
+        json(response, 200, { removed: true });
+        return;
+      }
+      if (url.pathname === "/api/bindings" && method === "GET") {
+        json(response, 200, await this.runtime.listBindings());
+        return;
+      }
+      if (url.pathname === "/api/bindings" && method === "PUT") {
+        const binding = Schema4.decodeUnknownSync(AgentBinding)(
+          await readJson(request)
+        );
+        json(response, 200, await this.runtime.putBinding(binding));
+        return;
+      }
+      const bindingDelete = url.pathname.match(/^\/api\/bindings\/([^/]+)$/);
+      if (bindingDelete && method === "DELETE") {
+        const id2 = Schema4.decodeUnknownSync(BindingId)(
+          decodeURIComponent(bindingDelete[1])
+        );
+        await this.runtime.removeBinding(id2);
+        json(response, 200, { removed: true });
+        return;
+      }
+      if (url.pathname === "/api/grants/resolve" && method === "POST") {
+        const requestBody = Schema4.decodeUnknownSync(
+          Schema4.Struct({
+            runId: RunId,
+            agentId: AgentId,
+            originRouteId: Schema4.optional(RouteId)
+          })
+        )(await readJson(request));
+        json(response, 200, await this.runtime.resolveGrant(requestBody));
+        return;
+      }
+      if (url.pathname === "/api/application-connections" && method === "GET") {
+        json(response, 200, this.runtime.listApplicationConnections());
+        return;
+      }
+      const connectionReconnect = url.pathname.match(
+        /^\/api\/application-connections\/([^/]+)\/reconnect$/
+      );
+      if (connectionReconnect && method === "POST") {
+        await this.runtime.reconnectApplicationConnection(
+          decodeURIComponent(connectionReconnect[1])
+        );
+        json(response, 200, { ok: true });
+        return;
+      }
+      if (url.pathname === "/api/events" && method === "GET") {
+        const filter = eventFilter(url);
+        if (request.headers.accept?.includes("text/event-stream")) {
+          this.streamEvents(request, response, filter);
+        } else {
+          json(response, 200, this.runtime.observability.list(filter));
+        }
+        return;
+      }
+      const transmissionFire = url.pathname.match(/^\/api\/transmissions\/([^/]+)\/fire$/);
+      if (transmissionFire && method === "POST") {
+        const body = await readJson(request);
+        if (typeof body.eventId !== "string" || typeof body.threadKey !== "string") {
+          throw new RequestError(400, "eventId and threadKey are required.");
+        }
+        json(response, 202, await this.runtime.dispatchInbound({
+          routeId: decodeURIComponent(transmissionFire[1]),
+          eventId: body.eventId,
+          threadKey: body.threadKey,
+          raw: body.raw
+        }));
+        return;
+      }
+      const transmissionDeliver = url.pathname.match(/^\/api\/transmissions\/([^/]+)\/deliver$/);
+      if (transmissionDeliver && method === "POST") {
+        const body = await readJson(request);
+        if (typeof body.agentId !== "string" || typeof body.runId !== "string") {
+          throw new RequestError(400, "agentId and runId are required.");
+        }
+        json(response, 200, await this.runtime.dispatchOutbound({
+          routeId: decodeURIComponent(transmissionDeliver[1]),
+          agentId: body.agentId,
+          runId: body.runId,
+          payload: body.payload
+        }));
+        return;
+      }
+      const route = agentRoute(url.pathname);
+      if (route && method === "POST") {
+        json(response, 202, await this.runtime.request(route, foundryRequestFrom(await readJson(request))));
+        return;
+      }
+      const cancelMatch = url.pathname.match(/^\/api\/runs\/([^/]+)\/cancel$/);
+      if (cancelMatch && method === "POST") {
+        json(response, 200, {
+          cancelled: await this.runtime.cancel(decodeURIComponent(cancelMatch[1]))
+        });
+        return;
+      }
+      const eventsMatch = url.pathname.match(/^\/api\/runs\/([^/]+)\/events$/);
+      if (eventsMatch && method === "GET") {
+        json(
+          response,
+          200,
+          this.runtime.observability.list({
+            runId: decodeURIComponent(eventsMatch[1]),
+            limit: 5e3
+          })
+        );
+        return;
+      }
+      const runMatch = url.pathname.match(/^\/api\/runs\/([^/]+)$/);
+      if (runMatch && method === "GET") {
+        const run = await this.runtime.getRun(decodeURIComponent(runMatch[1]));
+        if (!run) throw new RequestError(404, "Foundry run was not found.");
+        json(response, 200, run);
+        return;
+      }
+      throw new RequestError(404, "Foundry route was not found.");
+    } catch (error) {
+      const status = error instanceof RequestError ? error.status : 400;
+      const message = error instanceof Error ? error.message : String(error);
+      if (!response.headersSent) json(response, status, { error: message });
+      else response.end();
+    }
+  }
+  streamEvents(request, response, filter) {
+    response.writeHead(200, {
+      "content-type": "text/event-stream; charset=utf-8",
+      "cache-control": "no-cache, no-transform",
+      connection: "keep-alive",
+      "x-accel-buffering": "no"
+    });
+    this.eventStreams.add(response);
+    response.write(": glove-foundry\n\n");
+    for (const event of this.runtime.observability.list(filter)) {
+      response.write(`id: ${event.sequence}
+data: ${JSON.stringify(event)}
+
+`);
+    }
+    const unsubscribe = this.runtime.observability.subscribe((event) => {
+      if (matches(event, filter)) {
+        response.write(`id: ${event.sequence}
+data: ${JSON.stringify(event)}
+
+`);
+      }
+    });
+    const heartbeat = setInterval(() => response.write(": heartbeat\n\n"), 15e3);
+    const close = () => {
+      clearInterval(heartbeat);
+      unsubscribe();
+      this.eventStreams.delete(response);
+    };
+    request.once("close", close);
+    response.once("close", close);
+  }
+};
+
+export {
+  writeGeneratedTypes,
+  composeAgent,
+  EMPTY_AGENT_COMPOSITION,
+  TransmissionId,
+  AgentDefinitionId,
+  AgentId,
+  AccountId,
+  RouteId,
+  BindingId,
+  EventId,
+  RunId,
+  CapabilityId,
+  AccountReference,
+  AccountSummary,
+  InboundRoute,
+  OutboundRoute,
+  Route,
+  ReplyPolicy,
+  AgentBinding,
+  RunGrant,
+  EventReference,
+  AccountNotFound,
+  RouteNotFound,
+  BindingNotFound,
+  EventNotFound,
+  TopologyConflict,
+  AccountSessionUnavailable,
+  GrantResolutionError,
+  AccountDirectory,
+  TopologyStore,
+  EventStore,
+  memoryAccountDirectory,
+  memoryTopologyStore,
+  memoryEventStore,
+  GrantResolver,
+  grantResolverLive,
+  FoundryManifestCapability,
+  FoundryManifestTransmission,
+  FoundryApplicationManifest,
+  ManifestCompilationError,
+  compileApplicationManifest,
+  serializeInboundTransmissionXml,
+  MemoryObservabilityAdapter,
+  FoundryRuntimeError,
+  FoundryRuntime,
+  FoundryServer
+};