glove-foundry 0.0.0

package/dist/client-CLkZREDr.d.ts

@@ -0,0 +1,2186 @@
+import { ContentPart, Message, IGloveRunnable, StoreAdapter, GloveFoldArgs, SubscriberAdapter, ModelAdapter, DisplayManagerAdapter, HookHandler, DefineSkillArgs, DefineSubAgentArgs, InboxItem } from 'glove-core';
+import { Schema, Effect, Context, Layer } from 'effect';
+import { z } from 'zod';
+import { MeshAdapter, AgentIdentity } from 'glove-mesh';
+import { McpCatalogueEntry, McpAdapter } from 'glove-mcp';
+import { EntityMemoryAdapter, EpisodicMemoryAdapter, ResourceFsAdapter, ContextAdapter } from 'glove-memory';
+import { MemoryToolOptions } from 'glove-memory/tools';
+import { EnvSnapshot, EnvFsHandle, WorkingEnvironment, CreateWorkingEnvironmentOptions, MountWorkingEnvironmentConfig, Vfs } from 'glove-working-environment';
+import { JsSession, MountJsConfig } from 'glove-js';
+import { LispSession, MountLispConfig } from 'glove-lisp';
+import { PySession, MountPyConfig } from 'glove-python';
+import * as effect_Brand from 'effect/Brand';
+import { FoundryConfig } from './config.js';
+
+declare const TransmissionId: Schema.brand<Schema.refine<string, typeof Schema.String>, "FoundryTransmissionId">;
+type TransmissionId = typeof TransmissionId.Type;
+declare const AgentDefinitionId: Schema.brand<Schema.refine<string, typeof Schema.String>, "FoundryAgentDefinitionId">;
+type AgentDefinitionId = typeof AgentDefinitionId.Type;
+/** Runtime instance id. It is intentionally distinct from a file-routed definition id. */
+declare const AgentId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAgentId">;
+type AgentId = typeof AgentId.Type;
+declare const AccountId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAccountId">;
+type AccountId = typeof AccountId.Type;
+declare const RouteId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRouteId">;
+type RouteId = typeof RouteId.Type;
+declare const BindingId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryBindingId">;
+type BindingId = typeof BindingId.Type;
+declare const EventId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryEventId">;
+type EventId = typeof EventId.Type;
+declare const RunId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRunId">;
+type RunId = typeof RunId.Type;
+declare const CapabilityId: Schema.brand<Schema.filter<typeof Schema.String>, "FoundryCapabilityId">;
+type CapabilityId = typeof CapabilityId.Type;
+/**
+ * Public metadata for an external identity. `accessRef` is an opaque pointer
+ * owned by the application's account-session adapter. Foundry never resolves
+ * it into credential material itself and never serializes it into manifests.
+ */
+declare const AccountReference: Schema.Struct<{
+    id: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAccountId">;
+    transmissionId: Schema.brand<Schema.refine<string, typeof Schema.String>, "FoundryTransmissionId">;
+    externalAccountId: typeof Schema.NonEmptyTrimmedString;
+    label: Schema.optional<typeof Schema.NonEmptyTrimmedString>;
+    accessRef: typeof Schema.NonEmptyTrimmedString;
+    metadata: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+}>;
+type AccountReference = typeof AccountReference.Type;
+/** Account metadata safe to expose over Foundry's operator API. */
+declare const AccountSummary: Schema.Struct<{
+    id: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAccountId">;
+    transmissionId: Schema.brand<Schema.refine<string, typeof Schema.String>, "FoundryTransmissionId">;
+    externalAccountId: typeof Schema.NonEmptyTrimmedString;
+    label: Schema.optional<typeof Schema.NonEmptyTrimmedString>;
+    metadata: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+}>;
+type AccountSummary = typeof AccountSummary.Type;
+declare const InboundRoute: Schema.Struct<{
+    direction: Schema.Literal<["inbound"]>;
+    id: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRouteId">;
+    transmissionId: Schema.brand<Schema.refine<string, typeof Schema.String>, "FoundryTransmissionId">;
+    accountId: Schema.optional<Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAccountId">>;
+    visibility: Schema.Literal<["private", "workspace"]>;
+    enabled: typeof Schema.Boolean;
+    config: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+}>;
+type InboundRoute = typeof InboundRoute.Type;
+declare const OutboundRoute: Schema.Struct<{
+    direction: Schema.Literal<["outbound"]>;
+    id: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRouteId">;
+    transmissionId: Schema.brand<Schema.refine<string, typeof Schema.String>, "FoundryTransmissionId">;
+    accountId: Schema.optional<Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAccountId">>;
+    visibility: Schema.Literal<["private", "workspace"]>;
+    enabled: typeof Schema.Boolean;
+    config: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+}>;
+type OutboundRoute = typeof OutboundRoute.Type;
+declare const Route: Schema.Union<[Schema.Struct<{
+    direction: Schema.Literal<["inbound"]>;
+    id: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRouteId">;
+    transmissionId: Schema.brand<Schema.refine<string, typeof Schema.String>, "FoundryTransmissionId">;
+    accountId: Schema.optional<Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAccountId">>;
+    visibility: Schema.Literal<["private", "workspace"]>;
+    enabled: typeof Schema.Boolean;
+    config: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+}>, Schema.Struct<{
+    direction: Schema.Literal<["outbound"]>;
+    id: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRouteId">;
+    transmissionId: Schema.brand<Schema.refine<string, typeof Schema.String>, "FoundryTransmissionId">;
+    accountId: Schema.optional<Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAccountId">>;
+    visibility: Schema.Literal<["private", "workspace"]>;
+    enabled: typeof Schema.Boolean;
+    config: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+}>]>;
+type Route = typeof Route.Type;
+declare const ReplyPolicy: Schema.Union<[Schema.Struct<{
+    mode: Schema.Literal<["none"]>;
+}>, Schema.Struct<{
+    mode: Schema.Literal<["origin"]>;
+}>, Schema.Struct<{
+    mode: Schema.Literal<["route"]>;
+    routeId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRouteId">;
+}>]>;
+type ReplyPolicy = typeof ReplyPolicy.Type;
+declare const AgentBinding: Schema.Struct<{
+    id: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryBindingId">;
+    agentId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAgentId">;
+    transmissionId: Schema.brand<Schema.refine<string, typeof Schema.String>, "FoundryTransmissionId">;
+    accountId: Schema.optional<Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAccountId">>;
+    routeId: Schema.optional<Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRouteId">>;
+    capabilities: Schema.Array$<Schema.brand<Schema.filter<typeof Schema.String>, "FoundryCapabilityId">>;
+    reply: Schema.optional<Schema.Union<[Schema.Struct<{
+        mode: Schema.Literal<["none"]>;
+    }>, Schema.Struct<{
+        mode: Schema.Literal<["origin"]>;
+    }>, Schema.Struct<{
+        mode: Schema.Literal<["route"]>;
+        routeId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRouteId">;
+    }>]>>;
+    enabled: typeof Schema.Boolean;
+}>;
+type AgentBinding = typeof AgentBinding.Type;
+/** Authority calculated for one run. Grants are data, not prompt text. */
+declare const RunGrant: Schema.Struct<{
+    runId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRunId">;
+    agentId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAgentId">;
+    accountIds: Schema.Array$<Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAccountId">>;
+    outboundRouteIds: Schema.Array$<Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRouteId">>;
+    capabilities: Schema.Array$<Schema.brand<Schema.filter<typeof Schema.String>, "FoundryCapabilityId">>;
+    reply: Schema.Union<[Schema.Struct<{
+        mode: Schema.Literal<["none"]>;
+    }>, Schema.Struct<{
+        mode: Schema.Literal<["origin"]>;
+    }>, Schema.Struct<{
+        mode: Schema.Literal<["route"]>;
+        routeId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRouteId">;
+    }>]>;
+}>;
+type RunGrant = typeof RunGrant.Type;
+/** A concise pointer to an event whose full payload can live out-of-band. */
+declare const EventReference: Schema.Struct<{
+    id: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryEventId">;
+    transmissionId: Schema.brand<Schema.refine<string, typeof Schema.String>, "FoundryTransmissionId">;
+    routeId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRouteId">;
+    accountId: Schema.optional<Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAccountId">>;
+    externalEventId: typeof Schema.NonEmptyTrimmedString;
+    threadKey: typeof Schema.NonEmptyTrimmedString;
+    emittedAt: typeof Schema.NonEmptyTrimmedString;
+    payloadRef: typeof Schema.NonEmptyTrimmedString;
+}>;
+type EventReference = typeof EventReference.Type;
+declare const AccountNotFound_base: Schema.TaggedErrorClass<AccountNotFound, "AccountNotFound", {
+    readonly _tag: Schema.tag<"AccountNotFound">;
+} & {
+    accountId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAccountId">;
+}>;
+declare class AccountNotFound extends AccountNotFound_base {
+    get message(): string;
+}
+declare const RouteNotFound_base: Schema.TaggedErrorClass<RouteNotFound, "RouteNotFound", {
+    readonly _tag: Schema.tag<"RouteNotFound">;
+} & {
+    routeId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRouteId">;
+}>;
+declare class RouteNotFound extends RouteNotFound_base {
+    get message(): string;
+}
+declare const BindingNotFound_base: Schema.TaggedErrorClass<BindingNotFound, "BindingNotFound", {
+    readonly _tag: Schema.tag<"BindingNotFound">;
+} & {
+    bindingId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryBindingId">;
+}>;
+declare class BindingNotFound extends BindingNotFound_base {
+    get message(): string;
+}
+declare const EventNotFound_base: Schema.TaggedErrorClass<EventNotFound, "EventNotFound", {
+    readonly _tag: Schema.tag<"EventNotFound">;
+} & {
+    eventId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryEventId">;
+}>;
+declare class EventNotFound extends EventNotFound_base {
+    get message(): string;
+}
+declare const TopologyConflict_base: Schema.TaggedErrorClass<TopologyConflict, "TopologyConflict", {
+    readonly _tag: Schema.tag<"TopologyConflict">;
+} & {
+    resource: Schema.Literal<["route", "binding"]>;
+    id: typeof Schema.NonEmptyTrimmedString;
+    reason: typeof Schema.NonEmptyTrimmedString;
+}>;
+declare class TopologyConflict extends TopologyConflict_base {
+}
+declare const AccountSessionUnavailable_base: Schema.TaggedErrorClass<AccountSessionUnavailable, "AccountSessionUnavailable", {
+    readonly _tag: Schema.tag<"AccountSessionUnavailable">;
+} & {
+    accountId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAccountId">;
+    operation: typeof Schema.NonEmptyTrimmedString;
+    reason: typeof Schema.NonEmptyTrimmedString;
+}>;
+declare class AccountSessionUnavailable extends AccountSessionUnavailable_base {
+    get message(): string;
+}
+declare const GrantResolutionError_base: Schema.TaggedErrorClass<GrantResolutionError, "GrantResolutionError", {
+    readonly _tag: Schema.tag<"GrantResolutionError">;
+} & {
+    runId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryRunId">;
+    agentId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "FoundryAgentId">;
+    reason: typeof Schema.NonEmptyTrimmedString;
+}>;
+declare class GrantResolutionError extends GrantResolutionError_base {
+}
+type FoundryDomainError = AccountNotFound | RouteNotFound | BindingNotFound | EventNotFound | TopologyConflict | AccountSessionUnavailable | GrantResolutionError;
+
+/** A serializable instruction rendered into an inbound transmission turn. */
+interface PlaybookDirective {
+    readonly action: string;
+    readonly instruction: string;
+    readonly parameters?: Readonly<Record<string, unknown>>;
+}
+interface PlaybookActionOptions {
+    /** @deprecated File-routed definitions derive identity from their filename. */
+    readonly id?: string;
+    readonly description?: string;
+}
+type FoundryPlaybookAction = Readonly<PlaybookActionOptions> & {
+    readonly id: string;
+    readonly [FOUNDRY_PLAYBOOK_ACTION_BRAND]: true;
+};
+interface PlaybookDirectiveInput extends Omit<PlaybookDirective, "action"> {
+    readonly action: FoundryPlaybookAction;
+}
+/** Declarative match policy. Executable predicates live on the transmission definition. */
+interface PlaybookMatch {
+    readonly event?: string;
+    readonly routeIds?: ReadonlyArray<string>;
+    readonly predicate?: {
+        readonly name: string;
+        readonly parameters?: Readonly<Record<string, unknown>>;
+    };
+}
+interface PlaybookOutboundDirective {
+    readonly routeId: string;
+    readonly applicationId?: string;
+    readonly event?: string;
+    readonly accountId?: string;
+    readonly applicationAccountId?: string;
+    readonly instruction?: string;
+}
+/**
+ * Instance-owned, persistable transmission policy. Playbooks deliberately
+ * contain no functions; transmission definitions own all executable logic.
+ */
+interface AgentPlaybook {
+    readonly id: string;
+    readonly transmissionId: string;
+    readonly enabled?: boolean;
+    readonly match?: PlaybookMatch;
+    readonly directives: ReadonlyArray<PlaybookDirective>;
+    readonly applications?: ReadonlyArray<string>;
+    readonly outbound?: ReadonlyArray<PlaybookOutboundDirective>;
+    readonly serialization?: Readonly<Record<string, unknown>>;
+    readonly origin?: "agent-definition" | "instance";
+    readonly playbookName?: string;
+    readonly definitionRevision?: string;
+}
+interface PlaybookMatchInput extends Omit<PlaybookMatch, "event" | "routeIds" | "predicate"> {
+    readonly event?: FoundryTransmissionEvent<"inbound">;
+    readonly routes?: ReadonlyArray<InboundRoute>;
+    readonly predicate?: {
+        readonly definition: FoundryTransmissionPredicate<any, any, any>;
+        readonly parameters?: Readonly<Record<string, unknown>>;
+    };
+}
+interface PlaybookOutboundInput extends Omit<PlaybookOutboundDirective, "routeId" | "applicationId" | "event" | "accountId" | "applicationAccountId"> {
+    readonly route: OutboundRoute;
+    readonly application?: FoundryAgentApplication;
+    readonly event?: FoundryTransmissionEvent<"outbound">;
+    readonly account?: AccountReference;
+    readonly applicationAccount?: AccountReference;
+}
+/** Internal authoring shape used while runtime composition is materialized. */
+interface AgentPlaybookInput extends Omit<AgentPlaybook, "id" | "transmissionId" | "match" | "directives" | "applications" | "outbound"> {
+    readonly id?: string;
+    readonly transmission: AnyFoundryTransmission;
+    readonly match?: PlaybookMatchInput;
+    readonly directives: ReadonlyArray<PlaybookDirectiveInput>;
+    readonly applications?: ReadonlyArray<FoundryAgentApplication>;
+    readonly outbound?: ReadonlyArray<PlaybookOutboundInput>;
+}
+interface ComposedAgentPlaybookInput extends Omit<AgentPlaybookInput, "id"> {
+    readonly name: string;
+}
+type ComposedAgentPlaybook = Readonly<ComposedAgentPlaybookInput> & {
+    readonly [FOUNDRY_COMPOSED_PLAYBOOK_BRAND]: true;
+};
+/** Compose runtime policy from direct references to transmission primitives. */
+declare function composePlaybook(playbook: ComposedAgentPlaybookInput): ComposedAgentPlaybook;
+/** Rehydrate the JSON-safe data representation held by an instance adapter. */
+declare function reconstructPlaybook(playbook: AgentPlaybook): Readonly<AgentPlaybook>;
+
+declare const FOUNDRY_PLAYBOOK_ACTION_BRAND: unique symbol;
+declare const FOUNDRY_COMPOSED_PLAYBOOK_BRAND: unique symbol;
+declare function definePlaybookAction(options?: PlaybookActionOptions): FoundryPlaybookAction;
+
+declare const FOUNDRY_TRANSMISSION_BRAND: unique symbol;
+declare const FOUNDRY_TRANSMISSION_PREDICATE_BRAND: unique symbol;
+declare const FOUNDRY_TRANSMISSION_EVENT_BRAND: unique symbol;
+type TransmissionEventDirection = "inbound" | "outbound";
+interface TransmissionEventOptions<TDirection extends TransmissionEventDirection = TransmissionEventDirection> {
+    /** @deprecated File-routed definitions derive identity from their filename. */
+    readonly id?: string;
+    readonly direction: TDirection;
+    readonly description?: string;
+}
+type FoundryTransmissionEvent<TDirection extends TransmissionEventDirection = TransmissionEventDirection> = Readonly<TransmissionEventOptions<TDirection>> & {
+    readonly id: string;
+    readonly [FOUNDRY_TRANSMISSION_EVENT_BRAND]: true;
+};
+interface TransmissionPredicateOptions<TEvent = unknown, TError = never, TRequirements = never> {
+    /** @deprecated File-routed definitions derive identity from their filename. */
+    readonly id?: string;
+    readonly description?: string;
+    readonly match: (event: TEvent, parameters: Readonly<Record<string, unknown>>, context: IngressContext) => Effect.Effect<boolean, TError, TRequirements>;
+}
+type FoundryTransmissionPredicate<TEvent = unknown, TError = never, TRequirements = never> = Readonly<TransmissionPredicateOptions<TEvent, TError, TRequirements>> & {
+    readonly id: string;
+    readonly [FOUNDRY_TRANSMISSION_PREDICATE_BRAND]: true;
+};
+interface CapabilityDefinition {
+    readonly id: string;
+    readonly description: string;
+    readonly account: "none" | "optional" | "required";
+    readonly effect: "read" | "write";
+}
+interface IngressContext {
+    readonly route: InboundRoute;
+    readonly account?: AccountReference;
+}
+interface TransmissionSerializationContext extends IngressContext {
+    readonly eventId: string;
+    readonly eventName: string;
+    readonly threadKey: string;
+    readonly playbooks: ReadonlyArray<AgentPlaybook>;
+}
+interface EgressContext {
+    readonly route: OutboundRoute;
+    readonly account?: AccountReference;
+    readonly grant: RunGrant;
+}
+/** Provider ingress remains adapter-owned and returns typed Effects. */
+interface IngressAdapter<TEvent, TError = never, TRequirements = never> {
+    readonly authenticate: (raw: unknown, context: IngressContext) => Effect.Effect<boolean, TError, TRequirements>;
+    readonly normalize: (raw: unknown, context: IngressContext) => Effect.Effect<TEvent, TError, TRequirements>;
+}
+/** Provider delivery remains adapter-owned and revalidates its route per call. */
+interface EgressAdapter<TInput, TOutput, TError = never, TRequirements = never> {
+    readonly deliver: (input: TInput, context: EgressContext) => Effect.Effect<TOutput, TError, TRequirements>;
+}
+interface AccountContract<TMetadata extends Schema.Schema.AnyNoContext = Schema.Schema.AnyNoContext> {
+    readonly required: boolean;
+    readonly metadata: TMetadata;
+}
+interface InboundContract<TConfig extends Schema.Schema.AnyNoContext = Schema.Schema.AnyNoContext, TEvent extends Schema.Schema.AnyNoContext = Schema.Schema.AnyNoContext, TError = never, TRequirements = never> {
+    readonly config: TConfig;
+    readonly event: TEvent;
+    readonly adapter?: IngressAdapter<Schema.Schema.Type<TEvent>, TError, TRequirements>;
+    /** Resolve a predefined event after normalization. Omit to use provider event data at runtime. */
+    readonly classify?: (event: Schema.Schema.Type<TEvent>, context: IngressContext) => Effect.Effect<FoundryTransmissionEvent<"inbound">, TError, TRequirements>;
+    /** Executable definitions referenced directly by code-authored playbooks. */
+    readonly predicates?: ReadonlyArray<FoundryTransmissionPredicate<Schema.Schema.Type<TEvent>, TError, TRequirements>>;
+    /** Transmission-owned event rendering. Omit for Foundry's deterministic XML serializer. */
+    readonly serialize?: (event: Schema.Schema.Type<TEvent>, context: TransmissionSerializationContext) => Effect.Effect<string, TError, TRequirements>;
+}
+interface OutboundContract<TConfig extends Schema.Schema.AnyNoContext = Schema.Schema.AnyNoContext, TInput extends Schema.Schema.AnyNoContext = Schema.Schema.AnyNoContext, TOutput extends Schema.Schema.AnyNoContext = Schema.Schema.AnyNoContext, TError = never, TRequirements = never> {
+    readonly config: TConfig;
+    readonly input: TInput;
+    readonly output: TOutput;
+    readonly adapter?: EgressAdapter<Schema.Schema.Type<TInput>, Schema.Schema.Type<TOutput>, TError, TRequirements>;
+}
+interface TransmissionOptions {
+    /** @deprecated File-routed definitions derive identity from their filename. */
+    readonly id?: string;
+    readonly name: string;
+    readonly description: string;
+    readonly account?: AccountContract;
+    readonly capabilities?: ReadonlyArray<CapabilityDefinition>;
+    /** Events this transmission can receive or deliver. */
+    readonly events?: ReadonlyArray<FoundryTransmissionEvent>;
+    readonly inbound?: InboundContract;
+    readonly outbound?: OutboundContract;
+}
+type FoundryTransmission<TOptions extends TransmissionOptions> = Readonly<TOptions> & {
+    readonly id: string;
+    readonly [FOUNDRY_TRANSMISSION_BRAND]: true;
+};
+type AnyFoundryTransmission = FoundryTransmission<TransmissionOptions>;
+type InferAccountMetadata<TTransmission> = TTransmission extends FoundryTransmission<infer TOptions> ? TOptions["account"] extends AccountContract<infer TSchema> ? Schema.Schema.Type<TSchema> : never : never;
+type InferInboundEvent<TTransmission> = TTransmission extends FoundryTransmission<infer TOptions> ? TOptions["inbound"] extends InboundContract<Schema.Schema.AnyNoContext, infer TEvent> ? Schema.Schema.Type<TEvent> : never : never;
+type InferInboundConfig<TTransmission> = TTransmission extends FoundryTransmission<infer TOptions> ? TOptions["inbound"] extends InboundContract<infer TConfig, Schema.Schema.AnyNoContext> ? Schema.Schema.Type<TConfig> : never : never;
+type InferOutboundConfig<TTransmission> = TTransmission extends FoundryTransmission<infer TOptions> ? TOptions["outbound"] extends OutboundContract<infer TConfig, Schema.Schema.AnyNoContext, Schema.Schema.AnyNoContext> ? Schema.Schema.Type<TConfig> : never : never;
+type InferOutboundInput<TTransmission> = TTransmission extends FoundryTransmission<infer TOptions> ? TOptions["outbound"] extends OutboundContract<Schema.Schema.AnyNoContext, infer TInput, Schema.Schema.AnyNoContext> ? Schema.Schema.Type<TInput> : never : never;
+type InferOutboundOutput<TTransmission> = TTransmission extends FoundryTransmission<infer TOptions> ? TOptions["outbound"] extends OutboundContract<Schema.Schema.AnyNoContext, Schema.Schema.AnyNoContext, infer TOutput> ? Schema.Schema.Type<TOutput> : never : never;
+declare function isFoundryTransmission(value: unknown): value is AnyFoundryTransmission;
+declare function defineTransmissionPredicate<TEvent = unknown, TError = never, TRequirements = never>(options: TransmissionPredicateOptions<TEvent, TError, TRequirements>): FoundryTransmissionPredicate<TEvent, TError, TRequirements>;
+declare function defineTransmissionEvent<const TDirection extends TransmissionEventDirection>(options: TransmissionEventOptions<TDirection>): FoundryTransmissionEvent<TDirection>;
+declare function transmissionPredicate(transmission: AnyFoundryTransmission, id: string): FoundryTransmissionPredicate | undefined;
+/** Define a provider-neutral transmission backed by Effect adapters. */
+declare function defineTransmission<const TOptions extends TransmissionOptions>(options: TOptions): FoundryTransmission<TOptions>;
+
+declare const FOUNDRY_CONNECTION_BRAND: unique symbol;
+interface ConnectionReceiveInput {
+    readonly route: InboundRoute;
+    readonly eventId: string;
+    readonly threadKey: string;
+    readonly raw: unknown;
+}
+interface ApplicationConnectionContext {
+    readonly applicationId: string;
+    readonly connectionId: string;
+    readonly definitionId: string;
+    readonly workspaceId: string;
+    readonly account?: AccountReference;
+    readonly routes: ReadonlyArray<InboundRoute>;
+    readonly signal: AbortSignal;
+    readonly ready: () => Effect.Effect<void>;
+    readonly receive: (input: ConnectionReceiveInput) => Effect.Effect<void, unknown, never>;
+    readonly withAccountSession?: <A>(operation: string, use: (session: unknown) => Effect.Effect<A, unknown, never>) => Effect.Effect<A, unknown, never>;
+}
+interface DefineConnectionOptions<TError = never, TRequirements = never> {
+    /** @deprecated File-routed definitions derive identity from their filename. */
+    readonly id?: string;
+    readonly description: string;
+    /** Every inbound transmission this provider connection may emit. */
+    readonly transmissions: ReadonlyArray<AnyFoundryTransmission>;
+    readonly connect: (context: ApplicationConnectionContext) => Effect.Effect<void, TError, TRequirements>;
+}
+type FoundryApplicationConnection = Readonly<DefineConnectionOptions<any, any>> & {
+    readonly id: string;
+    readonly [FOUNDRY_CONNECTION_BRAND]: true;
+};
+type ApplicationConnectionStatus = "connecting" | "connected" | "reconnecting" | "disconnected" | "failed";
+interface ApplicationConnectionState {
+    readonly id: string;
+    readonly applicationId: string;
+    readonly connectionId: string;
+    readonly definitionId: string;
+    readonly workspaceId: string;
+    readonly accountId?: string;
+    readonly routeIds: ReadonlyArray<string>;
+    readonly status: ApplicationConnectionStatus;
+    readonly attempts: number;
+    readonly connectedAt?: string;
+    readonly disconnectedAt?: string;
+    readonly lastEventAt?: string;
+    readonly error?: string;
+}
+declare function defineConnection<TError = never, TRequirements = never>(options: DefineConnectionOptions<TError, TRequirements>): FoundryApplicationConnection;
+
+type AgentProvisioningPolicy = {
+    readonly mode: "singleton";
+    readonly key?: string;
+} | {
+    readonly mode: "per-thread";
+} | {
+    readonly mode: "per-event";
+} | {
+    readonly mode: "existing";
+    readonly agentIds: ReadonlyArray<string>;
+} | {
+    readonly mode: "custom";
+    readonly adapter: string;
+};
+interface PlaybookSubscriptionTarget {
+    readonly definitionId: string;
+    readonly provisioning: AgentProvisioningPolicy;
+    readonly context: Readonly<Record<string, unknown>>;
+    readonly installations: ReadonlyArray<AgentInstallation>;
+}
+interface PlaybookSubscription {
+    readonly id: string;
+    readonly workspaceId: string;
+    readonly enabled: boolean;
+    readonly playbook: AgentPlaybook;
+    readonly targets: ReadonlyArray<PlaybookSubscriptionTarget>;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface PlaybookSubscriptionTargetInput {
+    readonly agent: FoundryAgentDefinition;
+    readonly provisioning?: AgentProvisioningPolicy;
+    readonly context?: Readonly<Record<string, unknown>>;
+    readonly installations?: ReadonlyArray<AgentInstallation>;
+}
+interface DefinePlaybookSubscriptionOptions {
+    /** @deprecated File-routed subscriptions derive identity from their filename. */
+    readonly id?: string;
+    readonly workspaceId?: string;
+    readonly enabled?: boolean;
+    readonly playbook: AgentPlaybookInput | AgentPlaybook;
+    readonly targets: ReadonlyArray<PlaybookSubscriptionTargetInput>;
+    readonly createdAt?: string;
+    readonly updatedAt?: string;
+}
+interface CustomProvisioningContext {
+    readonly subscription: PlaybookSubscription;
+    readonly target: PlaybookSubscriptionTarget;
+    readonly route: InboundRoute;
+    readonly eventId: string;
+    readonly eventName: string;
+    readonly threadKey: string;
+    readonly event: unknown;
+}
+interface CustomProvisionedAgent extends CreateAgentInstanceOptions {
+    /** Stable uniqueness key; the data adapter enforces it atomically. */
+    readonly provisioningKey: string;
+}
+interface FoundryInstanceProvisioner {
+    readonly identifier: string;
+    provision(adapter: string, context: CustomProvisioningContext): Effect.Effect<ReadonlyArray<CustomProvisionedAgent>, unknown, never>;
+}
+declare function definePlaybookSubscription(options: DefinePlaybookSubscriptionOptions): PlaybookSubscription;
+/** Rehydrate the value-only representation returned by a durable adapter. */
+declare function reconstructPlaybookSubscription(subscription: PlaybookSubscription): PlaybookSubscription;
+
+declare const FOUNDRY_SCHEDULE_BRAND: unique symbol;
+type FoundryScheduleTimingInput = {
+    readonly kind: "at";
+    readonly at: string;
+} | {
+    readonly kind: "after";
+    readonly duration: string;
+} | {
+    readonly kind: "every";
+    readonly interval: string;
+} | {
+    readonly kind: "cron";
+    readonly expression: string;
+    readonly timezone?: string;
+};
+type FoundryScheduleTiming = {
+    readonly kind: "at";
+    readonly at: string;
+} | {
+    readonly kind: "every";
+    readonly intervalMs: number;
+} | {
+    readonly kind: "cron";
+    readonly expression: string;
+    readonly timezone: string;
+};
+interface DefineFoundryScheduleOptions {
+    /** Stable semantic name within one agent definition. It is not a runtime id. */
+    readonly name: string;
+    readonly description?: string;
+    readonly message: string;
+    readonly payload?: unknown;
+    readonly timing: FoundryScheduleTimingInput;
+    readonly enabled?: boolean;
+}
+type FoundryScheduleDefinition = Readonly<DefineFoundryScheduleOptions> & {
+    readonly [FOUNDRY_SCHEDULE_BRAND]: true;
+};
+declare function defineSchedule(options: DefineFoundryScheduleOptions): FoundryScheduleDefinition;
+declare function isFoundrySchedule(value: unknown): value is FoundryScheduleDefinition;
+
+interface AgentInstance {
+    readonly id: string;
+    readonly definitionId: string;
+    readonly workspaceId: string;
+    /** Stable adapter-enforced key used by lazy subscription provisioning. */
+    readonly provisioningKey?: string;
+    readonly context: Readonly<Record<string, unknown>>;
+    /** Persisted desired state. Definitions only provide the capability catalogue. */
+    readonly installations: ReadonlyArray<AgentInstallation>;
+    readonly playbooks: ReadonlyArray<AgentPlaybook>;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface Conversation {
+    readonly id: string;
+    readonly agentId: string;
+    readonly workspaceId: string;
+    readonly title?: string;
+    readonly context: Readonly<Record<string, unknown>>;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface WorkspaceEntry {
+    readonly workspaceId: string;
+    readonly key: string;
+    readonly value: unknown;
+    readonly updatedAt: string;
+}
+interface SharedInboxItem {
+    readonly id: string;
+    readonly workspaceId: string;
+    readonly conversationId?: string;
+    readonly agentId?: string;
+    readonly topic: string;
+    readonly payload: unknown;
+    readonly status: "pending" | "resolved" | "dismissed";
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface EnvironmentValue {
+    readonly key: string;
+    /** Secret values are deliberately never exposed through this primitive. */
+    readonly value: unknown;
+    readonly scope: "workspace" | "agent" | "conversation";
+    readonly workspaceId: string;
+    readonly agentId?: string;
+    readonly conversationId?: string;
+}
+interface FoundryTask {
+    readonly id: string;
+    readonly workspaceId: string;
+    readonly agentId?: string;
+    readonly conversationId?: string;
+    readonly title: string;
+    readonly detail?: string;
+    readonly status: "open" | "in-progress" | "completed" | "cancelled";
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface InboundDeliveryClaim {
+    readonly key: string;
+    readonly status: "pending" | "completed";
+    readonly runIds: ReadonlyArray<string>;
+    readonly claimedAt: string;
+    readonly completedAt?: string;
+}
+interface FoundryWorkingEnvironmentSnapshotOwner {
+    readonly scope: "agent" | "conversation";
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+}
+/**
+ * Adapter-backed runtime data created by Foundry's scheduling and sleep tools.
+ * This is reconstructed state, never a file-authored definition primitive.
+ */
+interface FoundryActivationRecord {
+    readonly id: string;
+    readonly kind: "scheduled" | "sleep";
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly message: string;
+    readonly payload?: unknown;
+    readonly timing: FoundryScheduleTiming;
+    readonly origin: "agent-definition" | "agent-tool";
+    readonly scheduleName?: string;
+    /** Hash of the last reconciled definition value; runtime edits remain overrides. */
+    readonly definitionRevision?: string;
+    readonly status: "pending" | "active" | "completed" | "cancelled";
+    readonly createdByRunId: string;
+    readonly lastRunId?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface FoundryDataAdapter {
+    readonly identifier: string;
+    getAgent(id: string): Effect.Effect<AgentInstance | null, unknown, never>;
+    putAgent(agent: AgentInstance): Effect.Effect<void, unknown, never>;
+    listAgents(definitionId?: string): Effect.Effect<ReadonlyArray<AgentInstance>, unknown, never>;
+    provisionAgent(input: ProvisionAgentOptions): Effect.Effect<AgentInstance, unknown, never>;
+    getPlaybookSubscription(id: string): Effect.Effect<PlaybookSubscription | null, unknown, never>;
+    putPlaybookSubscription(subscription: PlaybookSubscription): Effect.Effect<void, unknown, never>;
+    deletePlaybookSubscription(id: string): Effect.Effect<boolean, unknown, never>;
+    listPlaybookSubscriptions(workspaceId?: string): Effect.Effect<ReadonlyArray<PlaybookSubscription>, unknown, never>;
+    getInboundDelivery(key: string): Effect.Effect<InboundDeliveryClaim | null, unknown, never>;
+    claimInboundDelivery(key: string): Effect.Effect<boolean, unknown, never>;
+    completeInboundDelivery(key: string, runIds: ReadonlyArray<string>): Effect.Effect<void, unknown, never>;
+    releaseInboundDelivery(key: string): Effect.Effect<void, unknown, never>;
+    getActivation(id: string): Effect.Effect<FoundryActivationRecord | null, unknown, never>;
+    putActivation(activation: FoundryActivationRecord): Effect.Effect<void, unknown, never>;
+    listActivations(workspaceId?: string): Effect.Effect<ReadonlyArray<FoundryActivationRecord>, unknown, never>;
+    getConversation(id: string): Effect.Effect<Conversation | null, unknown, never>;
+    putConversation(conversation: Conversation): Effect.Effect<void, unknown, never>;
+    listConversations(agentId: string): Effect.Effect<ReadonlyArray<Conversation>, unknown, never>;
+    getWorkspaceEntry(workspaceId: string, key: string): Effect.Effect<WorkspaceEntry | null, unknown, never>;
+    putWorkspaceEntry(entry: WorkspaceEntry): Effect.Effect<void, unknown, never>;
+    listWorkspaceEntries(workspaceId: string): Effect.Effect<ReadonlyArray<WorkspaceEntry>, unknown, never>;
+    /** Private VFS persistence; snapshots are never exposed as workspace entries. */
+    getWorkingEnvironmentSnapshot(owner: FoundryWorkingEnvironmentSnapshotOwner): Effect.Effect<EnvSnapshot | null, unknown, never>;
+    putWorkingEnvironmentSnapshot(owner: FoundryWorkingEnvironmentSnapshotOwner, snapshot: EnvSnapshot): Effect.Effect<void, unknown, never>;
+    putInboxItem(item: SharedInboxItem): Effect.Effect<void, unknown, never>;
+    listInboxItems(workspaceId: string): Effect.Effect<ReadonlyArray<SharedInboxItem>, unknown, never>;
+    putTask(task: FoundryTask): Effect.Effect<void, unknown, never>;
+    listTasks(workspaceId: string): Effect.Effect<ReadonlyArray<FoundryTask>, unknown, never>;
+    listEnvironment(scope: {
+        readonly workspaceId: string;
+        readonly agentId?: string;
+        readonly conversationId?: string;
+    }): Effect.Effect<ReadonlyArray<EnvironmentValue>, unknown, never>;
+}
+/** The exact request shape accepted by `Glove.processRequest`. */
+type FoundryMessageInput = string | ReadonlyArray<ContentPart>;
+interface FoundryRequest {
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly message: FoundryMessageInput;
+    readonly payload?: unknown;
+    readonly context?: Readonly<Record<string, unknown>>;
+    readonly source?: {
+        readonly kind: "direct" | "transmission" | "activation" | "spawn" | "background";
+        readonly id?: string;
+        readonly provider?: string;
+        readonly eventId?: string;
+        readonly threadKey?: string;
+    };
+}
+/**
+ * Normalize Foundry's wire input into the native user `Message` seen by the
+ * Glove loop. Lazy assembly happens before hooks run, so this intentionally
+ * represents the unmodified inbound turn.
+ */
+declare function toGloveMessage(input: FoundryMessageInput): Message;
+/** Clone readonly request parts for Glove's mutable public input signature. */
+declare function toGloveRequestInput(input: FoundryMessageInput): string | ContentPart[];
+interface FoundryResult {
+    readonly status: "completed" | "suspended";
+    readonly value: unknown;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly suspension?: {
+        readonly commandId: string;
+        readonly wakeAt: string;
+    };
+}
+interface CreateAgentInstanceOptions {
+    readonly id?: string;
+    readonly workspaceId?: string;
+    readonly context?: Readonly<Record<string, unknown>>;
+    readonly installations?: ReadonlyArray<AgentInstallation>;
+    readonly playbooks?: ReadonlyArray<AgentPlaybook>;
+}
+interface ProvisionAgentOptions extends CreateAgentInstanceOptions {
+    readonly definitionId: string;
+    readonly provisioningKey: string;
+}
+interface UpdateAgentInstanceOptions {
+    readonly context?: Readonly<Record<string, unknown>>;
+    readonly installations?: ReadonlyArray<AgentInstallation>;
+    readonly playbooks?: ReadonlyArray<AgentPlaybook>;
+}
+interface CreateConversationOptions {
+    readonly id?: string;
+    readonly workspaceId?: string;
+    readonly title?: string;
+    readonly context?: Readonly<Record<string, unknown>>;
+}
+declare class MemoryFoundryDataAdapter implements FoundryDataAdapter {
+    readonly identifier: string;
+    private readonly agents;
+    private readonly agentsByProvisioningKey;
+    private readonly subscriptions;
+    private readonly inboundDeliveries;
+    private readonly activations;
+    private readonly conversations;
+    private readonly workspace;
+    private readonly workingEnvironments;
+    private readonly inbox;
+    private readonly tasks;
+    private readonly environment;
+    private pendingAgents;
+    private pendingSubscriptions;
+    constructor(options?: {
+        readonly identifier?: string;
+        readonly environment?: ReadonlyArray<EnvironmentValue>;
+        readonly agents?: ReadonlyArray<AgentInstance>;
+        readonly conversations?: ReadonlyArray<Conversation>;
+        readonly subscriptions?: ReadonlyArray<PlaybookSubscription>;
+        readonly activations?: ReadonlyArray<FoundryActivationRecord>;
+    });
+    /** Resolve file-owned identities only after Foundry discovery has bound them. */
+    private materializeSeeds;
+    getAgent(id: string): Effect.Effect<AgentInstance | null, never, never>;
+    putAgent(agent: AgentInstance): Effect.Effect<void, never, never>;
+    listAgents(definitionId?: string): Effect.Effect<AgentInstance[], never, never>;
+    provisionAgent(input: ProvisionAgentOptions): Effect.Effect<AgentInstance, never, never>;
+    getPlaybookSubscription(id: string): Effect.Effect<PlaybookSubscription | null, never, never>;
+    putPlaybookSubscription(subscription: PlaybookSubscription): Effect.Effect<void, never, never>;
+    deletePlaybookSubscription(id: string): Effect.Effect<boolean, never, never>;
+    listPlaybookSubscriptions(workspaceId?: string): Effect.Effect<PlaybookSubscription[], never, never>;
+    getInboundDelivery(key: string): Effect.Effect<InboundDeliveryClaim | null, never, never>;
+    claimInboundDelivery(key: string): Effect.Effect<boolean, never, never>;
+    completeInboundDelivery(key: string, runIds: ReadonlyArray<string>): Effect.Effect<void, never, never>;
+    releaseInboundDelivery(key: string): Effect.Effect<void, never, never>;
+    getActivation(id: string): Effect.Effect<FoundryActivationRecord | null, never, never>;
+    putActivation(activation: FoundryActivationRecord): Effect.Effect<void, never, never>;
+    listActivations(workspaceId?: string): Effect.Effect<FoundryActivationRecord[], never, never>;
+    getConversation(id: string): Effect.Effect<Conversation | null, never, never>;
+    putConversation(conversation: Conversation): Effect.Effect<void, never, never>;
+    listConversations(agentId: string): Effect.Effect<Conversation[], never, never>;
+    getWorkspaceEntry(workspaceId: string, key: string): Effect.Effect<WorkspaceEntry | null, never, never>;
+    putWorkspaceEntry(entry: WorkspaceEntry): Effect.Effect<void, never, never>;
+    listWorkspaceEntries(workspaceId: string): Effect.Effect<WorkspaceEntry[], never, never>;
+    getWorkingEnvironmentSnapshot(owner: FoundryWorkingEnvironmentSnapshotOwner): Effect.Effect<EnvSnapshot | null, never, never>;
+    putWorkingEnvironmentSnapshot(owner: FoundryWorkingEnvironmentSnapshotOwner, snapshot: EnvSnapshot): Effect.Effect<void, never, never>;
+    putInboxItem(item: SharedInboxItem): Effect.Effect<void, never, never>;
+    listInboxItems(workspaceId: string): Effect.Effect<SharedInboxItem[], never, never>;
+    putTask(task: FoundryTask): Effect.Effect<void, never, never>;
+    listTasks(workspaceId: string): Effect.Effect<FoundryTask[], never, never>;
+    listEnvironment(scope: {
+        readonly workspaceId: string;
+        readonly agentId?: string;
+        readonly conversationId?: string;
+    }): Effect.Effect<EnvironmentValue[], never, never>;
+}
+declare function createAgentInstance(definitionId: string, options?: CreateAgentInstanceOptions, provisioningKey?: string): AgentInstance;
+/** Code-authoring helper; instance data stores the referenced definition id. */
+declare function defineAgentInstance(definition: FoundryAgentDefinition, options?: CreateAgentInstanceOptions): AgentInstance;
+/** Rehydrate a durable adapter record into Foundry's immutable runtime shape. */
+declare function reconstructAgentInstance(agent: AgentInstance): AgentInstance;
+declare function createConversation(agent: AgentInstance, options?: CreateConversationOptions): Conversation;
+
+declare const FOUNDRY_SHARED_TOOL_BRAND: unique symbol;
+declare const FOUNDRY_AGENT_APPLICATION_BRAND: unique symbol;
+declare const FOUNDRY_MCP_BRAND: unique symbol;
+declare const FOUNDRY_MEMORY_BRAND: unique symbol;
+type AgentInstallationKind = "tool" | "application" | "mcp";
+type FoundryCapabilityKind = AgentInstallationKind | "memory";
+interface AgentInstallation {
+    readonly kind: AgentInstallationKind;
+    readonly id: string;
+    /** Durable account selection; code authoring supplies this through an AccountReference. */
+    readonly accountId?: string;
+    readonly config?: unknown;
+}
+type FoundryInstallable = FoundrySharedTool<any> | FoundryAgentApplication | FoundryMcp;
+/** Create persisted installation data from a code definition. */
+type DefinitionConfigInput<TDefinition> = TDefinition extends {
+    readonly config?: infer TSchema;
+} ? TSchema extends z.ZodType ? z.input<TSchema> : never : never;
+interface InstallationSelection {
+    readonly account?: AccountReference;
+}
+declare function install<TDefinition extends FoundryInstallable>(capability: TDefinition, ...configuration: [DefinitionConfigInput<TDefinition>] extends [never] ? [config?: never, selection?: InstallationSelection] : [config: DefinitionConfigInput<TDefinition>, selection?: InstallationSelection]): AgentInstallation;
+declare function installationKey(installation: AgentInstallation): string;
+interface AgentMountBaseContext {
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly runId: string;
+    readonly input: unknown;
+    readonly request: FoundryRequest;
+    readonly message: Message;
+    readonly messageInput: FoundryMessageInput;
+    readonly messageText: string;
+    readonly history: ReadonlyArray<Message>;
+    readonly messages: ReadonlyArray<Message>;
+    readonly glove: IGloveRunnable;
+    readonly store: StoreAdapter;
+    readonly emit: (event: {
+        type: string;
+        data?: unknown;
+    }) => void;
+}
+interface AgentInstallContext<TConfig = unknown> extends AgentMountBaseContext {
+    readonly installation: AgentInstallation;
+    readonly config: TConfig;
+    readonly accountId?: string;
+    readonly withAccountSession?: <A>(operation: string, use: (session: unknown) => Effect.Effect<A, unknown, never>) => Effect.Effect<A, unknown, never>;
+}
+interface AgentDefinitionSurfaceContext extends AgentMountBaseContext {
+    readonly surface: {
+        readonly kind: "memory";
+        readonly id: string;
+    };
+    readonly config: unknown;
+}
+/** Pure application-definition context. It deliberately exposes no Glove. */
+type AgentApplicationInstallContext<TConfig = unknown> = Omit<AgentInstallContext<TConfig>, "glove" | "store">;
+interface AgentApplicationContribution {
+    /** Tools Foundry will mount after the installer returns. */
+    readonly tools?: ReadonlyArray<GloveFoldArgs<any>>;
+}
+interface ConfiguredCapability<TConfigSchema extends z.ZodType | undefined = z.ZodType | undefined> {
+    /** @deprecated File-routed definitions derive identity from their filename. */
+    readonly id?: string;
+    readonly description: string;
+    readonly config?: TConfigSchema;
+}
+type SharedToolOptions<TInput = unknown, TConfigSchema extends z.ZodType | undefined = undefined> = ConfiguredCapability<TConfigSchema> & ({
+    readonly tool: GloveFoldArgs<TInput>;
+    readonly create?: never;
+} | {
+    readonly tool?: never;
+    readonly create: (context: AgentInstallContext<TConfigSchema extends z.ZodType ? z.output<TConfigSchema> : unknown>) => Effect.Effect<GloveFoldArgs<TInput>, unknown, never>;
+});
+type FoundrySharedTool<TInput = unknown, TConfigSchema extends z.ZodType | undefined = any> = Readonly<SharedToolOptions<TInput, TConfigSchema>> & {
+    readonly id: string;
+    readonly [FOUNDRY_SHARED_TOOL_BRAND]: true;
+};
+declare function defineSharedTool<TInput, const TConfigSchema extends z.ZodType | undefined = undefined>(options: SharedToolOptions<TInput, TConfigSchema>): FoundrySharedTool<TInput, TConfigSchema>;
+interface AgentApplicationOptions<TConfigSchema extends z.ZodType | undefined = undefined> extends ConfiguredCapability<TConfigSchema> {
+    /** Inbound transmission mechanisms owned by this application. */
+    readonly inbound?: ReadonlyArray<AnyFoundryTransmission>;
+    /** Outbound transmission mechanisms mounted as tools when installed. */
+    readonly outbound?: ReadonlyArray<AnyFoundryTransmission>;
+    /** Mixed/bidirectional definitions; prefer inbound/outbound for clarity. */
+    readonly transmissions?: ReadonlyArray<AnyFoundryTransmission>;
+    /** Purpose-built long-lived provider connections for inbound transmissions. */
+    readonly connections?: ReadonlyArray<FoundryApplicationConnection>;
+    readonly install?: (context: AgentApplicationInstallContext<TConfigSchema extends z.ZodType ? z.output<TConfigSchema> : unknown>) => Effect.Effect<AgentApplicationContribution | void, unknown, never>;
+}
+type FoundryAgentApplication<TConfigSchema extends z.ZodType | undefined = any> = Readonly<AgentApplicationOptions<TConfigSchema>> & {
+    readonly id: string;
+    readonly [FOUNDRY_AGENT_APPLICATION_BRAND]: true;
+};
+declare function defineAgentApplication<const TConfigSchema extends z.ZodType | undefined = undefined>(options: AgentApplicationOptions<TConfigSchema>): FoundryAgentApplication<TConfigSchema>;
+/** Concise authoring name for an agent-local application definition. */
+declare const defineApp: typeof defineAgentApplication;
+type FoundryApp = FoundryAgentApplication;
+interface FoundryMcpOptions<TConfigSchema extends z.ZodType | undefined = undefined> {
+    /** @deprecated File-routed definitions derive identity from their filename. */
+    readonly id?: string;
+    readonly description?: string;
+    readonly config?: TConfigSchema;
+    readonly entry: Omit<McpCatalogueEntry, "id">;
+}
+type FoundryMcp<TConfigSchema extends z.ZodType | undefined = any> = Readonly<FoundryMcpOptions<TConfigSchema>> & {
+    readonly id: string;
+    readonly [FOUNDRY_MCP_BRAND]: true;
+};
+declare function defineMcp<const TConfigSchema extends z.ZodType | undefined = undefined>(options: FoundryMcpOptions<TConfigSchema>): FoundryMcp<TConfigSchema>;
+type MemoryAdapterFactory<A> = (context: AgentDefinitionSurfaceContext) => Effect.Effect<A, unknown, never>;
+interface MemorySurfaceOptions {
+    readonly access?: "reader" | "curator";
+    readonly tools?: MemoryToolOptions["tools"];
+}
+interface FoundryMemoryProfileOptions<TConfigSchema extends z.ZodType | undefined = undefined> extends ConfiguredCapability<TConfigSchema> {
+    readonly entity?: MemorySurfaceOptions & {
+        readonly adapter: MemoryAdapterFactory<EntityMemoryAdapter>;
+    };
+    readonly episodic?: MemorySurfaceOptions & {
+        readonly adapter: MemoryAdapterFactory<EpisodicMemoryAdapter>;
+    };
+    readonly resources?: MemorySurfaceOptions & {
+        readonly adapter: MemoryAdapterFactory<ResourceFsAdapter>;
+    };
+    /** Ambient context remains on the main agent, matching glove-memory. */
+    readonly context?: {
+        readonly adapter: MemoryAdapterFactory<ContextAdapter>;
+        readonly tools?: MemoryToolOptions["tools"];
+    };
+    /** Escape hatch for subagent-delegated or application-specific composition. */
+    readonly mount?: (context: AgentDefinitionSurfaceContext) => Effect.Effect<void, unknown, never>;
+}
+type FoundryMemoryProfile<TConfigSchema extends z.ZodType | undefined = any> = Readonly<FoundryMemoryProfileOptions<TConfigSchema>> & {
+    readonly id: string;
+    readonly [FOUNDRY_MEMORY_BRAND]: true;
+};
+declare function defineMemory<const TConfigSchema extends z.ZodType | undefined = undefined>(options: FoundryMemoryProfileOptions<TConfigSchema>): FoundryMemoryProfile<TConfigSchema>;
+interface FoundryCapabilityRegistry {
+    readonly tools: ReadonlyArray<FoundrySharedTool<any>>;
+    readonly applications: ReadonlyArray<FoundryAgentApplication>;
+    readonly mcp: ReadonlyArray<FoundryMcp>;
+    readonly memory: ReadonlyArray<FoundryMemoryProfile>;
+}
+interface FoundryCapabilityManifestEntry {
+    readonly id: string;
+    readonly kind: FoundryCapabilityKind;
+    readonly description: string;
+    readonly ownership: "instance" | "definition";
+    readonly file?: string;
+}
+interface FoundryCapabilityManifest {
+    readonly tools: ReadonlyArray<FoundryCapabilityManifestEntry>;
+    readonly applications: ReadonlyArray<FoundryCapabilityManifestEntry>;
+    readonly mcp: ReadonlyArray<FoundryCapabilityManifestEntry>;
+    readonly memory: ReadonlyArray<FoundryCapabilityManifestEntry>;
+}
+declare const EMPTY_CAPABILITY_REGISTRY: FoundryCapabilityRegistry;
+interface McpAdapterFactory {
+    (context: Omit<AgentInstallContext, "installation" | "config"> & {
+        readonly installed: ReadonlyArray<FoundryMcp>;
+    }): Effect.Effect<McpAdapter, unknown, never>;
+}
+declare function isInboxCapableStore(store: StoreAdapter): store is StoreAdapter & Required<Pick<StoreAdapter, "getInboxItems" | "addInboxItem" | "updateInboxItem" | "getResolvedInboxItems">>;
+interface FoundryMemoryReference<TProfile extends FoundryMemoryProfile<any> = FoundryMemoryProfile<any>> {
+    readonly profile: TProfile;
+    readonly config: DefinitionConfigInput<TProfile>;
+}
+type FoundryMemorySelection = FoundryMemoryProfile | FoundryMemoryReference;
+/** Select a configured memory profile with schema-inferred input. */
+declare function configureMemory<TProfile extends FoundryMemoryProfile<any>>(profile: TProfile, config: DefinitionConfigInput<TProfile>): FoundryMemoryReference<TProfile>;
+interface MountAgentDefinitionMemoryOptions {
+    readonly registry: FoundryCapabilityRegistry;
+    readonly memory: ReadonlyArray<FoundryMemorySelection>;
+    readonly context: Omit<AgentDefinitionSurfaceContext, "surface" | "config">;
+}
+/** Mount definition-owned memory surfaces for one assembled run. */
+declare function mountAgentDefinitionMemory(options: MountAgentDefinitionMemoryOptions): Effect.Effect<void, unknown, never>;
+interface InstallRegistryOptions {
+    readonly registry: FoundryCapabilityRegistry;
+    readonly installations: ReadonlyArray<AgentInstallation>;
+    readonly context: Omit<AgentInstallContext, "installation" | "config">;
+    readonly mcpAdapter?: McpAdapterFactory;
+    readonly accountSessions?: FoundryAccountSessionAdapter;
+}
+interface FoundryAccountSessionAdapter {
+    readonly identifier: string;
+    withSession<A>(request: {
+        readonly accountId: string;
+        readonly operation: string;
+        readonly agentId: string;
+        readonly conversationId: string;
+        readonly workspaceId: string;
+    }, use: (session: unknown) => Effect.Effect<A, unknown, never>): Effect.Effect<A, unknown, never>;
+}
+/** Install only explicitly selected capabilities onto a running Glove. */
+declare function installRegistry(options: InstallRegistryOptions): Effect.Effect<ReadonlyArray<AgentInstallation>, unknown, never>;
+declare function isFoundryCapability(value: unknown): boolean;
+
+declare const FOUNDRY_WORKING_ENVIRONMENT_BRAND: unique symbol;
+declare const FOUNDRY_REPL_BRAND: unique symbol;
+type FoundryVfs = Vfs;
+type FoundryVfsHandle = EnvFsHandle;
+interface FoundryWorkingEnvironmentPersistenceContext {
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly runId: string;
+    readonly data: FoundryDataAdapter;
+    readonly signal: AbortSignal;
+}
+/**
+ * Storage is deliberately adapter-owned. Foundry never chooses a database,
+ * object store, locking policy, or credential lifecycle for an environment.
+ */
+interface FoundryWorkingEnvironmentPersistenceAdapter {
+    readonly identifier: string;
+    readonly load: (context: FoundryWorkingEnvironmentPersistenceContext) => Resolvable<EnvSnapshot | null>;
+    readonly save: (snapshot: EnvSnapshot, context: FoundryWorkingEnvironmentPersistenceContext) => Resolvable<void>;
+}
+interface FoundryWorkingEnvironmentCreateContext {
+    readonly assembly: AgentAssemblyContext<FoundryRequest>;
+    readonly snapshot: EnvSnapshot | null;
+}
+interface DefineFoundryWorkingEnvironmentOptions {
+    /**
+     * Build the native Glove environment. Use this when creation itself needs
+     * custom logic. The loaded snapshot is provided but never applied implicitly.
+     */
+    readonly create?: (context: FoundryWorkingEnvironmentCreateContext) => Resolvable<WorkingEnvironment>;
+    /**
+     * Native environment options. When persistence returns a snapshot and no
+     * filesystem is supplied, Foundry restores that snapshot automatically.
+     */
+    readonly options?: CreateWorkingEnvironmentOptions | ((context: FoundryWorkingEnvironmentCreateContext) => Resolvable<CreateWorkingEnvironmentOptions>);
+    readonly persistence?: FoundryWorkingEnvironmentPersistenceAdapter;
+    /** Native mount behavior: prompt priming and optional tool prefix. */
+    readonly mount?: Omit<MountWorkingEnvironmentConfig, "env">;
+    /** Close worker/adaptor resources after the run. Default true. */
+    readonly close?: boolean;
+}
+type FoundryWorkingEnvironmentDefinition = Readonly<DefineFoundryWorkingEnvironmentOptions> & {
+    readonly [FOUNDRY_WORKING_ENVIRONMENT_BRAND]: true;
+};
+declare function defineWorkingEnvironment(options?: DefineFoundryWorkingEnvironmentOptions): FoundryWorkingEnvironmentDefinition;
+/**
+ * Convenience persistence over the configured FoundryDataAdapter's private
+ * snapshot seam. VFS contents never become public workspace entries.
+ */
+declare function foundryDataEnvironmentPersistence(options?: {
+    readonly scope?: "agent" | "conversation";
+}): FoundryWorkingEnvironmentPersistenceAdapter;
+interface FoundryReplBase {
+    readonly [FOUNDRY_REPL_BRAND]: true;
+}
+type FoundryJavaScriptReplDefinition = FoundryReplBase & Readonly<{
+    readonly language: "javascript";
+    readonly session: JsSession;
+    readonly mount?: Omit<MountJsConfig, "session">;
+}>;
+type FoundryPythonReplDefinition = FoundryReplBase & Readonly<{
+    readonly language: "python";
+    readonly session: PySession;
+    readonly mount?: Omit<MountPyConfig, "session">;
+}>;
+type FoundryLispReplDefinition = FoundryReplBase & Readonly<{
+    readonly language: "lisp";
+    readonly session: LispSession;
+    readonly mount?: Omit<MountLispConfig, "session">;
+}>;
+type FoundryReplDefinition = FoundryJavaScriptReplDefinition | FoundryPythonReplDefinition | FoundryLispReplDefinition;
+type DefineFoundryReplOptions = Omit<FoundryJavaScriptReplDefinition, typeof FOUNDRY_REPL_BRAND> | Omit<FoundryPythonReplDefinition, typeof FOUNDRY_REPL_BRAND> | Omit<FoundryLispReplDefinition, typeof FOUNDRY_REPL_BRAND>;
+declare function defineRepl(options: DefineFoundryReplOptions): FoundryReplDefinition;
+type FoundryMountedRepl = Readonly<{
+    readonly language: "javascript";
+    readonly session: JsSession;
+}> | Readonly<{
+    readonly language: "python";
+    readonly session: PySession;
+}> | Readonly<{
+    readonly language: "lisp";
+    readonly session: LispSession;
+}>;
+
+declare const FOUNDRY_LAYER_BRAND: unique symbol;
+declare const FOUNDRY_SUBSCRIBER_BRAND: unique symbol;
+interface FoundrySurfaceContext<TInput = unknown> {
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly runId: string;
+    readonly input: TInput;
+    readonly request: FoundryRequest;
+    readonly message: Message;
+    readonly messageInput: FoundryMessageInput;
+    readonly messageText: string;
+    readonly history: ReadonlyArray<Message>;
+    readonly messages: ReadonlyArray<Message>;
+    readonly glove: IGloveRunnable;
+    readonly workingEnvironment?: WorkingEnvironment;
+    readonly vfs?: FoundryVfsHandle;
+    readonly repl?: FoundryMountedRepl;
+    readonly signal: AbortSignal;
+    readonly emit: (event: {
+        type: string;
+        data?: unknown;
+    }) => void;
+}
+type FoundrySurfaceCleanup = () => void | Promise<void> | Effect.Effect<void, unknown, never>;
+interface FoundryLayerOptions<TConfigSchema extends z.ZodType | undefined = undefined> {
+    /** @deprecated File-routed definitions derive identity from their filename. */
+    readonly id?: string;
+    readonly description: string;
+    readonly config?: TConfigSchema;
+    /**
+     * Mount any Glove-native package or application concern onto the compiled
+     * runnable. Mesh, memory subagent composition, scratchpads, image surfaces,
+     * voice bridges and future Glove packages all fit through this seam.
+     */
+    readonly setup: (context: FoundrySurfaceContext & {
+        readonly config: TConfigSchema extends z.ZodType ? z.output<TConfigSchema> : unknown;
+    }) => Effect.Effect<void | FoundrySurfaceCleanup, unknown, never>;
+}
+type FoundryLayer<TConfigSchema extends z.ZodType | undefined = undefined> = Readonly<FoundryLayerOptions<TConfigSchema>> & {
+    readonly id: string;
+    readonly [FOUNDRY_LAYER_BRAND]: true;
+};
+declare function defineLayer<TConfigSchema extends z.ZodType | undefined = undefined>(options: FoundryLayerOptions<TConfigSchema>): FoundryLayer<TConfigSchema>;
+interface FoundryLayerReference<TLayer extends FoundryLayer<any> = FoundryLayer<any>> {
+    readonly layer: TLayer;
+    readonly config?: TLayer extends FoundryLayer<infer TSchema> ? TSchema extends z.ZodType ? z.input<TSchema> : never : never;
+}
+type FoundryLayerSelection = FoundryLayerReference<any> | FoundryLayer<any>;
+/** Select a configured layer with schema-inferred input. */
+declare function configureLayer<TLayer extends FoundryLayer<any>>(layer: TLayer, config: FoundryLayerReference<TLayer>["config"]): FoundryLayerReference<TLayer>;
+interface FoundrySubscriberOptions {
+    /** @deprecated File-routed definitions derive identity from their filename. */
+    readonly id?: string;
+    readonly description: string;
+    readonly create: SubscriberAdapter | ((context: FoundrySurfaceContext) => SubscriberAdapter | Promise<SubscriberAdapter> | Effect.Effect<SubscriberAdapter, unknown, never>);
+}
+type FoundrySubscriber = Readonly<FoundrySubscriberOptions> & {
+    readonly id: string;
+    readonly [FOUNDRY_SUBSCRIBER_BRAND]: true;
+};
+declare function defineSubscriber(options: FoundrySubscriberOptions): FoundrySubscriber;
+type FoundrySubscriberSelection = FoundrySubscriber;
+interface FoundryNativeRegistry {
+    readonly layers: ReadonlyArray<FoundryLayer<any>>;
+    readonly subscribers: ReadonlyArray<FoundrySubscriber>;
+}
+interface FoundryNativeManifestEntry {
+    readonly id: string;
+    readonly kind: "layer" | "subscriber";
+    readonly description: string;
+    readonly file?: string;
+}
+interface FoundryNativeManifest {
+    readonly layers: ReadonlyArray<FoundryNativeManifestEntry>;
+    readonly subscribers: ReadonlyArray<FoundryNativeManifestEntry>;
+}
+declare const EMPTY_NATIVE_REGISTRY: FoundryNativeRegistry;
+declare function mountFoundrySurfaces(options: {
+    readonly registry: FoundryNativeRegistry;
+    readonly layers?: ReadonlyArray<FoundryLayerSelection>;
+    readonly subscribers?: ReadonlyArray<FoundrySubscriberSelection | SubscriberAdapter>;
+    readonly context: FoundrySurfaceContext;
+}): Promise<() => Promise<void>>;
+declare function isFoundryLayer(value: unknown): value is FoundryLayer;
+declare function isFoundrySubscriber(value: unknown): value is FoundrySubscriber;
+
+type FoundryAgentComponent = FoundrySharedTool<any> | FoundryAgentApplication | FoundryMcp | FoundryMemoryProfile | FoundryLayer<any> | FoundrySubscriber;
+interface FoundryAgentComposition {
+    readonly capabilities: FoundryCapabilityRegistry;
+    readonly native: FoundryNativeRegistry;
+}
+type FoundryCompositionSource = FoundryAgentComponent | FoundryAgentComposition | ReadonlyArray<FoundryCompositionSource> | (() => FoundryCompositionSource) | false | null | undefined;
+/**
+ * Compose colocated, headless agent parts into one immutable catalogue.
+ * Functions are factories, not runtime installers: they return definitions and
+ * never receive or mutate a Glove instance.
+ */
+declare function composeAgent(...sources: ReadonlyArray<FoundryCompositionSource>): FoundryAgentComposition;
+declare const EMPTY_AGENT_COMPOSITION: FoundryAgentComposition;
+
+declare const FOUNDRY_CORE_COMMAND_EVENT = "foundry.core.command";
+type FoundryCoreCommand = {
+    readonly id: string;
+    readonly type: "spawn";
+    readonly definitionId: string;
+    readonly agentId?: string;
+    readonly conversationId?: string;
+    readonly workspaceId: string;
+    readonly message: string;
+    readonly payload?: unknown;
+} | {
+    readonly id: string;
+    readonly type: "schedule";
+    readonly definitionId: string;
+    readonly agentId?: string;
+    readonly conversationId?: string;
+    readonly workspaceId: string;
+    readonly message: string;
+    readonly payload?: unknown;
+    readonly timing: {
+        readonly kind: "at";
+        readonly at: string;
+    } | {
+        readonly kind: "every";
+        readonly intervalMs: number;
+    } | {
+        readonly kind: "cron";
+        readonly expression: string;
+        readonly timezone: string;
+    };
+} | {
+    readonly id: string;
+    readonly type: "playbook.sync";
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly playbooks: ReadonlyArray<AgentPlaybook>;
+} | {
+    readonly id: string;
+    readonly type: "schedule.sync";
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly schedules: ReadonlyArray<{
+        readonly id: string;
+        readonly name: string;
+        readonly revision: string;
+        readonly message: string;
+        readonly payload?: unknown;
+        readonly timing: FoundryScheduleTiming;
+        readonly enabled: boolean;
+    }>;
+} | {
+    readonly id: string;
+    readonly type: "schedule.update";
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly activationId: string;
+    readonly patch: {
+        readonly message?: string;
+        readonly payload?: unknown;
+        readonly timing?: FoundryScheduleTiming;
+    };
+} | {
+    readonly id: string;
+    readonly type: "schedule.cancel";
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly activationId: string;
+} | {
+    readonly id: string;
+    readonly type: "sleep";
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly wakeAt: string;
+    readonly message: string;
+} | {
+    readonly id: string;
+    readonly type: "background";
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly message: string;
+    readonly payload?: unknown;
+    readonly reconvene: boolean;
+} | {
+    readonly id: string;
+    readonly type: "transmit";
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly routeId: string;
+    readonly payload: unknown;
+    readonly applicationId?: string;
+    readonly transmissionId?: string;
+};
+/**
+ * Installed apps expose one namespaced Glove tool per outbound transmission.
+ * The tool only queues a parent-runtime command; grants and delivery adapters
+ * remain authoritative outside the agent subprocess.
+ */
+declare function createInstalledApplicationTransmissionTools(context: AgentAssemblyContext, applications: ReadonlyArray<FoundryAgentApplication>, installations: ReadonlyArray<AgentInstallation>, playbooks?: ReadonlyArray<AgentPlaybook>): ReadonlyArray<GloveFoldArgs<any>>;
+/** Framework-owned orchestration tools. They emit commands for Foundry's runtime adapters. */
+declare function createFoundryCoreTools(context: AgentAssemblyContext, desiredSchedules?: Extract<FoundryCoreCommand, {
+    readonly type: "schedule.sync";
+}>["schedules"]): ReadonlyArray<GloveFoldArgs<any>>;
+
+declare const FOUNDRY_AGENT_DEFINITION_BRAND: unique symbol;
+/** @deprecated Agent modules are definitions; execution contracts are internal. */
+declare const FOUNDRY_AGENT_BRAND: symbol;
+declare const FOUNDRY_EVENT_PREFIX = "__GLOVE_FOUNDRY_EVENT__";
+declare const FOUNDRY_APPLICATION_ENV = "GLOVE_FOUNDRY_APPLICATION_FILE";
+declare const FOUNDRY_AGENT_ROUTE_ENV = "GLOVE_FOUNDRY_AGENT_ROUTE";
+declare const FOUNDRY_AGENT_FILE_ENV = "GLOVE_FOUNDRY_AGENT_FILE";
+declare const FOUNDRY_EXECUTION_MARKER = "__glove_foundry_execution_v1";
+type FoundryAgentMode = "agent";
+type Resolvable<T> = T | Promise<T> | Effect.Effect<T, unknown, never>;
+interface AgentRuntimeControls {
+    readonly signal: AbortSignal;
+    readonly emit: (event: {
+        type: string;
+        data?: unknown;
+    }) => void;
+    /** Commands are emitted to the parent runtime and retained for result semantics. */
+    readonly commands: FoundryCoreCommand[];
+}
+interface AgentAssemblyContext<TInput = unknown> {
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly name: string;
+    readonly runId: string;
+    readonly mode: "agent";
+    readonly request: FoundryRequest;
+    readonly agentInstance: AgentInstance;
+    readonly conversation: Conversation;
+    /** Parent-runtime snapshot used by agent schedule management tools. */
+    readonly activations: ReadonlyArray<FoundryActivationRecord>;
+    readonly data: FoundryDataAdapter;
+    readonly input: TInput;
+    /** Native Glove representation of the current inbound user turn. */
+    readonly message: Message;
+    /** Exact input that will be passed to `Glove.processRequest`. */
+    readonly messageInput: FoundryMessageInput;
+    /** Convenience text projection matching Glove's multimodal normalization. */
+    readonly messageText: string;
+    /** Persisted native Glove messages before the current inbound turn. */
+    readonly history: ReadonlyArray<Message>;
+    /** Prior history followed by the current inbound turn. */
+    readonly messages: ReadonlyArray<Message>;
+    readonly installations: ReadonlyArray<AgentInstallation>;
+    readonly store: StoreAdapter | null;
+    readonly subscriber: SubscriberAdapter;
+    readonly controls: AgentRuntimeControls;
+}
+/** @deprecated Use AgentAssemblyContext. */
+type AgentFactoryContext<TInput = unknown> = AgentAssemblyContext<TInput>;
+interface FoundryHookDefinition {
+    readonly name: string;
+    readonly handler: HookHandler;
+}
+interface FoundryCallContext<TInput = unknown> extends FoundrySurfaceContext<TInput> {
+    readonly installations: ReadonlyArray<AgentInstallation>;
+}
+interface FoundryCallOptions<TInputSchema extends z.ZodType, TOutputSchema extends z.ZodType> {
+    readonly name: string;
+    readonly description: string;
+    readonly input: TInputSchema;
+    readonly output: TOutputSchema;
+    readonly exposeToAgent?: boolean;
+    readonly handler: (input: z.output<TInputSchema>, context: FoundryCallContext) => Resolvable<z.input<TOutputSchema>>;
+}
+type FoundryCall<TInputSchema extends z.ZodType = z.ZodType, TOutputSchema extends z.ZodType = z.ZodType> = Readonly<FoundryCallOptions<TInputSchema, TOutputSchema>>;
+declare function defineCall<TInputSchema extends z.ZodType, TOutputSchema extends z.ZodType>(options: FoundryCallOptions<TInputSchema, TOutputSchema>): FoundryCall<TInputSchema, TOutputSchema>;
+interface FoundryExecutionContext<TInput = unknown> extends FoundrySurfaceContext<TInput> {
+    readonly installations: ReadonlyArray<AgentInstallation>;
+    /** Native persistent environment mounted for this run, when configured. */
+    readonly workingEnvironment?: WorkingEnvironment;
+    /** Guarded VFS handle for host-side handlers and layers. */
+    readonly vfs?: FoundryVfsHandle;
+    /** Native Glove REPL session mounted for this run, when configured. */
+    readonly repl?: FoundryMountedRepl;
+    readonly invoke: (name: string, input: unknown) => Promise<unknown>;
+}
+interface AgentHandlerContext<TInput = unknown> extends FoundryExecutionContext<TInput> {
+    readonly defaultRun: () => Promise<unknown>;
+    /** @deprecated Use defaultRun. */
+    readonly defaultHandler: () => Promise<unknown>;
+    readonly spawn: (message?: FoundryMessageInput) => Promise<unknown>;
+}
+type FoundryResolver<T, TInput> = T | ((agent: FoundryAgentDefinition, context: AgentAssemblyContext<TInput>) => Resolvable<T>);
+type FoundryListResolver<T, TInput> = FoundryResolver<ReadonlyArray<T>, TInput>;
+interface AgentAssemblyOptions<TInput = unknown> {
+    readonly model?: FoundryResolver<ModelAdapter, TInput>;
+    readonly systemPrompt?: FoundryResolver<string, TInput>;
+    readonly displayManager?: FoundryResolver<DisplayManagerAdapter, TInput>;
+    readonly serverMode?: boolean;
+    readonly maxRetries?: number;
+    readonly maxConsecutiveErrors?: number;
+    readonly compactionLimit?: FoundryResolver<number, TInput>;
+    readonly compactionInstructions?: FoundryResolver<string, TInput>;
+    readonly maxTurns?: FoundryResolver<number, TInput>;
+    readonly enableToolResultSummary?: boolean;
+    readonly tools?: FoundryListResolver<GloveFoldArgs<any>, TInput>;
+    readonly hooks?: FoundryListResolver<FoundryHookDefinition, TInput>;
+    readonly skills?: FoundryListResolver<DefineSkillArgs, TInput>;
+    readonly subagents?: FoundryListResolver<DefineSubAgentArgs, TInput>;
+    /** Definition-owned Glove memory surfaces; may resolve lazily from run context. */
+    readonly memory?: FoundryListResolver<FoundryMemorySelection, TInput>;
+    /** Lazily load native Glove inbox items into this run's conversation store. */
+    readonly inboxes?: (agent: FoundryAgentDefinition, context: AgentAssemblyContext<TInput>) => Resolvable<ReadonlyArray<InboxItem>>;
+    readonly subscribers?: FoundryListResolver<FoundrySubscriberSelection | SubscriberAdapter, TInput>;
+    readonly layers?: FoundryListResolver<FoundryLayerSelection, TInput>;
+    readonly calls?: FoundryListResolver<FoundryCall<any, any>, TInput>;
+    /** Agent-local desired schedules, resolved lazily for the current instance and message. */
+    readonly schedules?: FoundryListResolver<FoundryScheduleDefinition, TInput>;
+    /** Runtime policy composed from transmission primitives and persisted on the instance. */
+    readonly playbooks?: FoundryListResolver<ComposedAgentPlaybook, TInput>;
+    readonly mesh?: FoundryResolver<FoundryMeshConfig | undefined, TInput>;
+    /** Sandboxed persistent files + named script execution, assembled per context. */
+    readonly workingEnvironment?: FoundryResolver<FoundryWorkingEnvironmentDefinition | undefined, TInput>;
+    /** One native Glove JavaScript, Python, or Lisp REPL mounted for this run. */
+    readonly repl?: FoundryResolver<FoundryReplDefinition | undefined, TInput>;
+    /** Mount any adapter-backed native surface after lazy assembly. */
+    readonly configure?: (agent: IGloveRunnable, context: FoundryExecutionContext<TInput>) => Resolvable<void>;
+    /** Final transformation of the assembled runnable. Returning undefined keeps it. */
+    readonly build?: (agent: IGloveRunnable, context: AgentAssemblyContext<TInput>) => Resolvable<IGloveRunnable | undefined>;
+    /** Construct a layered S2S/S2V/custom execution for one message. */
+    readonly spawn?: (agent: IGloveRunnable, context: FoundryExecutionContext<TInput>, message: FoundryMessageInput) => Resolvable<unknown>;
+    /** Own request execution. Omit it to use spawn, then Glove's normal loop. */
+    readonly run?: (agent: IGloveRunnable, context: AgentHandlerContext<TInput>) => Resolvable<unknown>;
+    /** @deprecated Use run. */
+    readonly handler?: (context: AgentHandlerContext<TInput>) => Resolvable<unknown>;
+}
+interface FoundryMeshConfig {
+    readonly adapter: MeshAdapter;
+    readonly identity?: Omit<AgentIdentity, "id"> & {
+        readonly id?: string;
+    };
+}
+interface DefineAgentOptions extends AgentAssemblyOptions<FoundryRequest> {
+    /** @deprecated File-routed agents derive identity from agents/<route>/agent.ts. */
+    readonly id?: string;
+    readonly description: string;
+    readonly tags?: readonly string[];
+    /** Colocated catalogue of parts this definition allows its instances to use. */
+    readonly components?: FoundryAgentComposition;
+    /** Agent-local MCP state/auth seam. Foundry never acquires or refreshes credentials. */
+    readonly mcpAdapter?: McpAdapterFactory;
+    /** Agent-local account-session seam for application contribution factories. */
+    readonly accountSessions?: FoundryAccountSessionAdapter;
+    readonly store?: (context: {
+        readonly definitionId: string;
+        readonly agentId: string;
+        readonly conversationId: string;
+        readonly workspaceId: string;
+    }) => Promise<StoreAdapter> | StoreAdapter;
+}
+type FoundryAgentDefinition = Readonly<DefineAgentOptions> & {
+    readonly id: string;
+    readonly [FOUNDRY_AGENT_DEFINITION_BRAND]: true;
+};
+type FoundryAgent = FoundryAgentDefinition;
+type AnyFoundryAgent = FoundryAgentDefinition;
+interface FoundryAgentConventionModule {
+    readonly default?: unknown;
+    /** @deprecated Named convention modules also derive identity from their file route. */
+    readonly id?: string;
+    readonly description?: string;
+    readonly tags?: readonly string[];
+    readonly components?: FoundryAgentComposition;
+    readonly mcpAdapter?: McpAdapterFactory;
+    readonly accountSessions?: FoundryAccountSessionAdapter;
+    readonly store?: DefineAgentOptions["store"];
+    readonly model?: AgentAssemblyOptions["model"];
+    readonly systemPrompt?: AgentAssemblyOptions["systemPrompt"];
+    readonly displayManager?: AgentAssemblyOptions["displayManager"];
+    readonly serverMode?: boolean;
+    readonly maxRetries?: number;
+    readonly maxConsecutiveErrors?: number;
+    readonly compactionLimit?: AgentAssemblyOptions["compactionLimit"];
+    readonly compactionInstructions?: AgentAssemblyOptions["compactionInstructions"];
+    readonly maxTurns?: AgentAssemblyOptions["maxTurns"];
+    readonly enableToolResultSummary?: boolean;
+    readonly tools?: AgentAssemblyOptions["tools"];
+    readonly hooks?: AgentAssemblyOptions["hooks"];
+    readonly skills?: AgentAssemblyOptions["skills"];
+    readonly subagents?: AgentAssemblyOptions["subagents"];
+    readonly memory?: AgentAssemblyOptions["memory"];
+    readonly inboxes?: AgentAssemblyOptions["inboxes"];
+    readonly subscribers?: AgentAssemblyOptions["subscribers"];
+    readonly layers?: AgentAssemblyOptions["layers"];
+    readonly calls?: AgentAssemblyOptions["calls"];
+    readonly schedules?: AgentAssemblyOptions["schedules"];
+    readonly playbooks?: AgentAssemblyOptions["playbooks"];
+    readonly mesh?: AgentAssemblyOptions["mesh"];
+    readonly workingEnvironment?: AgentAssemblyOptions["workingEnvironment"];
+    readonly repl?: AgentAssemblyOptions["repl"];
+    readonly configure?: AgentAssemblyOptions["configure"];
+    readonly build?: AgentAssemblyOptions["build"];
+    readonly spawn?: AgentAssemblyOptions["spawn"];
+    readonly run?: AgentAssemblyOptions["run"];
+    readonly handler?: AgentAssemblyOptions["handler"];
+}
+/** Agent definitions do not own transport schemas. Calls can still be typed with defineCall. */
+type InferAgentInput<_TAgent> = unknown;
+type InferAgentOutput<_TAgent> = unknown;
+declare function internalAgentName(route: string): string;
+declare function routeFromInternalAgentName(name: string): string;
+declare function isFoundryAgentDefinition(value: unknown): value is FoundryAgentDefinition;
+declare const isFoundryAgent: typeof isFoundryAgentDefinition;
+/** Pure data helper. It never creates or registers an execution job. */
+declare function defineAgent(options: DefineAgentOptions): FoundryAgentDefinition;
+/** Normalize either `export default defineAgent(...)` or named convention exports. */
+declare function defineAgentFromModule(route: string, module: FoundryAgentConventionModule): FoundryAgentDefinition;
+interface DefineFoundrySubagentOptions {
+    readonly name: string;
+    readonly description: string;
+    readonly systemPrompt: string;
+    readonly model?: ModelAdapter;
+    readonly durable?: boolean;
+    readonly serverMode?: boolean;
+    readonly maxRetries?: number;
+    readonly maxConsecutiveErrors?: number;
+    readonly compactionLimit?: number;
+    readonly compactionInstructions?: string;
+    readonly maxTurns?: number;
+    readonly enableToolResultSummary?: boolean;
+    readonly tools?: ReadonlyArray<GloveFoldArgs<any>>;
+    readonly hooks?: ReadonlyArray<FoundryHookDefinition>;
+    readonly skills?: ReadonlyArray<DefineSkillArgs>;
+    readonly subagents?: ReadonlyArray<DefineSubAgentArgs>;
+    readonly layers?: ReadonlyArray<FoundryLayer<any>>;
+    readonly subscribers?: ReadonlyArray<FoundrySubscriber | SubscriberAdapter>;
+    readonly configure?: (context: FoundrySurfaceContext<string>) => Resolvable<void>;
+}
+declare function defineSubagent(options: DefineFoundrySubagentOptions): DefineSubAgentArgs;
+type FoundryRouteMap = Record<string, object>;
+declare function defineRoutes<const TRoutes extends FoundryRouteMap>(routes: TRoutes): TRoutes;
+
+interface DiscoveredAgent {
+    route: string;
+    filePath: string;
+    relativePath: string;
+    definition: FoundryAgentDefinition;
+    executionName: string;
+}
+interface FoundryManifestAgent {
+    id: string;
+    description: string;
+    mode: "agent";
+    file: string;
+    tags: readonly string[];
+    invocationContract: "foundry/request-v1";
+    resultContract: "foundry/result-v1";
+    assembly: "foundry" | "custom";
+    handler: "glove" | "custom";
+    layers: readonly string[];
+    subscribers: readonly string[];
+    tools: readonly string[];
+    hooks: readonly string[];
+    skills: readonly string[];
+    subagents: readonly string[];
+    memory: readonly string[];
+    inboxLoader: boolean;
+    calls: readonly string[];
+    schedules: readonly string[];
+    playbooks: readonly string[];
+    mesh: boolean;
+    workingEnvironment: boolean;
+    repl: "javascript" | "python" | "lisp" | "dynamic" | null;
+    lazy: readonly string[];
+}
+interface FoundryManifest {
+    version: 1;
+    generatedAt: string;
+    agents: FoundryManifestAgent[];
+}
+declare function routeFromAgentFile(agentsDir: string, filePath: string): string | null;
+declare function findAgentFiles(agentsDir: string): Promise<string[]>;
+declare function discoverAgents(options: {
+    agentsDir: string;
+    strictFileRoutes?: boolean;
+    cacheBust?: boolean;
+}): Promise<DiscoveredAgent[]>;
+declare function createManifest(agents: readonly DiscoveredAgent[]): FoundryManifest;
+
+interface AccountFilter {
+    readonly transmissionId?: TransmissionId;
+}
+declare const AccountDirectory_base: Context.TagClass<AccountDirectory, "@glove-foundry/AccountDirectory", {
+    readonly get: (id: AccountId) => Effect.Effect<AccountReference, AccountNotFound>;
+    readonly list: (filter?: AccountFilter) => Effect.Effect<ReadonlyArray<AccountReference>>;
+}>;
+/**
+ * Read-only account metadata supplied by the application. Deliberately no
+ * create, authorize, refresh, revoke, token, or credential methods exist.
+ */
+declare class AccountDirectory extends AccountDirectory_base {
+}
+interface RouteFilter {
+    readonly transmissionId?: TransmissionId;
+    readonly accountId?: AccountId;
+    readonly direction?: Route["direction"];
+    readonly enabled?: boolean;
+}
+interface BindingFilter {
+    readonly agentId?: AgentId;
+    readonly transmissionId?: TransmissionId;
+    readonly accountId?: AccountId;
+    readonly routeId?: RouteId;
+    readonly enabled?: boolean;
+}
+declare const TopologyStore_base: Context.TagClass<TopologyStore, "@glove-foundry/TopologyStore", {
+    readonly getRoute: (id: RouteId) => Effect.Effect<Route, RouteNotFound>;
+    readonly listRoutes: (filter?: RouteFilter) => Effect.Effect<ReadonlyArray<Route>>;
+    readonly putRoute: (route: Route) => Effect.Effect<Route, TopologyConflict>;
+    readonly removeRoute: (id: RouteId) => Effect.Effect<void, RouteNotFound>;
+    readonly getBinding: (id: BindingId) => Effect.Effect<AgentBinding, BindingNotFound>;
+    readonly listBindings: (filter?: BindingFilter) => Effect.Effect<ReadonlyArray<AgentBinding>>;
+    readonly putBinding: (binding: AgentBinding) => Effect.Effect<AgentBinding, TopologyConflict>;
+    readonly removeBinding: (id: BindingId) => Effect.Effect<void, BindingNotFound>;
+}>;
+/** Durable desired topology. It stores opaque account ids, never credentials. */
+declare class TopologyStore extends TopologyStore_base {
+}
+declare const EventStore_base: Context.TagClass<EventStore, "@glove-foundry/EventStore", {
+    readonly put: (reference: EventReference, payload: unknown) => Effect.Effect<void>;
+    readonly getReference: (id: EventId) => Effect.Effect<EventReference, EventNotFound>;
+    readonly getPayload: (id: EventId) => Effect.Effect<unknown, EventNotFound>;
+}>;
+declare class EventStore extends EventStore_base {
+}
+interface AccountSessionRequest {
+    readonly account: AccountReference;
+    readonly operation: string;
+    readonly runId?: RunId;
+}
+/**
+ * A user-owned adapter that produces an operation-scoped Effect Layer. Its
+ * implementation owns credential lookup, refresh, SDK construction, and
+ * cleanup. Foundry only provides the resulting service to the operation.
+ */
+interface AccountSessionAdapter<TSession> {
+    readonly layer: (request: AccountSessionRequest) => Layer.Layer<TSession, AccountSessionUnavailable>;
+}
+declare function memoryAccountDirectory(accounts: ReadonlyArray<AccountReference>): Layer.Layer<AccountDirectory>;
+declare const memoryTopologyStore: Layer.Layer<TopologyStore>;
+declare const memoryEventStore: Layer.Layer<EventStore>;
+
+interface ResolveGrantRequest {
+    readonly runId: RunId;
+    readonly agentId: AgentId;
+    /** The inbound route that caused the run, when one exists. */
+    readonly originRouteId?: RouteId;
+}
+declare const GrantResolver_base: Context.TagClass<GrantResolver, "@glove-foundry/GrantResolver", {
+    readonly resolve: (request: ResolveGrantRequest) => Effect.Effect<RunGrant, GrantResolutionError>;
+}>;
+declare class GrantResolver extends GrantResolver_base {
+}
+/**
+ * Resolve desired bindings into immutable authority for exactly one run.
+ * Agents consume the resulting grant; they never query the topology directly.
+ */
+declare const grantResolverLive: Layer.Layer<GrantResolver, never, TopologyStore>;
+
+declare const FoundryManifestCapability: Schema.Struct<{
+    id: typeof Schema.String;
+    description: typeof Schema.String;
+    account: Schema.Literal<["none", "optional", "required"]>;
+    effect: Schema.Literal<["read", "write"]>;
+}>;
+declare const FoundryManifestTransmission: Schema.Struct<{
+    id: typeof Schema.String;
+    name: typeof Schema.String;
+    description: typeof Schema.String;
+    shape: Schema.Literal<["capability-only", "inbound-only", "outbound-only", "bidirectional"]>;
+    account: Schema.optional<Schema.Struct<{
+        required: typeof Schema.Boolean;
+        metadataSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+    }>>;
+    capabilities: Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        description: typeof Schema.String;
+        account: Schema.Literal<["none", "optional", "required"]>;
+        effect: Schema.Literal<["read", "write"]>;
+    }>>;
+    inbound: Schema.optional<Schema.Struct<{
+        configSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+        eventSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+    }>>;
+    outbound: Schema.optional<Schema.Struct<{
+        configSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+        inputSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+        outputSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+    }>>;
+}>;
+declare const FoundryApplicationManifest: Schema.Struct<{
+    schemaVersion: Schema.Literal<[2]>;
+    generatedAt: typeof Schema.String;
+    transmissions: Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        name: typeof Schema.String;
+        description: typeof Schema.String;
+        shape: Schema.Literal<["capability-only", "inbound-only", "outbound-only", "bidirectional"]>;
+        account: Schema.optional<Schema.Struct<{
+            required: typeof Schema.Boolean;
+            metadataSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+        }>>;
+        capabilities: Schema.Array$<Schema.Struct<{
+            id: typeof Schema.String;
+            description: typeof Schema.String;
+            account: Schema.Literal<["none", "optional", "required"]>;
+            effect: Schema.Literal<["read", "write"]>;
+        }>>;
+        inbound: Schema.optional<Schema.Struct<{
+            configSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+            eventSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+        }>>;
+        outbound: Schema.optional<Schema.Struct<{
+            configSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+            inputSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+            outputSchema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+        }>>;
+    }>>;
+}>;
+type FoundryApplicationManifest = typeof FoundryApplicationManifest.Type;
+declare const ManifestCompilationError_base: Schema.TaggedErrorClass<ManifestCompilationError, "ManifestCompilationError", {
+    readonly _tag: Schema.tag<"ManifestCompilationError">;
+} & {
+    message: typeof Schema.String;
+}>;
+declare class ManifestCompilationError extends ManifestCompilationError_base {
+}
+/** Compile code definitions into a value-only, credential-free manifest. */
+declare function compileApplicationManifest(transmissions: ReadonlyArray<AnyFoundryTransmission>): Effect.Effect<FoundryApplicationManifest, ManifestCompilationError>;
+
+type FoundryEventCategory = "agent" | "run" | "model" | "tool" | "extension" | "application" | "inbox" | "memory" | "mcp" | "activation" | "system" | "log";
+interface FoundryEvent {
+    readonly id: string;
+    readonly sequence: number;
+    readonly timestamp: string;
+    readonly type: string;
+    readonly category: FoundryEventCategory;
+    readonly agent?: string;
+    readonly runId?: string;
+    readonly data: unknown;
+}
+interface EventFilter {
+    readonly after?: number;
+    readonly agent?: string;
+    readonly runId?: string;
+    readonly category?: FoundryEventCategory;
+    readonly limit?: number;
+}
+interface FoundryObservabilityAdapter {
+    append(event: Omit<FoundryEvent, "id" | "sequence" | "timestamp"> & {
+        timestamp?: string;
+    }): FoundryEvent;
+    list(filter?: EventFilter): FoundryEvent[];
+    subscribe(listener: (event: FoundryEvent) => void): () => void;
+    clear?(): void | Promise<void>;
+}
+declare class MemoryObservabilityAdapter implements FoundryObservabilityAdapter {
+    private readonly maxEvents;
+    private readonly events;
+    private readonly listeners;
+    private sequence;
+    constructor(options?: {
+        maxEvents?: number;
+    });
+    append(input: Omit<FoundryEvent, "id" | "sequence" | "timestamp"> & {
+        timestamp?: string;
+    }): FoundryEvent;
+    list(filter?: EventFilter): FoundryEvent[];
+    subscribe(listener: (event: FoundryEvent) => void): () => void;
+    clear(): void;
+}
+
+declare const FOUNDRY_APPLICATION_BRAND: unique symbol;
+/** Process infrastructure only; agent files own runtime capabilities. */
+interface FoundryApplicationOptions {
+    readonly name: string;
+    readonly accounts?: ReadonlyArray<AccountReference>;
+    readonly routes?: ReadonlyArray<Route>;
+    readonly bindings?: ReadonlyArray<AgentBinding>;
+    readonly data?: FoundryDataAdapter;
+    readonly conversationStore?: (scope: {
+        readonly definitionId: string;
+        readonly agentId: string;
+        readonly conversationId: string;
+        readonly workspaceId: string;
+    }) => Promise<StoreAdapter> | StoreAdapter;
+    /** User-owned strategy for subscriptions using `provisioning.mode = "custom"`. */
+    readonly provisioner?: FoundryInstanceProvisioner;
+    readonly services?: Layer.Layer<AccountDirectory | TopologyStore | EventStore, unknown>;
+}
+type FoundryApplication = Readonly<FoundryApplicationOptions> & {
+    readonly [FOUNDRY_APPLICATION_BRAND]: true;
+};
+declare function isFoundryApplication(value: unknown): value is FoundryApplication;
+/** Define infrastructure. Agent composition is deliberately absent here. */
+declare function defineApplication(options: FoundryApplicationOptions): FoundryApplication;
+declare const EMPTY_FOUNDRY_APPLICATION: FoundryApplication;
+
+interface DiscoveredCapability {
+    readonly kind: "tool" | "application" | "mcp" | "memory";
+    readonly id: string;
+    readonly filePath: string;
+    readonly relativePath: string;
+}
+interface DiscoveredFoundryRegistry {
+    readonly capabilities: FoundryCapabilityRegistry;
+    readonly native: FoundryNativeRegistry;
+    readonly files: ReadonlyArray<DiscoveredCapability>;
+    readonly nativeFiles: ReadonlyArray<{
+        readonly kind: "layer" | "subscriber";
+        readonly id: string;
+        readonly filePath: string;
+        readonly relativePath: string;
+    }>;
+}
+
+interface FoundryRun<TOutput = unknown> {
+    readonly id: string;
+    readonly agent: string;
+    readonly kind: "trigger" | "recurring";
+    readonly status: "pending" | "running" | "completed" | "failed" | "cancelled";
+    readonly input: unknown;
+    readonly output?: TOutput;
+    readonly agentId?: string;
+    readonly conversationId?: string;
+    readonly workspaceId?: string;
+    readonly error?: string;
+    readonly attempts: number;
+    readonly maxAttempts: number;
+    readonly timeoutMs: number;
+    readonly createdAt: string;
+    readonly startedAt?: string;
+    readonly completedAt?: string;
+}
+declare const FoundryRuntimeError_base: Schema.TaggedErrorClass<FoundryRuntimeError, "FoundryRuntimeError", {
+    readonly _tag: Schema.tag<"FoundryRuntimeError">;
+} & {
+    operation: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+declare class FoundryRuntimeError extends FoundryRuntimeError_base {
+}
+interface FoundryRuntimeOptions {
+    readonly rootDir: string;
+    readonly agents: DiscoveredAgent[];
+    readonly application?: FoundryApplication;
+    readonly applicationFilePath?: string;
+    readonly registry?: DiscoveredFoundryRegistry;
+    readonly config?: FoundryConfig;
+    readonly observability?: FoundryObservabilityAdapter;
+}
+declare class FoundryRuntime {
+    readonly rootDir: string;
+    readonly agents: readonly DiscoveredAgent[];
+    readonly application: FoundryApplication;
+    readonly applicationFilePath?: string;
+    readonly registry: DiscoveredFoundryRegistry;
+    readonly manifest: FoundryManifest;
+    readonly applicationManifest: FoundryApplicationManifest;
+    readonly observability: FoundryObservabilityAdapter;
+    readonly data: FoundryDataAdapter;
+    private readonly byRoute;
+    private readonly routeBySignalName;
+    private readonly transmissionById;
+    /** Stable topology view used by synchronous playbook validation. */
+    private readonly topologyRoutes;
+    private readonly compositionByDefinition;
+    private readonly connectionSupervisor;
+    private readonly execution;
+    private readonly observer;
+    private readonly signalRunner;
+    private readonly envStore;
+    private readonly envProvider;
+    private readonly scheduleAdapter;
+    private readonly services;
+    private readonly runnerLoops;
+    private readonly materializedActivations;
+    private started;
+    private disposed;
+    constructor(options: FoundryRuntimeOptions);
+    static discover(options: {
+        rootDir: string;
+        agentsDir: string;
+        application?: FoundryApplication;
+        applicationFilePath?: string;
+        config?: FoundryConfig;
+        observability?: FoundryObservabilityAdapter;
+    }): Promise<FoundryRuntime>;
+    startEffect(): Effect.Effect<void, FoundryRuntimeError>;
+    start(): Promise<void>;
+    stopEffect(): Effect.Effect<void, FoundryRuntimeError>;
+    stop(): Promise<void>;
+    requestEffect(route: string, request: FoundryRequest): Effect.Effect<FoundryRun, FoundryRuntimeError>;
+    request(route: string, request: FoundryRequest): Promise<FoundryRun>;
+    createAgent(definitionId: string, options?: CreateAgentInstanceOptions): Promise<AgentInstance>;
+    createConversation(agentId: string, options?: CreateConversationOptions): Promise<Conversation>;
+    listAgentInstances(definitionId?: string): Promise<ReadonlyArray<AgentInstance>>;
+    setAgentPlaybooks(agentId: string, playbooks: ReadonlyArray<AgentPlaybook>): Promise<AgentInstance>;
+    listPlaybookSubscriptions(workspaceId?: string): Promise<ReadonlyArray<PlaybookSubscription>>;
+    /** List persisted future activations created by schedules or sleeping runs. */
+    listActivations(workspaceId?: string): Promise<ReadonlyArray<FoundryActivationRecord>>;
+    putPlaybookSubscription(input: DefinePlaybookSubscriptionOptions | PlaybookSubscription): Promise<PlaybookSubscription>;
+    deletePlaybookSubscription(id: string): Promise<boolean>;
+    listApplicationConnections(): ReadonlyArray<ApplicationConnectionState>;
+    reconnectApplicationConnection(id: string): Promise<void>;
+    /** Atomically replace the persisted, frontend-editable instance configuration. */
+    configureAgent(agentId: string, options: UpdateAgentInstanceOptions): Promise<AgentInstance>;
+    listConversations(agentId: string): Promise<ReadonlyArray<Conversation>>;
+    listWorkspaceEntries(workspaceId: string): Promise<ReadonlyArray<WorkspaceEntry>>;
+    putWorkspaceEntry(workspaceId: string, key: string, value: unknown): Promise<WorkspaceEntry>;
+    listSharedInbox(workspaceId: string): Promise<ReadonlyArray<SharedInboxItem>>;
+    postSharedInbox(input: Omit<SharedInboxItem, "id" | "createdAt" | "updatedAt">): Promise<SharedInboxItem>;
+    updateSharedInbox(workspaceId: string, itemId: string, status: SharedInboxItem["status"]): Promise<SharedInboxItem>;
+    listTasks(workspaceId: string): Promise<ReadonlyArray<FoundryTask>>;
+    createTask(input: Omit<FoundryTask, "id" | "createdAt" | "updatedAt">): Promise<FoundryTask>;
+    updateTask(workspaceId: string, taskId: string, status: FoundryTask["status"]): Promise<FoundryTask>;
+    listDataEnvironment(scope: {
+        readonly workspaceId: string;
+        readonly agentId?: string;
+        readonly conversationId?: string;
+    }): Promise<ReadonlyArray<EnvironmentValue>>;
+    send(agentId: string, conversationId: string, message: FoundryMessageInput, options?: {
+        readonly payload?: unknown;
+        readonly context?: Readonly<Record<string, unknown>>;
+    }): Promise<FoundryRun<FoundryResult>>;
+    getRun<TOutput = unknown>(runId: string): Promise<FoundryRun<TOutput> | null>;
+    listRuns(route?: string): Promise<FoundryRun[]>;
+    waitForRun<TOutput = unknown>(runId: string, options?: {
+        pollMs?: number;
+        timeoutMs?: number;
+    }): Promise<FoundryRun<TOutput> | null>;
+    cancel(runId: string): Promise<boolean>;
+    capabilityManifest(definitionId: string): FoundryCapabilityManifest;
+    nativeManifest(definitionId: string): FoundryNativeManifest;
+    listInstallations(agentId: string): Promise<ReadonlyArray<AgentInstallation>>;
+    installCapability(agentId: string, installation: AgentInstallation): Promise<AgentInstance>;
+    uninstallCapability(agentId: string, installation: AgentInstallation): Promise<AgentInstance>;
+    listAccounts(): Promise<{
+        id: string & effect_Brand.Brand<"FoundryAccountId">;
+        transmissionId: string & effect_Brand.Brand<"FoundryTransmissionId">;
+        externalAccountId: string;
+        label?: string | undefined;
+        metadata: {
+            readonly [x: string]: unknown;
+        };
+    }[]>;
+    listRoutes(): Promise<readonly ({
+        readonly id: string & effect_Brand.Brand<"FoundryRouteId">;
+        readonly transmissionId: string & effect_Brand.Brand<"FoundryTransmissionId">;
+        readonly direction: "inbound";
+        readonly accountId?: (string & effect_Brand.Brand<"FoundryAccountId">) | undefined;
+        readonly visibility: "private" | "workspace";
+        readonly enabled: boolean;
+        readonly config: {
+            readonly [x: string]: unknown;
+        };
+    } | {
+        readonly id: string & effect_Brand.Brand<"FoundryRouteId">;
+        readonly transmissionId: string & effect_Brand.Brand<"FoundryTransmissionId">;
+        readonly direction: "outbound";
+        readonly accountId?: (string & effect_Brand.Brand<"FoundryAccountId">) | undefined;
+        readonly visibility: "private" | "workspace";
+        readonly enabled: boolean;
+        readonly config: {
+            readonly [x: string]: unknown;
+        };
+    })[]>;
+    putRoute(route: Route): Promise<Route>;
+    removeRoute(id: RouteId): Promise<void>;
+    listBindings(): Promise<readonly {
+        readonly id: string & effect_Brand.Brand<"FoundryBindingId">;
+        readonly transmissionId: string & effect_Brand.Brand<"FoundryTransmissionId">;
+        readonly accountId?: (string & effect_Brand.Brand<"FoundryAccountId">) | undefined;
+        readonly enabled: boolean;
+        readonly routeId?: (string & effect_Brand.Brand<"FoundryRouteId">) | undefined;
+        readonly agentId: string & effect_Brand.Brand<"FoundryAgentId">;
+        readonly capabilities: readonly (string & effect_Brand.Brand<"FoundryCapabilityId">)[];
+        readonly reply?: {
+            readonly mode: "none";
+        } | {
+            readonly mode: "origin";
+        } | {
+            readonly mode: "route";
+            readonly routeId: string & effect_Brand.Brand<"FoundryRouteId">;
+        } | undefined;
+    }[]>;
+    putBinding(binding: AgentBinding): Promise<AgentBinding>;
+    removeBinding(id: BindingId): Promise<void>;
+    resolveGrant(request: ResolveGrantRequest): Promise<RunGrant>;
+    putEvent(reference: EventReference, payload: unknown): Promise<void>;
+    dispatchInbound(input: {
+        readonly routeId: string;
+        readonly eventId: string;
+        readonly threadKey: string;
+        readonly raw: unknown;
+    }): Promise<ReadonlyArray<FoundryRun>>;
+    dispatchOutbound(input: {
+        readonly routeId: string;
+        readonly agentId: string;
+        readonly runId: string;
+        readonly payload: unknown;
+        readonly commandId?: string;
+        readonly applicationId?: string;
+        readonly transmissionId?: string;
+    }): Promise<unknown>;
+    health(): Promise<Record<string, unknown>>;
+    private runsFromIds;
+    private waitForInboundDelivery;
+    private validatePlaybookSubscription;
+    private playbookMatches;
+    private resolveSubscriptionTarget;
+    private attachSubscriptionPlaybook;
+    private reconcileApplicationConnections;
+    private assertRegisteredInstallation;
+    private validatePlaybooks;
+    private validateRoute;
+    private validateBinding;
+    private executionSignal;
+    private seedTopology;
+    private runInBackground;
+    private settleRunnerLoops;
+    private enqueueCoreRequest;
+    private executeCoreCommand;
+    private syncAgentPlaybooks;
+    private assertActivationOwnership;
+    private backendScheduleId;
+    private disarmActivation;
+    private syncDefinitionSchedules;
+    private updateScheduledActivation;
+    private cancelScheduledActivation;
+    private reconstructActivations;
+    private materializeActivation;
+    private deliverOutbound;
+    private executionEnvelope;
+    private toFoundryRun;
+}
+
+interface FoundryClientOptions {
+    baseUrl?: string;
+    fetch?: typeof globalThis.fetch;
+}
+interface WaitOptions {
+    pollMs?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+interface FoundryHealth {
+    readonly ok: boolean;
+    readonly execution: boolean;
+    readonly environment: boolean;
+    readonly activations: boolean;
+    readonly agents: number;
+    readonly capabilities: number;
+    readonly surfaces: number;
+}
+declare class FoundryRunHandle<TOutput> {
+    readonly id: string;
+    readonly initial: FoundryRun<TOutput>;
+    private readonly client;
+    constructor(id: string, initial: FoundryRun<TOutput>, client: FoundryClient<FoundryRouteMap>);
+    get(): Promise<FoundryRun<TOutput>>;
+    cancel(): Promise<boolean>;
+    events(): Promise<FoundryEvent[]>;
+    wait(options?: WaitOptions): Promise<FoundryRun<TOutput>>;
+}
+declare class FoundryClient<TRoutes extends FoundryRouteMap> {
+    private readonly baseUrl;
+    private readonly fetcher;
+    constructor(options?: FoundryClientOptions);
+    health(): Promise<FoundryHealth>;
+    agent<TRoute extends Extract<keyof TRoutes, string>>(route: TRoute): {
+        create(options?: CreateAgentInstanceOptions): Promise<AgentInstance>;
+        request(request: FoundryRequest): Promise<FoundryRunHandle<FoundryResult>>;
+    };
+    createAgent(definitionId: string, options?: CreateAgentInstanceOptions): Promise<AgentInstance>;
+    agentInstances(definitionId?: string): Promise<ReadonlyArray<AgentInstance>>;
+    configureAgent(agentId: string, options: UpdateAgentInstanceOptions): Promise<AgentInstance>;
+    setAgentPlaybooks(agentId: string, playbooks: ReadonlyArray<AgentPlaybook>): Promise<AgentInstance>;
+    createConversation(agentId: string, options?: CreateConversationOptions): Promise<Conversation>;
+    conversations(agentId: string): Promise<ReadonlyArray<Conversation>>;
+    workspaceEntries(workspaceId: string): Promise<ReadonlyArray<WorkspaceEntry>>;
+    putWorkspaceEntry(workspaceId: string, key: string, value: unknown): Promise<WorkspaceEntry>;
+    sharedInbox(workspaceId: string): Promise<ReadonlyArray<SharedInboxItem>>;
+    postSharedInbox(workspaceId: string, input: {
+        readonly topic: string;
+        readonly payload?: unknown;
+        readonly agentId?: string;
+        readonly conversationId?: string;
+    }): Promise<SharedInboxItem>;
+    updateSharedInbox(workspaceId: string, itemId: string, status: SharedInboxItem["status"]): Promise<SharedInboxItem>;
+    tasks(workspaceId: string): Promise<ReadonlyArray<FoundryTask>>;
+    createTask(workspaceId: string, input: {
+        readonly title: string;
+        readonly detail?: string;
+        readonly agentId?: string;
+        readonly conversationId?: string;
+    }): Promise<FoundryTask>;
+    updateTask(workspaceId: string, taskId: string, status: FoundryTask["status"]): Promise<FoundryTask>;
+    dataEnvironment(workspaceId: string, scope?: {
+        readonly agentId?: string;
+        readonly conversationId?: string;
+    }): Promise<ReadonlyArray<EnvironmentValue>>;
+    dispatchInbound(input: {
+        readonly routeId: string;
+        readonly eventId: string;
+        readonly threadKey: string;
+        readonly raw: unknown;
+    }): Promise<ReadonlyArray<FoundryRun>>;
+    playbookSubscriptions(workspaceId?: string): Promise<ReadonlyArray<PlaybookSubscription>>;
+    activations(workspaceId?: string): Promise<ReadonlyArray<FoundryActivationRecord>>;
+    putPlaybookSubscription(subscription: PlaybookSubscription): Promise<PlaybookSubscription>;
+    deletePlaybookSubscription(id: string): Promise<boolean>;
+    applicationConnections(): Promise<ReadonlyArray<ApplicationConnectionState>>;
+    reconnectApplicationConnection(id: string): Promise<void>;
+    dispatchOutbound(input: {
+        readonly routeId: string;
+        readonly agentId: string;
+        readonly runId: string;
+        readonly payload: unknown;
+    }): Promise<unknown>;
+    send(agentId: string, conversationId: string, message: FoundryMessageInput, options?: {
+        readonly payload?: unknown;
+        readonly context?: Readonly<Record<string, unknown>>;
+    }): Promise<FoundryRunHandle<FoundryResult>>;
+    getRun<TOutput = unknown>(runId: string): Promise<FoundryRun<TOutput>>;
+    runs<TOutput = unknown>(route?: string): Promise<ReadonlyArray<FoundryRun<TOutput>>>;
+    cancelRun(runId: string): Promise<boolean>;
+    getEvents(filter?: {
+        runId?: string;
+        agent?: string;
+        after?: number;
+        category?: FoundryEvent["category"];
+    }): Promise<FoundryEvent[]>;
+    manifest(): Promise<{
+        agents: FoundryManifest;
+        application: FoundryApplicationManifest;
+        definitions: Readonly<Record<string, {
+            capabilities: FoundryCapabilityManifest;
+            surfaces: FoundryNativeManifest;
+        }>>;
+    }>;
+    capabilities(definitionId: string): Promise<FoundryCapabilityManifest>;
+    surfaces(definitionId: string): Promise<FoundryNativeManifest>;
+    installations(agentId: string): Promise<ReadonlyArray<AgentInstallation>>;
+    install(agentId: string, installation: AgentInstallation): Promise<AgentInstance>;
+    uninstall(agentId: string, installation: AgentInstallation): Promise<AgentInstance>;
+    accounts(): Promise<ReadonlyArray<AccountSummary>>;
+    routes(): Promise<ReadonlyArray<Route>>;
+    putRoute(route: Route): Promise<Route>;
+    removeRoute(id: string): Promise<void>;
+    bindings(): Promise<ReadonlyArray<AgentBinding>>;
+    putBinding(binding: AgentBinding): Promise<AgentBinding>;
+    removeBinding(id: string): Promise<void>;
+    resolveGrant(request: ResolveGrantRequest): Promise<RunGrant>;
+    private asUntyped;
+}
+declare function createFoundryClient<TRoutes extends FoundryRouteMap = Record<string, AnyFoundryAgent>>(options?: FoundryClientOptions): FoundryClient<TRoutes>;
+
+export { type CreateConversationOptions as $, type AgentPlaybook as A, type AgentHandlerContext as B, type CapabilityDefinition as C, type DiscoveredAgent as D, AgentId as E, FoundryRuntime as F, type AgentInstallContext as G, type AgentInstallation as H, type InferAccountMetadata as I, type AgentInstallationKind as J, type AgentPlaybookInput as K, type AgentProvisioningPolicy as L, type AgentRuntimeControls as M, type AnyFoundryAgent as N, OutboundRoute as O, type ApplicationConnectionContext as P, type ApplicationConnectionState as Q, type ApplicationConnectionStatus as R, type BindingFilter as S, BindingId as T, BindingNotFound as U, CapabilityId as V, type ComposedAgentPlaybook as W, type ComposedAgentPlaybookInput as X, type ConnectionReceiveInput as Y, type Conversation as Z, type CreateAgentInstanceOptions as _, type FoundryManifest as a, type FoundryCapabilityManifest as a$, type CustomProvisionedAgent as a0, type CustomProvisioningContext as a1, type DefineAgentOptions as a2, type DefineConnectionOptions as a3, type DefineFoundryReplOptions as a4, type DefineFoundryScheduleOptions as a5, type DefineFoundrySubagentOptions as a6, type DefineFoundryWorkingEnvironmentOptions as a7, type DefinePlaybookSubscriptionOptions as a8, type DefinitionConfigInput as a9, FOUNDRY_MEMORY_BRAND as aA, FOUNDRY_PLAYBOOK_ACTION_BRAND as aB, FOUNDRY_REPL_BRAND as aC, FOUNDRY_SCHEDULE_BRAND as aD, FOUNDRY_SHARED_TOOL_BRAND as aE, FOUNDRY_SUBSCRIBER_BRAND as aF, FOUNDRY_TRANSMISSION_BRAND as aG, FOUNDRY_TRANSMISSION_EVENT_BRAND as aH, FOUNDRY_TRANSMISSION_PREDICATE_BRAND as aI, FOUNDRY_WORKING_ENVIRONMENT_BRAND as aJ, type FoundryAccountSessionAdapter as aK, type FoundryActivationRecord as aL, type FoundryAgent as aM, type FoundryAgentComponent as aN, type FoundryAgentComposition as aO, type FoundryAgentConventionModule as aP, type FoundryAgentDefinition as aQ, type FoundryAgentMode as aR, type FoundryApp as aS, type FoundryApplication as aT, type FoundryApplicationConnection as aU, FoundryApplicationManifest as aV, type FoundryApplicationOptions as aW, type FoundryCall as aX, type FoundryCallContext as aY, type FoundryCallOptions as aZ, type FoundryCapabilityKind as a_, EMPTY_AGENT_COMPOSITION as aa, EMPTY_CAPABILITY_REGISTRY as ab, EMPTY_FOUNDRY_APPLICATION as ac, EMPTY_NATIVE_REGISTRY as ad, type EgressAdapter as ae, type EgressContext as af, type EnvironmentValue as ag, type EventFilter as ah, EventId as ai, EventNotFound as aj, EventReference as ak, EventStore as al, FOUNDRY_AGENT_APPLICATION_BRAND as am, FOUNDRY_AGENT_BRAND as an, FOUNDRY_AGENT_DEFINITION_BRAND as ao, FOUNDRY_AGENT_FILE_ENV as ap, FOUNDRY_AGENT_ROUTE_ENV as aq, FOUNDRY_APPLICATION_BRAND as ar, FOUNDRY_APPLICATION_ENV as as, FOUNDRY_COMPOSED_PLAYBOOK_BRAND as at, FOUNDRY_CONNECTION_BRAND as au, FOUNDRY_CORE_COMMAND_EVENT as av, FOUNDRY_EVENT_PREFIX as aw, FOUNDRY_EXECUTION_MARKER as ax, FOUNDRY_LAYER_BRAND as ay, FOUNDRY_MCP_BRAND as az, type AnyFoundryTransmission as b, type FoundryWorkingEnvironmentCreateContext as b$, type FoundryCapabilityManifestEntry as b0, type FoundryCapabilityRegistry as b1, FoundryClient as b2, type FoundryClientOptions as b3, type FoundryCompositionSource as b4, type FoundryCoreCommand as b5, type FoundryDataAdapter as b6, type FoundryDomainError as b7, type FoundryEvent as b8, type FoundryEventCategory as b9, type FoundryNativeRegistry as bA, type FoundryObservabilityAdapter as bB, type FoundryPlaybookAction as bC, type FoundryPythonReplDefinition as bD, type FoundryReplDefinition as bE, type FoundryRequest as bF, type FoundryResolver as bG, type FoundryResult as bH, type FoundryRouteMap as bI, type FoundryRun as bJ, FoundryRunHandle as bK, FoundryRuntimeError as bL, type FoundryRuntimeOptions as bM, type FoundryScheduleDefinition as bN, type FoundryScheduleTiming as bO, type FoundryScheduleTimingInput as bP, type FoundrySharedTool as bQ, type FoundrySubscriber as bR, type FoundrySubscriberOptions as bS, type FoundrySubscriberSelection as bT, type FoundrySurfaceContext as bU, type FoundryTask as bV, type FoundryTransmission as bW, type FoundryTransmissionEvent as bX, type FoundryTransmissionPredicate as bY, type FoundryVfs as bZ, type FoundryVfsHandle as b_, type FoundryExecutionContext as ba, type FoundryHealth as bb, type FoundryHookDefinition as bc, type FoundryInstallable as bd, type FoundryInstanceProvisioner as be, type FoundryJavaScriptReplDefinition as bf, type FoundryLayer as bg, type FoundryLayerOptions as bh, type FoundryLayerReference as bi, type FoundryLayerSelection as bj, type FoundryLispReplDefinition as bk, type FoundryListResolver as bl, type FoundryManifestAgent as bm, FoundryManifestCapability as bn, FoundryManifestTransmission as bo, type FoundryMcp as bp, type FoundryMcpOptions as bq, type FoundryMemoryProfile as br, type FoundryMemoryProfileOptions as bs, type FoundryMemoryReference as bt, type FoundryMemorySelection as bu, type FoundryMeshConfig as bv, type FoundryMessageInput as bw, type FoundryMountedRepl as bx, type FoundryNativeManifest as by, type FoundryNativeManifestEntry as bz, AccountReference as c, createManifest as c$, type FoundryWorkingEnvironmentDefinition as c0, type FoundryWorkingEnvironmentPersistenceAdapter as c1, type FoundryWorkingEnvironmentPersistenceContext as c2, type FoundryWorkingEnvironmentSnapshotOwner as c3, GrantResolutionError as c4, GrantResolver as c5, type InboundContract as c6, type InboundDeliveryClaim as c7, type InferAgentInput as c8, type InferAgentOutput as c9, RouteId as cA, RouteNotFound as cB, RunGrant as cC, RunId as cD, type SharedInboxItem as cE, type SharedToolOptions as cF, TopologyConflict as cG, TopologyStore as cH, type TransmissionEventDirection as cI, type TransmissionEventOptions as cJ, TransmissionId as cK, type TransmissionOptions as cL, type TransmissionPredicateOptions as cM, type TransmissionSerializationContext as cN, type UpdateAgentInstanceOptions as cO, type WaitOptions as cP, type WorkspaceEntry as cQ, compileApplicationManifest as cR, composeAgent as cS, composePlaybook as cT, configureLayer as cU, configureMemory as cV, createAgentInstance as cW, createConversation as cX, createFoundryClient as cY, createFoundryCoreTools as cZ, createInstalledApplicationTransmissionTools as c_, type InferInboundEvent as ca, type InferOutboundInput as cb, type InferOutboundOutput as cc, type IngressAdapter as cd, type IngressContext as ce, type InstallationSelection as cf, ManifestCompilationError as cg, type McpAdapterFactory as ch, MemoryFoundryDataAdapter as ci, MemoryObservabilityAdapter as cj, type OutboundContract as ck, type PlaybookActionOptions as cl, type PlaybookDirective as cm, type PlaybookDirectiveInput as cn, type PlaybookMatch as co, type PlaybookMatchInput as cp, type PlaybookOutboundDirective as cq, type PlaybookOutboundInput as cr, type PlaybookSubscription as cs, type PlaybookSubscriptionTarget as ct, type PlaybookSubscriptionTargetInput as cu, type ProvisionAgentOptions as cv, ReplyPolicy as cw, type ResolveGrantRequest as cx, Route as cy, type RouteFilter as cz, AgentBinding as d, defineAgent as d0, defineAgentApplication as d1, defineAgentFromModule as d2, defineAgentInstance as d3, defineApp as d4, defineApplication as d5, defineCall as d6, defineConnection as d7, defineLayer as d8, defineMcp as d9, isFoundryLayer as dA, isFoundrySchedule as dB, isFoundrySubscriber as dC, isFoundryTransmission as dD, isInboxCapableStore as dE, memoryAccountDirectory as dF, memoryEventStore as dG, memoryTopologyStore as dH, mountAgentDefinitionMemory as dI, mountFoundrySurfaces as dJ, reconstructAgentInstance as dK, reconstructPlaybook as dL, reconstructPlaybookSubscription as dM, routeFromAgentFile as dN, routeFromInternalAgentName as dO, toGloveMessage as dP, toGloveRequestInput as dQ, transmissionPredicate as dR, defineMemory as da, definePlaybookAction as db, definePlaybookSubscription as dc, defineRepl as dd, defineRoutes as de, defineSchedule as df, defineSharedTool as dg, defineSubagent as dh, defineSubscriber as di, defineTransmission as dj, defineTransmissionEvent as dk, defineTransmissionPredicate as dl, defineWorkingEnvironment as dm, discoverAgents as dn, findAgentFiles as dp, foundryDataEnvironmentPersistence as dq, grantResolverLive as dr, install as ds, installRegistry as dt, installationKey as du, internalAgentName as dv, isFoundryAgent as dw, isFoundryAgentDefinition as dx, isFoundryApplication as dy, isFoundryCapability as dz, type AgentInstance as e, type FoundryAgentApplication as f, InboundRoute as g, type InferInboundConfig as h, type InferOutboundConfig as i, type AccountContract as j, AccountDirectory as k, type AccountFilter as l, AccountId as m, AccountNotFound as n, type AccountSessionAdapter as o, type AccountSessionRequest as p, AccountSessionUnavailable as q, AccountSummary as r, type AgentApplicationContribution as s, type AgentApplicationInstallContext as t, type AgentApplicationOptions as u, type AgentAssemblyContext as v, type AgentAssemblyOptions as w, AgentDefinitionId as x, type AgentDefinitionSurfaceContext as y, type AgentFactoryContext as z };