glove-foundry 0.5.1 → 0.5.2

package/dist/{chunk-SGF3CFUR.js → chunk-D2AHSYOB.js}

@@ -8,16 +8,13 @@ import {
   EMPTY_AGENT_COMPOSITION,
   EMPTY_CAPABILITY_REGISTRY,
   EMPTY_FOUNDRY_APPLICATION,
-  EMPTY_NATIVE_REGISTRY,
   FOUNDRY_AGENT_APPLICATION_BRAND,
   FOUNDRY_APPROVAL_DIRECTORY_ENV,
   FOUNDRY_CORE_COMMAND_DIRECTORY_ENV,
   FOUNDRY_CORE_COMMAND_EVENT,
-  FOUNDRY_LAYER_BRAND,
   FOUNDRY_MCP_BRAND,
   FOUNDRY_MEMORY_BRAND,
   FOUNDRY_SHARED_TOOL_BRAND,
-  FOUNDRY_SUBSCRIBER_BRAND,
   MemoryFoundryDataAdapter,
   claimFoundryCoreCommandRequest,
   createAgentInstance,
@@ -38,13 +35,17 @@ import {
   resolveFoundryApproval,
   settleFoundryCoreCommandRequest,
   transmissionPredicate
-} from "./chunk-KBMD4RYU.js";
+} from "./chunk-6Q2LGPSC.js";
 import {
+  EMPTY_NATIVE_REGISTRY,
   FOUNDRY_APPLICATION_ENV,
   FOUNDRY_EVENT_PREFIX,
   FOUNDRY_EXECUTION_MARKER,
+  FOUNDRY_LAYER_BRAND,
+  FOUNDRY_RUN_PROCESS_EVENT,
+  FOUNDRY_SUBSCRIBER_BRAND,
   bindFileIdentity
-} from "./chunk-5NFLGHOC.js";
+} from "./chunk-PVOKR4CN.js";
 
 // src/codegen.ts
 import { mkdir, writeFile } from "node:fs/promises";
@@ -1038,6 +1039,7 @@ var ApplicationConnectionSupervisor = class {
   }
   running = /* @__PURE__ */ new Map();
   states = /* @__PURE__ */ new Map();
