glove-foundry 0.4.0 → 0.5.0

package/dist/{chunk-25BGNRJN.js → chunk-SGF3CFUR.js}

@@ -1,29 +1,25 @@
 import {
   DEFAULT_FOUNDRY_CONFIG
 } from "./chunk-ZFNMFE3T.js";
+import {
+  executionEvents
+} from "./chunk-J7ZBJM54.js";
 import {
   EMPTY_AGENT_COMPOSITION,
   EMPTY_CAPABILITY_REGISTRY,
   EMPTY_FOUNDRY_APPLICATION,
   EMPTY_NATIVE_REGISTRY,
   FOUNDRY_AGENT_APPLICATION_BRAND,
-  FOUNDRY_AGENT_FILE_ENV,
-  FOUNDRY_AGENT_ROUTE_ENV,
-  FOUNDRY_APPLICATION_ENV,
   FOUNDRY_APPROVAL_DIRECTORY_ENV,
   FOUNDRY_CORE_COMMAND_DIRECTORY_ENV,
   FOUNDRY_CORE_COMMAND_EVENT,
-  FOUNDRY_EVENT_PREFIX,
-  FOUNDRY_EXECUTION_MARKER,
   FOUNDRY_LAYER_BRAND,
   FOUNDRY_MCP_BRAND,
   FOUNDRY_MEMORY_BRAND,
   FOUNDRY_SHARED_TOOL_BRAND,
   FOUNDRY_SUBSCRIBER_BRAND,
   MemoryFoundryDataAdapter,
-  bindFileIdentity,
   claimFoundryCoreCommandRequest,
-  compileAgentDefinition,
   createAgentInstance,
   createConversation,
   createManifest,
@@ -40,10 +36,15 @@ import {
   reconstructPlaybook,
   reconstructPlaybookSubscription,
   resolveFoundryApproval,
-  routeFromInternalAgentName,
   settleFoundryCoreCommandRequest,
   transmissionPredicate
-} from "./chunk-5LDW2N2E.js";
+} from "./chunk-KBMD4RYU.js";
+import {
+  FOUNDRY_APPLICATION_ENV,
+  FOUNDRY_EVENT_PREFIX,
+  FOUNDRY_EXECUTION_MARKER,
+  bindFileIdentity
+} from "./chunk-5NFLGHOC.js";
 
 // src/codegen.ts
 import { mkdir, writeFile } from "node:fs/promises";
@@ -837,27 +838,189 @@ var FoundryObserver = class {
 };
 
 // src/runtime.ts
-import { existsSync } from "node:fs";
-import { mkdir as mkdir2, rm } from "node:fs/promises";
+import { mkdir as mkdir2, rm as rm2 } from "node:fs/promises";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join2 } from "node:path";
 import {
   Effect as Effect5,
   Layer as Layer3,
   ManagedRuntime as EffectManagedRuntime,
   Schema as Schema3
 } from "effect";
