glove-foundry 0.3.2 → 0.4.0

package/dist/{client-CLkZREDr.d.ts → client-D0-pKEZM.d.ts}

@@ -1,14 +1,17 @@
-import { ContentPart, Message, IGloveRunnable, StoreAdapter, GloveFoldArgs, SubscriberAdapter, ModelAdapter, DisplayManagerAdapter, HookHandler, DefineSkillArgs, DefineSubAgentArgs, InboxItem } from 'glove-core';
+import { ContentPart, Message, IGloveRunnable, StoreAdapter, GloveFoldArgs, Tool, SubscriberAdapter, ModelAdapter, DisplayManagerAdapter, HookHandler, DefineSkillArgs, DefineSubAgentArgs, RuntimeContextProvider, InboxItem, Displaymanager, Slot, TokenConsumptionCounter } 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 { MemoryToolOptions, UseGoalRunnerConfig, UseFormRunnerConfig } 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 { FactAdapter, FactScope, FactStore, FactInput } from 'glove-facts';
+import { GoalAdapter, GoalScope, GoalProgram, GoalRunner } from 'glove-memory/goals';
+import { FormAdapter, FormRunner } from 'glove-memory/forms';
 import * as effect_Brand from 'effect/Brand';
 import { FoundryConfig } from './config.js';
 
