@axiom-lattice/core 6.2.0 → 6.3.1

package/dist/index.mjs

@@ -2115,7 +2115,7 @@ var InMemoryModelProviderStore = class {
    */
   async listProviders(tenantId2) {
     return Array.from(this.providers.values()).filter(
-      (provider) => provider.tenantId === tenantId2
+      (provider2) => provider2.tenantId === tenantId2
     );
   }
   /**
@@ -2129,7 +2129,7 @@ var InMemoryModelProviderStore = class {
    */
   async getProviderByName(tenantId2, name) {
     const providers = await this.listProviders(tenantId2);
-    return providers.find((provider) => provider.name === name) || null;
+    return providers.find((provider2) => provider2.name === name) || null;
   }
   /**
    * Create a new provider configuration
@@ -2313,8 +2313,8 @@ var InMemoryModelProviderStore = class {
    * Clear providers and models for a specific tenant
    */
   clearByTenant(tenantId2) {
-    for (const [key5, provider] of Array.from(this.providers.entries())) {
-      if (provider.tenantId === tenantId2) {
+    for (const [key5, provider2] of Array.from(this.providers.entries())) {
+      if (provider2.tenantId === tenantId2) {
         this.providers.delete(key5);
       }
     }
@@ -3190,6 +3190,123 @@ function entryKey(tenantId2, userId, endpoint) {
   return JSON.stringify([tenantId2, userId, endpoint]);
 }
 
+// src/store_lattice/InMemoryLeaseStore.ts
+var InMemoryLeaseStore = class {
+  /**
+   * @param now Injectable clock in epoch milliseconds (tests use a fake clock).
+   */
+  constructor(now = Date.now) {
+    this.leases = /* @__PURE__ */ new Map();
+    this.now = now;
+  }
+  /** Atomically acquires a free/expired key (or the caller's own key). */
+  async tryAcquire(key5, holder, ttlMs) {
+    const existing = this.leases.get(key5);
+    if (existing && Date.parse(existing.expiresAt) > this.now()) {
+      if (existing.holder !== holder) return false;
+      this.leases.set(key5, { ...existing, expiresAt: new Date(this.now() + ttlMs).toISOString() });
+      return true;
+    }
+    const acquiredAt = existing && existing.holder === holder ? existing.acquiredAt : new Date(this.now()).toISOString();
+    this.leases.set(key5, {
+      key: key5,
+      holder,
+      acquiredAt,
+      expiresAt: new Date(this.now() + ttlMs).toISOString()
+    });
+    return true;
+  }
+  /** Extends a lease only while `holder` still owns it. */
+  async renew(key5, holder, ttlMs) {
+    const existing = this.leases.get(key5);
+    if (!existing || existing.holder !== holder) return false;
+    this.leases.set(key5, { ...existing, expiresAt: new Date(this.now() + ttlMs).toISOString() });
+    return true;
+  }
+  /** Deletes a lease only when `holder` owns it. */
+  async release(key5, holder) {
+    const existing = this.leases.get(key5);
+    if (!existing || existing.holder !== holder) return false;
+    this.leases.delete(key5);
+    return true;
+  }
+  /** Returns the live lease, pruning an expired one. */
+  async get(key5) {
+    const existing = this.leases.get(key5);
+    if (!existing) return null;
+    if (Date.parse(existing.expiresAt) <= this.now()) {
+      this.leases.delete(key5);
+      return null;
+    }
+    return { ...existing };
+  }
+};
+
+// src/store_lattice/InMemoryOutboxStore.ts
+var InMemoryOutboxStore = class {
+  /**
+   * Creates an in-memory outbox store.
+   *
+   * @param now Optional clock override (defaults to the system clock); it stamps
+   * `createdAt` and is used to evaluate age-based retention.
+   */
+  constructor(now = () => /* @__PURE__ */ new Date()) {
+    this.events = [];
+    this.counter = 0;
+    this.now = now;
+  }
+  /**
+   * Appends one event, assigning the next monotonic id.
+   * @param input Topic, JSON-safe payload, and authoring replica id.
+   * @returns A defensive copy of the stored event.
+   */
+  async append(input) {
+    const event = {
+      id: String(++this.counter),
+      topic: input.topic,
+      payload: input.payload,
+      originReplicaId: input.originReplicaId,
+      createdAt: this.now().toISOString()
+    };
+    this.events.push(event);
+    return { ...event };
+  }
+  /**
+   * Lists events strictly newer than `cursor`, ascending, bounded by `limit`.
+   * @param cursor Last-seen id, or `null` to read from the start.
+   * @param limit Maximum number of events to return.
+   * @returns Defensive copies of the matching events.
+   */
+  async listAfter(cursor, limit) {
+    const floor = cursor === null ? 0 : Number(cursor);
+    return this.events.filter((event) => Number(event.id) > floor).slice(0, limit).map((event) => ({ ...event }));
+  }
+  /**
+   * Returns the newest event id.
+   * @returns The last id, or `null` when the log is empty.
+   */
+  async latestId() {
+    return this.events.length === 0 ? null : this.events[this.events.length - 1].id;
+  }
+  /**
+   * Deletes events older than `olderThanMs`, evaluated against this store's clock.
+   *
+   * @param olderThanMs Age threshold in milliseconds.
+   * @returns The number of events removed.
+   */
+  async pruneOlderThan(olderThanMs) {
+    const cutoff = this.now().getTime() - olderThanMs;
+    let removed = 0;
+    for (let i = this.events.length - 1; i >= 0; i -= 1) {
+      if (new Date(this.events[i].createdAt).getTime() < cutoff) {
+        this.events.splice(i, 1);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+};
+
 // src/store_lattice/InMemoryUserStore.ts
 var InMemoryUserStore = class {
   constructor() {
@@ -3396,7 +3513,8 @@ function isMessageContentValue(value) {
 
 // src/store_lattice/InMemoryThreadMessageQueueStore.ts
 var InMemoryThreadMessageQueueStore = class {
-  constructor() {
+  constructor(now = Date.now) {
+    this.now = now;
     this.messages = /* @__PURE__ */ new Map();
     this.messageIdCounter = 0;
     this.capacityTail = Promise.resolve();
@@ -3503,6 +3621,36 @@ var InMemoryThreadMessageQueueStore = class {
     const threadMessages = this.getMessagesForThread(threadId);
     return threadMessages.filter((msg) => msg.status === "processing" && this.inScope(msg, scope)).sort((a, b) => (b.priority || 0) - (a.priority || 0) || a.sequence - b.sequence).map(clonePendingMessage);
   }
+  async claimPendingMessages(threadId, scope, options) {
+    const threadMessages = this.getMessagesForThread(threadId);
+    const candidates = threadMessages.filter((msg) => (msg.status === "pending" || !msg.status) && this.inScope(msg, scope)).sort((a, b) => (b.priority || 0) - (a.priority || 0) || a.sequence - b.sequence);
+    const limit = options.limit === void 0 ? void 0 : Math.max(0, Math.floor(options.limit));
+    const selected = limit === void 0 ? candidates : candidates.slice(0, limit);
+    const now = this.now();
+    for (const message of selected) {
+      message.status = "processing";
+      message.lockedBy = options.owner;
+      message.lockedAt = new Date(now);
+      message.leaseExpiresAt = new Date(now + options.ttlMs);
+    }
+    return selected.map(clonePendingMessage);
+  }
+  async reclaimExpiredProcessing(threadId, scope) {
+    const messages = this.messages.get(threadId);
+    if (!messages) return 0;
+    const now = this.now();
+    let count = 0;
+    for (const msg of messages) {
+      if (msg.status === "processing" && this.inScope(msg, scope) && msg.leaseExpiresAt !== void 0 && msg.leaseExpiresAt.getTime() <= now) {
+        msg.status = "pending";
+        msg.lockedBy = void 0;
+        msg.lockedAt = void 0;
+        msg.leaseExpiresAt = void 0;
+        count += 1;
+      }
+    }
+    return count;
+  }
   async getQueueSize(threadId, scope) {
     const pending = await this.getPendingMessages(threadId, scope);
     return pending.length;
@@ -3566,6 +3714,9 @@ var InMemoryThreadMessageQueueStore = class {
     for (const msg of messages) {
       if (msg.status === "processing" && this.inScope(msg, scope)) {
         msg.status = "pending";
+        msg.lockedBy = void 0;
+        msg.lockedAt = void 0;
+        msg.leaseExpiresAt = void 0;
         count++;
       }
     }
@@ -4824,6 +4975,8 @@ var defaultProjectBotMembershipStore = new InMemoryProjectBotMembershipStore(def
 var defaultProjectRoomMessageStore = new InMemoryProjectRoomMessageStore(defaultProjectRoomCoordinator);
 var defaultProjectRoomReadStateStore = new InMemoryProjectRoomReadStateStore();
 var defaultUserPushSubscriptionStore = new InMemoryUserPushSubscriptionStore();
+var defaultLeaseStore = new InMemoryLeaseStore();
+var defaultOutboxStore = new InMemoryOutboxStore();
 storeLatticeManager.registerLattice("default", "thread", defaultThreadStore);
 storeLatticeManager.registerLattice(
   "default",
@@ -4845,6 +4998,8 @@ storeLatticeManager.registerLattice("default", "projectBotMembership", defaultPr
 storeLatticeManager.registerLattice("default", "projectRoomMessage", defaultProjectRoomMessageStore);
 storeLatticeManager.registerLattice("default", "projectRoomReadState", defaultProjectRoomReadStateStore);
 storeLatticeManager.registerLattice("default", "userPushSubscription", defaultUserPushSubscriptionStore);
+storeLatticeManager.registerLattice("default", "lease", defaultLeaseStore);
+storeLatticeManager.registerLattice("default", "outbox", defaultOutboxStore);
 var defaultUserStore = new InMemoryUserStore();
 var defaultTenantStore = new InMemoryTenantStore();
 var defaultUserTenantLinkStore = new InMemoryUserTenantLinkStore();
@@ -6713,8 +6868,8 @@ var MetricsServerManager = class _MetricsServerManager {
     } catch {
     }
     const tenantConfigs = this.configs.get(tenantId2);
-    const cached = tenantConfigs?.get(key5);
-    if (cached) return cached;
+    const cached2 = tenantConfigs?.get(key5);
+    if (cached2) return cached2;
     throw new Error(`Metrics server '${key5}' not found for tenant '${tenantId2}'`);
   }
   /**
@@ -8024,8 +8179,8 @@ var SandboxLatticeManager = class _SandboxLatticeManager extends BaseLatticeMana
   getLatticeType() {
     return "sandbox_manager";
   }
-  registerLattice(key5, provider) {
-    this.register(key5, provider);
+  registerLattice(key5, provider2) {
+    this.register(key5, provider2);
   }
   getSandboxLattice(key5) {
     const lattice = this.get(key5);
@@ -8076,8 +8231,8 @@ var SandboxLatticeManager = class _SandboxLatticeManager extends BaseLatticeMana
     return this.getVolumeBackendForPath(config, "/project");
   }
   async getVolumeBackendForPath(config, filePath) {
-    const provider = this._requireProvider();
-    if (!provider.createVolumeFsClient) {
+    const provider2 = this._requireProvider();
+    if (!provider2.createVolumeFsClient) {
       console.log(`[getVolumeBackendForPath] provider has no createVolumeFsClient, returning null`);
       return null;
     }
@@ -8088,7 +8243,7 @@ var SandboxLatticeManager = class _SandboxLatticeManager extends BaseLatticeMana
       return null;
     }
     console.log(`[getVolumeBackendForPath] path=${filePath} volume=${mapping.volumeName} prefix=${mapping.pathPrefix}`);
-    const client = provider.createVolumeFsClient(mapping.volumeName, mapping.pathPrefix);
+    const client = provider2.createVolumeFsClient(mapping.volumeName, mapping.pathPrefix);
     return new VolumeFilesystem(stripPrefixClient(client, mapping.pathPrefix), mapping.pathPrefix);
   }
   _resolveVolumeForPath(config, tenantId2, filePath) {
@@ -8123,35 +8278,35 @@ var SandboxLatticeManager = class _SandboxLatticeManager extends BaseLatticeMana
     };
   }
   async createSandbox(name, config) {
-    const provider = this._requireProvider();
-    return provider.createSandbox(name, config);
+    const provider2 = this._requireProvider();
+    return provider2.createSandbox(name, config);
   }
   async getSandbox(name) {
-    const provider = this._requireProvider();
-    return provider.getSandbox(name);
+    const provider2 = this._requireProvider();
+    return provider2.getSandbox(name);
   }
   async stopSandbox(name) {
-    const provider = this._requireProvider();
-    return provider.stopSandbox(name);
+    const provider2 = this._requireProvider();
+    return provider2.stopSandbox(name);
   }
   async deleteSandbox(name) {
-    const provider = this._requireProvider();
-    return provider.deleteSandbox(name);
+    const provider2 = this._requireProvider();
+    return provider2.deleteSandbox(name);
   }
   async listSandboxes() {
-    const provider = this._requireProvider();
-    return provider.listSandboxes();
+    const provider2 = this._requireProvider();
+    return provider2.listSandboxes();
   }
   _requireProvider() {
     const keys = this.keysByTenant("default");
     if (keys.length === 0) {
       throw new Error("Sandbox provider not configured.");
     }
-    const provider = this.get(keys[0]);
-    if (!provider) {
+    const provider2 = this.get(keys[0]);
+    if (!provider2) {
       throw new Error("Sandbox provider not configured.");
     }
-    return provider;
+    return provider2;
   }
   /**
    * Returns the first registered (default) sandbox provider.
@@ -8181,6 +8336,46 @@ import { tool as tool14 } from "langchain";
 // src/tool_lattice/shell_exec/index.ts
 import z17 from "zod";
 import { tool as tool15 } from "langchain";
+
+// src/sandbox_lattice/sandboxOpenCredential.ts
+var SANDBOX_OPEN_GATEWAY_URL_ENV = "API_GATEWAY_URL";
+var SANDBOX_OPEN_TOKEN_ENV = "OPEN_API_TOKEN";
+var provider;
+var providerErrorHandler;
+function registerSandboxOpenCredentialProvider(next, options = {}) {
+  provider = next;
+  providerErrorHandler = options.onError;
+  return () => {
+    if (provider === next) {
+      provider = void 0;
+      providerErrorHandler = void 0;
+    }
+  };
+}
+async function getSandboxOpenCredential(context) {
+  if (!provider) return void 0;
+  try {
+    return await provider(context);
+  } catch (error) {
+    try {
+      providerErrorHandler?.(error);
+    } catch {
+    }
+    return void 0;
+  }
+}
+function buildSandboxOpenEnv(credential) {
+  return `export ${SANDBOX_OPEN_GATEWAY_URL_ENV}=${shellSingleQuote(credential.gatewayUrl)} && export ${SANDBOX_OPEN_TOKEN_ENV}=${shellSingleQuote(credential.token)}`;
+}
+function shellSingleQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function clearSandboxOpenCredentialProviderForTests() {
+  provider = void 0;
+  providerErrorHandler = void 0;
+}
+
+// src/tool_lattice/shell_exec/index.ts
 var SHELL_EXEC_DESCRIPTION = `Execute a shell command in the sandbox environment.
 
 Use this to run CLI tools, install packages, inspect files, or perform any operation that requires a shell.
@@ -8213,8 +8408,19 @@ var createShellExecTool = ({
           projectId: runConfig.projectId,
           vmIsolation
         });
+        const tenantId2 = runConfig.tenantId;
+        const credential = tenantId2 ? await getSandboxOpenCredential({
+          tenantId: tenantId2,
+          workspaceId: runConfig.workspaceId,
+          projectId: runConfig.projectId,
+          sandboxName: sandbox.name,
+          assistantId: runConfig.assistant_id || void 0,
+          threadId: runConfig.thread_id || void 0,
+          depth: runConfig.depth
+        }) : void 0;
+        const command = credential ? `${buildSandboxOpenEnv(credential)} && ${input.command}` : input.command;
         const executeResult = await sandbox.shell.execCommand({
-          command: input.command,
+          command,
           exec_dir: input.exec_dir,
           timeout: input.timeout ?? 300
         });
@@ -12952,13 +13158,23 @@ var SandboxPluginExecutor = class {
     validateRelativePath(args.handler, "handler");
     const pluginDir = `${PLUGINS_ROOT}/${args.manifest.type}`;
     const handlerAbs = `${pluginDir}/${args.handler}`;
+    const tenantId2 = args.runConfig?.tenantId ?? args.context.tenantId;
     const sandbox = await this.deps.resolveSandbox({
-      tenantId: args.runConfig?.tenantId ?? args.context.tenantId,
+      tenantId: tenantId2,
       assistantId: args.runConfig?.assistantId,
       threadId: args.runConfig?.threadId,
       workspaceId: args.runConfig?.workspaceId,
       projectId: args.runConfig?.projectId
     });
+    const openCredential = tenantId2 ? await getSandboxOpenCredential({
+      tenantId: tenantId2,
+      workspaceId: args.runConfig?.workspaceId,
+      projectId: args.runConfig?.projectId,
+      sandboxName: sandbox.name,
+      assistantId: args.runConfig?.assistantId,
+      threadId: args.runConfig?.threadId,
+      depth: args.runConfig?.depth
+    }) : void 0;
     const timeoutMs = clamp(args.timeoutMs ?? DEFAULT_TIMEOUT_MS, MIN_TIMEOUT_MS, MAX_TIMEOUT_MS);
     const cap = clamp(
       args.maxResultBytes ?? DEFAULT_MAX_RESULT_BYTES,
@@ -12989,6 +13205,12 @@ var SandboxPluginExecutor = class {
         envParts.push(`PLUGIN_CONNECTION_FILE=${quotePosixShellArg(connectionFile)}`);
       }
       envParts.push(`PLUGIN_CONTEXT=${quotePosixShellArg(encode(args.context))}`);
+      if (openCredential) {
+        envParts.push(
+          `${SANDBOX_OPEN_GATEWAY_URL_ENV}=${quotePosixShellArg(openCredential.gatewayUrl)}`
+        );
+        envParts.push(`${SANDBOX_OPEN_TOKEN_ENV}=${quotePosixShellArg(openCredential.token)}`);
+      }
       const command = `${envParts.join(" ")} node ${quotePosixShellArg(handlerAbs)}`;
       const execResult = await sandbox.shell.execCommand({
         command,
@@ -13940,10 +14162,10 @@ var TenantPluginCatalog = class {
       candidates.push({ type, dirPath: dir.path, raw, manifestJson, files: dirFiles });
     }
     const hash = createHash3("sha256").update(hashParts.sort().join("\n")).digest("hex").slice(0, 16);
-    const cached = this.cache.get(tenantId2)?.value;
-    if (cached && cached.hash === hash) {
-      this.cache.set(tenantId2, { value: cached, checkedAt: this.now() });
-      return cached;
+    const cached2 = this.cache.get(tenantId2)?.value;
+    if (cached2 && cached2.hash === hash) {
+      this.cache.set(tenantId2, { value: cached2, checkedAt: this.now() });
+      return cached2;
     }
     const plugins = [];
     const manifests = {};
@@ -15304,7 +15526,7 @@ var AgentWorkerState = Annotation.Root({
     default: () => ({})
   }),
   command2: Annotation({
-    reducer: (x, y) => y ?? x,
+    reducer: (_x, y) => y,
     default: () => void 0
   }),
   // RunConfig for passing configuration through the graph
@@ -15321,12 +15543,12 @@ var AgentWorkerState = Annotation.Root({
   }),
   // Execution result
   result: Annotation({
-    reducer: (x, y) => y ?? x,
+    reducer: (_x, y) => y,
     default: () => void 0
   }),
   // Interrupt data
   interruptValue: Annotation({
-    reducer: (x, y) => y ?? x,
+    reducer: (_x, y) => y,
     default: () => void 0
   }),
   // Final state to return
@@ -17016,6 +17238,71 @@ var CapabilityRuntimeResolver = class {
 // src/services/TrustedAgentDispatchCapability.ts
 var TRUSTED_AGENT_DISPATCH = Symbol("axiom.trustedAgentDispatch");
 
+// src/services/threadRunLease.ts
+import { randomUUID as randomUUID6 } from "crypto";
+function threadRunLeaseKey(tenantId2, assistantId, threadId) {
+  return `thread-run:${tenantId2}:${assistantId}:${threadId}`;
+}
+async function tryAcquireThreadRun(input) {
+  const key5 = threadRunLeaseKey(input.tenantId, input.assistantId, input.threadId);
+  const holder = `${input.owner}#${randomUUID6()}`;
+  if (!await input.store.tryAcquire(key5, holder, input.ttlMs)) return null;
+  const heartbeatMs = input.heartbeatMs ?? Math.max(1e3, Math.floor(input.ttlMs / 3));
+  let released = false;
+  let lost = false;
+  const heartbeat = setInterval(() => {
+    void input.store.renew(key5, holder, input.ttlMs).then((renewed) => {
+      if (released || renewed || lost) return;
+      lost = true;
+      try {
+        input.onLost?.();
+      } catch {
+      }
+    }).catch(() => void 0);
+  }, heartbeatMs);
+  heartbeat.unref?.();
+  return {
+    get lost() {
+      return lost;
+    },
+    release: async () => {
+      if (released) return;
+      released = true;
+      clearInterval(heartbeat);
+      await input.store.release(key5, holder).catch(() => void 0);
+    }
+  };
+}
+async function getThreadRunOwner(input) {
+  let store = input.store;
+  if (!store) {
+    try {
+      store = storeLatticeManager.getStoreLattice("default", "lease").store;
+    } catch {
+      return null;
+    }
+  }
+  try {
+    const record = await store.get(threadRunLeaseKey(input.tenantId, input.assistantId, input.threadId));
+    if (!record) return null;
+    const hash = record.holder.lastIndexOf("#");
+    return hash > 0 ? record.holder.slice(0, hash) : record.holder;
+  } catch {
+    return null;
+  }
+}
+
+// src/services/replicaIdentity.ts
+import os from "os";
+var cached;
+function getReplicaId() {
+  cached ?? (cached = process.env.AXIOM_REPLICA_ID?.trim() || `${os.hostname()}:${process.pid}`);
+  return cached;
+}
+function resetReplicaIdForTests() {
+  cached = void 0;
+}
+
 // src/services/Agent.ts
 var ThreadStatus2 = /* @__PURE__ */ ((ThreadStatus3) => {
   ThreadStatus3["IDLE"] = "idle";
@@ -17333,6 +17620,10 @@ function checkpointCapabilityRevision(state) {
 var QUEUE_PROCESSOR_RETRY_BASE_MS = 100;
 var QUEUE_PROCESSOR_MAX_RETRIES = 3;
 var AGENT_RECURSION_LIMIT = 1e3;
+var THREAD_RUN_LEASE_TTL_MS = 6e4;
+var THREAD_RUN_LEASE_RETRY_BASE_MS = 150;
+var THREAD_RUN_LEASE_RETRY_CAP_MS = 1500;
+var THREAD_RUN_LEASE_MAX_RETRIES = 12;
 function hasExactKeys(record, required, optional = []) {
   const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
   return required.every((key5) => Object.prototype.hasOwnProperty.call(record, key5)) && Reflect.ownKeys(record).every((key5) => typeof key5 === "string" && allowed.has(key5));
@@ -17362,6 +17653,13 @@ var Agent = class {
     this.queueProcessorRetryAttempt = 0;
     this.queueProcessorGeneration = 0;
     this.queueWakeRequested = false;
+    /**
+     * Thread-run ownership lease held while this replica is actively processing
+     * the thread. Acquired non-blockingly in {@link startQueueProcessor}; released
+     * exactly once when the processor definitively stops.
+     */
+    this.threadRunLease = null;
+    this.threadRunLeaseRetryAttempt = 0;
     this.asyncTasks = [];
     this.agentExecutor = async ({ input, command, custom_run_config, expected_capability_revision, trusted_run_context }, signal) => {
       const { runnable_agent, runConfig } = await this.getLatticeClientAndRuntimeConfig(
@@ -17478,7 +17776,7 @@ var Agent = class {
       }
     };
     this.waitingForQueueEnd = async (signal) => {
-      while (!signal?.aborted) {
+      while (!signal?.aborted && !this.threadRunLease?.lost) {
         const pendings = await this.getPendingMessages();
         if (pendings.length === 0) {
           const state = await this.getCurrentState();
@@ -18254,12 +18552,47 @@ var Agent = class {
           id: interruptData.id,
           data: { content: interruptData.value }
         };
+        await this.awaitDurableInterrupt(interruptData.id, signal);
       }
       if (data) {
         this.addChunk(data);
       }
     }
   }
+  /**
+   * Waits until the thread's durable checkpoint reports the given interrupt id.
+   *
+   * Reads {@link getCurrentState} (the checkpoint, i.e. the single source of
+   * truth), never an in-memory status, so a `true` result guarantees a resume
+   * against this thread will find the interrupt. Bounded so a broken
+   * checkpointer cannot strand the stream; on timeout the interrupt is emitted
+   * anyway and a warning is logged.
+   *
+   * @param interruptId - Interrupt id from the streamed `__interrupt__` update.
+   * @param signal - Run abort signal; polling stops when aborted.
+   * @param timeoutMs - Maximum time to wait for durable confirmation.
+   */
+  async awaitDurableInterrupt(interruptId, signal, timeoutMs = 5e3) {
+    if (!interruptId) return;
+    const deadline = Date.now() + timeoutMs;
+    while (!signal?.aborted) {
+      try {
+        const state = await this.getCurrentState();
+        const durable = (state?.tasks ?? []).some(
+          (task) => (task.interrupts ?? []).some((interrupt5) => interrupt5.id === interruptId)
+        );
+        if (durable) return;
+      } catch {
+      }
+      if (Date.now() >= deadline) {
+        console.warn(
+          `[Agent] interrupt ${interruptId} not durable within ${timeoutMs}ms on thread ${this.thread_id}; emitting without durable confirmation`
+        );
+        return;
+      }
+      await new Promise((resolve4) => setTimeout(resolve4, 20));
+    }
+  }
   /**
    * Resume LangGraph execution from the last checkpoint.
    *
@@ -18309,6 +18642,29 @@ var Agent = class {
     }
     return this.queueStore;
   }
+  /**
+   * Resolves the shared lease store used to serialize thread runs across
+   * Gateway replicas. Returns `undefined` when no lease store is registered so
+   * single-process deployments keep running unconditionally.
+   */
+  getLeaseStore() {
+    try {
+      return storeLatticeManager.getStoreLattice("default", "lease").store;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Releases this replica's thread-run ownership lease, if held.
+   *
+   * @remarks Safe to call from any definitive-stop path; a second call is a
+   * no-op. The handle's unique holder makes a stale release harmless.
+   */
+  async releaseThreadRunLease() {
+    const lease = this.threadRunLease;
+    this.threadRunLease = null;
+    if (lease) await lease.release();
+  }
   getDefaultQueueConfig() {
     return {
       mode: "collect" /* COLLECT */,
@@ -18334,6 +18690,8 @@ var Agent = class {
    */
   stopQueueProcessor() {
     this.cancelQueueProcessorRetry();
+    this.cancelThreadRunLeaseRetry();
+    void this.releaseThreadRunLease();
     this.clearRecoveryBlock();
     this.queueProcessorGeneration += 1;
     if (this.abortController) {
@@ -18481,16 +18839,50 @@ var Agent = class {
   startQueueProcessorIfNeeded() {
     return this.startQueueProcessor(true);
   }
-  startQueueProcessor(freshWakeup) {
+  async startQueueProcessor(freshWakeup) {
     this.queueWakeRequested = true;
     if (this.queueProcessorPromise) return this.queueProcessorPromise;
-    if (this.queueProcessorRetryTimer) return Promise.resolve();
+    if (this.queueProcessorRetryTimer) return;
     if (freshWakeup && this.queueProcessorRetryAttempt >= QUEUE_PROCESSOR_MAX_RETRIES) {
       this.queueProcessorRetryAttempt = 0;
     }
+    if (freshWakeup && this.threadRunLeaseRetryAttempt >= THREAD_RUN_LEASE_MAX_RETRIES) {
+      this.threadRunLeaseRetryAttempt = 0;
+    }
     this.queueWakeRequested = false;
-    let processorFailed = false;
     const processorGeneration = this.queueProcessorGeneration;
+    if (this.threadRunLease?.lost) await this.releaseThreadRunLease();
+    let acquiredLeaseHere = false;
+    if (this.threadRunLease === null) {
+      const leaseStore = this.getLeaseStore();
+      if (leaseStore) {
+        const lease = await tryAcquireThreadRun({
+          store: leaseStore,
+          tenantId: this.tenant_id,
+          assistantId: this.assistant_id,
+          threadId: this.thread_id,
+          owner: getReplicaId(),
+          ttlMs: THREAD_RUN_LEASE_TTL_MS,
+          onLost: () => {
+            console.warn(`[Agent] Thread-run lease lost for thread ${this.thread_id}; aborting the held run`);
+            this.abortController?.abort();
+          }
+        });
+        if (!lease) {
+          this.scheduleThreadRunLeaseRetry();
+          return;
+        }
+        this.threadRunLease = lease;
+        acquiredLeaseHere = true;
+        this.cancelThreadRunLeaseRetry();
+      }
+    }
+    if (this.queueProcessorPromise) return this.queueProcessorPromise;
+    if (this.queueProcessorGeneration !== processorGeneration) {
+      if (acquiredLeaseHere) await this.releaseThreadRunLease();
+      return;
+    }
+    let processorFailed = false;
     const processor = this.runQueueProcessor().catch(async (error) => {
       processorFailed = true;
       console.error(`Queue processing error for thread ${this.thread_id}:`, error);
@@ -18508,7 +18900,11 @@ var Agent = class {
       if (this.queueWakeRequested) void this.startQueueProcessor(false);
       return;
     }
-    if (failed) return;
+    if (failed) {
+      this.cancelThreadRunLeaseRetry();
+      await this.releaseThreadRunLease();
+      return;
+    }
     this.queueProcessorRetryAttempt = 0;
     if (this.queueWakeRequested) {
       void this.startQueueProcessor(false);
@@ -18521,7 +18917,11 @@ var Agent = class {
         void this.startQueueProcessor(false);
         return;
       }
-      if (pendingMessages.length === 0) return;
+      if (pendingMessages.length === 0) {
+        this.cancelThreadRunLeaseRetry();
+        await this.releaseThreadRunLease();
+        return;
+      }
       const processingMessages = await this.getQueueStore().getProcessingMessages(
         this.thread_id,
         this.queueScope()
@@ -18533,12 +18933,20 @@ var Agent = class {
       }
       if (processingMessages.length > 0) {
         const runStatus = await this.getRunStatus();
-        if (runStatus === "busy" /* BUSY */ || runStatus === "interrupted" /* INTERRUPTED */) return;
+        if (runStatus === "busy" /* BUSY */ || runStatus === "interrupted" /* INTERRUPTED */) {
+          this.cancelThreadRunLeaseRetry();
+          await this.releaseThreadRunLease();
+          return;
+        }
       }
       void this.startQueueProcessor(false);
     } catch (error) {
       console.error(`Queue processor finalization failed for thread ${this.thread_id}:`, error);
       await this.scheduleQueueProcessorRetry(error, generation);
+      if (!this.queueProcessorPromise) {
+        await this.releaseThreadRunLease();
+        this.cancelThreadRunLeaseRetry();
+      }
     }
   }
   async scheduleQueueProcessorRetry(error, generation) {
@@ -18576,6 +18984,36 @@ var Agent = class {
     this.queueProcessorRetryAttempt = 0;
     this.queueWakeRequested = false;
   }
+  /**
+   * Bounded re-attempt after losing the thread-run lease to a peer. Covers the
+   * narrow window where the peer releases the lease without having observed a
+   * just-enqueued message. Bounded so a genuinely long-held thread does not make
+   * this replica poll forever — the owning replica's loop drains new messages.
+   */
+  scheduleThreadRunLeaseRetry() {
+    if (this.threadRunLeaseRetryTimer || this.threadRunLeaseRetryAttempt >= THREAD_RUN_LEASE_MAX_RETRIES) return;
+    const delay = Math.min(
+      THREAD_RUN_LEASE_RETRY_BASE_MS * 2 ** this.threadRunLeaseRetryAttempt,
+      THREAD_RUN_LEASE_RETRY_CAP_MS
+    );
+    this.threadRunLeaseRetryAttempt += 1;
+    this.threadRunLeaseRetryTimer = setTimeout(() => {
+      this.threadRunLeaseRetryTimer = void 0;
+      void this.startQueueProcessor(false);
+    }, delay);
+  }
+  /**
+   * Clears any pending thread-run lease retry and resets its backoff budget.
+   *
+   * @remarks Called on lease acquisition and on every definitive processor
+   * stop so the next enqueue starts from the base delay. Never called on
+   * continue/re-arm paths, which must preserve the bounded budget.
+   */
+  cancelThreadRunLeaseRetry() {
+    if (this.threadRunLeaseRetryTimer) clearTimeout(this.threadRunLeaseRetryTimer);
+    this.threadRunLeaseRetryTimer = void 0;
+    this.threadRunLeaseRetryAttempt = 0;
+  }
   async runQueueProcessor() {
     const store = this.getQueueStore();
     const processingMessages = await store.getProcessingMessages(this.thread_id, this.queueScope());
@@ -18720,6 +19158,38 @@ var Agent = class {
       console.error(`[Agent] Failed to initialize agent lattice for ${this.assistant_id} (tenant: ${this.tenant_id}):`, error);
       throw error;
     }
+    let acquiredLeaseHere = false;
+    if (this.threadRunLease === null) {
+      const leaseStore = this.getLeaseStore();
+      if (leaseStore) {
+        const lease = await tryAcquireThreadRun({
+          store: leaseStore,
+          tenantId: this.tenant_id,
+          assistantId: this.assistant_id,
+          threadId: this.thread_id,
+          owner: getReplicaId(),
+          ttlMs: THREAD_RUN_LEASE_TTL_MS,
+          onLost: () => {
+            console.warn(`[Agent] Thread-run lease lost for thread ${this.thread_id}; aborting the held run`);
+            this.abortController?.abort();
+          }
+        });
+        if (!lease) {
+          return { status: await this.getRunStatus(), settled: false, leaseContended: true };
+        }
+        this.threadRunLease = lease;
+        acquiredLeaseHere = true;
+        this.cancelThreadRunLeaseRetry();
+      }
+    }
+    try {
+      return await this.resumeTaskLocked();
+    } finally {
+      if (acquiredLeaseHere && !this.queueProcessorPromise) await this.releaseThreadRunLease();
+    }
+  }
+  /** Recovery body of {@link resumeTask}, executed while thread ownership is settled. */
+  async resumeTaskLocked() {
     const store = this.getQueueStore();
     const processingMessages = await store.getProcessingMessages(this.thread_id, this.queueScope());
     const preRunState = await this.getCurrentState();
@@ -18835,6 +19305,8 @@ var Agent = class {
    */
   async abort() {
     this.cancelQueueProcessorRetry();
+    this.cancelThreadRunLeaseRetry();
+    await this.releaseThreadRunLease();
     this.clearRecoveryBlock();
     this.queueProcessorGeneration += 1;
     if (this.abortController) {
@@ -19494,27 +19966,27 @@ function createCheckAsyncTaskTool() {
       if (!mainAgent) {
         return "Cannot access main agent state.";
       }
-      const cached = mainAgent.getAsyncTask(task_id);
-      if (!cached) {
+      const cached2 = mainAgent.getAsyncTask(task_id);
+      if (!cached2) {
         return `Task ${task_id} not found. Use list_async_tasks to see all tasks.`;
       }
       try {
         if (!agentInstanceManager.hasAgent({
-          assistant_id: cached.assistantId,
+          assistant_id: cached2.assistantId,
           thread_id: task_id,
           tenant_id: mainAgent.tenant_id
         })) {
-          return `Task ${task_id}: not found (may have been cleaned up). Status was: ${cached.status}`;
+          return `Task ${task_id}: not found (may have been cleaned up). Status was: ${cached2.status}`;
         }
         const subAgent = agentInstanceManager.getAgent({
-          assistant_id: cached.assistantId,
+          assistant_id: cached2.assistantId,
           thread_id: task_id,
           tenant_id: mainAgent.tenant_id
         });
         const status = await subAgent.getRunStatus();
         if (status === "busy") {
           return `Task ${task_id}: still running.
-Description: ${cached.description}`;
+Description: ${cached2.description}`;
         }
         if (status === "idle") {
           const state = await subAgent.getCurrentState();
@@ -19525,21 +19997,21 @@ Description: ${cached.description}`;
           mainAgent.updateAsyncTaskStatus(task_id, "completed");
           const result = lastAI?.content ?? "(completed, no output)";
           return `Task ${task_id}: COMPLETED.
-Description: ${cached.description}
+Description: ${cached2.description}
 Result:
 ${result}`;
         }
         if (status === "error") {
           mainAgent.updateAsyncTaskStatus(task_id, "failed");
           return `Task ${task_id}: failed.
-Description: ${cached.description}`;
+Description: ${cached2.description}`;
         }
         if (status === "interrupted") {
           return `Task ${task_id}: interrupted (waiting for input).
-Description: ${cached.description}`;
+Description: ${cached2.description}`;
         }
         return `Task ${task_id}: ${status}.
-Description: ${cached.description}`;
+Description: ${cached2.description}`;
       } catch (err) {
         return `Task ${task_id}: error checking status: ${err instanceof Error ? err.message : String(err)}`;
       }
@@ -19612,25 +20084,25 @@ function createCancelAsyncTaskTool() {
       if (!mainAgent) {
         return "Cannot access main agent state.";
       }
-      const cached = mainAgent.getAsyncTask(task_id);
-      if (!cached) {
+      const cached2 = mainAgent.getAsyncTask(task_id);
+      if (!cached2) {
         return `Task ${task_id} not found.`;
       }
       try {
         const subAgentExists = agentInstanceManager.hasAgent({
-          assistant_id: cached.assistantId,
+          assistant_id: cached2.assistantId,
           thread_id: task_id,
           tenant_id: mainAgent.tenant_id
         });
         if (subAgentExists) {
           const subAgent = agentInstanceManager.getAgent({
-            assistant_id: cached.assistantId,
+            assistant_id: cached2.assistantId,
             thread_id: task_id,
             tenant_id: mainAgent.tenant_id
           });
           await subAgent.abort();
           agentInstanceManager.removeAgent({
-            assistant_id: cached.assistantId,
+            assistant_id: cached2.assistantId,
             thread_id: task_id,
             tenant_id: mainAgent.tenant_id
           });
@@ -19879,6 +20351,48 @@ var MemoryScheduleStorage = class {
       });
     }
   }
+  /**
+   * Atomically claims one due fire by transitioning the task `pending -> running`.
+   *
+   * @param taskId Task to claim.
+   * @returns True when this caller won the claim (task was `pending`); false if
+   *   another replica already claimed it or it is not pending.
+   */
+  async claimScheduledRun(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task || task.status !== ScheduledTaskStatus.PENDING) {
+      return false;
+    }
+    this.tasks.set(taskId, {
+      ...task,
+      status: ScheduledTaskStatus.RUNNING,
+      updatedAt: Date.now()
+    });
+    return true;
+  }
+  /**
+   * Requeues `running` tasks whose `updatedAt` is older than `olderThanMs` back
+   * to `pending` (recovery after a crash that left a claim unsettled).
+   *
+   * @param olderThanMs Age threshold in milliseconds.
+   * @returns The number of tasks requeued.
+   */
+  async requeueStaleRunning(olderThanMs) {
+    const now = Date.now();
+    const cutoff = now - olderThanMs;
+    let requeued = 0;
+    for (const [taskId, task] of this.tasks.entries()) {
+      if (task.status === ScheduledTaskStatus.RUNNING && task.updatedAt < cutoff) {
+        this.tasks.set(taskId, {
+          ...task,
+          status: ScheduledTaskStatus.PENDING,
+          updatedAt: now
+        });
+        requeued++;
+      }
+    }
+    return requeued;
+  }
   /**
    * Delete task
    */
@@ -20243,6 +20757,7 @@ function describeCronExpression(expression) {
 }
 
 // src/schedule_lattice/DefaultScheduleClient.ts
+var STALE_RUNNING_MS = 30 * 6e4;
 var _DefaultScheduleClient = class _DefaultScheduleClient {
   constructor(storage) {
     this.handlers = /* @__PURE__ */ new Map();
@@ -20483,6 +20998,19 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
   }
   // ===== Recovery =====
   async restore() {
+    try {
+      const requeued = await this.storage.requeueStaleRunning(STALE_RUNNING_MS);
+      if (requeued > 0) {
+        console.log(
+          `[Scheduler] Requeued ${requeued} stale running task(s)`
+        );
+      }
+    } catch (error) {
+      console.error(
+        "[Scheduler] Failed to requeue stale running tasks:",
+        error
+      );
+    }
     const activeTasks = await this.storage.getActiveTasks();
     let restored = 0;
     for (const task of activeTasks) {
@@ -20543,6 +21071,16 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
     });
   }
   async executeTask(task) {
+    let claimed = false;
+    try {
+      claimed = await this.storage.claimScheduledRun(task.taskId);
+    } catch (error) {
+      console.error(`[Scheduler] Failed to claim task ${task.taskId}:`, error);
+      return;
+    }
+    if (!claimed) {
+      return;
+    }
     const handler = this.handlers.get(task.taskType);
     if (!handler) {
       console.error(
@@ -20554,9 +21092,6 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
       });
       return;
     }
-    await this.storage.update(task.taskId, {
-      status: ScheduledTaskStatus2.RUNNING
-    });
     console.log(`[Scheduler] Executing task: ${task.taskId}`);
     try {
       const latestTask = await this.storage.get(task.taskId);
@@ -25270,8 +25805,8 @@ var VectorStoreProviderManager = class _VectorStoreProviderManager extends BaseL
    * @param key Provider key name
    * @param provider VectorStoreProvider implementation
    */
-  registerProvider(key5, provider) {
-    const lattice = { key: key5, provider };
+  registerProvider(key5, provider2) {
+    const lattice = { key: key5, provider: provider2 };
     this.registerWithTenant("default", key5, lattice);
   }
   /**
@@ -25307,7 +25842,7 @@ var VectorStoreProviderManager = class _VectorStoreProviderManager extends BaseL
 };
 var vectorStoreProviderManager = VectorStoreProviderManager.getInstance();
 vectorStoreProviderManager.registerProvider("default", new MemoryVectorStoreProvider());
-var registerVectorStoreProvider = (key5, provider) => vectorStoreProviderManager.registerProvider(key5, provider);
+var registerVectorStoreProvider = (key5, provider2) => vectorStoreProviderManager.registerProvider(key5, provider2);
 var getVectorStoreProvider = (key5) => vectorStoreProviderManager.getProvider(key5);
 
 // src/store_lattice/configureStores.ts
@@ -28009,7 +28544,110 @@ independently before the workflow's integration eval.
 
 An unsupported architecture conversion interrupts the flow and requests a new
 user decision. Do not route backward to the Charter or to [[agent-build]], and do
-not create a replacement.`
+not create a replacement.`,
+  "ptc": `---
+name: ptc
+description: Programmatic Tool Calling (PTC) \u2014 write sandbox code that discovers and calls platform Open capabilities (MCP tools) through the gateway. Use when orchestration is multi-step, data-heavy, or needs loops/branches across platform tools instead of one-at-a-time model tool calls.
+metadata:
+  role: workflow
+  domain: orchestration
+verified: unverified
+---
+
+# Programmatic Tool Calling (PTC)
+
+PTC means the model writes and runs code that calls platform tools itself, instead
+of calling tools one at a time. Reach for it when orchestration is multi-step,
+data-heavy, or needs a loop/branch that would be wasteful as a chain of model tool
+calls.
+
+## Where the code runs
+
+Run the code with \`code_eval\` (backed by \`shell_exec\`). Each execution process is
+injected with two environment variables:
+
+- \`API_GATEWAY_URL\` \u2014 the gateway base URL.
+- \`OPEN_API_TOKEN\` \u2014 a short-lived bearer token **self-bound to this agent**. It is
+  not reusable elsewhere.
+
+The token already encodes this agent's authority: the platform reflects the agent's
+own configured middleware into Open grants, plus a small always-on baseline
+(\`kb\` read-only and \`sandbox:self\`). So the callable set = that baseline \u222A the
+domains your configured middleware exposes \u2014 and nothing beyond it.
+
+## Client
+
+The sandbox must have the zero-dependency \`@axiom-lattice/open-mcp-client\` package.
+Get it one of two ways:
+
+- **Preinstalled in the sandbox image** (recommended): \`open-mcp\` is on \`PATH\`; for
+  \`require("@axiom-lattice/open-mcp-client")\` to resolve, install it into the working
+  directory or point \`NODE_PATH\` at the global \`node_modules\`.
+- **Install it in this run** when the sandbox has network + npm:
+
+\`\`\`bash
+npm install @axiom-lattice/open-mcp-client
+# or use without installing:
+npx @axiom-lattice/open-mcp-client tools list --json
+\`\`\`
+
+\`\`\`js
+const { OpenMcpClient } = require("@axiom-lattice/open-mcp-client");
+const client = OpenMcpClient.fromEnv(); // reads API_GATEWAY_URL + OPEN_API_TOKEN
+\`\`\`
+
+CLI equivalents (config comes from the same env vars):
+
+\`\`\`bash
+open-mcp tools list --json
+open-mcp tools call kb_search --json '{"query":"refund policy"}'
+\`\`\`
+
+## Discover, then call
+
+1. **Discover first.** Call \`await client.listTools()\`. This returns exactly the
+   tools this agent is authorized to call (the server filters by the token's grants
+   on every request, so it is the source of truth).
+2. **Only call discovered tools.** Pick a tool from that list and call
+   \`await client.callTool(name, args)\` with args matching the tool's \`inputSchema\`.
+3. **Print the final result as JSON to stdout** so the calling agent can consume it.
+   Keep intermediate logs minimal.
+
+An unconfigured domain isn't registered, so calling it returns an \`isError\`
+tool-not-found result; a registered tool refused by the token's grants surfaces
+\`GRANT_DENIED\`. Either way the capability is **not configured for this agent**.
+Do not retry or work around it \u2014 drop that step or tell the user which
+middleware/domain must be enabled. A denied call is expected behavior, not a
+transient failure.
+
+## Tips
+
+- Fan out with \`Promise.all\` over many items instead of many sequential model turns;
+  that is the main win of PTC.
+- Inspect \`tool.inputSchema\` before calling to avoid schema-validation errors.
+- Reduce large results in code and return only the fields the agent needs.
+- The token is short-lived; for very long jobs re-read the env per \`code_eval\` run
+  rather than caching the token in a file.
+
+## Worked example
+
+\`\`\`js
+const { OpenMcpClient } = require("@axiom-lattice/open-mcp-client");
+
+async function main() {
+  const client = OpenMcpClient.fromEnv();          // API_GATEWAY_URL + OPEN_API_TOKEN
+  const tools = await client.listTools();           // exactly what this agent may call
+  const pick = tools.find((t) => t.name === "kb_search") ?? tools[0];
+  const out = await client.callTool(pick.name, { query: "refund policy" });
+  console.log(JSON.stringify({ called: pick.name, result: out.json() }));
+}
+
+main().catch((err) => { console.error(String(err)); process.exit(1); });
+\`\`\`
+
+Run this in \`code_eval\`. The first run proves env + client wiring; then extend it
+into the real fan-out/aggregation the task needs.
+`
 };
 function getBuiltInSkillMeta(name) {
   const content = BUILTIN_SKILLS[name];
@@ -28606,7 +29244,7 @@ ${body}` : `${frontmatter}
 };
 
 // src/store_lattice/InMemoryMenuStore.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 var InMemoryMenuStore = class {
   constructor() {
     this.items = /* @__PURE__ */ new Map();
@@ -28627,7 +29265,7 @@ var InMemoryMenuStore = class {
   async create(input) {
     const now = /* @__PURE__ */ new Date();
     const item = {
-      id: randomUUID6(),
+      id: randomUUID7(),
       tenantId: input.tenantId,
       menuTarget: input.menuTarget,
       group: input.group,
@@ -31139,9 +31777,9 @@ async function getOrCreateCollectionVectorStore(name, embeddingKey, tenantId2, p
     const pendingInitialization = pendingVectorStoreInitializations.get(storeKey);
     if (pendingInitialization) return pendingInitialization;
     const initialization = (async () => {
-      const provider = vectorStoreProviderManager.getProvider(providerKey);
+      const provider2 = vectorStoreProviderManager.getProvider(providerKey);
       const tableName = buildTableName(tenantId2, name);
-      const vectorStore = await provider.create({ tableName, embeddingKey });
+      const vectorStore = await provider2.create({ tableName, embeddingKey });
       vectorStoreLatticeManager.registerLattice(storeKey, vectorStore);
       return vectorStore;
     })();
@@ -31159,9 +31797,9 @@ async function getCollectionEntryCount(name, embeddingKey, tenantId2) {
     return vs.getDocumentCount();
   }
   try {
-    const provider = vectorStoreProviderManager.getProvider("default");
-    if (provider.getEntryCount) {
-      return provider.getEntryCount(buildTableName(tenantId2, name));
+    const provider2 = vectorStoreProviderManager.getProvider("default");
+    if (provider2.getEntryCount) {
+      return provider2.getEntryCount(buildTableName(tenantId2, name));
     }
   } catch {
   }
@@ -31173,9 +31811,9 @@ async function listCollectionEntries(name, embeddingKey, tenantId2) {
     return vs.getAllDocuments();
   }
   try {
-    const provider = vectorStoreProviderManager.getProvider("default");
-    if (provider.listEntries) {
-      return provider.listEntries(buildTableName(tenantId2, name));
+    const provider2 = vectorStoreProviderManager.getProvider("default");
+    if (provider2.listEntries) {
+      return provider2.listEntries(buildTableName(tenantId2, name));
     }
   } catch {
   }
@@ -31185,9 +31823,9 @@ async function removeCollectionVectorStore(name, tenantId2) {
   const storeKey = buildKey(tenantId2, name);
   const tableName = buildTableName(tenantId2, name);
   try {
-    const provider = vectorStoreProviderManager.getProvider("default");
-    if (provider.dropTable) {
-      await provider.dropTable(tableName);
+    const provider2 = vectorStoreProviderManager.getProvider("default");
+    if (provider2.dropTable) {
+      await provider2.dropTable(tableName);
     }
   } catch {
   }
@@ -33502,7 +34140,7 @@ var DaytonaProvider = class {
 
 // src/sandbox_lattice/providers/LocalSandboxProvider.ts
 import * as path6 from "path";
-import * as os from "os";
+import * as os2 from "os";
 import * as fs4 from "fs/promises";
 
 // src/sandbox_lattice/LocalSandboxInstance.ts
@@ -33529,6 +34167,32 @@ function assertRegularDeleteTarget(file, stat4) {
 function quoteShellArgument(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
+var PLATFORM_SECRET_ENV_VARS = [
+  "OPEN_TOKEN_SECRET",
+  "AUTH_TOKEN_SECRET",
+  "JWT_SECRET",
+  "WEB_APP_ATTACHMENT_SECRET",
+  "LATTICE_ENCRYPTION_KEY",
+  "DATABASE_URL",
+  "REDIS_PASSWORD",
+  "MICROSANDBOX_API_KEY",
+  "DAYTONA_API_KEY",
+  "E2B_API_KEY",
+  "OPENAI_API_KEY",
+  "AZURE_OPENAI_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "TAVILY_API_KEY",
+  "VAPID_PRIVATE_KEY",
+  "SUPABASE_KEY",
+  "A2A_API_KEYS"
+];
+function stripPlatformSecrets(env) {
+  const rest = { ...env };
+  for (const name of PLATFORM_SECRET_ENV_VARS) {
+    delete rest[name];
+  }
+  return rest;
+}
 function validatePackEntryName(name) {
   if (!name || name === "." || name === ".." || name.includes("\\") || name.includes("/")) {
     throw new Error(`Cannot pack: unsafe entry name '${name}'`);
@@ -33701,7 +34365,7 @@ var LocalSandboxInstance = class {
               timeout: timeoutMs,
               maxBuffer: 10 * 1024 * 1024,
               // 10MB
-              env: { ...process.env, HOME: this.rootDir }
+              env: stripPlatformSecrets({ ...process.env, HOME: this.rootDir })
             }
           );
           const output = stderr ? `${stdout}
@@ -33966,7 +34630,7 @@ var LocalSandboxProvider = class {
     this.instances = /* @__PURE__ */ new Map();
     this.creating = /* @__PURE__ */ new Map();
     this.createResourceAddress = createResourceAddress;
-    this.basePath = config.basePath ?? path6.join(os.homedir(), ".axiom-local-sandbox");
+    this.basePath = config.basePath ?? path6.join(os2.homedir(), ".axiom-local-sandbox");
   }
   async createSandbox(name, _config) {
     const existing = this.instances.get(name);
@@ -35342,6 +36006,10 @@ var TaskLifecycleNotifier = class {
     this.listeners = /* @__PURE__ */ new Set();
     this.tails = /* @__PURE__ */ new Map();
   }
+  /** Installs (or clears) the durable outbox used to fan notifications to other replicas. */
+  setOutbox(outbox2) {
+    this.outbox = outbox2;
+  }
   /**
    * Registers an async lifecycle listener.
    *
@@ -35362,6 +36030,25 @@ var TaskLifecycleNotifier = class {
    * @throws Error when the event is malformed or one or more listeners reject.
    */
   async publish(event) {
+    const snapshot = snapshotNotification(event);
+    const key5 = `${snapshot.tenantId}:${snapshot.taskId}`;
+    const previous = this.tails.get(key5) ?? Promise.resolve();
+    const delivery = previous.catch(() => void 0).then(() => this.deliver(snapshot));
+    this.tails.set(key5, delivery);
+    if (this.outbox) {
+      try {
+        await this.outbox.append({ topic: "task-lifecycle", payload: snapshot, originReplicaId: getReplicaId() });
+      } catch {
+      }
+    }
+    try {
+      await delivery;
+    } finally {
+      if (this.tails.get(key5) === delivery) this.tails.delete(key5);
+    }
+  }
+  /** Delivers one outbox payload to local listeners without re-appending (poller path). */
+  async deliverFromOutbox(event) {
     const snapshot = snapshotNotification(event);
     const key5 = `${snapshot.tenantId}:${snapshot.taskId}`;
     const previous = this.tails.get(key5) ?? Promise.resolve();
@@ -35426,6 +36113,10 @@ var ProjectTaskAdmissionNotifier = class {
     if (!Number.isSafeInteger(timeout) || timeout <= 0) throw new Error("Invalid admission listener timeout");
     this.listenerTimeoutMs = timeout;
   }
+  /** Installs (or clears) the durable outbox used to fan notifications to other replicas. */
+  setOutbox(outbox2) {
+    this.outbox = outbox2;
+  }
   /**
    * Registers a Project task admission listener.
    *
@@ -35445,6 +36136,30 @@ var ProjectTaskAdmissionNotifier = class {
    * @returns A promise settled after every snapshotted listener settles.
    */
   async publish(event) {
+    const snapshot = snapshotNotification2(event);
+    const listeners = [...this.listeners];
+    const key5 = `${snapshot.tenantId}\0${snapshot.taskId}`;
+    const previous = this.tails.get(key5) ?? Promise.resolve();
+    const delivery = previous.catch(() => void 0).then(() => this.deliver(snapshot, listeners));
+    this.tails.set(key5, delivery);
+    if (this.outbox) {
+      try {
+        await this.outbox.append({
+          topic: "project-task-admission",
+          payload: snapshot,
+          originReplicaId: getReplicaId()
+        });
+      } catch {
+      }
+    }
+    try {
+      await delivery;
+    } finally {
+      if (this.tails.get(key5) === delivery) this.tails.delete(key5);
+    }
+  }
+  /** Delivers one outbox payload to local listeners without re-appending (poller path). */
+  async deliverFromOutbox(event) {
     const snapshot = snapshotNotification2(event);
     const listeners = [...this.listeners];
     const key5 = `${snapshot.tenantId}\0${snapshot.taskId}`;
@@ -35514,8 +36229,137 @@ function canonicalTimestamp(value) {
   return Number.isFinite(parsed.getTime()) && parsed.toISOString() === value;
 }
 
+// src/services/OutboxPoller.ts
+var OutboxPoller = class {
+  /**
+   * Creates a poller bound to one durable outbox.
+   *
+   * @param deps Store, owner replica id, topic handlers, and optional tuning.
+   */
+  constructor(deps) {
+    this.deps = deps;
+    this.cursor = null;
+    this.polling = false;
+  }
+  /** Captures the starting cursor and begins polling. */
+  async start() {
+    this.cursor = await this.deps.store.latestId();
+    this.timer = setInterval(() => {
+      void this.pollOnce();
+    }, this.deps.intervalMs ?? 1e3);
+    this.timer.unref?.();
+  }
+  /** Stops polling. */
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+  }
+  /** Runs one drain pass (exported for tests). */
+  async pollOnce() {
+    if (this.polling) return;
+    this.polling = true;
+    try {
+      const batchSize = this.deps.batchSize ?? 100;
+      for (; ; ) {
+        const events = await this.deps.store.listAfter(this.cursor, batchSize);
+        if (events.length === 0) break;
+        for (const event of events) {
+          this.cursor = event.id;
+          if (event.originReplicaId === this.deps.owner) continue;
+          const handler = this.deps.handlers[event.topic];
+          if (!handler) continue;
+          try {
+            await this.deliverWithTimeout(handler, event.payload);
+          } catch {
+            this.deps.log?.warn("Outbox delivery failed", { topic: event.topic, id: event.id });
+          }
+        }
+        if (events.length < batchSize) break;
+      }
+    } catch (error) {
+      this.deps.log?.warn("Outbox poll failed", { error: error instanceof Error ? error.message : String(error) });
+    } finally {
+      this.polling = false;
+    }
+  }
+  /**
+   * Runs one handler bounded by `handlerTimeoutMs` so a hung listener cannot
+   * stall cross-replica delivery for this replica.
+   */
+  async deliverWithTimeout(handler, payload) {
+    const timeoutMs = this.deps.handlerTimeoutMs ?? 5e3;
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => reject(new Error("Outbox handler timed out")), timeoutMs);
+      timer.unref?.();
+    });
+    try {
+      await Promise.race([Promise.resolve().then(() => handler(payload)), timeout]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+};
+
 // src/services/ProjectMutationMutex.ts
 import { snapshotExactRecord as snapshotExactRecord4 } from "@axiom-lattice/protocols";
+
+// src/services/coordinationLease.ts
+var configured;
+function configureCoordinationLeaseStore(store) {
+  configured = store;
+}
+function getCoordinationLeaseStore() {
+  return configured;
+}
+
+// src/services/withLease.ts
+import { randomUUID as randomUUID8 } from "crypto";
+var LeaseAcquisitionTimeoutError = class extends Error {
+  /**
+   * @param key Lease key that could not be acquired.
+   * @param holder Unique holder that attempted acquisition.
+   * @param timeoutMs How long the caller waited before giving up.
+   */
+  constructor(key5, holder, timeoutMs) {
+    super(`Could not acquire lease '${key5}' for '${holder}' within ${timeoutMs}ms`);
+    this.key = key5;
+    this.holder = holder;
+    this.timeoutMs = timeoutMs;
+    /** Stable machine-readable code. */
+    this.code = "LEASE_ACQUISITION_TIMEOUT";
+    this.name = "LeaseAcquisitionTimeoutError";
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+async function withLease(store, key5, ownerLabel, fn, options = {}) {
+  const ttlMs = options.ttlMs ?? 3e4;
+  const acquireTimeoutMs = options.acquireTimeoutMs ?? 1e4;
+  const retryDelayMs = options.retryDelayMs ?? 50;
+  const heartbeatMs = options.heartbeatMs ?? Math.max(1e3, Math.floor(ttlMs / 3));
+  const holder = `${ownerLabel}#${randomUUID8()}`;
+  const deadline = Date.now() + acquireTimeoutMs;
+  for (; ; ) {
+    if (await store.tryAcquire(key5, holder, ttlMs)) break;
+    if (Date.now() >= deadline) throw new LeaseAcquisitionTimeoutError(key5, holder, acquireTimeoutMs);
+    await sleep(retryDelayMs);
+  }
+  const heartbeat = setInterval(() => {
+    void store.renew(key5, holder, ttlMs).catch(() => void 0);
+  }, heartbeatMs);
+  heartbeat.unref?.();
+  try {
+    return await fn();
+  } finally {
+    clearInterval(heartbeat);
+    await store.release(key5, holder).catch(() => void 0);
+  }
+}
+
+// src/services/ProjectMutationMutex.ts
+var MUTATION_LEASE_OPTIONS = { ttlMs: 6e4, acquireTimeoutMs: 9e4, retryDelayMs: 100 };
 function projectKey(scope) {
   const row = snapshotExactRecord4(scope, ["tenantId", "projectId"]);
   if (!row || typeof row.tenantId !== "string" || !row.tenantId || row.tenantId.includes("\0") || typeof row.projectId !== "string" || !row.projectId || row.projectId.includes("\0")) {
@@ -35531,9 +36375,12 @@ var ProjectMutationMutex = class {
   /** Runs one mutation after all earlier mutations for the same Tenant and Project. */
   async runExclusive(scope, operation, signal) {
     const key5 = projectKey(scope);
+    const leaseKey = `project-mutation:${encodeURIComponent(scope.tenantId)}:${encodeURIComponent(scope.projectId)}`;
     await this.acquire(key5, signal);
     try {
-      return await operation();
+      const store = getCoordinationLeaseStore();
+      if (!store) return await operation();
+      return await withLease(store, leaseKey, getReplicaId(), operation, MUTATION_LEASE_OPTIONS);
     } finally {
       this.release(key5);
     }
@@ -35591,7 +36438,7 @@ function createTrustedAgentMessageDispatcher(resolve4) {
 }
 
 // src/services/RoomAgentMessageService.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { snapshotExactArray, snapshotExactRecord as snapshotExactRecord5 } from "@axiom-lattice/protocols";
 var INPUT_KEYS = [
   "tenantId",
@@ -35679,7 +36526,7 @@ var RoomAgentMessageService = class {
       throw new Error("Invalid project room membership");
     }
     const candidate = {
-      id: (this.deps.idFactory ?? randomUUID7)(),
+      id: (this.deps.idFactory ?? randomUUID9)(),
       tenantId: input.tenantId,
       workspaceId: input.workspaceId,
       projectId: input.projectId,
@@ -36040,9 +36887,9 @@ var BELIEF_OWNER_WRITE_ATTEMPTS = 3;
 function isWellFormedImpact(impact) {
   return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(impact.key) && Number.isInteger(impact.after) && impact.after >= 0 && impact.after <= 100 && impact.basis.trim().length > 0 && impact.basis.length <= 1e3 && !/[\r\n]/.test(impact.basis);
 }
-async function applyBeliefImpacts(taskStore, owner, impacts) {
-  if (impacts.length === 0) return { description: owner.description ?? "" };
-  let current = owner;
+async function applyBeliefImpacts(taskStore, owner2, impacts) {
+  if (impacts.length === 0) return { description: owner2.description ?? "" };
+  let current = owner2;
   for (let attempt = 0; attempt < BELIEF_OWNER_WRITE_ATTEMPTS; attempt += 1) {
     const parsed = parseTaskBeliefState(current.description ?? "");
     const existingTable = parsed.success;
@@ -36171,14 +37018,14 @@ function sameBeliefOwner(left, right) {
 function sameBeliefOwnerIdentity(left, right) {
   return canonicalJson({ ...left, beliefState: void 0 }) === canonicalJson({ ...right, beliefState: void 0 });
 }
-function canonicalBeliefOwner(owner) {
+function canonicalBeliefOwner(owner2) {
   const beliefState = {
-    entries: owner.beliefState.entries.map((entry) => ({
+    entries: owner2.beliefState.entries.map((entry) => ({
       ...entry,
       basis: entry.basis.trim().replace(/\s+/g, " ")
     })).sort((left, right) => left.key < right.key ? -1 : left.key > right.key ? 1 : 0)
   };
-  return { ...owner, beliefState };
+  return { ...owner2, beliefState };
 }
 function eventKeyFor(taskId, result, impacts, beliefOwner) {
   const base = `belief-impact:${taskId}:${buildBeliefCompletionEventKey(taskId, result, impacts)}`;
@@ -37545,8 +38392,8 @@ var TaskLifecycleService = class {
     return { task: existing, parent: parentResult, eventKey, evidence, result, impacts };
   }
   beliefOwnerSnapshot(task, parent) {
-    const owner = parent?.ownerType === "agent" ? parent : task;
-    const parsed = parseTaskBeliefState(owner.description ?? "");
+    const owner2 = parent?.ownerType === "agent" ? parent : task;
+    const parsed = parseTaskBeliefState(owner2.description ?? "");
     const beliefState = parsed.success ? parsed.state : { entries: [] };
     if (parent?.ownerType === "agent") {
       return {
@@ -38266,7 +39113,7 @@ function createTaskLifecycleService(deps) {
 }
 
 // src/services/TaskExecutionService.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 import { isExecutionResultEventKey as isExecutionResultEventKey2 } from "@axiom-lattice/protocols";
 
@@ -38525,12 +39372,20 @@ var TaskRunRegistry = class {
   }
 };
 var taskRunRegistry = new TaskRunRegistry();
+async function safelyLive(probe, task) {
+  try {
+    return await probe(task);
+  } catch {
+    return true;
+  }
+}
 async function reconcileStaleTaskRuns(input) {
   const registry4 = input.registry ?? taskRunRegistry;
   const converged = [];
   const convergedTasks = [];
   for (const task of input.tasks) {
     if (task.status !== "in_progress" || registry4.isLive(task.id)) continue;
+    if (input.isTaskLive && await safelyLive(input.isTaskLive, task)) continue;
     const result = await input.lifecycle.failTask({
       tenantId: task.tenantId,
       taskId: task.id,
@@ -38551,7 +39406,8 @@ async function reconcileTenantTaskRuns(input) {
     tasks: candidates,
     actor: input.actor,
     lifecycle: input.lifecycle,
-    ...input.registry ? { registry: input.registry } : {}
+    ...input.registry ? { registry: input.registry } : {},
+    ...input.isTaskLive ? { isTaskLive: input.isTaskLive } : {}
   });
 }
 async function reconcileAllTenantTaskRuns(input) {
@@ -38567,7 +39423,8 @@ async function reconcileAllTenantTaskRuns(input) {
         taskStore: input.taskStore,
         lifecycle: input.lifecycle,
         ...input.registry ? { registry: input.registry } : {},
-        ...input.include ? { include: input.include } : {}
+        ...input.include ? { include: input.include } : {},
+        ...input.isTaskLive ? { isTaskLive: input.isTaskLive } : {}
       });
     } catch {
       continue;
@@ -38578,6 +39435,42 @@ async function reconcileAllTenantTaskRuns(input) {
   return { converged, convergedTasks };
 }
 
+// src/services/taskRunLease.ts
+import { randomUUID as randomUUID10 } from "crypto";
+function taskRunLeaseKey(taskId) {
+  return `task-run:${taskId}`;
+}
+async function tryAcquireTaskRun(input) {
+  const key5 = taskRunLeaseKey(input.taskId);
+  const holder = `${input.owner}#${randomUUID10()}`;
+  if (!await input.store.tryAcquire(key5, holder, input.ttlMs)) return null;
+  const heartbeatMs = input.heartbeatMs ?? Math.max(1e3, Math.floor(input.ttlMs / 3));
+  let released = false;
+  let lost = false;
+  const heartbeat = setInterval(() => {
+    void input.store.renew(key5, holder, input.ttlMs).then((renewed) => {
+      if (released || renewed || lost) return;
+      lost = true;
+      try {
+        input.onLost?.();
+      } catch {
+      }
+    }).catch(() => void 0);
+  }, heartbeatMs);
+  heartbeat.unref?.();
+  return {
+    get lost() {
+      return lost;
+    },
+    release: async () => {
+      if (released) return;
+      released = true;
+      clearInterval(heartbeat);
+      await input.store.release(key5, holder).catch(() => void 0);
+    }
+  };
+}
+
 // src/services/ExecutionAuthorityRegistry.ts
 var ManagedTaskStartError = class extends Error {
   /**
@@ -38848,6 +39741,14 @@ async function prepareTaskDispatch(deps, input) {
 
 // src/services/TaskExecutionService.ts
 import { GraphInterrupt as GraphInterrupt2 } from "@langchain/langgraph";
+var TASK_RUN_LEASE_TTL_MS = 12e4;
+function getLeaseStore() {
+  try {
+    return storeLatticeManager.getStoreLattice("default", "lease").store;
+  } catch {
+    return void 0;
+  }
+}
 function persistedExecutionObservation(item, attempted) {
   const detail = item.detail;
   const persistedObservation = toJsonSafeValue(detail?.observation);
@@ -38908,11 +39809,11 @@ function createTaskExecutionService(deps) {
     let threadId;
     let runId;
     try {
-      threadId = storedThreadId ?? (deps.createThreadId ?? randomUUID8)();
+      threadId = storedThreadId ?? (deps.createThreadId ?? randomUUID11)();
       if (task.status === "interrupted" && reuseCurrentRun) {
         runId = storedRunId;
       } else if (task.status === "interrupted" || task.status === "failed") {
-        runId = (deps.createRunId ?? randomUUID8)();
+        runId = (deps.createRunId ?? randomUUID11)();
       }
     } catch (error) {
       return {
@@ -38975,7 +39876,21 @@ function createTaskExecutionService(deps) {
       warnings.push(...begun.warnings);
     }
     taskRunRegistry.register(task.id);
+    let taskRunLease = null;
     try {
+      const leaseStore = getLeaseStore();
+      if (leaseStore) {
+        try {
+          taskRunLease = await tryAcquireTaskRun({
+            store: leaseStore,
+            taskId: task.id,
+            owner: getReplicaId(),
+            ttlMs: TASK_RUN_LEASE_TTL_MS
+          });
+        } catch {
+          taskRunLease = null;
+        }
+      }
       const invocation = {
         tenantId: tenantId2,
         workspaceId: task.workspaceId,
@@ -39143,6 +40058,7 @@ function createTaskExecutionService(deps) {
       }
     } finally {
       taskRunRegistry.unregister(task.id);
+      if (taskRunLease) await taskRunLease.release();
     }
   };
   return {
@@ -39155,6 +40071,43 @@ function createTaskExecutionService(deps) {
   };
 }
 
+// src/services/leadership.ts
+import { randomUUID as randomUUID12 } from "crypto";
+async function runAsLeader(store, name, fn, options = {}) {
+  const key5 = `leader:${name}`;
+  const owner2 = options.owner ?? getReplicaId();
+  const holder = `${owner2}#${randomUUID12()}`;
+  const ttlMs = options.ttlMs ?? 6e4;
+  if (!await store.tryAcquire(key5, holder, ttlMs)) return { ran: false };
+  const heartbeat = setInterval(() => {
+    void store.renew(key5, holder, ttlMs).catch(() => void 0);
+  }, Math.max(1e3, Math.floor(ttlMs / 3)));
+  heartbeat.unref?.();
+  try {
+    const result = await fn();
+    return { ran: true, result };
+  } finally {
+    clearInterval(heartbeat);
+    if (!options.hold) await store.release(key5, holder).catch(() => void 0);
+  }
+}
+
+// src/services/pluginCatalogSync.ts
+var PLUGIN_CATALOG_CHANGED_TOPIC = "plugin-catalog-changed";
+var outbox;
+var owner = "unknown";
+function configurePluginCatalogSync(next) {
+  outbox = next?.outbox;
+  owner = next?.owner ?? "unknown";
+}
+async function publishPluginCatalogChanged(tenantId2) {
+  if (!outbox || !tenantId2) return;
+  try {
+    await outbox.append({ topic: PLUGIN_CATALOG_CHANGED_TOPIC, payload: { tenantId: tenantId2 }, originReplicaId: owner });
+  } catch {
+  }
+}
+
 // src/index.ts
 import * as Protocols from "@axiom-lattice/protocols";
 
@@ -39297,9 +40250,9 @@ var createLoadSkillsTool = ({ skills, readAll, pluginSkills, pluginSkillOwners }
           if (!skillName) continue;
           if (await isPluginSkillManagedInSandbox(sandbox, skillName)) {
             const enabledDefinition = pluginSkills?.[skillName];
-            const owner = pluginSkillOwners?.[skillName];
-            const registered = owner && enabledDefinition ? PluginRegistry.getSkillForPlugin(owner, skillName) : void 0;
-            if (!registered || registered.definition !== enabledDefinition || !owner || !await isPluginSkillAuthorizedInSandbox(sandbox, skillName, owner) || await getPluginSkillManifestVersion(sandbox, skillName) !== enabledDefinition.version) {
+            const owner2 = pluginSkillOwners?.[skillName];
+            const registered = owner2 && enabledDefinition ? PluginRegistry.getSkillForPlugin(owner2, skillName) : void 0;
+            if (!registered || registered.definition !== enabledDefinition || !owner2 || !await isPluginSkillAuthorizedInSandbox(sandbox, skillName, owner2) || await getPluginSkillManifestVersion(sandbox, skillName) !== enabledDefinition.version) {
               continue;
             }
           }
@@ -39325,8 +40278,8 @@ var createLoadSkillsTool = ({ skills, readAll, pluginSkills, pluginSkillOwners }
       const seenNames = new Set(filteredSkills.map((skill) => skill.name));
       try {
         for (const [name, definition] of Object.entries(pluginSkills ?? {})) {
-          const owner = pluginSkillOwners?.[name];
-          const registered = owner ? PluginRegistry.getSkillForPlugin(owner, name) : void 0;
+          const owner2 = pluginSkillOwners?.[name];
+          const registered = owner2 ? PluginRegistry.getSkillForPlugin(owner2, name) : void 0;
           if (!registered || registered.definition !== definition) continue;
           const { meta } = parseSkillFrontmatter(definition.content);
           if (!meta.name || !meta.description || seenNames.has(meta.name)) continue;
@@ -39363,24 +40316,24 @@ import z54 from "zod";
 import { tool as tool48 } from "langchain";
 
 // src/sandbox_plugin/pluginSkillResolution.ts
-async function resolveTenantPluginSkill(tenantId2, owner, skillName) {
+async function resolveTenantPluginSkill(tenantId2, owner2, skillName) {
   try {
     const { plugins } = await getSandboxPluginCatalog().ensureLoaded(tenantId2);
-    const plugin = plugins.find((candidate) => candidate.meta.type === owner);
+    const plugin = plugins.find((candidate) => candidate.meta.type === owner2);
     return plugin?.skills?.[skillName];
   } catch {
     return void 0;
   }
 }
-async function resolveEnabledPluginSkill(owner, skillName, enabledDefinition, tenantId2) {
-  if (!owner || !enabledDefinition) return void 0;
-  const registered = PluginRegistry.getSkillForPlugin(owner, skillName);
-  if (registered && registered.pluginType === owner && registered.definition === enabledDefinition) {
-    return { pluginType: owner, definition: enabledDefinition };
+async function resolveEnabledPluginSkill(owner2, skillName, enabledDefinition, tenantId2) {
+  if (!owner2 || !enabledDefinition) return void 0;
+  const registered = PluginRegistry.getSkillForPlugin(owner2, skillName);
+  if (registered && registered.pluginType === owner2 && registered.definition === enabledDefinition) {
+    return { pluginType: owner2, definition: enabledDefinition };
   }
   if (!tenantId2) return void 0;
-  const tenantDefinition = await resolveTenantPluginSkill(tenantId2, owner, skillName);
-  return tenantDefinition ? { pluginType: owner, definition: tenantDefinition } : void 0;
+  const tenantDefinition = await resolveTenantPluginSkill(tenantId2, owner2, skillName);
+  return tenantDefinition ? { pluginType: owner2, definition: tenantDefinition } : void 0;
 }
 
 // src/tool_lattice/skill/load_skill_content.ts
@@ -39442,10 +40395,10 @@ var createLoadSkillContentTool = (pluginSkills, pluginSkillOwnersOrStaticSelecti
           return result2;
         }
         const enabledDefinition = pluginSkills?.[input.skill_name];
-        const owner = pluginSkillOwners?.[input.skill_name];
+        const owner2 = pluginSkillOwners?.[input.skill_name];
         const runConfig = _exe_config?.configurable?.runConfig || {};
         const pluginSkill = await resolveEnabledPluginSkill(
-          owner,
+          owner2,
           input.skill_name,
           enabledDefinition,
           runConfig.tenantId
@@ -39552,9 +40505,9 @@ var createLoadSkillResourceTool = (pluginSkills, pluginSkillOwners) => {
         validateRelativePath(input.resource_path, "resource");
         const sandbox = await getSandboxFromExeConfig3(_exe_config);
         const definition = pluginSkills?.[input.skill_name];
-        const owner = pluginSkillOwners?.[input.skill_name];
+        const owner2 = pluginSkillOwners?.[input.skill_name];
         const tenantId2 = _exe_config?.configurable?.runConfig?.tenantId;
-        const resolved = await resolveEnabledPluginSkill(owner, input.skill_name, definition, tenantId2);
+        const resolved = await resolveEnabledPluginSkill(owner2, input.skill_name, definition, tenantId2);
         if (definition) {
           if (!resolved || !resolved.definition.resources?.[input.resource_path]) {
             return `Resource "${input.resource_path}" not found for skill "${input.skill_name}".`;
@@ -41786,9 +42739,9 @@ async function renderAvailableExecutors(rc, tenantId2) {
   const governed = authority.kind === "projectRoom" || authority.kind === "projectTask";
   const projectId = governed ? (authority.trusted.projectTask ?? authority.trusted.projectRoom)?.projectId : void 0;
   const cacheKey = `${tenantId2}:${governed ? `project:${projectId ?? ""}` : "ordinary"}`;
-  const cached = executorCache.get(cacheKey);
+  const cached2 = executorCache.get(cacheKey);
   const now = Date.now();
-  if (cached && now - cached.at < EXECUTOR_CACHE_TTL_MS) return cached.text;
+  if (cached2 && now - cached2.at < EXECUTOR_CACHE_TTL_MS) return cached2.text;
   const lines = [];
   try {
     if (governed && projectId) {
@@ -46074,6 +47027,7 @@ var sandboxPluginsPlugin = {
             }
             case "reload": {
               const loaded = await catalog2.reload(tenantId2);
+              void publishPluginCatalogChanged(tenantId2);
               return JSON.stringify({ reloaded: true, plugins: loaded.plugins.length, diagnostics: loaded.diagnostics });
             }
             case "create":
@@ -46093,12 +47047,14 @@ var sandboxPluginsPlugin = {
               if (!check.manifest) return JSON.stringify({ written: false, diagnostics: check.diagnostics });
               await catalog2.writePlugin(tenantId2, input.type, input.manifest, handlers);
               const loaded = await catalog2.reload(tenantId2);
+              void publishPluginCatalogChanged(tenantId2);
               return JSON.stringify({ written: true, diagnostics: loaded.diagnostics, hash: loaded.hash });
             }
             case "delete": {
               if (!input.type) return "type is required";
               await catalog2.deletePlugin(tenantId2, input.type);
               await catalog2.reload(tenantId2);
+              void publishPluginCatalogChanged(tenantId2);
               return JSON.stringify({ deleted: true });
             }
             case "validate": {
@@ -46210,6 +47166,26 @@ function registerBuiltinPlugins() {
   }
 }
 
+// src/sandbox_plugin/provisionOpenClient.ts
+import { readFileSync } from "fs";
+var SDK_ROOT = "/root/.agents/sdk";
+var CLIENT_DIR = `${SDK_ROOT}/open-mcp-client`;
+var MANIFEST_PATH2 = `${SDK_ROOT}/.open-client-manifest.json`;
+async function provisionSandboxOpenClient(sandbox, bundle) {
+  await sandbox.file.createDirectory(SDK_ROOT);
+  await sandbox.file.createDirectory(CLIENT_DIR);
+  await sandbox.file.writeFile(`${CLIENT_DIR}/index.js`, bundle.indexJs);
+  await sandbox.file.writeFile(`${CLIENT_DIR}/cli.js`, bundle.cliJs);
+  await sandbox.file.writeFile(MANIFEST_PATH2, JSON.stringify({ version: bundle.version }));
+}
+function buildBundleFromDist(distDir, version) {
+  return {
+    indexJs: readFileSync(`${distDir}/index.js`, "utf8"),
+    cliJs: readFileSync(`${distDir}/cli.js`, "utf8"),
+    version
+  };
+}
+
 // src/personal_assistant/PersonalAssistantConfig.ts
 function deepClone(obj) {
   return JSON.parse(JSON.stringify(obj));
@@ -46671,10 +47647,12 @@ export {
   InMemoryChunkBuffer,
   InMemoryCollectionStore,
   InMemoryDatabaseConfigStore,
+  InMemoryLeaseStore,
   InMemoryMailboxStore,
   InMemoryMenuStore,
   InMemoryModelProviderStore,
   InMemoryOpenAuditStore,
+  InMemoryOutboxStore,
   InMemoryProjectBotMembershipStore,
   InMemoryProjectMembershipStore,
   InMemoryProjectRoomCoordinator,
@@ -46694,6 +47672,7 @@ export {
   LatticeEval,
   LatticeEvalProject,
   LatticeEvalSuite,
+  LeaseAcquisitionTimeoutError,
   LocalSandboxInstance,
   LocalSandboxProvider,
   LoggerLatticeManager,
@@ -46716,7 +47695,10 @@ export {
   MicrosandboxServiceClient,
   ModelLatticeManager,
   MysqlDatabase,
+  OutboxPoller,
   PACK_DIRECTORY_TIMEOUT_SECONDS,
+  PLATFORM_SECRET_ENV_VARS,
+  PLUGIN_CATALOG_CHANGED_TOPIC,
   PersonalAssistantConfig,
   PinoLoggerClient,
   PluginRegistry,
@@ -46737,6 +47719,8 @@ export {
   RepeatedToolCallError,
   RoomAgentMessageService,
   SAFE_PATH_COMPONENT,
+  SANDBOX_OPEN_GATEWAY_URL_ENV,
+  SANDBOX_OPEN_TOKEN_ENV,
   STTModelLattice,
   STTModelLatticeManager,
   SandboxFilesystem,
@@ -46777,11 +47761,13 @@ export {
   appendReconciliationWarning,
   appendUiFence,
   assertSafeUpstreamUrl,
+  buildBundleFromDist,
   buildGrepResultsDict,
   buildInput,
   buildNamedVolumeName,
   buildRemotePackDirectoryCommand,
   buildSandboxMetadataEnv,
+  buildSandboxOpenEnv,
   buildSkillFile,
   buildStateAnnotation,
   buildTableName,
@@ -46790,11 +47776,14 @@ export {
   checkEmptyContent,
   clearEncryptionKeyCache,
   clearEvalRunService,
+  clearSandboxOpenCredentialProviderForTests,
   collectionLatticeManager,
   compileInternal,
   compileSandboxPlugin,
   compileWorkflow,
   computeSandboxName,
+  configureCoordinationLeaseStore,
+  configurePluginCatalogSync,
   configureStores,
   connectAllChannels,
   convertToConnection,
@@ -46826,6 +47815,7 @@ export {
   createSandboxResolver,
   createSchedulerMiddleware,
   createSharePayload,
+  createShellExecTool,
   createTaskExecutionService,
   createTaskLifecycleService,
   createTaskMiddleware,
@@ -46872,6 +47862,7 @@ export {
   getCheckpointSaver,
   getChunkBuffer,
   getCollectionEntryCount,
+  getCoordinationLeaseStore,
   getEmbeddingsClient,
   getEmbeddingsLattice,
   getEncryptionKey,
@@ -46883,15 +47874,18 @@ export {
   getOrCreateCollectionVectorStore,
   getPluginSkillManifestVersion,
   getQueueLattice,
+  getReplicaId,
   getRuntimeCapabilityConfig,
   getRuntimeSkillSelection,
   getSTTClient,
   getSTTClientWithTenant,
   getSTTModelLattice,
   getSandBoxManager,
+  getSandboxOpenCredential,
   getSandboxPluginCatalog,
   getScheduleLattice,
   getStoreLattice,
+  getThreadRunOwner,
   getToolClient,
   getToolClientWithTenant,
   getToolDefinition,
@@ -46945,6 +47939,8 @@ export {
   projectMutationMutex,
   projectRoomPlugin,
   projectTaskAdmissionNotifier,
+  provisionSandboxOpenClient,
+  publishPluginCatalogChanged,
   queueLatticeManager,
   readLoopBreakerConfig,
   reconcileAllTenantTaskRuns,
@@ -46963,6 +47959,7 @@ export {
   registerModelLatticeForTenant,
   registerQueueLattice,
   registerSTTModelLattice,
+  registerSandboxOpenCredentialProvider,
   registerSandboxProviderType,
   registerScheduleLattice,
   registerStoreLattice,
@@ -46973,6 +47970,7 @@ export {
   registerWorkflowRun,
   removeCollectionVectorStore,
   renderTemplate,
+  resetReplicaIdForTests,
   resolveEnabledPluginSkill,
   resolveJudgeModelKey,
   resolvePath,
@@ -46980,6 +47978,7 @@ export {
   resolveSandboxPluginConnections,
   resolveTenantPluginSkill,
   roomCoordinatorConfig,
+  runAsLeader,
   runRemotePackDirectory,
   safeTaskResponseId,
   sandboxLatticeManager,
@@ -46998,11 +47997,15 @@ export {
   storeLatticeManager,
   sttModelLatticeManager,
   taskLifecycleNotifier,
+  taskRunLeaseKey,
   taskRunRegistry,
+  threadRunLeaseKey,
   toJsonSchema,
   toSafeStateExpr,
   toolLatticeManager,
   truncateIfTooLong,
+  tryAcquireTaskRun,
+  tryAcquireThreadRun,
   unregisterTeammateAgent,
   unregisterWorkflowRun,
   updateFileData,
@@ -47018,6 +48021,7 @@ export {
   validateToolInput,
   vectorStoreLatticeManager,
   vectorStoreProviderManager,
+  withLease,
   withTimeout,
   wrapMcpToolWithUi
 };