+  closed = false;
   list() {
     return [...this.states.values()].map((state) => ({
       ...state,
@@ -1063,10 +1065,18 @@ var ApplicationConnectionSupervisor = class {
     await this.stop(id2);
     this.start(current);
   }
+  /**
+   * Stop every connection for good. A reconcile still in flight (a run's
+   * playbook sync, an installation change) must not start a connection after
+   * this: nothing would stop it, and a provider connection runs until it is
+   * interrupted, so the process could never exit.
+   */
   async stopAll() {
+    this.closed = true;
     await Promise.all([...this.running.keys()].map((id2) => this.stop(id2)));
   }
   start(desired) {
+    if (this.closed) return;
     const controller = new AbortController();
     const task = this.run(desired, controller.signal).finally(() => {
       const current = this.running.get(desired.id);
@@ -1444,6 +1454,9 @@ function promiseEffect(operation, evaluate) {
     catch: (cause) => runtimeFailure(operation, cause)
   }).pipe(Effect5.withSpan(`foundry.${operation}`));
 }
+var RUN_PROCESS_RELEASE_TIMEOUT_MS = 1e4;
+var RUN_PROCESS_REPORT_GRACE_MS = 1e3;
+var RUN_PROCESS_RETENTION_MS = 6e4;
 var FoundryRuntime = class _FoundryRuntime {
   rootDir;
   agents;
@@ -1472,6 +1485,8 @@ var FoundryRuntime = class _FoundryRuntime {
   activationTransitions = Effect5.unsafeMakeSemaphore(1);
   activationDispatches = /* @__PURE__ */ new Map();
   activationTimers = /* @__PURE__ */ new Map();
+  /** Whether each run's child process still holds its conversation, from FOUNDRY_RUN_PROCESS_EVENT. */
+  runProcesses = /* @__PURE__ */ new Map();
   approvalDirectory = join2(
     tmpdir2(),
     "glove-foundry-approvals",
@@ -1545,6 +1560,11 @@ var FoundryRuntime = class _FoundryRuntime {
       this.observability,
       (name) => this.routeBySignalName.get(name) ?? name,
       (event) => {
+        if (event.type === FOUNDRY_RUN_PROCESS_EVENT) {
+          const state = event.data?.state;
+          if (state === "acquired" || state === "released") this.trackRunProcess(event.run.id, state);
+          return;
+        }
         if (event.type === FOUNDRY_CORE_COMMAND_EVENT) {
           void this.executeCoreCommand(event.data, event.run.id).catch((cause) => {
             this.observability.append({
@@ -2049,6 +2069,42 @@ var FoundryRuntime = class _FoundryRuntime {
   cancel(runId) {
     return this.signalRunner.cancel(runId);
   }
+  trackRunProcess(runId, state) {
+    this.runProcesses.set(runId, state);
+    if (state !== "released") return;
+    const forget = setTimeout(() => {
+      if (this.runProcesses.get(runId) === "released") this.runProcesses.delete(runId);
+    }, RUN_PROCESS_RETENTION_MS);
+    forget.unref?.();
+  }
+  /**
+   * Wait until a cancelled run's process has let go of its conversation. A run
+   * that never started has no process. A process that dies before it reports
+   * (SIGTERM during startup, or Station's SIGKILL five seconds after the
+   * cancel) cannot report, so the wait is bounded by that kill.
+   */
+  async waitForRunProcessRelease(run, agent) {
+    if (!run.startedAt) return;
+    const started = Date.now();
+    for (; ; ) {
+      const state = this.runProcesses.get(run.id);
+      const waited = Date.now() - started;
+      if (state === "released") return;
+      if (state === void 0 && waited >= RUN_PROCESS_REPORT_GRACE_MS) return;
+      if (waited >= RUN_PROCESS_RELEASE_TIMEOUT_MS) {
+        this.runProcesses.delete(run.id);
+        this.observability.append({
+          type: "run.steer.release-timeout",
+          category: "system",
+          agent,
+          runId: run.id,
+          data: { waitedMs: waited }
+        });
+        return;
+      }
+      await new Promise((resolveWait) => setTimeout(resolveWait, 25));
+    }
+  }
   /**
    * Change course at a run boundary.
    *
@@ -2073,6 +2129,7 @@ var FoundryRuntime = class _FoundryRuntime {
       if (!terminal || (terminal.status === "pending" || terminal.status === "running")) {
         throw new Error(`Foundry could not reach a safe steering boundary for run "${runId}".`);
       }
+      await this.waitForRunProcessRelease(terminal, source.agent);
     }
     const run = await this.send(source.agentId, source.conversationId, message, {
       context: {
@@ -3771,7 +3828,8 @@ function skeleton(rows){
 async function api(url,options){
   const response=await fetch(url,options);let body;
   try{body=await response.json()}catch{body={error:"The runtime returned an unreadable response."}}
-  if(!response.ok)throw new Error(body.error||("Request failed ("+response.status+")"));return body;
+  /* /health answers 503 with the same body when a subsystem is down; the header shows it. */
+  if(!response.ok&&!(url==="/health"&&response.status===503))throw new Error(body.error||("Request failed ("+response.status+")"));return body;
 }
 function toast(message){const node=$("toast");node.textContent=message;node.classList.add("show");setTimeout(()=>node.classList.remove("show"),2400)}
 function route(){const parts=location.pathname.split("/").filter(Boolean).map(decodeURIComponent);return{parts,section:parts[0]||"overview",id:parts.slice(1).join("/")}}
@@ -4772,11 +4830,15 @@ function installationFrom(value) {
   if (typeof body.id !== "string" || !body.id) {
     throw new RequestError(400, "id is required.");
   }
+  if (body.accountId !== void 0 && (typeof body.accountId !== "string" || !body.accountId)) {
+    throw new RequestError(400, "accountId must be a non-empty string.");
+  }
   return {
     agentId: body.agentId,
     installation: {
       kind: body.kind,
       id: body.id,
+      ...body.accountId !== void 0 ? { accountId: body.accountId } : {},
       ...body.config !== void 0 ? { config: body.config } : {}
     }
   };
@@ -5097,12 +5159,13 @@ var FoundryServer = class {
         return;
       }
       if (method === "GET" && url.pathname === "/health") {
-        json(response, 200, await this.runtime.health());
+        const health = await this.runtime.health();
+        json(response, health.ok ? 200 : 503, health);
         return;
       }
       if (method === "GET" && url.pathname === "/health/detailed") {
         const health = await this.runtime.health();
-        json(response, 200, {
+        json(response, health.ok ? 200 : 503, {
           ...health,
           connections: this.runtime.listApplicationConnections(),
           runs: await this.runtime.listRuns()

package/dist/{chunk-TH5ETCG2.js → chunk-MABLKZVO.js}

@@ -1,7 +1,7 @@
 import {
   mountFoundryGuidance,
   mountFoundryWorkbench
-} from "./chunk-LW5PJ2FN.js";
+} from "./chunk-NHV64WNO.js";
 import {
   EMPTY_CAPABILITY_REGISTRY,
   EMPTY_FOUNDRY_APPLICATION,
@@ -23,20 +23,21 @@ import {
   isInboxCapableStore,
   materializeComposedPlaybook,
   mountAgentDefinitionMemory,
-  mountFoundrySurfaces,
   normalizeScheduleTiming,
   toGloveMessage,
   toGloveRequestInput,
   withFoundryPermissions
-} from "./chunk-KBMD4RYU.js";
+} from "./chunk-6Q2LGPSC.js";
 import {
   FOUNDRY_APPLICATION_ENV,
   FOUNDRY_EVENT_PREFIX,
   FOUNDRY_EXECUTION_MARKER,
+  FOUNDRY_RUN_PROCESS_EVENT,
   defineAgentFromModule,
   internalAgentName,
+  mountFoundrySurfaces,
   resolveResolvable
-} from "./chunk-5NFLGHOC.js";
+} from "./chunk-PVOKR4CN.js";
 
 // src/agent-runtime.ts
 import { pathToFileURL } from "node:url";
@@ -173,6 +174,14 @@ async function executeSpawned(spawned, message, signal2) {
   return spawned;
 }
 async function runDefinition(definition, id, runtimeValue) {
+  await writeAgentEvent(FOUNDRY_RUN_PROCESS_EVENT, { state: "acquired" }).catch(() => void 0);
+  try {
+    return await executeDefinition(definition, id, runtimeValue);
+  } finally {
+    await writeAgentEvent(FOUNDRY_RUN_PROCESS_EVENT, { state: "released" }).catch(() => void 0);
+  }
+}
+async function executeDefinition(definition, id, runtimeValue) {
   const envelope = runtimeValue;
   const request = envelope.request;
   const input = request;

package/dist/{chunk-LW5PJ2FN.js → chunk-NHV64WNO.js}

@@ -1,6 +1,6 @@
 import {
   resolveResolvable
-} from "./chunk-5NFLGHOC.js";
+} from "./chunk-PVOKR4CN.js";
 
 // src/guidance.ts
 import { createHash } from "node:crypto";

package/dist/{chunk-5NFLGHOC.js → chunk-PVOKR4CN.js}

@@ -1,5 +1,4 @@
-// src/definition.ts
-import { Displaymanager, Glove } from "glove-core";
+// src/surfaces.ts
 import { Effect } from "effect";
 
 // src/identity.ts
@@ -54,12 +53,157 @@ function fileDefinitionLabel(value) {
   return cell?.id ?? `<${cell?.kind ?? "definition"} file route>`;
 }
 
+// src/surfaces.ts
+var FOUNDRY_LAYER_BRAND = /* @__PURE__ */ Symbol.for("glove-foundry-layer");
+var FOUNDRY_SUBSCRIBER_BRAND = /* @__PURE__ */ Symbol.for(
+  "glove-foundry-subscriber"
+);
+var SURFACE_ID = /^[a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)*$/;
+function assertSurfaceId(id, label) {
+  if (!SURFACE_ID.test(id)) {
+    throw new Error(
+      `Invalid Foundry ${label} id "${id}". Use lowercase path segments containing letters, digits, and hyphens.`
+    );
+  }
+}
+function defineLayer(options) {
+  if (options.id) assertSurfaceId(options.id, "layer");
+  const { id, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    [FOUNDRY_LAYER_BRAND]: true
+  }, "layer", id));
+}
+function configureLayer(layer, config) {
+  return Object.freeze({ layer, config });
+}
+function defineSubscriber(options) {
+  if (options.id) assertSurfaceId(options.id, "subscriber");
+  const { id, ...definition } = options;
+  return Object.freeze(fileIdentified({
+    ...definition,
+    [FOUNDRY_SUBSCRIBER_BRAND]: true
+  }, "subscriber", id));
+}
+var EMPTY_NATIVE_REGISTRY = Object.freeze({
+  layers: Object.freeze([]),
+  subscribers: Object.freeze([])
+});
+function indexById(values, label) {
+  const indexed = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    if (indexed.has(value.id)) {
+      throw new Error(`Duplicate Foundry ${label} id "${value.id}".`);
+    }
+    indexed.set(value.id, value);
+  }
+  return indexed;
+}
+async function mountFoundrySurfaces(options) {
+  const layers = indexById(options.registry.layers, "layer");
+  const subscribers = indexById(options.registry.subscribers, "subscriber");
+  const cleanup = [];
+  const disposeAll = async () => {
+    const failures = [];
+    for (const dispose of cleanup.reverse()) {
+      try {
+        const result = dispose();
+        if (Effect.isEffect(result)) await Effect.runPromise(result);
+        else await Promise.resolve(result);
+      } catch (cause) {
+        failures.push(cause);
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(failures, "Foundry surface cleanup failed.");
+    }
+  };
+  try {
+    for (const selected of options.subscribers ?? []) {
+      let definition = selected;
+      if (typeof definition === "object" && definition !== null && FOUNDRY_SUBSCRIBER_BRAND in definition) {
+        const registered = subscribers.get(definition.id);
+        if (!registered) {
+          throw new Error(
+            `Agent "${options.context.agentId}" references unknown subscriber "${definition.id}".`
+          );
+        }
+        definition = registered;
+      }
+      let subscriber;
+      let subscriberId = "inline";
+      if (typeof definition === "object" && definition !== null && definition[FOUNDRY_SUBSCRIBER_BRAND] === true) {
+        const foundrySubscriber = definition;
+        const created = typeof foundrySubscriber.create === "function" ? foundrySubscriber.create(options.context) : foundrySubscriber.create;
+        subscriber = Effect.isEffect(created) ? await Effect.runPromise(created) : await Promise.resolve(created);
+        subscriberId = foundrySubscriber.id;
+      } else {
+        subscriber = definition;
+      }
+      options.context.glove.addSubscriber(subscriber);
+      cleanup.push(() => options.context.glove.removeSubscriber(subscriber));
+      options.context.emit({
+        type: "foundry.subscriber.mounted",
+        data: { id: subscriberId }
+      });
+    }
+    for (const selected of options.layers ?? []) {
+      const reference = FOUNDRY_LAYER_BRAND in selected ? { layer: selected } : selected;
+      const definition = layers.get(reference.layer.id);
+      if (!definition) {
+        throw new Error(
+          `Agent "${options.context.agentId}" references unknown layer "${reference.layer.id}".`
+        );
+      }
+      const referenceConfig = "config" in reference ? reference.config : void 0;
+      const parsed = definition.config ? definition.config.safeParse(referenceConfig ?? {}) : { success: true, data: referenceConfig };
+      if (!parsed.success) {
+        throw new Error(
+          `Invalid config for layer "${definition.id}": ${parsed.error.message}`
+        );
+      }
+      const dispose = await Effect.runPromise(
+        definition.setup({ ...options.context, config: parsed.data })
+      );
+      if (dispose) cleanup.push(dispose);
+      options.context.emit({
+        type: "foundry.layer.mounted",
+        data: { id: definition.id }
+      });
+    }
+  } catch (cause) {
+    try {
+      await disposeAll();
+    } catch (cleanupCause) {
+      throw new AggregateError(
+        [cause, cleanupCause],
+        "Foundry surface mount and cleanup failed."
+      );
+    }
+    throw cause;
+  }
+  return disposeAll;
+}
+function isFoundryLayer(value) {
+  return Boolean(
+    value && typeof value === "object" && value[FOUNDRY_LAYER_BRAND] === true
+  );
+}
+function isFoundrySubscriber(value) {
+  return Boolean(
+    value && typeof value === "object" && value[FOUNDRY_SUBSCRIBER_BRAND] === true
+  );
+}
+
 // src/definition.ts
+import { Displaymanager, Glove } from "glove-core";
+import { Effect as Effect2 } from "effect";
 var FOUNDRY_AGENT_DEFINITION_BRAND = /* @__PURE__ */ Symbol.for(
   "glove-foundry-agent-definition"
 );
 var FOUNDRY_AGENT_BRAND = FOUNDRY_AGENT_DEFINITION_BRAND;
 var FOUNDRY_EVENT_PREFIX = "__GLOVE_FOUNDRY_EVENT__";
+var FOUNDRY_RUN_PROCESS_EVENT = "foundry.run.process";
 var FOUNDRY_APPLICATION_ENV = "GLOVE_FOUNDRY_APPLICATION_FILE";
 var FOUNDRY_AGENT_ROUTE_ENV = "GLOVE_FOUNDRY_AGENT_ROUTE";
 var FOUNDRY_AGENT_FILE_ENV = "GLOVE_FOUNDRY_AGENT_FILE";
@@ -217,39 +361,67 @@ function defineSubagent(options) {
       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);
-      if (options.configure) {
-        const message = { sender: "user", text: prompt };
-        const request = {
-          agentId: options.name,
-          conversationId: `subagent:${options.name}`,
-          workspaceId: "subagent",
-          message: prompt,
-          source: { kind: "spawn" }
-        };
-        await resolveResolvable(options.configure({
-          definitionId: options.name,
-          agentId: options.name,
-          conversationId: request.conversationId,
-          workspaceId: request.workspaceId,
-          runId: `subagent:${options.name}`,
-          input: prompt,
-          request,
-          message,
-          messageInput: prompt,
-          messageText: prompt,
-          history: [],
-          messages: [message],
-          glove,
-          signal: new AbortController().signal,
-          emit: () => void 0
-        }));
+      const message = { sender: "user", text: prompt };
+      const request = {
+        agentId: options.name,
+        conversationId: `subagent:${options.name}`,
+        workspaceId: "subagent",
+        message: prompt,
+        source: { kind: "spawn" }
+      };
+      const context = {
+        definitionId: options.name,
+        agentId: options.name,
+        conversationId: request.conversationId,
+        workspaceId: request.workspaceId,
+        runId: `subagent:${options.name}`,
+        input: prompt,
+        request,
+        message,
+        messageInput: prompt,
+        messageText: prompt,
+        history: [],
+        messages: [message],
+        glove,
+        signal: new AbortController().signal,
+        emit: () => void 0
+      };
+      const disposeSurfaces = await mountFoundrySurfaces({
+        registry: {
+          layers: uniqueById((options.layers ?? []).map((selected) => "layer" in selected ? selected.layer : selected)),
+          subscribers: uniqueById((options.subscribers ?? []).filter(isFoundrySubscriber))
+        },
+        layers: options.layers ?? [],
+        subscribers: options.subscribers ?? [],
+        context
+      });
+      try {
+        if (options.configure) await resolveResolvable(options.configure(context));
+      } catch (cause) {
+        await disposeSurfaces();
+        throw cause;
       }
+      const processRequest = glove.processRequest.bind(glove);
+      let disposed = false;
+      glove.processRequest = async (...args) => {
+        try {
+          return await processRequest(...args);
+        } finally {
+          if (!disposed) {
+            disposed = true;
+            await disposeSurfaces();
+          }
+        }
+      };
       return glove;
     }
   });
 }
+function uniqueById(values) {
+  return [...new Map(values.map((value) => [value.id, value])).values()];
+}
 async function resolveResolvable(value) {
-  if (Effect.isEffect(value)) return Effect.runPromise(value);
+  if (Effect2.isEffect(value)) return Effect2.runPromise(value);
   return Promise.resolve(value);
 }
 function defineRoutes(routes) {
@@ -261,9 +433,19 @@ export {
   bindFileIdentity,
   fileDefinitionKey,
   fileDefinitionLabel,
+  FOUNDRY_LAYER_BRAND,
+  FOUNDRY_SUBSCRIBER_BRAND,
+  defineLayer,
+  configureLayer,
+  defineSubscriber,
+  EMPTY_NATIVE_REGISTRY,
+  mountFoundrySurfaces,
+  isFoundryLayer,
+  isFoundrySubscriber,
   FOUNDRY_AGENT_DEFINITION_BRAND,
   FOUNDRY_AGENT_BRAND,
   FOUNDRY_EVENT_PREFIX,
+  FOUNDRY_RUN_PROCESS_EVENT,
   FOUNDRY_APPLICATION_ENV,
   FOUNDRY_AGENT_ROUTE_ENV,
   FOUNDRY_AGENT_FILE_ENV,

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   FoundryRuntime,
   FoundryServer,
   writeGeneratedTypes
-} from "./chunk-SGF3CFUR.js";
+} from "./chunk-D2AHSYOB.js";
 import {
   DEFAULT_FOUNDRY_CONFIG
 } from "./chunk-ZFNMFE3T.js";
@@ -11,8 +11,8 @@ import "./chunk-J7ZBJM54.js";
 import {
   EMPTY_FOUNDRY_APPLICATION,
   isFoundryApplication
-} from "./chunk-KBMD4RYU.js";
-import "./chunk-5NFLGHOC.js";
+} from "./chunk-6Q2LGPSC.js";
+import "./chunk-PVOKR4CN.js";
 
 // src/cli.ts
 import { watch } from "node:fs";
@@ -147,7 +147,7 @@ var TEMPLATE_IMPORTS = Object.freeze({
     "glove-working-environment",
     "zod"
   ],
-  minimal: ["effect", "glove-core", "zod"]
+  minimal: ["glove-core", "zod"]
 });
 var TEMPLATE_AGENT_ROUTE = Object.freeze({
   "travel-concierge": "concierge",
@@ -312,6 +312,7 @@ export default defineConfig({
 });
 `
     );
+    files.set(`${foundryDir}/.gitignore`, ".data\n");
     files.set(
       `${foundryDir}/package.json`,
       `${JSON.stringify(
@@ -495,7 +496,8 @@ function nextReadme(projectName, route, placeholders) {
     "| --- | --- |",
     `| \`foundry/agents/${route}/agent.ts\` | The agent. The file path is its id. |`,
     "| `foundry/foundry.application.ts` | Data adapter, accounts, routes |",
-    "| `foundry.config.ts` | Points the runtime at `foundry/agents` |",
+    "| `foundry.config.mts` | Points the runtime at `foundry/agents` |",
+    "| `foundry/.data/` | Runtime data, transcripts and memory. Ignored by git; delete it to start fresh |",
     "| `lib/foundry.ts` | Typed HTTP client for your app to import |",
     `| \`app/api/${route}/route.ts\` | An example Next.js route handler |`,
     "| `.foundry/routes.d.ts` | Generated. Do not edit |",

package/dist/{client-DcsnudMI.d.ts → client-CLTds1uV.d.ts}

@@ -1734,7 +1734,8 @@ interface DefineFoundrySubagentOptions {
     readonly hooks?: ReadonlyArray<FoundryHookDefinition>;
     readonly skills?: ReadonlyArray<DefineSkillArgs>;
     readonly subagents?: ReadonlyArray<DefineSubAgentArgs>;
-    readonly layers?: ReadonlyArray<FoundryLayer<any>>;
+    /** Mounted on each invocation and disposed when the subagent's request ends. */
+    readonly layers?: ReadonlyArray<FoundryLayerSelection>;
     readonly subscribers?: ReadonlyArray<FoundrySubscriber | SubscriberAdapter>;
     readonly configure?: (context: FoundrySurfaceContext<string>) => Resolvable<void>;
 }
@@ -2200,6 +2201,8 @@ declare class FoundryRuntime {
     private readonly activationTransitions;
     private readonly activationDispatches;
     private readonly activationTimers;
+    /** Whether each run's child process still holds its conversation, from FOUNDRY_RUN_PROCESS_EVENT. */
+    private readonly runProcesses;
     private readonly approvalDirectory;
     private readonly coreCommandDirectory;
     private started;
@@ -2267,6 +2270,14 @@ declare class FoundryRuntime {
         timeoutMs?: number;
     }): Promise<FoundryRun<TOutput> | null>;
     cancel(runId: string): Promise<boolean>;
+    private trackRunProcess;
+    /**
+     * Wait until a cancelled run's process has let go of its conversation. A run
+     * that never started has no process. A process that dies before it reports
+     * (SIGTERM during startup, or Station's SIGKILL five seconds after the
+     * cancel) cannot report, so the wait is bounded by that kill.
+     */
+    private waitForRunProcessRelease;
     /**
      * Change course at a run boundary.
      *
@@ -2440,6 +2451,7 @@ declare class FoundryClient<TRoutes extends FoundryRouteMap> {
     private readonly baseUrl;
     private readonly fetcher;
     constructor(options?: FoundryClientOptions);
+    /** Resolves with `ok: false` when a subsystem is down (the server answers 503). */
     health(): Promise<FoundryHealth>;
     agent<TRoute extends Extract<keyof TRoutes, string>>(route: TRoute): {
         create(options?: CreateAgentInstanceOptions): Promise<AgentInstance>;

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-export { bf as FoundryClient, bg as FoundryClientAuthorizationAdapter, bh as FoundryClientOptions, bu as FoundryHealth, c7 as FoundryRunHandle, ce as FoundrySteerHandleResult, db as WaitOptions, dk as createFoundryClient } from './client-DcsnudMI.js';
+export { bf as FoundryClient, bg as FoundryClientAuthorizationAdapter, bh as FoundryClientOptions, bu as FoundryHealth, c7 as FoundryRunHandle, ce as FoundrySteerHandleResult, db as WaitOptions, dk as createFoundryClient } from './client-CLTds1uV.js';
 import 'glove-core';
 import 'effect';
 import 'zod';

package/dist/client.js

@@ -2,7 +2,7 @@ import {
   FoundryClient,
   FoundryRunHandle,
   createFoundryClient
-} from "./chunk-GKZLWD5M.js";
+} from "./chunk-7F7QVO6I.js";
 export {
   FoundryClient,
   FoundryRunHandle,

package/dist/execution-agent.js

@@ -1,14 +1,14 @@
 import {
   compileAgentModule
-} from "./chunk-TH5ETCG2.js";
-import "./chunk-LW5PJ2FN.js";
+} from "./chunk-MABLKZVO.js";
+import "./chunk-NHV64WNO.js";
 import {
   bindAgentLocalDefinitions
-} from "./chunk-KBMD4RYU.js";
+} from "./chunk-6Q2LGPSC.js";
 import {
   FOUNDRY_AGENT_FILE_ENV,
   FOUNDRY_AGENT_ROUTE_ENV
-} from "./chunk-5NFLGHOC.js";
+} from "./chunk-PVOKR4CN.js";
 
 // src/execution-agent.ts
 import { pathToFileURL } from "node:url";

package/dist/execution-daemon.js

@@ -4,7 +4,7 @@ import {
 import {
   FOUNDRY_APPLICATION_ENV,
   internalAgentName
-} from "./chunk-5NFLGHOC.js";
+} from "./chunk-PVOKR4CN.js";
 
 // src/execution-daemon.ts
 import { randomBytes } from "node:crypto";

package/dist/execution-loader.js

@@ -1,11 +1,11 @@
 import {
   compileAgentModule
-} from "./chunk-TH5ETCG2.js";
-import "./chunk-LW5PJ2FN.js";
+} from "./chunk-MABLKZVO.js";
+import "./chunk-NHV64WNO.js";
 import {
   bindAgentLocalDefinitions
-} from "./chunk-KBMD4RYU.js";
-import "./chunk-5NFLGHOC.js";
+} from "./chunk-6Q2LGPSC.js";
+import "./chunk-PVOKR4CN.js";
 
 // src/execution-loader.ts
 import { dirname } from "node:path";