@@ -345,6 +348,13 @@ interface EgressContext {
     readonly route: OutboundRoute;
     readonly account?: AccountReference;
     readonly grant: RunGrant;
+    /** Cancels provider work when an awaiting agent call is stopped or expires. */
+    readonly signal: AbortSignal;
+    /**
+     * Enter the agent definition's user-owned credential/session boundary for
+     * this delivery. Foundry never receives the credential value itself.
+     */
+    readonly withAccountSession?: <A>(operation: string, use: (session: unknown) => Effect.Effect<A, unknown, never>) => Effect.Effect<A, unknown, never>;
 }
 /** Provider ingress remains adapter-owned and returns typed Effects. */
 interface IngressAdapter<TEvent, TError = never, TRequirements = never> {
@@ -374,6 +384,21 @@ interface OutboundContract<TConfig extends Schema.Schema.AnyNoContext = Schema.S
     readonly config: TConfig;
     readonly input: TInput;
     readonly output: TOutput;
+    /** Require Glove's exact-input approval before this outbound effect is dispatched. */
+    readonly requiresPermission?: boolean | ((input: Schema.Schema.Type<TInput>) => boolean);
+    /**
+     * Project provider output into the model-visible tool result. Use this to
+     * omit large or sensitive presentation-only bytes without weakening the
+     * adapter's typed output contract.
+     */
+    readonly project?: (output: Schema.Schema.Type<TOutput>) => unknown;
+    /** Project provider output into UI-only render data retained with tool history. */
+    readonly render?: (output: Schema.Schema.Type<TOutput>) => unknown;
+    /**
+     * Project the validated outbound input into secret-safe observability data.
+     * The execution payload still reaches the adapter but is never retained.
+     */
+    readonly observe?: (input: Schema.Schema.Type<TInput>) => unknown;
     readonly adapter?: EgressAdapter<Schema.Schema.Type<TInput>, Schema.Schema.Type<TOutput>, TError, TRequirements>;
 }
 interface TransmissionOptions {
@@ -411,6 +436,16 @@ interface ConnectionReceiveInput {
     readonly route: InboundRoute;
     readonly eventId: string;
     readonly threadKey: string;
+    /** Optional durable conversation key, independent of the provider thread. */
+    readonly conversationKey?: string;
+    /** Route is the safe default; agent lets a trusted identity adapter join routes. */
+    readonly conversationScope?: "route" | "agent";
+    /**
+     * Keep this connection's receive effect open until every dispatched agent
+     * run reaches a terminal state. Stateful transports can use this to
+     * serialize turns that share a durable conversation.
+     */
+    readonly awaitCompletion?: boolean;
     readonly raw: unknown;
 }
 interface ApplicationConnectionContext {
@@ -653,7 +688,7 @@ interface FoundryActivationRecord {
     readonly scheduleName?: string;
     /** Hash of the last reconciled definition value; runtime edits remain overrides. */
     readonly definitionRevision?: string;
-    readonly status: "pending" | "active" | "completed" | "cancelled";
+    readonly status: "pending" | "active" | "paused" | "completed" | "cancelled";
     readonly createdByRunId: string;
     readonly lastRunId?: string;
     readonly createdAt: string;
@@ -681,6 +716,8 @@ interface FoundryDataAdapter {
     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>;
+    /** Atomic optimistic update. null requires absence; updates must advance updatedAt. */
+    compareAndSetWorkspaceEntry?(entry: WorkspaceEntry, expectedUpdatedAt: string | null): Effect.Effect<boolean, 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>;
@@ -753,6 +790,10 @@ interface CreateConversationOptions {
     readonly title?: string;
     readonly context?: Readonly<Record<string, unknown>>;
 }
+interface UpdateConversationOptions {
+    readonly title?: string;
+    readonly context?: Readonly<Record<string, unknown>>;
+}
 declare class MemoryFoundryDataAdapter implements FoundryDataAdapter {
     readonly identifier: string;
     private readonly agents;
@@ -798,6 +839,7 @@ declare class MemoryFoundryDataAdapter implements FoundryDataAdapter {
     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>;
+    compareAndSetWorkspaceEntry(entry: WorkspaceEntry, expectedUpdatedAt: string | null): Effect.Effect<boolean, 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>;
@@ -922,8 +964,16 @@ interface FoundryMcpOptions<TConfigSchema extends z.ZodType | undefined = undefi
     readonly id?: string;
     readonly description?: string;
     readonly config?: TConfigSchema;
-    readonly entry: Omit<McpCatalogueEntry, "id">;
+    /**
+     * Static catalogue metadata or a lazy, instance-configured resolver.
+     *
+     * The resolver receives decoded installation data but never credentials.
+     * Auth remains the responsibility of the agent-owned `mcpAdapter` and is
+     * resolved only when glove-mcp opens a connection.
+     */
+    readonly entry: McpCatalogueEntryWithoutId | ((context: AgentApplicationInstallContext<TConfigSchema extends z.ZodType ? z.output<TConfigSchema> : unknown>) => McpCatalogueEntryWithoutId | Promise<McpCatalogueEntryWithoutId> | Effect.Effect<McpCatalogueEntryWithoutId, unknown, never>);
 }
+type McpCatalogueEntryWithoutId = McpCatalogueEntry extends infer Entry ? Entry extends unknown ? Omit<Entry, "id"> : never : never;
 type FoundryMcp<TConfigSchema extends z.ZodType | undefined = any> = Readonly<FoundryMcpOptions<TConfigSchema>> & {
     readonly id: string;
     readonly [FOUNDRY_MCP_BRAND]: true;
@@ -980,8 +1030,16 @@ declare const EMPTY_CAPABILITY_REGISTRY: FoundryCapabilityRegistry;
 interface McpAdapterFactory {
     (context: Omit<AgentInstallContext, "installation" | "config"> & {
         readonly installed: ReadonlyArray<FoundryMcp>;
+        /** Fully decoded, per-instance MCP selections for this assembly. */
+        readonly resolved: ReadonlyArray<FoundryResolvedMcp>;
     }): Effect.Effect<McpAdapter, unknown, never>;
 }
+interface FoundryResolvedMcp {
+    readonly definition: FoundryMcp;
+    readonly installation: AgentInstallation;
+    readonly config: unknown;
+    readonly entry: McpCatalogueEntry;
+}
 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;
@@ -1074,6 +1132,44 @@ declare function foundryDataEnvironmentPersistence(options?: {
 }): FoundryWorkingEnvironmentPersistenceAdapter;
 interface FoundryReplBase {
     readonly [FOUNDRY_REPL_BRAND]: true;
+    /**
+     * Project an explicit set of the fully assembled agent's tools into the
+     * sandbox as ordinary functions. Selection happens after applications,
+     * installed capabilities, memory, mesh, calls, and `configure` have mounted.
+     *
+     * Returning the actual tool values keeps code relationships referential;
+     * Foundry never accepts a second list of copied string ids here.
+     */
+    readonly programmaticTools?: FoundryProgrammaticTools;
+}
+interface FoundryProgrammaticToolSelection {
+    /** One of the exact live tools supplied to the selector context. */
+    readonly tool: Tool<unknown>;
+    /** Optional valid interpreter identifier when the tool name is unsuitable. */
+    readonly name?: string;
+    /** Informational effect hint used by capability discovery. */
+    readonly readOnly?: boolean;
+    /** Optional capability group used by progressive discovery. */
+    readonly server?: string;
+    readonly serverDescription?: string;
+    readonly resultShape?: string;
+}
+interface FoundryProgrammaticToolContext {
+    readonly assembly: AgentAssemblyContext<FoundryRequest>;
+    readonly glove: IGloveRunnable;
+    /** Snapshot of every tool mounted before the programmatic surface itself. */
+    readonly tools: ReadonlyArray<Tool<unknown>>;
+    readonly workingEnvironment?: WorkingEnvironment;
+    readonly vfs?: EnvFsHandle;
+}
+interface FoundryProgrammaticTools {
+    /**
+     * Select direct live tool references. A selection may decorate its callable
+     * name and discovery metadata without replacing the underlying capability.
+     */
+    readonly select: (context: FoundryProgrammaticToolContext) => Resolvable<ReadonlyArray<Tool<unknown> | FoundryProgrammaticToolSelection>>;
+    /** Total underlying calls permitted during this assembled run. Default 50. */
+    readonly maxCalls?: number;
 }
 type FoundryJavaScriptReplDefinition = FoundryReplBase & Readonly<{
     readonly language: "javascript";
@@ -1193,11 +1289,17 @@ 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;
+/**
+ * A colocated `*.tool.ts` may export the Glove tool body directly. Foundry
+ * supplies the runtime tool name from the file route, so the authored module
+ * never has to repeat its identity as a string.
+ */
+type FoundryToolBody = Omit<GloveFoldArgs<any>, "name">;
 interface FoundryAgentComposition {
     readonly capabilities: FoundryCapabilityRegistry;
     readonly native: FoundryNativeRegistry;
 }
-type FoundryCompositionSource = FoundryAgentComponent | FoundryAgentComposition | ReadonlyArray<FoundryCompositionSource> | (() => FoundryCompositionSource) | false | null | undefined;
+type FoundryCompositionSource = FoundryAgentComponent | FoundryToolBody | 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
@@ -1273,6 +1375,22 @@ type FoundryCoreCommand = {
         readonly payload?: unknown;
         readonly timing?: FoundryScheduleTiming;
     };
+} | {
+    readonly id: string;
+    readonly type: "schedule.pause";
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly activationId: string;
+} | {
+    readonly id: string;
+    readonly type: "schedule.resume";
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly activationId: string;
 } | {
     readonly id: string;
     readonly type: "schedule.cancel";
@@ -1309,13 +1427,22 @@ type FoundryCoreCommand = {
     readonly workspaceId: string;
     readonly routeId: string;
     readonly payload: unknown;
+    readonly observability?: unknown;
     readonly applicationId?: string;
     readonly transmissionId?: string;
 };
+/** Resolve an installed app's generated outbound tool without duplicating ids. */
+declare function installedApplicationTransmissionToolName(application: {
+    readonly id: string;
+}, transmission: {
+    readonly id: string;
+}): 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.
+ * The parent runtime remains authoritative for grants, credentials, and the
+ * delivery adapter. A private request/result bridge returns the adapter's
+ * validated output to the calling tool without moving those concerns into 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. */
@@ -1323,6 +1450,46 @@ declare function createFoundryCoreTools(context: AgentAssemblyContext, desiredSc
     readonly type: "schedule.sync";
 }>["schedules"]): ReadonlyArray<GloveFoldArgs<any>>;
 
+/** Conversation isolation is the default. Instance scope deliberately shares conversations. */
+type FoundryGuidanceScope = "conversation" | "instance";
+interface FoundryFactsOptions {
+    readonly adapter: FactAdapter;
+    readonly scope?: FoundryGuidanceScope | FactScope;
+    readonly maxRevisions?: number;
+    readonly onUrgent?: ConstructorParameters<typeof FactStore>[1]["onUrgent"];
+    /** A dedicated native runnable, never the conversational runnable. */
+    readonly preparationAgent?: IGloveRunnable;
+    readonly source?: () => {
+        source: FactInput["source"];
+        operationId: string;
+    };
+}
+interface FoundryGoalsOptions extends Omit<UseGoalRunnerConfig<IGloveRunnable>, "scope" | "preparation"> {
+    readonly adapter: GoalAdapter;
+    readonly scope?: FoundryGuidanceScope | GoalScope;
+    /** Starts only if absent. Revisions require the native runner's explicit CAS operation. */
+    readonly program?: GoalProgram;
+    readonly preparation?: Omit<NonNullable<UseGoalRunnerConfig["preparation"]>, "preparer">;
+}
+interface FoundryFormsOptions extends Omit<UseFormRunnerConfig, "subject" | "preparation"> {
+    readonly adapter: FormAdapter;
+    readonly scope?: FoundryGuidanceScope | {
+        readonly subject: string;
+    };
+    readonly preparation?: Omit<NonNullable<UseFormRunnerConfig["preparation"]>, "preparer">;
+}
+/** Pure, composable configuration values; these helpers create no runtime state. */
+declare const defineFacts: <T extends FoundryFactsOptions>(options: T) => Readonly<T>;
+declare const defineGoals: <T extends FoundryGoalsOptions>(options: T) => Readonly<T>;
+declare const defineForms: <T extends FoundryFormsOptions>(options: T) => Readonly<T>;
+interface FoundryGuidanceHandles {
+    readonly facts?: FactStore;
+    readonly goals?: GoalRunner;
+    readonly forms?: FormRunner;
+}
+/** Stable, bounded ownership key, unrelated to an execution/run id. */
+declare function foundryGuidanceSubject(context: Pick<AgentAssemblyContext, "workspaceId" | "agentId" | "conversationId">, scope?: FoundryGuidanceScope): string;
+
 declare const FOUNDRY_AGENT_DEFINITION_BRAND: unique symbol;
 /** @deprecated Agent modules are definitions; execution contracts are internal. */
 declare const FOUNDRY_AGENT_BRAND: symbol;
@@ -1391,7 +1558,7 @@ interface FoundryCallOptions<TInputSchema extends z.ZodType, TOutputSchema exten
 }
 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> {
+interface FoundryExecutionContext<TInput = unknown> extends FoundrySurfaceContext<TInput>, FoundryGuidanceHandles {
     readonly installations: ReadonlyArray<AgentInstallation>;
     /** Native persistent environment mounted for this run, when configured. */
     readonly workingEnvironment?: WorkingEnvironment;
@@ -1402,9 +1569,10 @@ interface FoundryExecutionContext<TInput = unknown> extends FoundrySurfaceContex
     readonly invoke: (name: string, input: unknown) => Promise<unknown>;
 }
 interface AgentHandlerContext<TInput = unknown> extends FoundryExecutionContext<TInput> {
-    readonly defaultRun: () => Promise<unknown>;
+    /** Run the standard Glove loop, optionally with a handler-enriched message. */
+    readonly defaultRun: (message?: FoundryMessageInput) => Promise<unknown>;
     /** @deprecated Use defaultRun. */
-    readonly defaultHandler: () => Promise<unknown>;
+    readonly defaultHandler: (message?: FoundryMessageInput) => Promise<unknown>;
     readonly spawn: (message?: FoundryMessageInput) => Promise<unknown>;
 }
 type FoundryResolver<T, TInput> = T | ((agent: FoundryAgentDefinition, context: AgentAssemblyContext<TInput>) => Resolvable<T>);
@@ -1426,6 +1594,11 @@ interface AgentAssemblyOptions<TInput = unknown> {
     readonly subagents?: FoundryListResolver<DefineSubAgentArgs, TInput>;
     /** Definition-owned Glove memory surfaces; may resolve lazily from run context. */
     readonly memory?: FoundryListResolver<FoundryMemorySelection, TInput>;
+    readonly goals?: FoundryResolver<FoundryGoalsOptions | undefined, TInput>;
+    readonly facts?: FoundryResolver<FoundryFactsOptions | undefined, TInput>;
+    readonly forms?: FoundryResolver<FoundryFormsOptions | undefined, TInput>;
+    /** Native providers re-read transient context before each model iteration. */
+    readonly contextProviders?: FoundryListResolver<RuntimeContextProvider, 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>;
@@ -1506,6 +1679,10 @@ interface FoundryAgentConventionModule {
     readonly skills?: AgentAssemblyOptions["skills"];
     readonly subagents?: AgentAssemblyOptions["subagents"];
     readonly memory?: AgentAssemblyOptions["memory"];
+    readonly goals?: AgentAssemblyOptions["goals"];
+    readonly facts?: AgentAssemblyOptions["facts"];
+    readonly forms?: AgentAssemblyOptions["forms"];
+    readonly contextProviders?: AgentAssemblyOptions["contextProviders"];
     readonly inboxes?: AgentAssemblyOptions["inboxes"];
     readonly subscribers?: AgentAssemblyOptions["subscribers"];
     readonly layers?: AgentAssemblyOptions["layers"];
@@ -1545,7 +1722,12 @@ interface DefineFoundrySubagentOptions {
     readonly compactionInstructions?: string;
     readonly maxTurns?: number;
     readonly enableToolResultSummary?: boolean;
-    readonly tools?: ReadonlyArray<GloveFoldArgs<any>>;
+    /**
+     * A fixed tool set, or an invocation-time projection of the fully assembled
+     * parent. The resolver makes least-privilege delegation possible without
+     * copying application/MCP tools into static agent code.
+     */
+    readonly tools?: ReadonlyArray<GloveFoldArgs<any>> | ((context: FoundrySubagentToolContext) => Resolvable<ReadonlyArray<GloveFoldArgs<any>>>);
     readonly hooks?: ReadonlyArray<FoundryHookDefinition>;
     readonly skills?: ReadonlyArray<DefineSkillArgs>;
     readonly subagents?: ReadonlyArray<DefineSubAgentArgs>;
@@ -1553,6 +1735,11 @@ interface DefineFoundrySubagentOptions {
     readonly subscribers?: ReadonlyArray<FoundrySubscriber | SubscriberAdapter>;
     readonly configure?: (context: FoundrySurfaceContext<string>) => Resolvable<void>;
 }
+interface FoundrySubagentToolContext {
+    readonly name: string;
+    readonly prompt: string;
+    readonly parent: IGloveRunnable;
+}
 declare function defineSubagent(options: DefineFoundrySubagentOptions): DefineSubAgentArgs;
 type FoundryRouteMap = Record<string, object>;
 declare function defineRoutes<const TRoutes extends FoundryRouteMap>(routes: TRoutes): TRoutes;
@@ -1798,6 +1985,29 @@ declare class MemoryObservabilityAdapter implements FoundryObservabilityAdapter
 }
 
 declare const FOUNDRY_APPLICATION_BRAND: unique symbol;
+/**
+ * Secret-bearing HTTP request data passed only to the consumer-owned
+ * authorization adapter. Foundry does not persist or observe this value.
+ */
+interface FoundryRequestAuthorizationInput {
+    readonly method: string;
+    readonly path: string;
+    readonly query: string;
+    readonly authorization?: string;
+    readonly cookie?: string;
+    readonly remoteAddress?: string;
+}
+/**
+ * Gate the Foundry HTTP surface without making credential acquisition or
+ * refresh a framework concern. The adapter may validate a basic/bearer
+ * credential, a session cookie, or an identity asserted by a trusted proxy.
+ */
+interface FoundryRequestAuthorizationAdapter<TError = never> {
+    readonly identifier: string;
+    /** Value for WWW-Authenticate when access is denied. */
+    readonly challenge?: string;
+    readonly authorize: (input: FoundryRequestAuthorizationInput) => Effect.Effect<boolean, TError, never>;
+}
 /** Process infrastructure only; agent files own runtime capabilities. */
 interface FoundryApplicationOptions {
     readonly name: string;
@@ -1811,6 +2021,11 @@ interface FoundryApplicationOptions {
         readonly conversationId: string;
         readonly workspaceId: string;
     }) => Promise<StoreAdapter> | StoreAdapter;
+    /**
+     * User-owned HTTP authorization boundary. Required for non-loopback binds;
+     * credential values never enter Foundry data, manifests, or observability.
+     */
+    readonly requestAuthorization?: FoundryRequestAuthorizationAdapter<unknown>;
     /** User-owned strategy for subscriptions using `provisioning.mode = "custom"`. */
     readonly provisioner?: FoundryInstanceProvisioner;
     readonly services?: Layer.Layer<AccountDirectory | TopologyStore | EventStore, unknown>;
@@ -1841,6 +2056,58 @@ interface DiscoveredFoundryRegistry {
     }>;
 }
 
+declare const FOUNDRY_APPROVAL_DIRECTORY_ENV = "GLOVE_FOUNDRY_APPROVAL_DIRECTORY";
+type FoundryApprovalDecision = "approve" | "deny";
+type FoundryApprovalStatus = "pending" | "approved" | "denied" | "expired" | "cancelled";
+interface FoundryApproval {
+    readonly id: string;
+    readonly runId: string;
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly toolName: string;
+    readonly toolInput: unknown;
+    readonly status: FoundryApprovalStatus;
+    readonly requestedAt: string;
+    readonly expiresAt: string;
+    readonly resolvedAt?: string;
+}
+declare function createFoundryApproval(directory: string, input: {
+    readonly runId: string;
+    readonly definitionId: string;
+    readonly agentId: string;
+    readonly conversationId: string;
+    readonly workspaceId: string;
+    readonly toolName: string;
+    readonly toolInput: unknown;
+    readonly timeoutMs?: number;
+}): Promise<FoundryApproval>;
+declare function listFoundryApprovals(directory: string, filter?: {
+    readonly runId?: string;
+    readonly status?: FoundryApprovalStatus;
+}): Promise<ReadonlyArray<FoundryApproval>>;
+declare function resolveFoundryApproval(directory: string, id: string, decision: FoundryApprovalDecision): Promise<FoundryApproval>;
+declare class FoundryApprovalDisplayManager extends Displaymanager implements DisplayManagerAdapter {
+    private readonly context;
+    constructor(context: {
+        readonly directory?: string;
+        readonly runId: string;
+        readonly definitionId: string;
+        readonly agentId: string;
+        readonly conversationId: string;
+        readonly workspaceId: string;
+        readonly signal: AbortSignal;
+        readonly emit: (event: {
+            readonly type: string;
+            readonly data?: unknown;
+        }) => void;
+    });
+    pushAndWait<I, O>(slot: Omit<Slot<I>, "id">): Promise<O>;
+}
+/** Add fail-closed per-input permissions to a custom store that omitted them. */
+declare function withFoundryPermissions(store: StoreAdapter): StoreAdapter;
+
 interface FoundryRun<TOutput = unknown> {
     readonly id: string;
     readonly agent: string;
@@ -1859,6 +2126,31 @@ interface FoundryRun<TOutput = unknown> {
     readonly startedAt?: string;
     readonly completedAt?: string;
 }
+interface FoundrySteerResult<TOutput = unknown> {
+    /** The run whose direction was changed. */
+    readonly fromRunId: string;
+    /** True when an active source run accepted cooperative cancellation. */
+    readonly interrupted: boolean;
+    /** The replacement run in the same instance and conversation. */
+    readonly run: FoundryRun<TOutput>;
+}
+/** Exact native Glove history and counters for one persisted conversation. */
+interface FoundryConversationTranscript {
+    readonly conversation: Conversation;
+    readonly messages: ReadonlyArray<Message>;
+    readonly turnCount: number;
+    readonly tokenCount: number;
+    readonly tokenConsumption?: TokenConsumptionCounter;
+    readonly page: {
+        readonly offset: number;
+        readonly limit: number;
+        readonly total: number;
+        readonly hasEarlier: boolean;
+        readonly hasLater: boolean;
+    };
+    /** False means the definition did not configure a durable conversation store. */
+    readonly persisted: boolean;
+}
 declare const FoundryRuntimeError_base: Schema.TaggedErrorClass<FoundryRuntimeError, "FoundryRuntimeError", {
     readonly _tag: Schema.tag<"FoundryRuntimeError">;
 } & {
@@ -1902,6 +2194,9 @@ declare class FoundryRuntime {
     private readonly services;
     private readonly runnerLoops;
     private readonly materializedActivations;
+    private readonly activationTimers;
+    private readonly approvalDirectory;
+    private readonly coreCommandDirectory;
     private started;
     private disposed;
     constructor(options: FoundryRuntimeOptions);
@@ -1933,6 +2228,16 @@ declare class FoundryRuntime {
     /** Atomically replace the persisted, frontend-editable instance configuration. */
     configureAgent(agentId: string, options: UpdateAgentInstanceOptions): Promise<AgentInstance>;
     listConversations(agentId: string): Promise<ReadonlyArray<Conversation>>;
+    updateConversation(agentId: string, conversationId: string, options: UpdateConversationOptions): Promise<Conversation>;
+    /**
+     * Read the same StoreAdapter the child agent process uses. Foundry never
+     * reconstructs chat history from runs or observability events: adapters stay
+     * the single source of truth for durable conversations.
+     */
+    conversationTranscript(agentId: string, conversationId: string, options?: {
+        readonly offset?: number;
+        readonly limit?: number;
+    }): Promise<FoundryConversationTranscript>;
     listWorkspaceEntries(workspaceId: string): Promise<ReadonlyArray<WorkspaceEntry>>;
     putWorkspaceEntry(workspaceId: string, key: string, value: unknown): Promise<WorkspaceEntry>;
     listSharedInbox(workspaceId: string): Promise<ReadonlyArray<SharedInboxItem>>;
@@ -1957,6 +2262,20 @@ declare class FoundryRuntime {
         timeoutMs?: number;
     }): Promise<FoundryRun<TOutput> | null>;
     cancel(runId: string): Promise<boolean>;
+    /**
+     * Change course at a run boundary.
+     *
+     * Foundry does not inject text into an arbitrary in-flight tool. If the
+     * source is active, steering cooperatively cancels it first, waits for that
+     * terminal boundary, then starts a replacement turn in the same durable
+     * conversation with explicit lineage in the request context.
+     */
+    steer(runId: string, message: FoundryMessageInput): Promise<FoundrySteerResult<FoundryResult>>;
+    listApprovals(filter?: {
+        readonly runId?: string;
+        readonly status?: FoundryApprovalStatus;
+    }): Promise<ReadonlyArray<FoundryApproval>>;
+    resolveApproval(approvalId: string, decision: FoundryApprovalDecision): Promise<FoundryApproval>;
     capabilityManifest(definitionId: string): FoundryCapabilityManifest;
     nativeManifest(definitionId: string): FoundryNativeManifest;
     listInstallations(agentId: string): Promise<ReadonlyArray<AgentInstallation>>;
@@ -2019,6 +2338,8 @@ declare class FoundryRuntime {
         readonly routeId: string;
         readonly eventId: string;
         readonly threadKey: string;
+        readonly conversationKey?: string;
+        readonly conversationScope?: "route" | "agent";
         readonly raw: unknown;
     }): Promise<ReadonlyArray<FoundryRun>>;
     dispatchOutbound(input: {
@@ -2029,6 +2350,7 @@ declare class FoundryRuntime {
         readonly commandId?: string;
         readonly applicationId?: string;
         readonly transmissionId?: string;
+        readonly signal?: AbortSignal;
     }): Promise<unknown>;
     health(): Promise<Record<string, unknown>>;
     private runsFromIds;
@@ -2054,9 +2376,12 @@ declare class FoundryRuntime {
     private disarmActivation;
     private syncDefinitionSchedules;
     private updateScheduledActivation;
+    private pauseScheduledActivation;
+    private resumeScheduledActivation;
     private cancelScheduledActivation;
     private reconstructActivations;
     private materializeActivation;
+    private armOneShotActivation;
     private deliverOutbound;
     private executionEnvelope;
     private toFoundryRun;
@@ -2065,12 +2390,26 @@ declare class FoundryRuntime {
 interface FoundryClientOptions {
     baseUrl?: string;
     fetch?: typeof globalThis.fetch;
+    /** Resolve secret-bearing request headers outside Foundry data and state. */
+    authorization?: FoundryClientAuthorizationAdapter;
+}
+interface FoundryClientAuthorizationAdapter {
+    readonly identifier: string;
+    readonly headers: (request: {
+        readonly url: string;
+        readonly method: string;
+    }) => HeadersInit | Promise<HeadersInit>;
 }
 interface WaitOptions {
     pollMs?: number;
     timeoutMs?: number;
     signal?: AbortSignal;
 }
+interface FoundrySteerHandleResult<TOutput = unknown> {
+    readonly fromRunId: string;
+    readonly interrupted: boolean;
+    readonly run: FoundryRunHandle<TOutput>;
+}
 interface FoundryHealth {
     readonly ok: boolean;
     readonly execution: boolean;
@@ -2087,6 +2426,7 @@ declare class FoundryRunHandle<TOutput> {
     constructor(id: string, initial: FoundryRun<TOutput>, client: FoundryClient<FoundryRouteMap>);
     get(): Promise<FoundryRun<TOutput>>;
     cancel(): Promise<boolean>;
+    steer(message: FoundryMessageInput): Promise<FoundrySteerHandleResult<TOutput>>;
     events(): Promise<FoundryEvent[]>;
     wait(options?: WaitOptions): Promise<FoundryRun<TOutput>>;
 }
@@ -2105,6 +2445,11 @@ declare class FoundryClient<TRoutes extends FoundryRouteMap> {
     setAgentPlaybooks(agentId: string, playbooks: ReadonlyArray<AgentPlaybook>): Promise<AgentInstance>;
     createConversation(agentId: string, options?: CreateConversationOptions): Promise<Conversation>;
     conversations(agentId: string): Promise<ReadonlyArray<Conversation>>;
+    updateConversation(agentId: string, conversationId: string, options: UpdateConversationOptions): Promise<Conversation>;
+    conversationTranscript(agentId: string, conversationId: string, options?: {
+        readonly offset?: number;
+        readonly limit?: number;
+    }): Promise<FoundryConversationTranscript>;
     workspaceEntries(workspaceId: string): Promise<ReadonlyArray<WorkspaceEntry>>;
     putWorkspaceEntry(workspaceId: string, key: string, value: unknown): Promise<WorkspaceEntry>;
     sharedInbox(workspaceId: string): Promise<ReadonlyArray<SharedInboxItem>>;
@@ -2131,6 +2476,8 @@ declare class FoundryClient<TRoutes extends FoundryRouteMap> {
         readonly routeId: string;
         readonly eventId: string;
         readonly threadKey: string;
+        readonly conversationKey?: string;
+        readonly conversationScope?: "route" | "agent";
         readonly raw: unknown;
     }): Promise<ReadonlyArray<FoundryRun>>;
     playbookSubscriptions(workspaceId?: string): Promise<ReadonlyArray<PlaybookSubscription>>;
@@ -2152,12 +2499,18 @@ declare class FoundryClient<TRoutes extends FoundryRouteMap> {
     getRun<TOutput = unknown>(runId: string): Promise<FoundryRun<TOutput>>;
     runs<TOutput = unknown>(route?: string): Promise<ReadonlyArray<FoundryRun<TOutput>>>;
     cancelRun(runId: string): Promise<boolean>;
+    steerRun<TOutput = FoundryResult>(runId: string, message: FoundryMessageInput): Promise<FoundrySteerResult<TOutput>>;
     getEvents(filter?: {
         runId?: string;
         agent?: string;
         after?: number;
         category?: FoundryEvent["category"];
     }): Promise<FoundryEvent[]>;
+    approvals(filter?: {
+        readonly runId?: string;
+        readonly status?: FoundryApprovalStatus;
+    }): Promise<ReadonlyArray<FoundryApproval>>;
+    resolveApproval(approvalId: string, decision: FoundryApprovalDecision): Promise<FoundryApproval>;
     manifest(): Promise<{
         agents: FoundryManifest;
         application: FoundryApplicationManifest;
@@ -2183,4 +2536,4 @@ declare class FoundryClient<TRoutes extends FoundryRouteMap> {
 }
 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 };
+export { type ApplicationConnectionState as $, type AgentInstance as A, type AgentApplicationInstallContext as B, type Conversation as C, type DiscoveredAgent as D, type EnvironmentValue as E, type FoundryDataAdapter as F, type AgentApplicationOptions as G, type AgentAssemblyContext as H, type InboundDeliveryClaim as I, type AgentAssemblyOptions as J, AgentDefinitionId as K, type AgentDefinitionSurfaceContext as L, type AgentFactoryContext as M, type AgentHandlerContext as N, OutboundRoute as O, type PlaybookSubscription as P, AgentId as Q, type AgentInstallContext as R, type SharedInboxItem as S, type AgentInstallation as T, type AgentInstallationKind as U, type AgentPlaybookInput as V, type WorkspaceEntry as W, type AgentProvisioningPolicy as X, type AgentRuntimeControls as Y, type AnyFoundryAgent as Z, type ApplicationConnectionContext as _, type FoundryActivationRecord as a, type FoundryApp as a$, type ApplicationConnectionStatus as a0, type BindingFilter as a1, BindingId as a2, BindingNotFound as a3, CapabilityId as a4, type ComposedAgentPlaybook as a5, type ComposedAgentPlaybookInput as a6, type ConnectionReceiveInput as a7, type CreateAgentInstanceOptions as a8, type CreateConversationOptions as a9, FOUNDRY_APPLICATION_BRAND as aA, FOUNDRY_APPLICATION_ENV as aB, FOUNDRY_APPROVAL_DIRECTORY_ENV as aC, FOUNDRY_COMPOSED_PLAYBOOK_BRAND as aD, FOUNDRY_CONNECTION_BRAND as aE, FOUNDRY_CORE_COMMAND_EVENT as aF, FOUNDRY_EVENT_PREFIX as aG, FOUNDRY_EXECUTION_MARKER as aH, FOUNDRY_LAYER_BRAND as aI, FOUNDRY_MCP_BRAND as aJ, FOUNDRY_MEMORY_BRAND as aK, FOUNDRY_PLAYBOOK_ACTION_BRAND as aL, FOUNDRY_REPL_BRAND as aM, FOUNDRY_SCHEDULE_BRAND as aN, FOUNDRY_SHARED_TOOL_BRAND as aO, FOUNDRY_SUBSCRIBER_BRAND as aP, FOUNDRY_TRANSMISSION_BRAND as aQ, FOUNDRY_TRANSMISSION_EVENT_BRAND as aR, FOUNDRY_TRANSMISSION_PREDICATE_BRAND as aS, FOUNDRY_WORKING_ENVIRONMENT_BRAND as aT, type FoundryAccountSessionAdapter as aU, type FoundryAgent as aV, type FoundryAgentComponent as aW, type FoundryAgentComposition as aX, type FoundryAgentConventionModule as aY, type FoundryAgentDefinition as aZ, type FoundryAgentMode as a_, type CustomProvisionedAgent as aa, type CustomProvisioningContext as ab, type DefineAgentOptions as ac, type DefineConnectionOptions as ad, type DefineFoundryReplOptions as ae, type DefineFoundryScheduleOptions as af, type DefineFoundrySubagentOptions as ag, type DefineFoundryWorkingEnvironmentOptions as ah, type DefinePlaybookSubscriptionOptions as ai, type DefinitionConfigInput as aj, EMPTY_AGENT_COMPOSITION as ak, EMPTY_CAPABILITY_REGISTRY as al, EMPTY_FOUNDRY_APPLICATION as am, EMPTY_NATIVE_REGISTRY as an, type EgressAdapter as ao, type EgressContext as ap, type EventFilter as aq, EventId as ar, EventNotFound as as, EventReference as at, EventStore as au, FOUNDRY_AGENT_APPLICATION_BRAND as av, FOUNDRY_AGENT_BRAND as aw, FOUNDRY_AGENT_DEFINITION_BRAND as ax, FOUNDRY_AGENT_FILE_ENV as ay, FOUNDRY_AGENT_ROUTE_ENV as az, type ProvisionAgentOptions as b, type FoundryRequest as b$, type FoundryApplication as b0, type FoundryApplicationConnection as b1, FoundryApplicationManifest as b2, type FoundryApplicationOptions as b3, type FoundryApproval as b4, type FoundryApprovalDecision as b5, FoundryApprovalDisplayManager as b6, type FoundryApprovalStatus as b7, type FoundryCall as b8, type FoundryCallContext as b9, type FoundryLayerOptions as bA, type FoundryLayerReference as bB, type FoundryLayerSelection as bC, type FoundryLispReplDefinition as bD, type FoundryListResolver as bE, type FoundryManifestAgent as bF, FoundryManifestCapability as bG, FoundryManifestTransmission as bH, type FoundryMcp as bI, type FoundryMcpOptions as bJ, type FoundryMemoryProfile as bK, type FoundryMemoryProfileOptions as bL, type FoundryMemoryReference as bM, type FoundryMemorySelection as bN, type FoundryMeshConfig as bO, type FoundryMessageInput as bP, type FoundryMountedRepl as bQ, type FoundryNativeManifest as bR, type FoundryNativeManifestEntry as bS, type FoundryNativeRegistry as bT, type FoundryObservabilityAdapter as bU, type FoundryPlaybookAction as bV, type FoundryProgrammaticToolContext as bW, type FoundryProgrammaticToolSelection as bX, type FoundryProgrammaticTools as bY, type FoundryPythonReplDefinition as bZ, type FoundryReplDefinition as b_, type FoundryCallOptions as ba, type FoundryCapabilityKind as bb, type FoundryCapabilityManifest as bc, type FoundryCapabilityManifestEntry as bd, type FoundryCapabilityRegistry as be, FoundryClient as bf, type FoundryClientAuthorizationAdapter as bg, type FoundryClientOptions as bh, type FoundryCompositionSource as bi, type FoundryConversationTranscript as bj, type FoundryCoreCommand as bk, type FoundryDomainError as bl, type FoundryEvent as bm, type FoundryEventCategory as bn, type FoundryExecutionContext as bo, type FoundryFactsOptions as bp, type FoundryFormsOptions as bq, type FoundryGoalsOptions as br, type FoundryGuidanceHandles as bs, type FoundryGuidanceScope as bt, type FoundryHealth as bu, type FoundryHookDefinition as bv, type FoundryInstallable as bw, type FoundryInstanceProvisioner as bx, type FoundryJavaScriptReplDefinition as by, type FoundryLayer as bz, type FoundryWorkingEnvironmentSnapshotOwner as c, RunId as c$, type FoundryRequestAuthorizationAdapter as c0, type FoundryRequestAuthorizationInput as c1, type FoundryResolvedMcp as c2, type FoundryResolver as c3, type FoundryResult as c4, type FoundryRouteMap as c5, type FoundryRun as c6, FoundryRunHandle as c7, FoundryRuntimeError as c8, type FoundryRuntimeOptions as c9, 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 PlaybookSubscriptionTarget as cS, type PlaybookSubscriptionTargetInput as cT, ReplyPolicy as cU, type ResolveGrantRequest as cV, Route as cW, type RouteFilter as cX, RouteId as cY, RouteNotFound as cZ, RunGrant as c_, type FoundryScheduleDefinition as ca, type FoundryScheduleTiming as cb, type FoundryScheduleTimingInput as cc, type FoundrySharedTool as cd, type FoundrySteerHandleResult as ce, type FoundrySteerResult as cf, type FoundrySubagentToolContext as cg, type FoundrySubscriber as ch, type FoundrySubscriberOptions as ci, type FoundrySubscriberSelection as cj, type FoundrySurfaceContext as ck, type FoundryToolBody as cl, type FoundryTransmission as cm, type FoundryTransmissionEvent as cn, type FoundryTransmissionPredicate as co, type FoundryVfs as cp, type FoundryVfsHandle as cq, type FoundryWorkingEnvironmentCreateContext as cr, type FoundryWorkingEnvironmentDefinition as cs, type FoundryWorkingEnvironmentPersistenceAdapter as ct, type FoundryWorkingEnvironmentPersistenceContext as cu, GrantResolutionError as cv, GrantResolver as cw, type InboundContract as cx, type InferAgentInput as cy, type InferAgentOutput as cz, type FoundryTask as d, isFoundryApplication as d$, type SharedToolOptions as d0, TopologyConflict as d1, TopologyStore as d2, type TransmissionEventDirection as d3, type TransmissionEventOptions as d4, TransmissionId as d5, type TransmissionOptions as d6, type TransmissionPredicateOptions as d7, type TransmissionSerializationContext as d8, type UpdateAgentInstanceOptions as d9, defineLayer as dA, defineMcp as dB, defineMemory as dC, definePlaybookAction as dD, definePlaybookSubscription as dE, defineRepl as dF, defineRoutes as dG, defineSchedule as dH, defineSharedTool as dI, defineSubagent as dJ, defineSubscriber as dK, defineTransmission as dL, defineTransmissionEvent as dM, defineTransmissionPredicate as dN, defineWorkingEnvironment as dO, discoverAgents as dP, findAgentFiles as dQ, foundryDataEnvironmentPersistence as dR, foundryGuidanceSubject as dS, grantResolverLive as dT, install as dU, installRegistry as dV, installationKey as dW, installedApplicationTransmissionToolName as dX, internalAgentName as dY, isFoundryAgent as dZ, isFoundryAgentDefinition as d_, type UpdateConversationOptions as da, type WaitOptions as db, compileApplicationManifest as dc, composeAgent as dd, composePlaybook as de, configureLayer as df, configureMemory as dg, createAgentInstance as dh, createConversation as di, createFoundryApproval as dj, createFoundryClient as dk, createFoundryCoreTools as dl, createInstalledApplicationTransmissionTools as dm, createManifest as dn, defineAgent as dp, defineAgentApplication as dq, defineAgentFromModule as dr, defineAgentInstance as ds, defineApp as dt, defineApplication as du, defineCall as dv, defineConnection as dw, defineFacts as dx, defineForms as dy, defineGoals as dz, type AgentPlaybook as e, isFoundryCapability as e0, isFoundryLayer as e1, isFoundrySchedule as e2, isFoundrySubscriber as e3, isFoundryTransmission as e4, isInboxCapableStore as e5, listFoundryApprovals as e6, memoryAccountDirectory as e7, memoryEventStore as e8, memoryTopologyStore as e9, mountAgentDefinitionMemory as ea, mountFoundrySurfaces as eb, reconstructAgentInstance as ec, reconstructPlaybook as ed, reconstructPlaybookSubscription as ee, resolveFoundryApproval as ef, routeFromAgentFile as eg, routeFromInternalAgentName as eh, toGloveMessage as ei, toGloveRequestInput as ej, transmissionPredicate as ek, withFoundryPermissions as el, FoundryRuntime as f, type FoundryManifest as g, type AnyFoundryTransmission as h, AccountReference as i, type InferAccountMetadata as j, AgentBinding as k, type FoundryAgentApplication as l, InboundRoute as m, type CapabilityDefinition as n, type InferInboundConfig as o, type InferOutboundConfig as p, type AccountContract as q, AccountDirectory as r, type AccountFilter as s, AccountId as t, AccountNotFound as u, type AccountSessionAdapter as v, type AccountSessionRequest as w, AccountSessionUnavailable as x, AccountSummary as y, type AgentApplicationContribution as z };