glove-foundry 0.3.3 → 0.4.0

package/dist/{chunk-CRWY7M66.js → chunk-5LDW2N2E.js}

@@ -186,6 +186,10 @@ var CONVENTION_EXPORTS = [
   "skills",
   "subagents",
   "memory",
+  "goals",
+  "facts",
+  "forms",
+  "contextProviders",
   "inboxes",
   "subscribers",
   "layers",
@@ -227,6 +231,11 @@ function defineSubagent(options) {
     description: options.description,
     factory: async ({ parentStore, parentControls, prompt }) => {
       const store = await parentStore.createSubAgentStore?.(options.name, options.durable ?? false) ?? void 0;
+      const tools = typeof options.tools === "function" ? await resolveResolvable(options.tools({
+        name: options.name,
+        prompt,
+        parent: parentControls.glove
+      })) : options.tools ?? [];
       const glove = new Glove({
         ...store ? { store } : {},
         model: options.model ?? parentControls.glove.model,
@@ -242,7 +251,7 @@ function defineSubagent(options) {
         },
         ...options.enableToolResultSummary !== void 0 ? { enableToolResultSummary: options.enableToolResultSummary } : {}
       }).build();
-      for (const tool of options.tools ?? []) glove.fold(tool);
+      for (const tool of tools) glove.fold(tool);
       for (const hook of options.hooks ?? []) glove.defineHook(hook.name, hook.handler);
       for (const skill of options.skills ?? []) glove.defineSkill(skill);
       for (const subagent of options.subagents ?? []) glove.defineSubAgent(subagent);
@@ -285,6 +294,125 @@ function defineRoutes(routes) {
   return Object.freeze({ ...routes });
 }
 
+// src/guidance.ts
+import { createHash } from "node:crypto";
+import { FactPreparation, FactStore, useFacts } from "glove-facts";
+import { useGoalRunner, useFormRunner } from "glove-memory/tools";
+var defineFacts = (options) => Object.freeze({ ...options });
+var defineGoals = (options) => Object.freeze({ ...options });
+var defineForms = (options) => Object.freeze({ ...options });
+function foundryGuidanceSubject(context, scope = "conversation") {
+  return `foundry:${scope}:${createHash("sha256").update(JSON.stringify([
+    context.workspaceId,
+    context.agentId,
+    ...scope === "conversation" ? [context.conversationId] : []
+  ])).digest("hex")}`;
+}
+async function mountFoundryGuidance(glove, context, options) {
+  const { facts, goals, forms } = options;
+  const subject = (scope) => typeof scope === "object" ? scope.subject : foundryGuidanceSubject(context, scope);
+  const handles = {};
+  let preparer;
+  if (facts) {
+    handles.facts = new FactStore(facts.adapter, {
+      scope: typeof facts.scope === "object" ? facts.scope : { subject: subject(facts.scope), context: "conversation-evidence" },
+      maxRevisions: facts.maxRevisions,
+      onUrgent: facts.onUrgent
+    });
+    if (facts.preparationAgent) {
+      if (facts.preparationAgent === glove) throw new Error("Fact preparation requires a dedicated agent.");
+      preparer = new FactPreparation(handles.facts, { agent: facts.preparationAgent });
+    }
+    useFacts(glove, handles.facts, facts.source ?? (() => ({
+      source: { kind: "message", id: context.message.id ?? context.runId },
+      operationId: context.message.id ?? context.runId
+    })));
+  }
+  if ((goals?.preparation || forms?.preparation) && !preparer) {
+    throw new Error("Guidance preparation requires facts with a dedicated preparationAgent.");
+  }
+  if (goals) {
+    const scope = typeof goals.scope === "object" ? goals.scope : {
+      subject: subject(goals.scope),
+      key: goals.program?.key ?? "conversation"
+    };
+    if (goals.preparation && preparer.facts.scope().subject !== scope.subject) throw new Error("Goals and facts must share the same subject.");
+    handles.goals = useGoalRunner(glove, goals.adapter, {
+      ...goals,
+      scope,
+      preparation: goals.preparation ? { ...goals.preparation, preparer } : void 0
+    }).runner;
+    if (goals.program) await handles.goals.start(goals.program, "Initialize definition-provided goals; preserve existing progress.");
+  }
+  if (forms) {
+    if (forms.preparation && preparer.facts.scope().subject !== subject(forms.scope)) throw new Error("Forms and facts must share the same subject.");
+    handles.forms = useFormRunner(glove, forms.adapter, {
+      ...forms,
+      subject: subject(forms.scope),
+      preparation: forms.preparation ? { ...forms.preparation, preparer } : void 0
+    }).runner;
+  }
+  let previous = "";
+  const snapshot = async () => {
+    if (!facts && !goals && !forms && options.contextProviders.length === 0) return;
+    const goalState = await handles.goals?.status();
+    const factState = await handles.facts?.inspect();
+    const formState = forms ? await forms.adapter.findInstances({ subject: subject(forms.scope) }) : void 0;
+    const state = {
+      goals: goalState ? {
+        version: goalState.version,
+        status: goalState.status,
+        activeGoal: goalState.activeGoal,
+        items: goalState.goals.map((g) => ({
+          key: g.definition.key,
+          title: g.definition.title,
+          status: g.status,
+          completed: g.items.filter((i) => i.state?.done).length,
+          total: g.items.length
+        }))
+      } : null,
+      facts: factState ? {
+        version: factState.version,
+        revisions: factState.facts.length,
+        claims: factState.claims.length,
+        urgent: factState.facts.filter((f) => f.urgent).length
+      } : null,
+      forms: formState?.map((f) => ({
+        id: f.id,
+        definitionId: f.defId,
+        version: f.version,
+        status: f.status,
+        answered: Object.values(f.entries).filter((e) => e.cursor >= 0).length,
+        pendingHooks: Object.keys(f.pendingHooks ?? {}).length,
+        blockedOn: f.blockedOn ?? null
+      })) ?? null,
+      contextProviders: options.contextProviders.length
+    };
+    const encoded = JSON.stringify(state);
+    if (encoded !== previous) {
+      context.controls.emit({ type: "foundry.guidance.state", data: state });
+      previous = encoded;
+    }
+  };
+  const cleanups = [];
+  try {
+    for (const provider of options.contextProviders) cleanups.push(glove.addContextProvider(provider));
+    if (facts || goals || forms) {
+      await snapshot();
+      cleanups.push(glove.addContextProvider(async () => {
+        await snapshot();
+        return null;
+      }));
+    }
+    return { handles, snapshot, dispose: () => {
+      for (const remove of cleanups.reverse()) remove();
+    } };
+  } catch (error) {
+    for (const remove of cleanups.reverse()) remove();
+    throw error;
+  }
+}
+
 // src/capabilities.ts
 import { Effect as Effect2 } from "effect";
 import { mountMcp } from "glove-mcp";
@@ -410,6 +538,10 @@ function defineAgentApplication(options) {
   }, "application", id2));
 }
 var defineApp = defineAgentApplication;