-import { EnvStore, MemoryEnvStorage } from "station-env";
-import {
-  MemoryAdapter,
-  parseInterval,
-  SignalRunner
-} from "station-signal";
+
+// src/execution-backend.ts
+import { fork } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+function entry(name) {
+  const built = fileURLToPath(new URL(`./${name}.js`, import.meta.url));
+  return existsSync(built) ? built : fileURLToPath(new URL(`./${name}.ts`, import.meta.url));
+}
+var FoundryExecutionBackend = class {
+  constructor(options) {
+    this.options = options;
+  }
+  child;
+  directory;
+  sequence = 0;
+  stopped = false;
+  stopping;
+  pending = /* @__PURE__ */ new Map();
+  loopResolve;
+  loopReject;
+  loop;
+  get processId() {
+    return this.child?.pid;
+  }
+  async initialize() {
+    if (this.child || this.stopped) throw new Error("Execution backend cannot be initialized twice.");
+    this.directory = await mkdtemp(join(tmpdir(), "glove-foundry-daemon-"));
+    const env = { ...process.env, ...this.options.env };
+    for (const name of ["NODE_OPTIONS", "LD_PRELOAD", "LD_LIBRARY_PATH", "DYLD_INSERT_LIBRARIES"]) delete env[name];
+    const child = this.child = fork(entry("execution-daemon"), [], {
+      cwd: this.options.rootDir,
+      env,
+      serialization: "advanced",
+      execArgv: ["--import", import.meta.resolve("tsx")],
+      stdio: ["ignore", "ignore", "pipe", "ipc"]
+    });
+    child.stderr?.resume();
+    this.loop = new Promise((resolve3, reject) => {
+      this.loopResolve = resolve3;
+      this.loopReject = reject;
+    });
+    void this.loop.catch(() => {
+    });
+    child.on("message", (message) => {
+      if ("event" in message) {
+        if (executionEvents.includes(message.event)) {
+          const handler = this.options.observer[message.event];
+          handler.call(this.options.observer, message.value);
+        }
+        return;
+      }
+      const request = this.pending.get(message.id);
+      if (!request) return;
+      clearTimeout(request.timer);
+      this.pending.delete(message.id);
+      if (message.error) request.reject(new Error(message.error));
+      else request.resolve(message.value);
+    });
+    const failed = () => {
+      const error = new Error("Foundry execution daemon disconnected. A pending mutation may have completed; inspect state before retrying.");
+      for (const request of this.pending.values()) {
+        clearTimeout(request.timer);
+        request.reject(error);
+      }
+      this.pending.clear();
+      if (this.stopped) this.loopResolve?.();
+      else this.loopReject?.(error);
+    };
+    child.once("error", failed);
+    child.once("exit", failed);
+    child.once("disconnect", failed);
+    try {
+      await this.request({ method: "init", options: {
+        rootDir: this.options.rootDir,
+        directory: this.directory,
+        loader: entry("execution-loader"),
+        agents: this.options.agents,
+        runner: this.options.runner
+      } }, 6e4);
+    } catch (error) {
+      await this.stop();
+      throw error;
+    }
+  }
+  request(command, timeout = 3e4) {
+    if (!this.child?.connected || this.stopped && command.method !== "stop") return Promise.reject(new Error("Execution daemon is unavailable."));
+    const id2 = ++this.sequence;
+    return new Promise((resolve3, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id2);
+        reject(new Error("Execution daemon request timed out. Its outcome may be unknown; do not automatically retry mutations."));
+      }, timeout);
+      this.pending.set(id2, { resolve: (value) => resolve3(value), reject, timer });
+      this.child.send({ id: id2, command }, (error) => {
+        if (error) {
+          clearTimeout(timer);
+          this.pending.delete(id2);
+          reject(new Error("Execution daemon request could not be delivered."));
+        }
+      });
+    });
+  }
+  start() {
+    return this.loop ?? Promise.reject(new Error("Execution backend is not initialized."));
+  }
+  stop(_options) {
+    if (this.stopping) return this.stopping;
+    this.stopped = true;
+    this.stopping = (async () => {
+      const child = this.child;
+      try {
+        if (child) {
+          try {
+            if (child.connected) await this.request({ method: "stop" }, 15e3);
+          } finally {
+            if (child.exitCode === null && child.signalCode === null) {
+              await new Promise((resolve3) => {
+                const timer = setTimeout(() => child.kill("SIGKILL"), 5e3);
+                child.once("exit", () => {
+                  clearTimeout(timer);
+                  resolve3();
+                });
+                if (child.connected) child.disconnect();
+              });
+            }
+          }
+        }
+      } finally {
+        if (this.directory) await rm(this.directory, { recursive: true, force: true });
+      }
+    })();
+    return this.stopping;
+  }
+  triggerSignal(name, input) {
+    return this.request({ method: "trigger", name, input });
+  }
+  getRun(id2) {
+    return this.request({ method: "get", id: id2 });
+  }
+  listAllRuns(options = {}) {
+    return this.request({ method: "list", ...options });
+  }
+  cancel(id2) {
+    return this.request({ method: "cancel", id: id2 });
+  }
+  ping() {
+    return this.request({ method: "ping" });
+  }
+  getAdapter() {
+    return { ping: () => this.ping() };
+  }
+  schedules = {
+    add: (schedule) => this.request({ method: "schedule.add", schedule }),
+    delete: (id2) => this.request({ method: "schedule.delete", id: id2 }),
+    ping: () => this.ping()
+  };
+  async waitForRun(id2, options = {}) {
+    const deadline = Date.now() + (options.timeoutMs ?? 6e4);
+    do {
+      const run = await this.getRun(id2);
+      if (!run || ["completed", "failed", "cancelled"].includes(run.status)) return run;
+      await new Promise((resolve3) => setTimeout(resolve3, options.pollMs ?? 100));
+    } while (Date.now() < deadline);
+    return this.getRun(id2);
+  }
+};
+
+// src/runtime.ts
 import {
-  ScheduleMemoryAdapter,
-  ScheduleReconciler,
   nextCronOccurrence
 } from "station-schedules";
 
@@ -1077,11 +1240,11 @@ async function moduleFiles(directory, suffix) {
     if (code === "ENOENT") return [];
     throw cause;
   }