+function identifyMcpEntry(entry, id2) {
+  if (entry.transport) return { ...entry, id: id2 };
+  return { ...entry, id: id2, url: entry.url };
+}
 function defineMcp(options) {
   if (options.id) assertCapabilityId(options.id, "MCP");
   const { id: id2, ...definition } = options;
@@ -585,7 +717,19 @@ function installRegistry(options) {
         const contribution = application.install ? yield* application.install(headlessContext) : void 0;
         for (const tool of contribution?.tools ?? []) options.context.glove.fold(tool);
       } else {
-        installedMcp.push(definition);
+        const mcpDefinition = definition;
+        const headlessContext = (() => {
+          const { glove: _glove, store: _store, ...headless } = context;
+          return headless;
+        })();
+        const source = typeof mcpDefinition.entry === "function" ? mcpDefinition.entry(headlessContext) : mcpDefinition.entry;
+        const entry = Effect2.isEffect(source) ? yield* source : source instanceof Promise ? yield* Effect2.tryPromise({ try: () => source, catch: (cause) => cause }) : source;
+        installedMcp.push({
+          definition: mcpDefinition,
+          installation,
+          config,
+          entry: identifyMcpEntry(entry, mcpDefinition.id)
+        });
       }
       installed.push(installation);
       options.context.emit({
@@ -601,24 +745,23 @@ function installRegistry(options) {
       }
       const adapter = yield* options.mcpAdapter({
         ...options.context,
-        installed: installedMcp
+        installed: installedMcp.map(({ definition }) => definition),
+        resolved: installedMcp
       });
-      const selectedIds = new Set(installedMcp.map((entry) => entry.id));
+      const selectedIds = new Set(installedMcp.map(({ definition }) => definition.id));
       const scopedAdapter = {
         identifier: adapter.identifier,
         getActive: async () => [...selectedIds],
         activate: (id2) => adapter.activate(id2),
         deactivate: (id2) => adapter.deactivate(id2),
         ...adapter.getAccessToken ? { getAccessToken: (id2) => adapter.getAccessToken(id2) } : {},
-        ...adapter.getAuthHeaders ? { getAuthHeaders: (id2) => adapter.getAuthHeaders(id2) } : {}
+        ...adapter.getAuthHeaders ? { getAuthHeaders: (id2) => adapter.getAuthHeaders(id2) } : {},
+        ...adapter.getStdioEnvironment ? { getStdioEnvironment: (id2) => adapter.getStdioEnvironment(id2) } : {}
       };
       yield* Effect2.tryPromise({
         try: () => mountMcp(options.context.glove, {
           adapter: scopedAdapter,
-          entries: installedMcp.map((definition) => ({
-            ...definition.entry,
-            id: definition.id
-          })),
+          entries: installedMcp.map(({ entry }) => entry),
           ambiguityPolicy: { type: "auto-pick-best" }
         }),
         catch: (cause) => cause
@@ -777,7 +920,7 @@ function isFoundrySubscriber(value) {
 }
 
 // src/playbook.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 var ID = /^[a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)*$/;
 function assertData(value, path, seen = /* @__PURE__ */ new Set()) {
   if (value === void 0) throw new Error(`Playbook ${path} cannot contain undefined.`);
@@ -921,12 +1064,12 @@ function reconstructPlaybook(playbook) {
 var FOUNDRY_PLAYBOOK_ACTION_BRAND = /* @__PURE__ */ Symbol.for("glove-foundry-playbook-action");
 var FOUNDRY_COMPOSED_PLAYBOOK_BRAND = /* @__PURE__ */ Symbol.for("glove-foundry-composed-playbook");
 function agentPlaybookId(definitionId, agentId, name) {
-  return `playbook-${createHash("sha256").update(`${definitionId}\0${agentId}\0${name}`).digest("hex").slice(0, 24)}`;
+  return `playbook-${createHash2("sha256").update(`${definitionId}\0${agentId}\0${name}`).digest("hex").slice(0, 24)}`;
 }
 function composedPlaybookRevision(playbook) {
   const materialized = materializeComposedPlaybook(playbook, "playbook-revision", "pending");
   const { id: _id, definitionRevision: _revision, ...data } = materialized;
-  return createHash("sha256").update(JSON.stringify(data)).digest("hex");
+  return createHash2("sha256").update(JSON.stringify(data)).digest("hex");
 }
 function definePlaybookAction(options = {}) {
   if (options.id && !ID.test(options.id)) {
@@ -981,9 +1124,15 @@ function definePlaybookSubscription(options) {
   return Object.freeze(authored);
 }
 function reconstructPlaybookSubscription(subscription) {
+  const { playbook, ...data } = subscription;
   return freezeData2({
-    ...structuredClone(subscription),
-    playbook: reconstructPlaybook(subscription.playbook)
+    ...structuredClone(data),
+    // A file-routed subscription owns exactly one playbook, so its route is
+    // also the stable persisted playbook identity when the author supplied a
+    // composed policy without a runtime id.
+    playbook: reconstructPlaybook(
+      playbook.id ? playbook : { ...playbook, id: subscription.id }
+    )
   });
 }
 
@@ -1190,6 +1339,18 @@ var MemoryFoundryDataAdapter = class {
       this.workspace.set(`${entry.workspaceId}:${entry.key}`, Object.freeze({ ...entry }));
     });
   }
+  compareAndSetWorkspaceEntry(entry, expectedUpdatedAt) {
+    return Effect4.sync(() => {
+      const key = `${entry.workspaceId}:${entry.key}`;
+      const current = this.workspace.get(key);
+      if ((current?.updatedAt ?? null) !== expectedUpdatedAt) return false;
+      if (!Number.isFinite(Date.parse(entry.updatedAt)) || current && Date.parse(entry.updatedAt) <= Date.parse(current.updatedAt)) {
+        throw new Error("An atomic workspace update must advance updatedAt.");
+      }
+      this.workspace.set(key, freezeInstanceData(structuredClone(entry)));
+      return true;
+    });
+  }
   listWorkspaceEntries(workspaceId) {
     return Effect4.succeed([...this.workspace.values()].filter((item) => item.workspaceId === workspaceId));
   }
@@ -1321,7 +1482,7 @@ function id(prefix) {
 }
 
 // src/schedule.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { Duration } from "effect";
 var FOUNDRY_SCHEDULE_BRAND = /* @__PURE__ */ Symbol.for("glove-foundry-schedule");
 var COMPACT_DURATION = /^(\d+)\s*(ms|s|m|h|d|w)$/i;
@@ -1365,11 +1526,11 @@ function isFoundrySchedule(value) {
   return Boolean(value && typeof value === "object" && value[FOUNDRY_SCHEDULE_BRAND] === true);
 }
 function agentScheduleActivationId(definitionId, agentId, name) {
-  const digest = createHash2("sha256").update(`${definitionId}\0${agentId}\0${name}`).digest("hex").slice(0, 24);
+  const digest = createHash3("sha256").update(`${definitionId}\0${agentId}\0${name}`).digest("hex").slice(0, 24);
   return `activation_${digest}`;
 }
 function agentScheduleRevision(schedule) {
-  return createHash2("sha256").update(JSON.stringify({
+  return createHash3("sha256").update(JSON.stringify({
     message: schedule.message,
     payload: schedule.payload,
     timing: schedule.timing,
@@ -1381,10 +1542,194 @@ function agentScheduleRevision(schedule) {
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { Effect as Effect5, JSONSchema, Schema } from "effect";
 import { z } from "zod";
+
+// src/core-command-result.ts
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var FOUNDRY_CORE_COMMAND_DIRECTORY_ENV = "GLOVE_FOUNDRY_CORE_COMMAND_DIRECTORY";
+var REQUEST_SUFFIX = ".request.json";
+var CLAIM_SUFFIX = ".claim";
+var CANCELLATION_SUFFIX = ".cancellation.json";
+var RESULT_SUFFIX = ".result.json";
+var COMMAND_ID = /^command_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function commandPath(directory, id2, suffix) {
+  if (!COMMAND_ID.test(id2)) throw new Error("Invalid Foundry core command id.");
+  return join(directory, `${id2}${suffix}`);
+}
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (cause) {
+    if (cause.code === "ENOENT") return null;
+    throw cause;
+  }
+}
+function requestRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  const item = value;
+  const valid = typeof item.id === "string" && COMMAND_ID.test(item.id) && typeof item.runId === "string" && item.type === "transmit" && typeof item.requestedAt === "string" && typeof item.expiresAt === "string";
+  if (!valid) return null;
+  if (item.command !== void 0) {
+    const command = item.command;
+    if (!command || typeof command !== "object" || command.type !== "transmit" || command.id !== item.id || typeof command.definitionId !== "string" || typeof command.agentId !== "string" || typeof command.conversationId !== "string" || typeof command.workspaceId !== "string" || typeof command.routeId !== "string" || !("payload" in command)) return null;
+  }
+  return item;
+}
+function resultRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  const item = value;
+  if (typeof item.id !== "string" || !COMMAND_ID.test(item.id) || typeof item.resolvedAt !== "string") return null;
+  if (item.status === "success") return item;
+  return item.status === "error" && typeof item.error === "string" ? item : null;
+}
+function cancellationRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  const item = value;
+  return typeof item.id === "string" && COMMAND_ID.test(item.id) && (item.status === "cancelled" || item.status === "expired") && typeof item.cancelledAt === "string" ? item : null;
+}
+function jsonValue(value) {
+  if (value === void 0) return void 0;
+  return JSON.parse(JSON.stringify(value));
+}
+async function createFoundryCoreCommandRequest(directory, input) {
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const requestedAt = /* @__PURE__ */ new Date();
+  const timeoutMs = Math.min(Math.max(input.timeoutMs ?? 3e5, 1e3), 6e5);
+  const request = Object.freeze({
+    id: input.id,
+    runId: input.runId,
+    type: input.type,
+    requestedAt: requestedAt.toISOString(),
+    expiresAt: new Date(requestedAt.getTime() + timeoutMs).toISOString(),
+    ...input.command ? { command: jsonValue(input.command) } : {}
+  });
+  await writeFile(
+    commandPath(directory, request.id, REQUEST_SUFFIX),
+    `${JSON.stringify(request)}
+`,
+    { encoding: "utf8", flag: "wx", mode: 384 }
+  );
+  return request;
+}
+async function getFoundryCoreCommandRequest(directory, id2) {
+  return requestRecord(await readJson(commandPath(directory, id2, REQUEST_SUFFIX)));
+}
+async function claimFoundryCoreCommandRequest(directory, id2) {
+  try {
+    await writeFile(
+      commandPath(directory, id2, CLAIM_SUFFIX),
+      `${(/* @__PURE__ */ new Date()).toISOString()}
+`,
+      { encoding: "utf8", flag: "wx", mode: 384 }
+    );
+    return true;
+  } catch (cause) {
+    if (cause.code === "EEXIST") return false;
+    throw cause;
+  }
+}
+async function settleFoundryCoreCommandRequest(directory, id2, outcome) {
+  const result = outcome.status === "success" ? Object.freeze({
+    id: id2,
+    status: "success",
+    ...outcome.output !== void 0 ? { output: jsonValue(outcome.output) } : {},
+    resolvedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }) : Object.freeze({
+    id: id2,
+    status: "error",
+    error: outcome.error,
+    resolvedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  try {
+    await writeFile(
+      commandPath(directory, id2, RESULT_SUFFIX),
+      `${JSON.stringify(result)}
+`,
+      { encoding: "utf8", flag: "wx", mode: 384 }
+    );
+  } catch (cause) {
+    if (cause.code !== "EEXIST") throw cause;
+  }
+}
+async function cancelFoundryCoreCommandRequest(directory, id2, status) {
+  const cancellation = Object.freeze({
+    id: id2,
+    status,
+    cancelledAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  try {
+    await writeFile(
+      commandPath(directory, id2, CANCELLATION_SUFFIX),
+      `${JSON.stringify(cancellation)}
+`,
+      { encoding: "utf8", flag: "wx", mode: 384 }
+    );
+  } catch (cause) {
+    if (cause.code !== "EEXIST") throw cause;
+  }
+}
+async function monitorFoundryCoreCommandRequest(directory, request, delivery, stopped) {
+  while (!stopped.aborted && !delivery.signal.aborted) {
+    const cancellation = cancellationRecord(
+      await readJson(commandPath(directory, request.id, CANCELLATION_SUFFIX))
+    );
+    if (cancellation) {
+      delivery.abort(new Error(
+        cancellation.status === "cancelled" ? "Foundry transmission call was cancelled." : "Foundry transmission call timed out."
+      ));
+      return;
+    }
+    if (Date.parse(request.expiresAt) <= Date.now()) {
+      delivery.abort(new Error("Foundry transmission call timed out."));
+      return;
+    }
+    await new Promise((resolveWait) => setTimeout(resolveWait, 50));
+  }
+}
+async function waitForFoundryCoreCommandResult(directory, request, signal2, options = {}) {
+  for (; ; ) {
+    const result = resultRecord(
+      await readJson(commandPath(directory, request.id, RESULT_SUFFIX))
+    );
+    if (result) {
+      if (options.cleanup) await cleanupFoundryCoreCommandRequest(directory, request.id);
+      if (result.status === "error") throw new Error(result.error);
+      return result.output;
+    }
+    if (signal2.aborted) {
+      await cancelFoundryCoreCommandRequest(directory, request.id, "cancelled");
+      throw new Error("Foundry transmission call was cancelled.");
+    }
+    if (Date.parse(request.expiresAt) <= Date.now()) {
+      await cancelFoundryCoreCommandRequest(directory, request.id, "expired");
+      throw new Error("Foundry transmission call timed out.");
+    }
+    await new Promise((resolveWait) => setTimeout(resolveWait, 50));
+  }
+}
+async function cleanupFoundryCoreCommandRequest(directory, id2) {
+  await Promise.all([
+    REQUEST_SUFFIX,
+    CLAIM_SUFFIX,
+    RESULT_SUFFIX,
+    CANCELLATION_SUFFIX
+  ].map(async (suffix) => {
+    try {
+      await unlink(commandPath(directory, id2, suffix));
+    } catch (cause) {
+      if (cause.code !== "ENOENT") throw cause;
+    }
+  }));
+}
+
+// src/core-tools.ts
 var FOUNDRY_CORE_COMMAND_EVENT = "foundry.core.command";
 function commandId() {
   return `command_${randomUUID2()}`;
 }
+function privateTransmitEvent(command) {
+  return Object.freeze({ ...command, payload: { privateRequest: true } });
+}
 function durationSchema(description) {
   return z.string().describe(description).refine((value) => {
     try {
@@ -1407,6 +1752,9 @@ var timingInputSchema = z.discriminatedUnion("kind", [
 function toolSegment(value) {
   return value.replaceAll("/", "__").replaceAll("-", "_");
 }
+function installedApplicationTransmissionToolName(application, transmission) {
+  return `glove_app_${toolSegment(application.id)}__${toolSegment(transmission.id)}_send`;
+}
 function outboundToolSchema(transmission, routeIds) {
   const document = JSONSchema.make(transmission.outbound.input);
   const { $schema: _schema, $defs, ...payload } = document;
@@ -1429,10 +1777,9 @@ function createInstalledApplicationTransmissionTools(context, applications, inst
   const installed = new Set(
     installations.filter((item) => item.kind === "application").map((item) => item.id)
   );
-  const emit = (command) => {
+  const emit = (command, eventCommand = command) => {
     context.controls.commands.push(command);
-    context.controls.emit({ type: FOUNDRY_CORE_COMMAND_EVENT, data: command });
-    return success(command);
+    context.controls.emit({ type: FOUNDRY_CORE_COMMAND_EVENT, data: eventCommand });
   };
   const tools = [];
   for (const application of applications) {
@@ -1448,13 +1795,25 @@ function createInstalledApplicationTransmissionTools(context, applications, inst
           ).map((outbound) => outbound.routeId)
         )
       )].sort();
+      const requiresPermission = transmission.outbound.requiresPermission;
       tools.push({
-        name: `glove_app_${toolSegment(application.id)}__${toolSegment(transmission.id)}_send`,
+        name: installedApplicationTransmissionToolName(application, transmission),
         description: [
           `Send through the ${transmission.name} outbound transmission installed by the ${application.id} application.`,
           routeIds.length > 0 ? `Allowed playbook routes: ${routeIds.join(", ")}.` : "Supply a route authorized for this agent run."
         ].join(" "),
         jsonSchema: outboundToolSchema(transmission, routeIds),
+        ...requiresPermission !== void 0 ? {
+          requiresPermission: (input) => {
+            if (routeIds.length > 0 && !routeIds.includes(input.routeId)) return false;
+            try {
+              const payload = Schema.decodeUnknownSync(transmission.outbound.input)(input.payload);
+              return typeof requiresPermission === "function" ? requiresPermission(payload) : requiresPermission;
+            } catch {
+              return false;
+            }
+          }
+        } : {},
         async do(input) {
           if (routeIds.length > 0 && !routeIds.includes(input.routeId)) {
             return {
@@ -1467,7 +1826,13 @@ function createInstalledApplicationTransmissionTools(context, applications, inst
             const payload = await Schema.decodeUnknownPromise(
               transmission.outbound.input
             )(input.payload);
-            return emit({
+            const directory = process.env[FOUNDRY_CORE_COMMAND_DIRECTORY_ENV];
+            if (!directory) {
+              throw new Error(
+                "Foundry cannot call an application transmission without its parent runtime."
+              );
+            }
+            const command = {
               id: commandId(),
               type: "transmit",
               definitionId: context.definitionId,
@@ -1476,9 +1841,31 @@ function createInstalledApplicationTransmissionTools(context, applications, inst
               workspaceId: context.workspaceId,
               routeId: input.routeId,
               payload,
+              ...transmission.outbound.observe ? { observability: transmission.outbound.observe(payload) } : {},
               applicationId: application.id,
               transmissionId: transmission.id
+            };
+            const request = await createFoundryCoreCommandRequest(directory, {
+              id: command.id,
+              runId: context.runId,
+              type: command.type,
+              command
             });
+            emit(command, privateTransmitEvent(command));
+            const output = await waitForFoundryCoreCommandResult(
+              directory,
+              request,
+              context.controls.signal,
+              { cleanup: true }
+            );
+            const decoded = await Schema.decodeUnknownPromise(
+              transmission.outbound.output
+            )(output);
+            return {
+              status: "success",
+              data: transmission.outbound.project ? transmission.outbound.project(decoded) : decoded,
+              ...transmission.outbound.render ? { renderData: transmission.outbound.render(decoded) } : {}
+            };
           } catch (cause) {
             return {
               status: "error",
@@ -1511,9 +1898,9 @@ function createFoundryCoreTools(context, desiredSchedules = []) {
     context.controls.emit({ type: FOUNDRY_CORE_COMMAND_EVENT, data: command });
     return success(command);
   };
-  const scheduleView = () => {
+  const scheduleView = async () => {
     const records = new Map(
-      context.activations.filter((item) => item.kind === "scheduled").map((item) => [item.id, item])
+      [...context.activations, ...await Effect5.runPromise(context.data.listActivations(context.workspaceId))].filter((item) => item.kind === "scheduled" && item.agentId === context.agentId).map((item) => [item.id, item])
     );
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const desired of desiredSchedules) {
@@ -1561,6 +1948,20 @@ function createFoundryCoreTools(context, desiredSchedules = []) {
         if (current) records.set(command.activationId, {
           ...current,
           ...command.patch,
+          status: current.status === "paused" ? "paused" : "pending",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } else if (command.type === "schedule.pause") {
+        const current = records.get(command.activationId);
+        if (current) records.set(command.activationId, {
+          ...current,
+          status: "paused",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } else if (command.type === "schedule.resume") {
+        const current = records.get(command.activationId);
+        if (current) records.set(command.activationId, {
+          ...current,
           status: "pending",
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
@@ -1626,11 +2027,11 @@ function createFoundryCoreTools(context, desiredSchedules = []) {
     },
     {
       name: "glove_foundry_schedules",
-      description: "List, update, or cancel scheduled triggers owned by this agent instance. Use the activation id returned by list.",
+      description: "List, update, pause, resume, or cancel scheduled triggers owned by this agent instance. Use the activation id returned by list.",
       inputSchema: z.discriminatedUnion("action", [
         z.object({
           action: z.literal("list"),
-          status: z.enum(["active", "completed", "cancelled", "all"]).default("active")
+          status: z.enum(["active", "paused", "completed", "cancelled", "all"]).default("active")
         }),
         z.object({
           action: z.literal("update"),
@@ -1639,16 +2040,18 @@ function createFoundryCoreTools(context, desiredSchedules = []) {
           payload: z.unknown().optional(),
           timing: timingInputSchema.optional()
         }),
+        z.object({ action: z.literal("pause"), activationId: z.string().min(1) }),
+        z.object({ action: z.literal("resume"), activationId: z.string().min(1) }),
         z.object({ action: z.literal("cancel"), activationId: z.string().min(1) })
       ]),
       async do(input) {
+        const scheduled = await scheduleView();
         if (input.action === "list") {
-          const scheduled = scheduleView();
           const filter = input.status ?? "active";
           const filtered = filter === "all" ? scheduled : filter === "active" ? scheduled.filter((item) => item.status === "pending" || item.status === "active") : scheduled.filter((item) => item.status === filter);
           return { status: "success", data: filtered };
         }
-        if (!scheduleView().some((item) => item.id === input.activationId && item.agentId === context.agentId && item.kind === "scheduled")) {
+        if (!scheduled.some((item) => item.id === input.activationId && item.agentId === context.agentId && item.kind === "scheduled")) {
           return { status: "error", data: null, message: `Schedule "${input.activationId}" is not owned by this agent instance.` };
         }
         if (input.action === "cancel") {
@@ -1662,6 +2065,35 @@ function createFoundryCoreTools(context, desiredSchedules = []) {
             workspaceId: context.workspaceId
           });
         }
+        if (input.action === "pause" || input.action === "resume") {
+          const current = scheduled.find((item) => item.id === input.activationId);
+          if (input.action === "pause" && current.status === "paused") {
+            return { status: "success", data: current };
+          }
+          if (input.action === "resume" && current.status !== "paused") {
+            return {
+              status: "error",
+              data: null,
+              message: `Schedule "${input.activationId}" is not paused.`
+            };
+          }
+          if (input.action === "pause" && (current.status === "completed" || current.status === "cancelled")) {
+            return {
+              status: "error",
+              data: null,
+              message: `Schedule "${input.activationId}" cannot be paused from status "${current.status}".`
+            };
+          }
+          return emit({
+            id: commandId(),
+            type: input.action === "pause" ? "schedule.pause" : "schedule.resume",
+            activationId: input.activationId,
+            definitionId: context.definitionId,
+            agentId: context.agentId,
+            conversationId: context.conversationId,
+            workspaceId: context.workspaceId
+          });
+        }
         const patch = {};
         if (input.message !== void 0) patch.message = input.message;
         if (input.payload !== void 0) patch.payload = input.payload;
@@ -1740,7 +2172,7 @@ function createFoundryCoreTools(context, desiredSchedules = []) {
         payload: z.unknown()
       }),
       async do(input) {
-        return emit({
+        const command = {
           id: commandId(),
           type: "transmit",
           definitionId: context.definitionId,
@@ -1749,7 +2181,36 @@ function createFoundryCoreTools(context, desiredSchedules = []) {
           workspaceId: context.workspaceId,
           routeId: input.routeId,
           payload: input.payload
+        };
+        const directory = process.env[FOUNDRY_CORE_COMMAND_DIRECTORY_ENV];
+        if (!directory) {
+          return emit(command);
+        }
+        const request = await createFoundryCoreCommandRequest(directory, {
+          id: command.id,
+          runId: context.runId,
+          type: command.type,
+          command
         });
+        context.controls.commands.push(command);
+        context.controls.emit({ type: FOUNDRY_CORE_COMMAND_EVENT, data: privateTransmitEvent(command) });
+        try {
+          return {
+            status: "success",
+            data: await waitForFoundryCoreCommandResult(
+              directory,
+              request,
+              context.controls.signal,
+              { cleanup: true }
+            )
+          };
+        } catch (cause) {
+          return {
+            status: "error",
+            data: null,
+            message: cause instanceof Error ? cause.message : String(cause)
+          };
+        }
       }
     },
     {
@@ -1888,6 +2349,9 @@ function createFoundryCoreTools(context, desiredSchedules = []) {
 
 // src/workbench.ts
 import { Effect as Effect6 } from "effect";
+import {
+  getToolJsonSchema
+} from "glove-core";
 import {
   JsSession,
   mountJs
@@ -1976,6 +2440,153 @@ function defineRepl(options) {
     [FOUNDRY_REPL_BRAND]: true
   });
 }
+function isProgrammaticSelection(value) {
+  return typeof value === "object" && value !== null && "tool" in value;
+}
+function parseProgrammaticToolData(data) {
+  if (typeof data !== "string") return data;
+  const text = data.trim();
+  if (!text.startsWith("{") && !text.startsWith("[")) return data;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return data;
+  }
+}
+async function runProgrammaticTool(tool, input, signal2) {
+  if (tool.unAbortable || !signal2) return tool.run(input, void 0, signal2);
+  if (signal2.aborted) throw signal2.reason ?? new DOMException("Aborted", "AbortError");
+  return new Promise((resolve2, reject) => {
+    const abort = () => reject(signal2.reason ?? new DOMException("Aborted", "AbortError"));
+    signal2.addEventListener("abort", abort, { once: true });
+    tool.run(input, void 0, signal2).then(
+      (value) => {
+        signal2.removeEventListener("abort", abort);
+        resolve2(value);
+      },
+      (cause) => {
+        signal2.removeEventListener("abort", abort);
+        reject(cause);
+      }
+    );
+  });
+}
+function programmaticToolFunction(selection, options) {
+  const decorated = isProgrammaticSelection(selection) ? selection : { tool: selection };
+  const tool = decorated.tool;
+  if (!options.available.has(tool)) {
+    throw new Error(
+      `Programmatic tool "${tool.name}" is not an exact reference from the assembled agent tool registry.`
+    );
+  }
+  const name = decorated.name ?? tool.name;
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+    throw new Error(
+      `Programmatic tool name "${name}" is not a valid JavaScript/Python/Lisp identifier; provide a valid name override.`
+    );
+  }
+  return {
+    name,
+    description: tool.description,
+    inputSchema: getToolJsonSchema(tool),
+    ...decorated.readOnly !== void 0 ? { readOnlyHint: decorated.readOnly } : {},
+    ...decorated.server !== void 0 ? { server: decorated.server } : {},
+    ...decorated.serverDescription !== void 0 ? { serverDescription: decorated.serverDescription } : {},
+    ...decorated.resultShape !== void 0 ? { resultShape: decorated.resultShape } : {},
+    async call(input, fnContext = {}) {
+      if (options.budget.used >= options.budget.max) {
+        options.context.controls.emit({
+          type: "foundry.repl.programmatic-tool.limit",
+          data: { tool: tool.name, function: name, maxCalls: options.budget.max }
+        });
+        throw new Error(
+          `Programmatic tool-call limit (${options.budget.max}) reached for this run. Return the result already computed or continue in a new run.`
+        );
+      }
+      options.budget.used += 1;
+      const parsed = tool.input_schema?.safeParse(input);
+      if (parsed && !parsed.success) {
+        throw new Error(
+          parsed.error.issues.slice(0, 3).map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`).join("; ")
+        );
+      }
+      const validated = parsed?.success ? parsed.data : input;
+      const permission = typeof tool.requiresPermission === "function" ? tool.requiresPermission(validated) : Boolean(tool.requiresPermission);
+      if (permission) {
+        options.context.controls.emit({
+          type: "foundry.repl.programmatic-tool.denied",
+          data: { tool: tool.name, function: name, reason: "interactive-approval-required" }
+        });
+        throw new Error(
+          `Tool "${tool.name}" requires interactive approval and cannot run inside a programmatic workflow. Call it directly so the approval can be shown.`
+        );
+      }
+      const started = Date.now();
+      options.context.controls.emit({
+        type: "foundry.repl.programmatic-tool.started",
+        data: { tool: tool.name, function: name, call: options.budget.used }
+      });
+      try {
+        const result = await runProgrammaticTool(tool, validated, fnContext.signal);
+        if (result.status !== "success") {
+          throw new Error(result.message ?? `Tool "${tool.name}" failed.`);
+        }
+        options.context.controls.emit({
+          type: "foundry.repl.programmatic-tool.completed",
+          data: { tool: tool.name, function: name, durationMs: Date.now() - started }
+        });
+        return parseProgrammaticToolData(result.data);
+      } catch (cause) {
+        options.context.controls.emit({
+          type: "foundry.repl.programmatic-tool.failed",
+          data: {
+            tool: tool.name,
+            function: name,
+            durationMs: Date.now() - started,
+            outcome: "error"
+          }
+        });
+        throw cause;
+      }
+    }
+  };
+}
+async function registerProgrammaticTools(options) {
+  const config = options.repl.programmaticTools;
+  if (!config) return 0;
+  const max = config.maxCalls ?? 50;
+  if (!Number.isInteger(max) || max < 1 || max > 1e3) {
+    throw new Error("Foundry programmaticTools.maxCalls must be an integer from 1 to 1000.");
+  }
+  const tools = Object.freeze([...options.glove.tools]);
+  const selected = await resolveResolvable(config.select({
+    assembly: options.context,
+    glove: options.glove,
+    tools,
+    ...options.workingEnvironment ? { workingEnvironment: options.workingEnvironment } : {},
+    ...options.vfs ? { vfs: options.vfs } : {}
+  }));
+  const available = new Set(tools);
+  const budget = { used: 0, max };
+  const functions = selected.map(
+    (selection) => programmaticToolFunction(selection, { available, budget, context: options.context })
+  );
+  const names = /* @__PURE__ */ new Set();
+  for (const fn of functions) {
+    if (names.has(fn.name)) throw new Error(`Duplicate programmatic function name "${fn.name}".`);
+    names.add(fn.name);
+  }
+  switch (options.repl.language) {
+    case "javascript":
+    case "python":
+      options.repl.session.registerAll(functions);
+      break;
+    case "lisp":
+      options.repl.session.registerFns(functions);
+      break;
+  }
+  return functions.length;
+}
 function persistenceContext(context) {
   return {
     definitionId: context.definitionId,
@@ -2018,6 +2629,7 @@ async function mountFoundryWorkbench(options) {
   let environment;
   let persistence;
   let mountedRepl;
+  let replMountPromise;
   const dispose = async () => {
     if (!environment || !options.workingEnvironment) return;
     const failures = [];
@@ -2052,6 +2664,54 @@ async function mountFoundryWorkbench(options) {
       );
     }
   };
+  const mountRepl = () => {
+    const repl = options.repl;
+    if (!repl) return Promise.resolve();
+    if (replMountPromise) return replMountPromise;
+    replMountPromise = (async () => {
+      if (repl[FOUNDRY_REPL_BRAND] !== true) {
+        throw new Error("Agent repl must be created with defineRepl(...).");
+      }
+      const programmaticTools = await registerProgrammaticTools({
+        repl,
+        glove: options.glove,
+        context: options.context,
+        ...environment ? { workingEnvironment: environment, vfs: environment.fs } : {}
+      });
+      switch (repl.language) {
+        case "javascript":
+          mountJs(options.glove, {
+            session: repl.session,
+            ...repl.mount ?? {},
+            exclusive: false
+          });
+          break;
+        case "python":
+          mountPy(options.glove, {
+            session: repl.session,
+            ...repl.mount ?? {},
+            exclusive: false
+          });
+          break;
+        case "lisp":
+          mountLisp(options.glove, {
+            session: repl.session,
+            ...repl.mount ?? {},
+            exclusive: false
+          });
+          break;
+      }
+      options.context.controls.emit({
+        type: "foundry.repl.mounted",
+        data: {
+          language: repl.language,
+          frame: repl.mount?.frame ?? "repl",
+          programmaticTools
+        }
+      });
+    })();
+    return replMountPromise;
+  };
   try {
     if (options.workingEnvironment) {
       const created = await createEnvironment(
@@ -2075,52 +2735,13 @@ async function mountFoundryWorkbench(options) {
       });
     }
     if (options.repl) {
-      if (options.repl[FOUNDRY_REPL_BRAND] !== true) {
-        throw new Error("Agent repl must be created with defineRepl(...).");
-      }
-      switch (options.repl.language) {
-        case "javascript":
-          mountJs(options.glove, {
-            session: options.repl.session,
-            ...options.repl.mount ?? {}
-          });
-          mountedRepl = Object.freeze({
-            language: "javascript",
-            session: options.repl.session
-          });
-          break;
-        case "python":
-          mountPy(options.glove, {
-            session: options.repl.session,
-            ...options.repl.mount ?? {}
-          });
-          mountedRepl = Object.freeze({
-            language: "python",
-            session: options.repl.session
-          });
-          break;
-        case "lisp":
-          mountLisp(options.glove, {
-            session: options.repl.session,
-            ...options.repl.mount ?? {}
-          });
-          mountedRepl = Object.freeze({
-            language: "lisp",
-            session: options.repl.session
-          });
-          break;
-      }
-      options.context.controls.emit({
-        type: "foundry.repl.mounted",
-        data: {
-          language: options.repl.language,
-          frame: options.repl.mount?.frame ?? "repl"
-        }
-      });
+      mountedRepl = options.repl.language === "javascript" ? Object.freeze({ language: "javascript", session: options.repl.session }) : options.repl.language === "python" ? Object.freeze({ language: "python", session: options.repl.session }) : Object.freeze({ language: "lisp", session: options.repl.session });
+      if (!options.deferRepl) await mountRepl();
     }
     return {
       ...environment ? { workingEnvironment: environment, vfs: environment.fs } : {},
       ...mountedRepl ? { repl: mountedRepl } : {},
+      mountRepl,
       dispose
     };
   } catch (cause) {
@@ -2136,9 +2757,220 @@ async function mountFoundryWorkbench(options) {
   }
 }
 
+// src/approval.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir as mkdir2, readFile as readFile2, readdir, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import {
+  Displaymanager as Displaymanager2,
+  permissionKey
+} from "glove-core";
+var FOUNDRY_APPROVAL_DIRECTORY_ENV = "GLOVE_FOUNDRY_APPROVAL_DIRECTORY";
+var REQUEST_SUFFIX2 = ".request.json";
+var RESOLUTION_SUFFIX = ".resolution.json";
+var APPROVAL_ID = /^approval_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function approvalPath(directory, id2, suffix) {
+  if (!APPROVAL_ID.test(id2)) throw new Error("Invalid Foundry approval id.");
+  return join2(directory, `${id2}${suffix}`);
+}
+function serializable(value) {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return String(value);
+  }
+}
+async function readJson2(path) {
+  try {
+    return JSON.parse(await readFile2(path, "utf8"));
+  } catch (cause) {
+    if (cause.code === "ENOENT") return null;
+    throw cause;
+  }
+}
+function requestRecord2(value) {
+  if (!value || typeof value !== "object") return null;
+  const item = value;
+  return typeof item.id === "string" && APPROVAL_ID.test(item.id) && typeof item.runId === "string" && typeof item.definitionId === "string" && typeof item.agentId === "string" && typeof item.conversationId === "string" && typeof item.workspaceId === "string" && typeof item.toolName === "string" && typeof item.requestedAt === "string" && typeof item.expiresAt === "string" ? item : null;
+}
+function resolutionRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  const item = value;
+  return typeof item.id === "string" && APPROVAL_ID.test(item.id) && ["approved", "denied", "expired", "cancelled"].includes(item.status ?? "") && typeof item.resolvedAt === "string" ? item : null;
+}
+async function writeResolution(directory, id2, status, rejectExisting = false) {
+  const resolution = Object.freeze({ id: id2, status, resolvedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  try {
+    await writeFile2(
+      approvalPath(directory, id2, RESOLUTION_SUFFIX),
+      `${JSON.stringify(resolution)}
+`,
+      { encoding: "utf8", flag: "wx", mode: 384 }
+    );
+    return resolution;
+  } catch (cause) {
+    if (cause.code !== "EEXIST") throw cause;
+    const existing = resolutionRecord(
+      await readJson2(approvalPath(directory, id2, RESOLUTION_SUFFIX))
+    );
+    if (!existing) throw new Error(`Foundry approval "${id2}" has an invalid resolution.`);
+    if (rejectExisting) {
+      throw new Error(`Foundry approval "${id2}" is already ${existing.status}.`);
+    }
+    return existing;
+  }
+}
+async function createFoundryApproval(directory, input) {
+  await mkdir2(directory, { recursive: true, mode: 448 });
+  const requestedAt = /* @__PURE__ */ new Date();
+  const timeoutMs = Math.min(Math.max(input.timeoutMs ?? 3e5, 1e3), 6e5);
+  const request = Object.freeze({
+    id: `approval_${randomUUID3()}`,
+    runId: input.runId,
+    definitionId: input.definitionId,
+    agentId: input.agentId,
+    conversationId: input.conversationId,
+    workspaceId: input.workspaceId,
+    toolName: input.toolName,
+    toolInput: serializable(input.toolInput),
+    requestedAt: requestedAt.toISOString(),
+    expiresAt: new Date(requestedAt.getTime() + timeoutMs).toISOString()
+  });
+  await writeFile2(
+    approvalPath(directory, request.id, REQUEST_SUFFIX2),
+    `${JSON.stringify(request)}
+`,
+    { encoding: "utf8", flag: "wx", mode: 384 }
+  );
+  return Object.freeze({ ...request, status: "pending" });
+}
+async function listFoundryApprovals(directory, filter = {}) {
+  let names;
+  try {
+    names = await readdir(directory);
+  } catch (cause) {
+    if (cause.code === "ENOENT") return [];
+    throw cause;
+  }
+  const approvals = [];
+  for (const name of names.filter((item) => item.endsWith(REQUEST_SUFFIX2)).sort()) {
+    const request = requestRecord2(await readJson2(join2(directory, name)));
+    if (!request) continue;
+    const resolution = resolutionRecord(
+      await readJson2(approvalPath(directory, request.id, RESOLUTION_SUFFIX))
+    );
+    const status = resolution?.status ?? (Date.parse(request.expiresAt) <= Date.now() ? "expired" : "pending");
+    const approval = Object.freeze({
+      ...request,
+      status,
+      ...resolution ? { resolvedAt: resolution.resolvedAt } : {}
+    });
+    if (filter.runId && approval.runId !== filter.runId) continue;
+    if (filter.status && approval.status !== filter.status) continue;
+    approvals.push(approval);
+  }
+  return approvals.sort((a, b) => a.requestedAt.localeCompare(b.requestedAt));
+}
+async function resolveFoundryApproval(directory, id2, decision) {
+  const request = requestRecord2(await readJson2(approvalPath(directory, id2, REQUEST_SUFFIX2)));
+  if (!request) throw new Error(`Foundry approval "${id2}" was not found.`);
+  const current = (await listFoundryApprovals(directory)).find((item) => item.id === id2);
+  if (!current || current.status !== "pending") {
+    throw new Error(`Foundry approval "${id2}" is already ${current?.status ?? "unavailable"}.`);
+  }
+  const resolution = await writeResolution(
+    directory,
+    id2,
+    decision === "approve" ? "approved" : "denied",
+    true
+  );
+  return Object.freeze({ ...request, status: resolution.status, resolvedAt: resolution.resolvedAt });
+}
+async function waitForResolution(directory, approval, signal2) {
+  for (; ; ) {
+    const resolved = resolutionRecord(
+      await readJson2(approvalPath(directory, approval.id, RESOLUTION_SUFFIX))
+    );
+    if (resolved) return resolved;
+    if (signal2.aborted) return writeResolution(directory, approval.id, "cancelled");
+    if (Date.parse(approval.expiresAt) <= Date.now()) {
+      return writeResolution(directory, approval.id, "expired");
+    }
+    await new Promise((resolveWait) => setTimeout(resolveWait, 100));
+  }
+}
+var FoundryApprovalDisplayManager = class extends Displaymanager2 {
+  constructor(context) {
+    super();
+    this.context = context;
+  }
+  async pushAndWait(slot) {
+    if (slot.renderer !== "permission_request") {
+      return super.pushAndWait(slot);
+    }
+    const request = slot.input && typeof slot.input === "object" ? slot.input : {};
+    const toolName = typeof request.toolName === "string" ? request.toolName : void 0;
+    if (!this.context.directory || !toolName) {
+      this.context.emit({
+        type: "foundry.approval.unavailable",
+        data: { toolName: toolName ?? "unknown", reason: "approval-channel-unavailable" }
+      });
+      return false;
+    }
+    try {
+      const approval = await createFoundryApproval(this.context.directory, {
+        runId: this.context.runId,
+        definitionId: this.context.definitionId,
+        agentId: this.context.agentId,
+        conversationId: this.context.conversationId,
+        workspaceId: this.context.workspaceId,
+        toolName,
+        toolInput: request.toolInput
+      });
+      this.context.emit({ type: "foundry.approval.requested", data: approval });
+      const resolution = await waitForResolution(
+        this.context.directory,
+        approval,
+        this.context.signal
+      );
+      this.context.emit({
+        type: "foundry.approval.settled",
+        data: { approvalId: approval.id, toolName, status: resolution.status }
+      });
+      return resolution.status === "approved";
+    } catch (cause) {
+      this.context.emit({
+        type: "foundry.approval.failed",
+        data: { toolName, error: cause instanceof Error ? cause.message : String(cause) }
+      });
+      return false;
+    }
+  }
+};
+function withFoundryPermissions(store) {
+  if (store.getPermission && store.setPermission) return store;
+  const permissions = /* @__PURE__ */ new Map();
+  return new Proxy(store, {
+    get(target, property, receiver) {
+      if (property === "getPermission") {
+        return async (toolName, input) => permissions.get(permissionKey(toolName, input)) ?? "unset";
+      }
+      if (property === "setPermission") {
+        return async (toolName, status, input) => {
+          const key = permissionKey(toolName, input);
+          if (status === "unset") permissions.delete(key);
+          else permissions.set(key, status);
+        };
+      }
+      const value = Reflect.get(target, property, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+
 // src/agent-runtime.ts
 import { pathToFileURL } from "node:url";
-import { Displaymanager as Displaymanager2, Glove as Glove2 } from "glove-core";
+import { Glove as Glove2 } from "glove-core";
 import { mountMesh } from "glove-mesh";
 import { Effect as Effect7 } from "effect";
 import { signal } from "station-signal";
@@ -2191,7 +3023,7 @@ function extractOutput(result) {
   }
   return "text" in object ? object.text : result;
 }
-function serializable(value) {
+function serializable2(value) {
   try {
     return JSON.parse(JSON.stringify(value));
   } catch {
@@ -2201,7 +3033,7 @@ function serializable(value) {
 function writeAgentEvent(type, data) {
   const line = `${FOUNDRY_EVENT_PREFIX}${JSON.stringify({
     type,
-    data: serializable(data),
+    data: serializable2(data),
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   })}
 `;
@@ -2289,8 +3121,9 @@ async function runDefinition(definition, id2, runtimeValue) {
     conversationId: request.conversationId,
     workspaceId: request.workspaceId
   }) : null;
+  const runtimeStore = store ? withFoundryPermissions(store) : null;
   const history = Object.freeze(
-    (store ? await store.getMessages() : []).map(freezeGloveMessage)
+    (runtimeStore ? await runtimeStore.getMessages() : []).map(freezeGloveMessage)
   );
   const message = toGloveMessage(request.message);
   const messages = Object.freeze([...history, message]);
@@ -2333,7 +3166,7 @@ async function runDefinition(definition, id2, runtimeValue) {
       history,
       messages,
       installations,
-      store,
+      store: runtimeStore,
       subscriber,
       controls
     };
@@ -2347,13 +3180,26 @@ async function runDefinition(definition, id2, runtimeValue) {
     const [model, systemPrompt, displayManager, compactionLimit, compactionInstructions, maxTurns] = await Promise.all([
       resolveOptional("model", definition.model, HANDLER_ONLY_MODEL),
       resolveOptional("systemPrompt", definition.systemPrompt, ""),
-      resolveOptional("displayManager", definition.displayManager, new Displaymanager2()),
+      resolveOptional(
+        "displayManager",
+        definition.displayManager,
+        new FoundryApprovalDisplayManager({
+          directory: process.env[FOUNDRY_APPROVAL_DIRECTORY_ENV],
+          runId,
+          definitionId: id2,
+          agentId: request.agentId,
+          conversationId: request.conversationId,
+          workspaceId: request.workspaceId,
+          signal: abortController.signal,
+          emit: controls.emit
+        })
+      ),
       resolveOptional("compactionLimit", definition.compactionLimit, void 0),
       resolveOptional("compactionInstructions", definition.compactionInstructions, "Preserve goals, decisions, unresolved work, tool results, and pending inbox items."),
       resolveOptional("maxTurns", definition.maxTurns, void 0)
     ]);
     const base = new Glove2({
-      ...store ? { store } : {},
+      ...runtimeStore ? { store: runtimeStore } : {},
       model,
       displayManager,
       systemPrompt,
@@ -2481,7 +3327,8 @@ async function runDefinition(definition, id2, runtimeValue) {
       glove: base,
       context: assemblyContext,
       ...workingEnvironment ? { workingEnvironment } : {},
-      ...repl ? { repl } : {}
+      ...repl ? { repl } : {},
+      deferRepl: Boolean(repl?.programmaticTools)
     });
     cleanups.push(workbench.dispose);
     const callByName = /* @__PURE__ */ new Map();
@@ -2511,8 +3358,22 @@ async function runDefinition(definition, id2, runtimeValue) {
       signal: abortController.signal,
       emit: controls.emit
     };
+    const guidance = await mountFoundryGuidance(base, assemblyContext, {
+      facts: await resolveOptional("facts", definition.facts, void 0),
+      goals: await resolveOptional("goals", definition.goals, void 0),
+      forms: await resolveOptional("forms", definition.forms, void 0),
+      contextProviders: await resolveOptional("contextProviders", definition.contextProviders, [])
+    });
+    cleanups.push(async () => {
+      try {
+        await guidance.snapshot();
+      } finally {
+        guidance.dispose();
+      }
+    });
     const callContext = {
       ...surfaceContext,
+      ...guidance.handles,
       installations: effectiveInstallations,
       invoke
     };
@@ -2616,11 +3477,12 @@ async function runDefinition(definition, id2, runtimeValue) {
     if (definition.configure) {
       await resolveResolvable(definition.configure(base, callContext));
     }
+    await workbench.mountRepl();
     const glove = definition.build ? await resolveResolvable(definition.build(base, assemblyContext)) ?? base : base;
     const runtimeContext = { ...callContext, glove };
-    const defaultRun = async () => extractOutput(
+    const defaultRun = async (messageInput = assemblyContext.messageInput) => extractOutput(
       await glove.processRequest(
-        toGloveRequestInput(assemblyContext.messageInput),
+        toGloveRequestInput(messageInput),
         abortController.signal
       )
     );
@@ -2628,7 +3490,7 @@ async function runDefinition(definition, id2, runtimeValue) {
       await resolveResolvable(definition.spawn(glove, runtimeContext, messageInput)),
       messageInput,
       abortController.signal
-    ) : defaultRun();
+    ) : defaultRun(messageInput);
     const handlerContext = {
       ...runtimeContext,
       defaultRun,
@@ -2636,12 +3498,13 @@ async function runDefinition(definition, id2, runtimeValue) {
       spawn
     };
     const result = definition.run ? await resolveResolvable(definition.run(glove, handlerContext)) : definition.handler ? await resolveResolvable(definition.handler(handlerContext)) : definition.spawn ? await spawn() : await defaultRun();
+    await guidance.snapshot();
     const sleep = [...controls.commands].reverse().find(
       (command) => command.type === "sleep"
     );
     return {
       status: sleep ? "suspended" : "completed",
-      value: serializable(result),
+      value: serializable2(result),
       agentId: request.agentId,
       conversationId: request.conversationId,
       workspaceId: request.workspaceId,
@@ -2669,6 +3532,7 @@ function compileAgentDefinition(definition, route) {
   const contentPartSchema = z2.object({
     type: z2.enum(["text", "image", "video", "document"]),
     text: z2.string().optional(),
+    name: z2.string().optional(),
     source: z2.object({
       type: z2.enum(["base64", "url"]),
       media_type: z2.string(),
@@ -2764,7 +3628,7 @@ function compileAgentDefinition(definition, route) {
       origin: z2.enum(["agent-definition", "agent-tool"]),
       scheduleName: z2.string().optional(),
       definitionRevision: z2.string().optional(),
-      status: z2.enum(["pending", "active", "completed", "cancelled"]),
+      status: z2.enum(["pending", "active", "paused", "completed", "cancelled"]),
       createdByRunId: z2.string(),
       lastRunId: z2.string().optional(),
       createdAt: z2.string(),
@@ -2788,6 +3652,115 @@ function compileAgentModule(route, module) {
   return compileAgentDefinition(defineAgentFromModule(route, module), route);
 }
 
+// src/composition.ts
+var composedToolBodies = /* @__PURE__ */ new WeakMap();
+function isToolBody(value) {
+  if (!value || typeof value !== "object") return false;
+  const body = value;
+  return typeof body.description === "string" && typeof body.do === "function" && (body.inputSchema !== void 0 || body.jsonSchema !== void 0);
+}
+function toolFromBody(body) {
+  const existing = composedToolBodies.get(body);
+  if (existing) return existing;
+  let definition;
+  const tool = { ...body };
+  Object.defineProperty(tool, "name", {
+    enumerable: true,
+    get: () => definition.id.replaceAll("/", "__").replaceAll("-", "_")
+  });
+  definition = defineSharedTool({
+    description: body.description,
+    tool
+  });
+  composedToolBodies.set(body, definition);
+  return definition;
+}
+function composedToolDefinition(body) {
+  if (!isToolBody(body)) return void 0;
+  return composedToolBodies.get(body) ?? toolFromBody(body);
+}
+function addUnique(values, value, kind) {
+  const key = fileDefinitionKey(value);
+  if (values.some((candidate) => fileDefinitionKey(candidate) === key)) {
+    throw new Error(`Duplicate agent-local ${kind} "${fileDefinitionLabel(value)}".`);
+  }
+  values.push(value);
+}
+function composeAgent(...sources) {
+  const capabilities = {
+    tools: [...EMPTY_CAPABILITY_REGISTRY.tools],
+    applications: [...EMPTY_CAPABILITY_REGISTRY.applications],
+    mcp: [...EMPTY_CAPABILITY_REGISTRY.mcp],
+    memory: [...EMPTY_CAPABILITY_REGISTRY.memory]
+  };
+  const native = {
+    layers: [...EMPTY_NATIVE_REGISTRY.layers],
+    subscribers: [...EMPTY_NATIVE_REGISTRY.subscribers]
+  };
+  const visit = (source) => {
+    if (!source) return;
+    if (typeof source === "function") {
+      visit(source());
+      return;
+    }
+    if (Array.isArray(source)) {
+      for (const child of source) visit(child);
+      return;
+    }
+    if ("capabilities" in source && "native" in source) {
+      visit([
+        ...source.capabilities.tools,
+        ...source.capabilities.applications,
+        ...source.capabilities.mcp,
+        ...source.capabilities.memory,
+        ...source.native.layers,
+        ...source.native.subscribers
+      ]);
+      return;
+    }
+    const branded = source;
+    if (branded[FOUNDRY_SHARED_TOOL_BRAND] === true) {
+      addUnique(capabilities.tools, branded, "tool");
+    } else if (branded[FOUNDRY_AGENT_APPLICATION_BRAND] === true) {
+      addUnique(
+        capabilities.applications,
+        branded,
+        "application"
+      );
+    } else if (branded[FOUNDRY_MCP_BRAND] === true) {
+      addUnique(capabilities.mcp, branded, "MCP");
+    } else if (branded[FOUNDRY_MEMORY_BRAND] === true) {
+      addUnique(
+        capabilities.memory,
+        branded,
+        "memory"
+      );
+    } else if (branded[FOUNDRY_LAYER_BRAND] === true) {
+      addUnique(native.layers, branded, "layer");
+    } else if (branded[FOUNDRY_SUBSCRIBER_BRAND] === true) {
+      addUnique(native.subscribers, branded, "subscriber");
+    } else if (isToolBody(source)) {
+      addUnique(capabilities.tools, toolFromBody(source), "tool");
+    } else {
+      throw new Error("composeAgent received an unrecognized Foundry definition.");
+    }
+  };
+  for (const source of sources) visit(source);
+  return Object.freeze({
+    capabilities: Object.freeze({
+      tools: Object.freeze(capabilities.tools),
+      applications: Object.freeze(capabilities.applications),
+      mcp: Object.freeze(capabilities.mcp),
+      memory: Object.freeze(capabilities.memory)
+    }),
+    native: Object.freeze({
+      layers: Object.freeze(native.layers),
+      subscribers: Object.freeze(native.subscribers)
+    })
+  });
+}
+var EMPTY_AGENT_COMPOSITION = composeAgent();
+
 // src/connection.ts
 var FOUNDRY_CONNECTION_BRAND = /* @__PURE__ */ Symbol.for(
   "glove-foundry-application-connection"
@@ -2976,12 +3949,13 @@ function defineTransmission(options) {
         predicates: Object.freeze([...options.inbound.predicates ?? []])
       })
     } : {},
+    ...options.outbound ? { outbound: Object.freeze({ ...options.outbound }) } : {},
     [FOUNDRY_TRANSMISSION_BRAND]: true
   }, "transmission", id2));
 }
 
 // src/discovery.ts
-import { readdir } from "node:fs/promises";
+import { readdir as readdir2 } from "node:fs/promises";
 import { dirname, extname, relative, resolve, sep } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 var AGENT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".js", ".mjs"]);
@@ -3019,7 +3993,7 @@ function localDefinitionRoute(agentDirectory, filePath, suffix) {
 async function bindAgentLocalDefinitions(agentDirectory) {
   let entries;
   try {
-    entries = await readdir(agentDirectory, { recursive: true });
+    entries = await readdir2(agentDirectory, { recursive: true });
   } catch {
     return;
   }
@@ -3034,10 +4008,10 @@ async function bindAgentLocalDefinitions(agentDirectory) {
     const filePath = resolve(agentDirectory, entry);
     const url = pathToFileURL2(filePath);
     const imported = await import(url.href);
-    const value = imported.default;
+    const value = matched.kind === "tool" ? imported.default && typeof imported.default === "object" && imported.default[matched.brand] === true ? imported.default : composedToolDefinition(imported.default ?? imported) : imported.default;
     if (!value || typeof value !== "object" || value[matched.brand] !== true) {
       throw new Error(
-        `${normalizePath(relative(agentDirectory, filePath))} must default-export its Foundry ${matched.kind} definition so the file can own its identity.`
+        `${normalizePath(relative(agentDirectory, filePath))} must ${matched.kind === "tool" ? "export a Glove tool body or default-export" : "default-export"} its Foundry ${matched.kind} definition so the file can own its identity.`
       );
     }
     const route = localDefinitionRoute(agentDirectory, filePath, matched.suffix);
@@ -3063,7 +4037,7 @@ async function findAgentFiles(agentsDir) {
   const absolute = resolve(agentsDir);
   let entries;
   try {
-    entries = await readdir(absolute, { recursive: true });
+    entries = await readdir2(absolute, { recursive: true });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Cannot read Foundry agents directory ${absolute}: ${message}`);
@@ -3164,6 +4138,10 @@ function createManifest(agents) {
         "skills",
         "subagents",
         "memory",
+        "goals",
+        "facts",
+        "forms",
+        "contextProviders",
         "inboxes",
         "subscribers",
         "layers",
@@ -3184,8 +4162,6 @@ export {
   defineApplication,
   EMPTY_FOUNDRY_APPLICATION,
   bindFileIdentity,
-  fileDefinitionKey,
-  fileDefinitionLabel,
   FOUNDRY_AGENT_DEFINITION_BRAND,
   FOUNDRY_AGENT_BRAND,
   FOUNDRY_EVENT_PREFIX,
@@ -3202,6 +4178,10 @@ export {
   defineAgentFromModule,
   defineSubagent,
   defineRoutes,
+  defineFacts,
+  defineGoals,
+  defineForms,
+  foundryGuidanceSubject,
   FOUNDRY_SHARED_TOOL_BRAND,
   FOUNDRY_AGENT_APPLICATION_BRAND,
   FOUNDRY_MCP_BRAND,
@@ -3236,6 +4216,7 @@ export {
   definePlaybookSubscription,
   reconstructPlaybookSubscription,
   toGloveMessage,
+  freezeGloveMessage,
   toGloveRequestInput,
   MemoryFoundryDataAdapter,
   createAgentInstance,
@@ -3247,7 +4228,13 @@ export {
   FOUNDRY_SCHEDULE_BRAND,
   defineSchedule,
   isFoundrySchedule,
+  FOUNDRY_CORE_COMMAND_DIRECTORY_ENV,
+  getFoundryCoreCommandRequest,
+  claimFoundryCoreCommandRequest,
+  settleFoundryCoreCommandRequest,
+  monitorFoundryCoreCommandRequest,
   FOUNDRY_CORE_COMMAND_EVENT,
+  installedApplicationTransmissionToolName,
   createInstalledApplicationTransmissionTools,
   createFoundryCoreTools,
   FOUNDRY_WORKING_ENVIRONMENT_BRAND,
@@ -3255,8 +4242,16 @@ export {
   defineWorkingEnvironment,
   foundryDataEnvironmentPersistence,
   defineRepl,
+  FOUNDRY_APPROVAL_DIRECTORY_ENV,
+  createFoundryApproval,
+  listFoundryApprovals,
+  resolveFoundryApproval,
+  FoundryApprovalDisplayManager,
+  withFoundryPermissions,
   compileAgentDefinition,
   compileAgentModule,
+  composeAgent,
+  EMPTY_AGENT_COMPOSITION,
   FOUNDRY_CONNECTION_BRAND,
   defineConnection,
   FOUNDRY_TRANSMISSION_BRAND,