-  return entries.filter((entry) => {
-    if (entry.endsWith(".d.ts")) return false;
-    const extension = extname(entry);
-    return MODULE_EXTENSIONS.has(extension) && entry.slice(0, -extension.length).endsWith(suffix);
-  }).map((entry) => resolve2(directory, entry)).sort();
+  return entries.filter((entry2) => {
+    if (entry2.endsWith(".d.ts")) return false;
+    const extension = extname(entry2);
+    return MODULE_EXTENSIONS.has(extension) && entry2.slice(0, -extension.length).endsWith(suffix);
+  }).map((entry2) => resolve2(directory, entry2)).sort();
 }
 function routeFromModule(directory, filePath, suffix) {
   const rel = normalizePath(relative2(directory, filePath));
@@ -1281,11 +1444,6 @@ function promiseEffect(operation, evaluate) {
     catch: (cause) => runtimeFailure(operation, cause)
   }).pipe(Effect5.withSpan(`foundry.${operation}`));
 }
-function executionAgentEntrypoint() {
-  const built = fileURLToPath(new URL("./execution-agent.js", import.meta.url));
-  if (existsSync(built)) return built;
-  return fileURLToPath(new URL("./execution-agent.ts", import.meta.url));
-}
 var FoundryRuntime = class _FoundryRuntime {
   rootDir;
   agents;
@@ -1306,20 +1464,21 @@ var FoundryRuntime = class _FoundryRuntime {
   execution;
   observer;
   signalRunner;
-  envStore;
-  envProvider;
   scheduleAdapter;
   services;
   runnerLoops = [];
   materializedActivations = /* @__PURE__ */ new Set();
+  // Serialize host-owned activation transitions across asynchronous adapters and daemon IPC.
+  activationTransitions = Effect5.unsafeMakeSemaphore(1);
+  activationDispatches = /* @__PURE__ */ new Map();
   activationTimers = /* @__PURE__ */ new Map();
-  approvalDirectory = join(
-    tmpdir(),
+  approvalDirectory = join2(
+    tmpdir2(),
     "glove-foundry-approvals",
     randomUUID2()
   );
-  coreCommandDirectory = join(
-    tmpdir(),
+  coreCommandDirectory = join2(
+    tmpdir2(),
     "glove-foundry-core-commands",
     randomUUID2()
   );
@@ -1440,63 +1599,21 @@ var FoundryRuntime = class _FoundryRuntime {
       pollIntervalMs: configured?.pollIntervalMs ?? defaults.pollIntervalMs,
       idlePollIntervalMs: configured?.idlePollIntervalMs ?? defaults.idlePollIntervalMs
     };
-    this.envStore = new EnvStore(new MemoryEnvStorage());
-    this.envProvider = {
-      resolveFor: async (target) => {
-        const resolvedEnvironment = await this.envStore.resolveFor(target);
-        if (target.kind === "signal") {
-          const route = routeFromInternalAgentName(target.name);
-          resolvedEnvironment[FOUNDRY_AGENT_ROUTE_ENV] = route;
-          const discovered = this.byRoute.get(route);
-          if (discovered) {
-            resolvedEnvironment[FOUNDRY_AGENT_FILE_ENV] = discovered.filePath;
-          }
-          resolvedEnvironment[FOUNDRY_APPROVAL_DIRECTORY_ENV] = this.approvalDirectory;
-          resolvedEnvironment[FOUNDRY_CORE_COMMAND_DIRECTORY_ENV] = this.coreCommandDirectory;
-        }
-        if (this.applicationFilePath) {
-          resolvedEnvironment[FOUNDRY_APPLICATION_ENV] = this.applicationFilePath;
-        }
-        return resolvedEnvironment;
+    if (this.application.daemon && !this.applicationFilePath) {
+      throw new Error("A daemon adapter requires applicationFilePath so Foundry can load it in the managed process.");
+    }
+    this.signalRunner = new FoundryExecutionBackend({
+      rootDir: this.rootDir,
+      agents: this.agents.map((agent) => ({ route: agent.route, filePath: agent.filePath })),
+      runner: this.execution,
+      observer: this.observer,
+      env: {
+        [FOUNDRY_APPROVAL_DIRECTORY_ENV]: this.approvalDirectory,
+        [FOUNDRY_CORE_COMMAND_DIRECTORY_ENV]: this.coreCommandDirectory,
+        ...this.applicationFilePath ? { [FOUNDRY_APPLICATION_ENV]: this.applicationFilePath } : {}
       }
-    };
-    this.scheduleAdapter = new ScheduleMemoryAdapter();
-    const signalAdapter = new MemoryAdapter();
-    const signalScheduleReconciler = new ScheduleReconciler({
-      adapter: this.scheduleAdapter,
-      kinds: ["signal"],
-      triggerFn: (schedule, scheduledFor) => this.signalRunner.triggerSignal(
-        schedule.target,
-        schedule.input,
-        { id: schedule.id, scheduledFor }
-      ),
-      hasPendingOrRunning: (schedule) => this.signalRunner.hasPendingOrRunningForSignal(schedule.target),
-      parseInterval,
-      onError: (error, schedule) => this.observability.append({
-        type: "schedule.error",
-        category: "activation",
-        data: { scheduleId: schedule?.id, error: error.message }
-      })
-    });
-    this.signalRunner = new SignalRunner({
-      adapter: signalAdapter,
-      pollIntervalMs: this.execution.pollIntervalMs,
-      idlePollIntervalMs: this.execution.idlePollIntervalMs,
-      maxConcurrent: this.execution.maxConcurrent,
-      maxAttempts: this.execution.maxAttempts,
-      retryBackoffMs: this.execution.retryBackoffMs,
-      subscribers: [this.observer],
-      scheduleReconciler: signalScheduleReconciler,
-      envProvider: this.envProvider,
-      stationId: "foundry-local",
-      failUnknownSignals: true
     });
-    for (const discovered of this.agents) {
-      this.signalRunner.registerSignal(
-        this.executionSignal(discovered),
-        executionAgentEntrypoint()
-      );
-    }
+    this.scheduleAdapter = this.signalRunner.schedules;
     const topologyLayer = memoryTopologyStore;
     const defaultServices = Layer3.mergeAll(
       memoryAccountDirectory(this.application.accounts ?? []),
@@ -1586,26 +1703,25 @@ var FoundryRuntime = class _FoundryRuntime {
       if (!this.started) {
         await this.services.dispose();
         await Promise.all([
-          rm(this.approvalDirectory, { recursive: true, force: true }),
-          rm(this.coreCommandDirectory, { recursive: true, force: true })
+          rm2(this.approvalDirectory, { recursive: true, force: true }),
+          rm2(this.coreCommandDirectory, { recursive: true, force: true })
         ]);
         this.disposed = true;
         return;
       }
       for (const timer of this.activationTimers.values()) clearTimeout(timer);
       this.activationTimers.clear();
+      this.activationDispatches.clear();
       await this.connectionSupervisor.stopAll();
       this.observability.append({ type: "runtime.stop.signals", category: "system", data: {} });
       await this.signalRunner.stop({ graceful: true, timeoutMs: 1e4 });
       this.observability.append({ type: "runtime.stop.loops", category: "system", data: {} });
       await this.settleRunnerLoops(1e3);
       this.runnerLoops.length = 0;
-      await this.envStore.close();
-      await this.scheduleAdapter.close?.();
       await this.services.dispose();
       await Promise.all([
-        rm(this.approvalDirectory, { recursive: true, force: true }),
-        rm(this.coreCommandDirectory, { recursive: true, force: true })
+        rm2(this.approvalDirectory, { recursive: true, force: true }),
+        rm2(this.coreCommandDirectory, { recursive: true, force: true })
       ]);
       this.started = false;
       this.disposed = true;
@@ -1864,9 +1980,9 @@ var FoundryRuntime = class _FoundryRuntime {
     return Effect5.runPromise(this.data.listWorkspaceEntries(workspaceId));
   }
   async putWorkspaceEntry(workspaceId, key, value) {
-    const entry = { workspaceId, key, value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-    await Effect5.runPromise(this.data.putWorkspaceEntry(entry));
-    return entry;
+    const entry2 = { workspaceId, key, value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await Effect5.runPromise(this.data.putWorkspaceEntry(entry2));
+    return entry2;
   }
   listSharedInbox(workspaceId) {
     return Effect5.runPromise(this.data.listInboxItems(workspaceId));
@@ -2431,7 +2547,7 @@ var FoundryRuntime = class _FoundryRuntime {
   async health() {
     const [execution, environment, activations] = await Promise.all([
       this.signalRunner.getAdapter().ping(),
-      this.envStore.ping(),
+      this.signalRunner.ping(),
       this.scheduleAdapter.ping()
     ]);
     return {
@@ -2867,12 +2983,6 @@ var FoundryRuntime = class _FoundryRuntime {
       }
     }
   }
-  executionSignal(discovered) {
-    return compileAgentDefinition(
-      discovered.definition,
-      discovered.route
-    );
-  }
   async seedTopology() {
     for (const route of this.application.routes ?? []) {
       await this.putRoute(route);
@@ -2920,7 +3030,19 @@ var FoundryRuntime = class _FoundryRuntime {
       await this.executionEnvelope(request)
     );
   }
+  withActivationTransition(work) {
+    return Effect5.runPromise(this.activationTransitions.withPermits(1)(Effect5.tryPromise({
+      try: work,
+      catch: (cause) => cause
+    })));
+  }
   async executeCoreCommand(command, parentRunId) {
+    if (command.type === "sleep" || command.type === "schedule" || command.type.startsWith("schedule.")) {
+      return this.withActivationTransition(() => this.executeCoreCommandUnlocked(command, parentRunId));
+    }
+    return this.executeCoreCommandUnlocked(command, parentRunId);
+  }
+  async executeCoreCommandUnlocked(command, parentRunId) {
     if (command.type === "transmit") {
       const request2 = await getFoundryCoreCommandRequest(
         this.coreCommandDirectory,
@@ -3126,6 +3248,7 @@ var FoundryRuntime = class _FoundryRuntime {
     return `activation/${activationId.replaceAll("_", "-")}`;
   }
   async disarmActivation(activation) {
+    this.activationDispatches.delete(activation.id);
     const timer = this.activationTimers.get(activation.id);
     if (timer) {
       clearTimeout(timer);
@@ -3279,11 +3402,13 @@ var FoundryRuntime = class _FoundryRuntime {
       data: { commandId: command.id, activationId: existing.id }
     });
   }
-  async reconstructActivations() {
-    for (const activation of await Effect5.runPromise(this.data.listActivations())) {
-      if (activation.status === "paused" || activation.status === "completed" || activation.status === "cancelled") continue;
-      await this.materializeActivation(activation);
-    }
+  reconstructActivations() {
+    return this.withActivationTransition(async () => {
+      for (const activation of await Effect5.runPromise(this.data.listActivations())) {
+        if (activation.status === "paused" || activation.status === "completed" || activation.status === "cancelled") continue;
+        await this.materializeActivation(activation);
+      }
+    });
   }
   async materializeActivation(activation) {
     if (this.materializedActivations.has(activation.id)) return;
@@ -3373,7 +3498,11 @@ var FoundryRuntime = class _FoundryRuntime {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     await Effect5.runPromise(this.data.putActivation(active));
-    const dispatch = async () => {
+    const generation = {};
+    this.activationDispatches.set(activation.id, generation);
+    const dispatch = () => this.withActivationTransition(async () => {
+      if (this.activationDispatches.get(activation.id) !== generation) return;
+      this.activationDispatches.delete(activation.id);
       this.activationTimers.delete(activation.id);
       if (this.disposed || !this.started) return;
       const current = await Effect5.runPromise(this.data.getActivation(activation.id));
@@ -3393,7 +3522,7 @@ var FoundryRuntime = class _FoundryRuntime {
         runId: activation.createdByRunId,
         data: { commandId: activation.id, childRunId: runId, type: activation.kind }
       });
-      void this.waitForRun(runId).then(async (run) => {
+      void this.waitForRun(runId).then((run) => this.withActivationTransition(async () => {
         if (!run || run.status !== "completed" && run.status !== "failed" && run.status !== "cancelled") return;
         const latest = await Effect5.runPromise(this.data.getActivation(activation.id));
         if (!latest || latest.status !== "active" || latest.lastRunId !== runId) return;
@@ -3402,7 +3531,7 @@ var FoundryRuntime = class _FoundryRuntime {
           status: run.status === "cancelled" ? "cancelled" : "completed",
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         }));
-      }).catch((cause) => {
+      })).catch((cause) => {
         this.observability.append({
           type: "activation.persistence.error",
           category: "activation",
@@ -3411,7 +3540,7 @@ var FoundryRuntime = class _FoundryRuntime {
           data: { error: cause instanceof Error ? cause.message : String(cause) }
         });
       });
-    };
+    });
     const arm = () => {
       const remaining = target - Date.now();
       if (remaining <= 0) {
@@ -3437,8 +3566,7 @@ var FoundryRuntime = class _FoundryRuntime {
       runId: activation.createdByRunId,
       data: { commandId: activation.id, recurring: false, nextRunAt: activation.timing.at }
     });
-    if (target <= Date.now()) await dispatch();
-    else arm();
+    arm();
   }
   async deliverOutbound(command, parentRunId, signal) {
     return this.dispatchOutbound({