@axiom-lattice/core 6.1.1 → 6.3.0

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
@@ -15404,6 +15626,324 @@ function createAgentWorkerGraph() {
 }
 var agentWorkerGraph = createAgentWorkerGraph();
 
+// src/util/toJsonSafeValue.ts
+var CIRCULAR_VALUE = "[Circular]";
+var REPEATED_VALUE = "[Repeated]";
+var arrayFrom = Array.from.bind(Array);
+var arrayIsArray = Array.isArray.bind(Array);
+var hasOwnProperty = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty);
+var isPrototypeOf = Object.prototype.isPrototypeOf.call.bind(Object.prototype.isPrototypeOf);
+var objectCreate = Object.create.bind(Object);
+var objectDefineProperty = Object.defineProperty.bind(Object);
+var objectIs = Object.is.bind(Object);
+var reflectGet = Reflect.get.bind(Reflect);
+var reflectGetOwnPropertyDescriptor = Reflect.getOwnPropertyDescriptor.bind(Reflect);
+var reflectOwnKeys = Reflect.ownKeys.bind(Reflect);
+var stringifyJson = JSON.stringify.bind(JSON);
+var numberIsFinite = Number.isFinite.bind(Number);
+var numberIsNaN = Number.isNaN.bind(Number);
+var numberIsSafeInteger = Number.isSafeInteger.bind(Number);
+var mathMax = Math.max.bind(Math);
+var dateConstructor = Date;
+var datePrototype = dateConstructor.prototype;
+var dateGetTime = datePrototype.getTime.call.bind(datePrototype.getTime);
+var dateToISOString = datePrototype.toISOString.call.bind(datePrototype.toISOString);
+var bigintToString = BigInt.prototype.toString.call.bind(BigInt.prototype.toString);
+var stringSlice = String.prototype.slice.call.bind(String.prototype.slice);
+var weakMapGet = WeakMap.prototype.get.call.bind(WeakMap.prototype.get);
+var weakMapSet = WeakMap.prototype.set.call.bind(WeakMap.prototype.set);
+var WeakMapConstructor = WeakMap;
+var utf8Encoder = new TextEncoder();
+var encodeUtf8 = TextEncoder.prototype.encode.bind(utf8Encoder);
+var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+var typedArrayByteLengthGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength")?.get;
+if (!typedArrayByteLengthGetter) throw new Error("TypedArray byteLength getter is unavailable");
+var typedArrayByteLength = typedArrayByteLengthGetter.call.bind(typedArrayByteLengthGetter);
+var JSON_SAFE_MAX_DEPTH = 32;
+var JSON_SAFE_MAX_NODES = 1e4;
+var JSON_SAFE_MAX_COLLECTION_ENTRIES = 1e4;
+var JSON_SAFE_MAX_STRING_LENGTH = 64 * 1024;
+var JSON_SAFE_MAX_PROPERTY_KEY_LENGTH = JSON_SAFE_MAX_STRING_LENGTH;
+var JSON_SAFE_MAX_PROPERTY_KEY_BYTES = 256 * 1024;
+var JSON_SAFE_MAX_SERIALIZED_BYTES = 256 * 1024;
+var JsonSafeValueError = class extends Error {
+  /**
+   * Create a bounded normalization error.
+   *
+   * @param code Stable normalization failure code.
+   * @param message Human-readable bounded failure description.
+   */
+  constructor(code, message) {
+    super(message);
+    objectDefineProperty(this, "name", {
+      value: "JsonSafeValueError",
+      writable: true,
+      configurable: true
+    });
+    objectDefineProperty(this, "code", {
+      value: code,
+      writable: true,
+      configurable: true
+    });
+  }
+};
+function fail(code, message) {
+  throw new JsonSafeValueError(code, message);
+}
+function propertyAccess(operation, path8) {
+  try {
+    return operation();
+  } catch {
+    fail("PROPERTY_ACCESS_FAILED", `Unable to inspect JSON-safe value at ${path8}`);
+  }
+}
+function serializedStringBytes(value) {
+  if (value.length > JSON_SAFE_MAX_STRING_LENGTH) {
+    fail("MAX_STRING_LENGTH", `JSON-safe string exceeds ${JSON_SAFE_MAX_STRING_LENGTH} characters`);
+  }
+  return typedArrayByteLength(encodeUtf8(stringifyJson(value)));
+}
+function validatePropertyKey(key5) {
+  if (key5.length > JSON_SAFE_MAX_PROPERTY_KEY_LENGTH) {
+    fail(
+      "MAX_STRING_LENGTH",
+      `JSON-safe property key exceeds ${JSON_SAFE_MAX_PROPERTY_KEY_LENGTH} characters`
+    );
+  }
+}
+function chargePropertyKey(state, key5) {
+  state.propertyKeyBytes += typedArrayByteLength(encodeUtf8(key5));
+  if (state.propertyKeyBytes > JSON_SAFE_MAX_PROPERTY_KEY_BYTES) {
+    fail(
+      "MAX_PROPERTY_KEY_BYTES",
+      `JSON-safe property keys exceed ${JSON_SAFE_MAX_PROPERTY_KEY_BYTES} traversed UTF-8 bytes`
+    );
+  }
+}
+function chargeBytes(state, bytes) {
+  state.serializedBytes += bytes;
+  if (state.serializedBytes > JSON_SAFE_MAX_SERIALIZED_BYTES) {
+    fail(
+      "MAX_SERIALIZED_BYTES",
+      `JSON-safe value exceeds ${JSON_SAFE_MAX_SERIALIZED_BYTES} serialized bytes`
+    );
+  }
+}
+function chargeString(state, value) {
+  chargeBytes(state, serializedStringBytes(value));
+}
+function objectPropertyPath(path8, key5) {
+  const boundedKey = key5.length > 128 ? `${stringSlice(key5, 0, 128)}...` : key5;
+  return `${path8}[${stringifyJson(boundedKey)}]`;
+}
+function convertJsonValue(value, state, depth, inArray, path8) {
+  state.nodes += 1;
+  if (state.nodes > JSON_SAFE_MAX_NODES) {
+    fail("MAX_NODES", `JSON-safe value exceeds ${JSON_SAFE_MAX_NODES} total nodes`);
+  }
+  if (typeof value === "string") {
+    chargeString(state, value);
+    return value;
+  }
+  if (value === null) {
+    chargeBytes(state, 4);
+    return value;
+  }
+  if (typeof value === "boolean") {
+    chargeBytes(state, value ? 4 : 5);
+    return value;
+  }
+  if (typeof value === "number") {
+    const normalized = numberIsFinite(value) ? objectIs(value, -0) ? 0 : value : null;
+    chargeBytes(state, normalized === null ? 4 : stringifyJson(normalized).length);
+    return normalized;
+  }
+  if (typeof value === "bigint") {
+    const normalized = bigintToString(value);
+    chargeString(state, normalized);
+    return normalized;
+  }
+  if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") {
+    if (inArray) chargeBytes(state, 4);
+    return inArray ? null : void 0;
+  }
+  const isDate = propertyAccess(() => isPrototypeOf(datePrototype, value), path8);
+  if (isDate) {
+    const time = propertyAccess(() => dateGetTime(value), path8);
+    if (numberIsNaN(time)) {
+      chargeBytes(state, 4);
+      return null;
+    }
+    const normalized = propertyAccess(() => dateToISOString(value), path8);
+    chargeString(state, normalized);
+    return normalized;
+  }
+  if (depth > JSON_SAFE_MAX_DEPTH) {
+    fail("MAX_DEPTH", `JSON-safe value exceeds maximum depth ${JSON_SAFE_MAX_DEPTH}`);
+  }
+  const referenceState = weakMapGet(state.references, value);
+  if (referenceState === "visiting") {
+    chargeString(state, CIRCULAR_VALUE);
+    return CIRCULAR_VALUE;
+  }
+  if (referenceState === "visited") {
+    chargeString(state, REPEATED_VALUE);
+    return REPEATED_VALUE;
+  }
+  weakMapSet(state.references, value, "visiting");
+  if (propertyAccess(() => arrayIsArray(value), path8)) {
+    const arrayValue = value;
+    const length = propertyAccess(
+      () => arrayValue.length,
+      path8
+    );
+    if (typeof length !== "number" || !numberIsSafeInteger(length) || length < 0) {
+      fail("PROPERTY_ACCESS_FAILED", `Unable to inspect JSON-safe array length at ${path8}`);
+    }
+    if (length > JSON_SAFE_MAX_COLLECTION_ENTRIES) {
+      fail(
+        "COLLECTION_TOO_LARGE",
+        `JSON-safe array exceeds ${JSON_SAFE_MAX_COLLECTION_ENTRIES} entries`
+      );
+    }
+    chargeBytes(state, 2 + mathMax(0, length - 1));
+    const result2 = arrayFrom({ length }, (_, index) => {
+      const entryPath = `${path8}[${index}]`;
+      const hasEntry = propertyAccess(
+        () => hasOwnProperty(arrayValue, index),
+        entryPath
+      );
+      if (!hasEntry) {
+        chargeBytes(state, 4);
+        return null;
+      }
+      const entry = propertyAccess(() => arrayValue[index], entryPath);
+      return convertJsonValue(entry, state, depth + 1, true, `${path8}[${index}]`);
+    });
+    objectDefineProperty(result2, "toJSON", {
+      value: void 0,
+      configurable: true,
+      writable: true
+    });
+    weakMapSet(state.references, value, "visited");
+    return result2;
+  }
+  const keys = propertyAccess(() => reflectOwnKeys(value), path8);
+  if (keys.length > JSON_SAFE_MAX_COLLECTION_ENTRIES) {
+    fail(
+      "COLLECTION_TOO_LARGE",
+      `JSON-safe object exceeds ${JSON_SAFE_MAX_COLLECTION_ENTRIES} own keys`
+    );
+  }
+  for (let index = 0; index < keys.length; index += 1) {
+    const key5 = keys[index];
+    if (typeof key5 !== "string") continue;
+    validatePropertyKey(key5);
+    chargePropertyKey(state, key5);
+  }
+  chargeBytes(state, 2);
+  const result = objectCreate(null);
+  let emittedProperties = 0;
+  for (let index = 0; index < keys.length; index += 1) {
+    const key5 = keys[index];
+    const entryPath = typeof key5 === "string" ? objectPropertyPath(path8, key5) : path8;
+    const descriptor = propertyAccess(
+      () => reflectGetOwnPropertyDescriptor(value, key5),
+      entryPath
+    );
+    if (typeof key5 !== "string" || !descriptor?.enumerable) continue;
+    const entry = propertyAccess(() => reflectGet(value, key5), entryPath);
+    const converted = convertJsonValue(entry, state, depth + 1, false, entryPath);
+    if (converted !== void 0) {
+      chargeBytes(state, serializedStringBytes(key5) + 1 + (emittedProperties === 0 ? 0 : 1));
+      propertyAccess(() => objectDefineProperty(result, key5, {
+        value: converted,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      }), entryPath);
+      emittedProperties += 1;
+    }
+  }
+  weakMapSet(state.references, value, "visited");
+  return result;
+}
+function toJsonSafeValue(value) {
+  const state = {
+    nodes: 0,
+    propertyKeyBytes: 0,
+    serializedBytes: 0,
+    references: new WeakMapConstructor()
+  };
+  const converted = convertJsonValue(value, state, 0, false, "$");
+  if (converted === void 0) chargeBytes(state, 4);
+  const result = converted ?? null;
+  const serialized = propertyAccess(() => stringifyJson(result), "$");
+  if (typedArrayByteLength(encodeUtf8(serialized)) > JSON_SAFE_MAX_SERIALIZED_BYTES) {
+    fail(
+      "MAX_SERIALIZED_BYTES",
+      `JSON-safe value exceeds ${JSON_SAFE_MAX_SERIALIZED_BYTES} serialized bytes`
+    );
+  }
+  return result;
+}
+
+// src/util/truncateForJson.ts
+var TRUNCATION_MARKER = "...[truncated]";
+function truncateString(value, cap) {
+  if (value.length <= cap) return value;
+  const budget = Math.max(0, cap - TRUNCATION_MARKER.length);
+  return value.slice(0, budget) + TRUNCATION_MARKER;
+}
+function truncateValue(value, depth, maxDepth, maxEntries, maxStringLength, seen) {
+  if (typeof value === "string") return truncateString(value, maxStringLength);
+  if (value === null || typeof value !== "object") return value;
+  if (depth >= maxDepth) return "[truncated:max-depth]";
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  try {
+    if (value instanceof Date) return value.toISOString();
+    if (Array.isArray(value)) {
+      const limit2 = Math.min(value.length, maxEntries);
+      const output2 = [];
+      for (let index = 0; index < limit2; index += 1) {
+        output2.push(truncateValue(value[index], depth + 1, maxDepth, maxEntries, maxStringLength, seen));
+      }
+      if (value.length > limit2) output2.push("[truncated:entries]");
+      return output2;
+    }
+    const record = value;
+    const output = {};
+    const keys = Object.keys(record);
+    const limit = Math.min(keys.length, maxEntries);
+    for (let index = 0; index < limit; index += 1) {
+      const key5 = keys[index];
+      output[truncateString(key5, maxStringLength)] = truncateValue(
+        record[key5],
+        depth + 1,
+        maxDepth,
+        maxEntries,
+        maxStringLength,
+        seen
+      );
+    }
+    if (keys.length > limit) output["[truncated]"] = true;
+    return output;
+  } finally {
+    seen.delete(value);
+  }
+}
+function truncateForJson(value, options = {}) {
+  return truncateValue(
+    value,
+    0,
+    options.maxDepth ?? JSON_SAFE_MAX_DEPTH,
+    options.maxEntries ?? JSON_SAFE_MAX_COLLECTION_ENTRIES,
+    options.maxStringLength ?? JSON_SAFE_MAX_STRING_LENGTH,
+    /* @__PURE__ */ new WeakSet()
+  );
+}
+
 // src/services/Agent.ts
 import { descriptorDataValue } from "@axiom-lattice/protocols";
 import { Command as Command2 } from "@langchain/langgraph";
@@ -16698,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";
@@ -16945,6 +17550,27 @@ function statusFromSnapshot(state) {
   if (Array.isArray(state.next) && state.next.length > 0) return "busy" /* BUSY */;
   return "idle" /* IDLE */;
 }
+var MAX_EXECUTION_ERROR_LENGTH = 2e3;
+function executionErrorFromSnapshot(state) {
+  if (!isPlainRecord(state) || !Array.isArray(state.tasks)) return void 0;
+  for (const task of state.tasks) {
+    if (!isPlainRecord(task) || task.error === void 0 || task.error === null) continue;
+    const raw = task.error;
+    const message = typeof raw === "string" ? raw : raw instanceof Error ? raw.message : isPlainRecord(raw) && typeof raw.message === "string" ? raw.message : (() => {
+      try {
+        return JSON.stringify(raw);
+      } catch {
+        return String(raw);
+      }
+    })();
+    if (typeof message !== "string") continue;
+    const trimmed = message.trim();
+    if (trimmed.length === 0) continue;
+    const bounded = truncateForJson(trimmed, { maxStringLength: MAX_EXECUTION_ERROR_LENGTH });
+    if (typeof bounded === "string" && bounded.length > 0) return bounded;
+  }
+  return void 0;
+}
 function freshReply(state, preRunMarker, inputMessageId, consumedInputMessageIds) {
   const output = finalAiMessageMarker(state);
   if (output?.text === void 0 || output.index <= (preRunMarker?.index ?? -1) || output.totalMessageCount <= (preRunMarker?.totalMessageCount ?? 0)) return void 0;
@@ -16994,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));
@@ -17023,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(
@@ -17139,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();
@@ -17224,7 +17861,7 @@ var Agent = class {
                   state
                 });
               } else if (runStatus === "error" /* ERROR */) {
-                const failureReason = "Agent execution ended in an error state";
+                const failureReason = executionErrorFromSnapshot(state) ?? "Agent execution ended in an error state";
                 this.addChunk({
                   type: "message_failed",
                   data: { id: humanContent.id, content: failureReason }
@@ -17337,7 +17974,7 @@ var Agent = class {
               }
               if (runStatus === "busy" /* BUSY */) return;
               if (runStatus === "error" /* ERROR */) {
-                const failureReason = "Agent execution ended in an error state";
+                const failureReason = executionErrorFromSnapshot(state) ?? "Agent execution ended in an error state";
                 for (const p of collectPendings) {
                   const messageId = p.content.id;
                   this.addChunk({
@@ -17438,7 +18075,7 @@ var Agent = class {
                   });
                   if (p.execution_mode === "followup") return;
                 } else if (runStatus === "error" /* ERROR */) {
-                  const failureReason = "Agent execution ended in an error state";
+                  const failureReason = executionErrorFromSnapshot(state) ?? "Agent execution ended in an error state";
                   this.addChunk({
                     type: "message_failed",
                     data: { id: humanContent.id, content: failureReason }
@@ -17745,12 +18382,17 @@ var Agent = class {
       capabilityRuntimeRevision: capabilityRuntime.revision,
       tenantId: this.tenant_id,
       workspaceId: this.workspace_id,
-      projectId: this.project_id,
+      // The propagated project scope must not fabricate `"default"`:
+      // `queue_project_id` is `null` when the run had no project, so an unscoped
+      // run stays unscoped instead of later querying a project that may not
+      // exist. An explicitly passed `"default"` is a real project for some
+      // tenants and is preserved.
+      projectId: this.queue_project_id ?? void 0,
       assistant_id: this.assistant_id,
       thread_id: this.thread_id,
       "x-tenant-id": this.tenant_id,
       "x-workspace-id": this.workspace_id,
-      "x-project-id": this.project_id,
+      "x-project-id": this.queue_project_id ?? void 0,
       "x-thread-id": this.thread_id,
       "x-assistant-id": this.assistant_id
     };
@@ -17965,6 +18607,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 */,
@@ -17990,6 +18655,8 @@ var Agent = class {
    */
   stopQueueProcessor() {
     this.cancelQueueProcessorRetry();
+    this.cancelThreadRunLeaseRetry();
+    void this.releaseThreadRunLease();
     this.clearRecoveryBlock();
     this.queueProcessorGeneration += 1;
     if (this.abortController) {
@@ -18095,7 +18762,15 @@ var Agent = class {
       if (!accepted) throw new Error(`Queue is full (max ${maxSize} messages)`);
       if (useMode === "steer" /* STEER */ && !queueMessage.command) {
         this.stopQueueProcessor();
-        await store.resetProcessingToPending(this.thread_id, this.queueScope());
+        let runStatus;
+        try {
+          runStatus = await this.getRunStatus();
+        } catch {
+          runStatus = void 0;
+        }
+        if (runStatus !== "interrupted" /* INTERRUPTED */) {
+          await store.resetProcessingToPending(this.thread_id, this.queueScope());
+        }
         console.log(`[Agent] STEER mode: stopped current processing, reset queue, message ${messageId} will execute next`);
       }
     } else {
@@ -18129,16 +18804,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);
@@ -18156,7 +18865,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);
@@ -18169,7 +18882,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()
@@ -18181,12 +18898,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) {
@@ -18224,6 +18949,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());
@@ -18368,6 +19123,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();
@@ -18411,7 +19198,7 @@ var Agent = class {
           }
         } else if (resumedStatus === "error" /* ERROR */) {
           this.clearRecoveryBlock();
-          const failureReason = "Agent execution ended in an error state";
+          const failureReason = executionErrorFromSnapshot(state) ?? "Agent execution ended in an error state";
           for (const msg of processingMessages) {
             this.addChunk({ type: "message_failed", data: { id: msg.id, content: failureReason } });
             this.publish("message:failed", {
@@ -18447,7 +19234,7 @@ var Agent = class {
     } else if (runStatus === "error" /* ERROR */) {
       this.processingExecutionContext(processingMessages);
       this.clearRecoveryBlock();
-      const failureReason = "Agent execution ended in an error state";
+      const failureReason = executionErrorFromSnapshot(preRunState) ?? "Agent execution ended in an error state";
       for (const msg of processingMessages) {
         this.addChunk({ type: "message_failed", data: { id: msg.id, content: failureReason } });
         this.publish("message:failed", {
@@ -18483,6 +19270,8 @@ var Agent = class {
    */
   async abort() {
     this.cancelQueueProcessorRetry();
+    this.cancelThreadRunLeaseRetry();
+    await this.releaseThreadRunLease();
     this.clearRecoveryBlock();
     this.queueProcessorGeneration += 1;
     if (this.abortController) {
@@ -18593,8 +19382,19 @@ var AgentInstanceManager = class _AgentInstanceManager {
     }
     return _AgentInstanceManager._instance;
   }
+  /**
+   * A thread's identity is `(tenant_id, assistant_id, thread_id)`.
+   *
+   * Workspace/project are execution scope chosen when the instance is created,
+   * not part of identity: including them let the same thread exist as several
+   * Agents when callers defaulted optional workspace/project headers
+   * differently (e.g. `createRun` passing `undefined` while `abort` defaulted
+   * to `"default"`), so control-plane calls could address a different instance
+   * than the one running. `undefined`/`null` normalize to `""`; ids are assumed
+   * not to contain `:` (UUID-shaped in practice).
+   */
   getKey(params) {
-    return `${params.tenant_id}:${params.assistant_id}:${params.thread_id}:${params.workspace_id}:${params.project_id}`;
+    return [params.tenant_id, params.assistant_id, params.thread_id].map((value) => value ?? "").join(":");
   }
   /**
    * Get or create Agent instance for a thread
@@ -18608,6 +19408,24 @@ var AgentInstanceManager = class _AgentInstanceManager {
     }
     return this.agents.get(key5);
   }
+  /**
+   * Get the managed Agent for a thread WITHOUT creating or registering one.
+   *
+   * Read-only control-plane callers (state, memory, inbox) must not be the first
+   * to establish a thread's execution scope: since identity is
+   * `(tenant_id, assistant_id, thread_id)`, whichever caller reaches
+   * {@link getAgent} first fixes the instance's workspace/project for its whole
+   * lifetime, and a later trusted dispatch on that thread would then fail
+   * trusted-scope validation. This returns the existing managed instance when
+   * present, otherwise a transient unregistered Agent that is sufficient for
+   * state reads and disappears with the request.
+   *
+   * @param params - Thread identity; scope is only used for the transient Agent.
+   * @returns The managed instance if any, else an unregistered read-only Agent.
+   */
+  getAgentForRead(params) {
+    return this.agents.get(this.getKey(params)) ?? new Agent(params);
+  }
   /**
    * Check if an agent instance exists for the thread
    */
@@ -18643,55 +19461,6 @@ var AgentInstanceManager = class _AgentInstanceManager {
     });
     this.agents.clear();
   }
-  /**
-   * Restore agent instances for threads with pending messages after server restart
-   * Queries the message queue store for threads with pending/processing messages
-   * and recreates agent instances to resume processing
-   */
-  async restore() {
-    const stats = { restored: 0, errors: 0 };
-    try {
-      const queueStoreLattice = storeLatticeManager.getStoreLattice("default", "threadMessageQueue");
-      const queueStore = queueStoreLattice.store;
-      const threadsWithPending = await queueStore.getThreadsWithPendingMessages();
-      if (threadsWithPending.length === 0) {
-        console.log("[AgentInstanceManager] No threads with pending messages found");
-        return stats;
-      }
-      console.log(`[AgentInstanceManager] Found ${threadsWithPending.length} threads with pending messages, restoring...`);
-      for (const threadInfo of threadsWithPending) {
-        try {
-          await this.restoreThread(threadInfo);
-          stats.restored++;
-        } catch (error) {
-          console.error(`[AgentInstanceManager] Failed to restore thread ${threadInfo.threadId}:`, error);
-          stats.errors++;
-        }
-      }
-      console.log(`[AgentInstanceManager] Restore complete: ${stats.restored} restored, ${stats.errors} errors`);
-      return stats;
-    } catch (error) {
-      console.error("[AgentInstanceManager] Restore failed:", error);
-      throw error;
-    }
-  }
-  /**
-   * Restore a single thread
-   * Delegates actual recovery logic to Agent.resumeTask()
-   */
-  async restoreThread(threadInfo) {
-    const { tenantId: tenantId2, assistantId, threadId, workspaceId, projectId } = threadInfo;
-    const threadParams = {
-      tenant_id: tenantId2,
-      assistant_id: assistantId,
-      thread_id: threadId,
-      workspace_id: workspaceId,
-      project_id: projectId
-    };
-    const agent = this.getAgent(threadParams);
-    await agent.resumeTask();
-    console.log(`[AgentInstanceManager] Restored thread ${threadId}`);
-  }
 };
 var agentInstanceManager = AgentInstanceManager.getInstance();
 
@@ -19162,27 +19931,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();
@@ -19193,21 +19962,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)}`;
       }
@@ -19280,25 +20049,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
           });
@@ -19547,6 +20316,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
    */
@@ -19911,6 +20722,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();
@@ -20151,6 +20963,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) {
@@ -20211,6 +21036,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(
@@ -20222,9 +21057,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);
@@ -24938,8 +25770,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);
   }
   /**
@@ -24975,7 +25807,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
@@ -27677,7 +28509,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];
@@ -28274,7 +29209,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();
@@ -28295,7 +29230,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,
@@ -30807,9 +31742,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;
     })();
@@ -30827,9 +31762,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 {
   }
@@ -30841,9 +31776,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 {
   }
@@ -30853,9 +31788,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 {
   }
@@ -33170,7 +34105,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
@@ -33197,6 +34132,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}'`);
@@ -33369,7 +34330,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}
@@ -33634,7 +34595,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);
@@ -35010,6 +35971,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.
    *
@@ -35030,6 +35995,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();
@@ -35094,6 +36078,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.
    *
@@ -35113,6 +36101,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}`;
@@ -35182,8 +36194,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")) {
@@ -35199,9 +36340,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);
     }
@@ -35259,7 +36403,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",
@@ -35347,7 +36491,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,
@@ -35687,6 +36831,8 @@ function buildParentBeliefActivity(input) {
 }
 
 // src/services/TaskLifecycleService.ts
+var WORK_ITEM_WRITE_ATTEMPTS = 3;
+var WORK_ITEM_WRITE_RETRY_DELAYS_MS = [20, 50];
 var RETRYABLE_LIFECYCLE_CODES = /* @__PURE__ */ new Set([
   "TASK_STATUS_CONFLICT",
   "TASK_STORE_WRITE_FAILED",
@@ -35706,9 +36852,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;
@@ -35837,14 +36983,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)}`;
@@ -36053,7 +37199,8 @@ var TaskLifecycleService = class {
       const resumeKey = this.resumeEventKey(task);
       const audit = { eventKey: resumeKey, previousInterruption };
       const context = withLifecycleAudit(task.context, "lifecycle_resume_audit", audit);
-      if (input.threadId && !task.context?.thread_id) context.thread_id = input.threadId;
+      if (input.threadId) context.thread_id = input.threadId;
+      if (input.runId) context.run_id = input.runId;
       const updated = await this.deps.taskStore.updateIfStatusAndUpdatedAt(
         input.tenantId,
         input.taskId,
@@ -36150,7 +37297,13 @@ var TaskLifecycleService = class {
     if (task.status !== "pending") {
       return { ...failure2("TASK_STATUS_CONFLICT", "Task cannot start."), transitioned: false };
     }
-    const context = { ...task.context ?? {}, ...input.threadId ? { thread_id: input.threadId } : {} };
+    const context = {
+      ...task.context ?? {},
+      ...input.threadId ? { thread_id: input.threadId } : {},
+      ...input.runId ? { run_id: input.runId } : {},
+      ...input.callerThreadId ? { caller_thread_id: input.callerThreadId } : {},
+      ...input.callerAssistantId ? { caller_assistant_id: input.callerAssistantId } : {}
+    };
     let updated;
     try {
       updated = await this.deps.taskStore.updateIfStatusAndUpdatedAt(
@@ -36226,7 +37379,9 @@ var TaskLifecycleService = class {
       expectedStatuses: ["failed"],
       updates: { status: "in_progress", failureReason: null },
       summary: "Task retried",
-      detail: { previousStatus: "failed" }
+      detail: { previousStatus: "failed" },
+      // A retry dispatches a new run thread; replace a stale persisted link.
+      replaceThread: true
     });
   }
   /**
@@ -37202,8 +38357,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 {
@@ -37712,7 +38867,9 @@ var TaskLifecycleService = class {
     }
     if (!input.expectedStatuses.includes(task.status)) return failure2("TASK_STATUS_CONFLICT", "Task status cannot make this transition.");
     const clearedContext = clearInterruptionContext(task.context);
-    const withThread = input.threadId && task.context?.thread_id === void 0 ? { ...clearedContext ?? {}, thread_id: input.threadId } : clearedContext;
+    const threadInput = input.threadId && (input.replaceThread || task.context?.thread_id === void 0) ? { thread_id: input.threadId } : {};
+    const runInput = input.runId ? { run_id: input.runId } : {};
+    const withThread = Object.keys(threadInput).length > 0 || Object.keys(runInput).length > 0 ? { ...clearedContext ?? {}, ...threadInput, ...runInput } : clearedContext;
     const updates = { ...input.updates, context: withThread };
     let updated;
     try {
@@ -37750,6 +38907,31 @@ var TaskLifecycleService = class {
   statusEventKey(task, status, detail) {
     return `task-lifecycle:${task.id}:${status}:${task.updatedAt.toISOString()}:${sha256(detail)}`;
   }
+  /**
+   * Writes a lifecycle work-item event, retrying transient store failures.
+   *
+   * @param request Event request passed through to the work-item store.
+   * @returns The persisted or pre-existing work item.
+   * @remarks The write is idempotent by `eventKey`
+   * (`createIfAbsentByEventKey`), so retrying after a transient failure (pool
+   * exhaustion, shutdown, statement timeout, disk IO) is safe. The status CAS has
+   * already committed by this point, and the event key embeds `updatedAt`, so a
+   * lost event cannot be reconstructed later — hence the bounded retry.
+   */
+  async writeWorkItemWithRetry(request) {
+    let lastError;
+    for (let attempt = 0; attempt < WORK_ITEM_WRITE_ATTEMPTS; attempt += 1) {
+      if (attempt > 0) {
+        await new Promise((resolve4) => setTimeout(resolve4, WORK_ITEM_WRITE_RETRY_DELAYS_MS[attempt - 1]));
+      }
+      try {
+        return await this.deps.workItemStore.createIfAbsentByEventKey(request);
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    throw lastError;
+  }
   async writeStatusEvent(task, actor, threadId, action, summary, detail, eventKey) {
     const warningCode = `${action.toUpperCase()}_WORK_ITEM_WRITE_FAILED`;
     const request = {
@@ -37765,7 +38947,7 @@ var TaskLifecycleService = class {
       eventKey
     };
     try {
-      const item = await this.deps.workItemStore.createIfAbsentByEventKey(request);
+      const item = await this.writeWorkItemWithRetry(request);
       if (item.eventKey !== request.eventKey) throw new Error("Canonical lifecycle event key mismatch");
       return { eventKey: item.eventKey };
     } catch {
@@ -37896,7 +39078,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";
 
@@ -37951,7 +39133,7 @@ function createTaskRunBridge(deps) {
       return { success: true, task: updated };
     },
     async beginRun(input) {
-      const { tenantId: tenantId2, actor, threadId } = input;
+      const { tenantId: tenantId2, actor, threadId, runId, callerThreadId, callerAssistantId } = input;
       let task = input.task;
       const warnings = [];
       if (task.status === "pending") {
@@ -37960,7 +39142,10 @@ function createTaskRunBridge(deps) {
             tenantId: tenantId2,
             taskId: task.id,
             actor,
-            threadId
+            ...threadId !== void 0 ? { threadId } : {},
+            ...runId !== void 0 ? { runId } : {},
+            ...callerThreadId ? { callerThreadId } : {},
+            ...callerAssistantId ? { callerAssistantId } : {}
           });
           if (!started.success) {
             return {
@@ -38048,7 +39233,19 @@ function createTaskRunBridge(deps) {
             error: "Lifecycle transitions only support agent tasks."
           };
         }
-        const result = task.status === "interrupted" ? await deps.lifecycle.resumeInterruption({ tenantId: tenantId2, taskId: task.id, actor, threadId }) : await deps.lifecycle.retryTask({ tenantId: tenantId2, taskId: task.id, actor, threadId });
+        const result = task.status === "interrupted" ? await deps.lifecycle.resumeInterruption({
+          tenantId: tenantId2,
+          taskId: task.id,
+          actor,
+          ...threadId !== void 0 ? { threadId } : {},
+          ...runId !== void 0 ? { runId } : {}
+        }) : await deps.lifecycle.retryTask({
+          tenantId: tenantId2,
+          taskId: task.id,
+          actor,
+          ...threadId !== void 0 ? { threadId } : {},
+          ...runId !== void 0 ? { runId } : {}
+        });
         if (!result.success) {
           return {
             success: false,
@@ -38113,6 +39310,132 @@ function createTaskRunBridge(deps) {
   };
 }
 
+// src/services/TaskRunRegistry.ts
+var TaskRunRegistry = class {
+  constructor() {
+    this.live = /* @__PURE__ */ new Set();
+  }
+  /** Marks a task as currently held by a live run. */
+  register(taskId) {
+    this.live.add(taskId);
+  }
+  /** Removes a task once its run has ended. */
+  unregister(taskId) {
+    this.live.delete(taskId);
+  }
+  /** Reports whether a task is currently held by a live run. */
+  isLive(taskId) {
+    return this.live.has(taskId);
+  }
+  /** Returns a snapshot of the live task ids (diagnostics/tests). */
+  snapshot() {
+    return [...this.live];
+  }
+  /** Clears all live entries (tests / process teardown). */
+  clear() {
+    this.live.clear();
+  }
+};
+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,
+      actor: input.actor,
+      failureReason: "Run is no longer executing this task (no_executor)"
+    });
+    if (result.success) {
+      converged.push(task.id);
+      convergedTasks.push(result.task);
+    }
+  }
+  return { converged, convergedTasks };
+}
+async function reconcileTenantTaskRuns(input) {
+  const tasks = await input.taskStore.list({ tenantId: input.tenantId, status: "in_progress" });
+  const candidates = input.include ? tasks.filter(input.include) : tasks;
+  return reconcileStaleTaskRuns({
+    tasks: candidates,
+    actor: input.actor,
+    lifecycle: input.lifecycle,
+    ...input.registry ? { registry: input.registry } : {},
+    ...input.isTaskLive ? { isTaskLive: input.isTaskLive } : {}
+  });
+}
+async function reconcileAllTenantTaskRuns(input) {
+  const tenants = await input.tenantStore.listTenants();
+  const converged = [];
+  const convergedTasks = [];
+  for (const tenant of tenants) {
+    let result;
+    try {
+      result = await reconcileTenantTaskRuns({
+        tenantId: tenant.id,
+        actor: input.actor,
+        taskStore: input.taskStore,
+        lifecycle: input.lifecycle,
+        ...input.registry ? { registry: input.registry } : {},
+        ...input.include ? { include: input.include } : {},
+        ...input.isTaskLive ? { isTaskLive: input.isTaskLive } : {}
+      });
+    } catch {
+      continue;
+    }
+    converged.push(...result.converged);
+    convergedTasks.push(...result.convergedTasks);
+  }
+  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 {
   /**
@@ -38374,276 +39697,23 @@ async function prepareTaskDispatch(deps, input) {
       agentId: input.agentId,
       actor: input.actor,
       ...input.callerThreadId !== void 0 ? { callerThreadId: input.callerThreadId } : {},
+      ...input.callerAssistantId !== void 0 ? { callerAssistantId: input.callerAssistantId } : {},
       parent,
       completedDependencies
     }
   };
 }
 
-// src/util/toJsonSafeValue.ts
-var CIRCULAR_VALUE = "[Circular]";
-var REPEATED_VALUE = "[Repeated]";
-var arrayFrom = Array.from.bind(Array);
-var arrayIsArray = Array.isArray.bind(Array);
-var hasOwnProperty = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty);
-var isPrototypeOf = Object.prototype.isPrototypeOf.call.bind(Object.prototype.isPrototypeOf);
-var objectCreate = Object.create.bind(Object);
-var objectDefineProperty = Object.defineProperty.bind(Object);
-var objectIs = Object.is.bind(Object);
-var reflectGet = Reflect.get.bind(Reflect);
-var reflectGetOwnPropertyDescriptor = Reflect.getOwnPropertyDescriptor.bind(Reflect);
-var reflectOwnKeys = Reflect.ownKeys.bind(Reflect);
-var stringifyJson = JSON.stringify.bind(JSON);
-var numberIsFinite = Number.isFinite.bind(Number);
-var numberIsNaN = Number.isNaN.bind(Number);
-var numberIsSafeInteger = Number.isSafeInteger.bind(Number);
-var mathMax = Math.max.bind(Math);
-var dateConstructor = Date;
-var datePrototype = dateConstructor.prototype;
-var dateGetTime = datePrototype.getTime.call.bind(datePrototype.getTime);
-var dateToISOString = datePrototype.toISOString.call.bind(datePrototype.toISOString);
-var bigintToString = BigInt.prototype.toString.call.bind(BigInt.prototype.toString);
-var stringSlice = String.prototype.slice.call.bind(String.prototype.slice);
-var weakMapGet = WeakMap.prototype.get.call.bind(WeakMap.prototype.get);
-var weakMapSet = WeakMap.prototype.set.call.bind(WeakMap.prototype.set);
-var WeakMapConstructor = WeakMap;
-var utf8Encoder = new TextEncoder();
-var encodeUtf8 = TextEncoder.prototype.encode.bind(utf8Encoder);
-var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
-var typedArrayByteLengthGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength")?.get;
-if (!typedArrayByteLengthGetter) throw new Error("TypedArray byteLength getter is unavailable");
-var typedArrayByteLength = typedArrayByteLengthGetter.call.bind(typedArrayByteLengthGetter);
-var JSON_SAFE_MAX_DEPTH = 32;
-var JSON_SAFE_MAX_NODES = 1e4;
-var JSON_SAFE_MAX_COLLECTION_ENTRIES = 1e4;
-var JSON_SAFE_MAX_STRING_LENGTH = 64 * 1024;
-var JSON_SAFE_MAX_PROPERTY_KEY_LENGTH = JSON_SAFE_MAX_STRING_LENGTH;
-var JSON_SAFE_MAX_PROPERTY_KEY_BYTES = 256 * 1024;
-var JSON_SAFE_MAX_SERIALIZED_BYTES = 256 * 1024;
-var JsonSafeValueError = class extends Error {
-  /**
-   * Create a bounded normalization error.
-   *
-   * @param code Stable normalization failure code.
-   * @param message Human-readable bounded failure description.
-   */
-  constructor(code, message) {
-    super(message);
-    objectDefineProperty(this, "name", {
-      value: "JsonSafeValueError",
-      writable: true,
-      configurable: true
-    });
-    objectDefineProperty(this, "code", {
-      value: code,
-      writable: true,
-      configurable: true
-    });
-  }
-};
-function fail(code, message) {
-  throw new JsonSafeValueError(code, message);
-}
-function propertyAccess(operation, path8) {
+// src/services/TaskExecutionService.ts
+import { GraphInterrupt as GraphInterrupt2 } from "@langchain/langgraph";
+var TASK_RUN_LEASE_TTL_MS = 12e4;
+function getLeaseStore() {
   try {
-    return operation();
+    return storeLatticeManager.getStoreLattice("default", "lease").store;
   } catch {
-    fail("PROPERTY_ACCESS_FAILED", `Unable to inspect JSON-safe value at ${path8}`);
-  }
-}
-function serializedStringBytes(value) {
-  if (value.length > JSON_SAFE_MAX_STRING_LENGTH) {
-    fail("MAX_STRING_LENGTH", `JSON-safe string exceeds ${JSON_SAFE_MAX_STRING_LENGTH} characters`);
-  }
-  return typedArrayByteLength(encodeUtf8(stringifyJson(value)));
-}
-function validatePropertyKey(key5) {
-  if (key5.length > JSON_SAFE_MAX_PROPERTY_KEY_LENGTH) {
-    fail(
-      "MAX_STRING_LENGTH",
-      `JSON-safe property key exceeds ${JSON_SAFE_MAX_PROPERTY_KEY_LENGTH} characters`
-    );
-  }
-}
-function chargePropertyKey(state, key5) {
-  state.propertyKeyBytes += typedArrayByteLength(encodeUtf8(key5));
-  if (state.propertyKeyBytes > JSON_SAFE_MAX_PROPERTY_KEY_BYTES) {
-    fail(
-      "MAX_PROPERTY_KEY_BYTES",
-      `JSON-safe property keys exceed ${JSON_SAFE_MAX_PROPERTY_KEY_BYTES} traversed UTF-8 bytes`
-    );
-  }
-}
-function chargeBytes(state, bytes) {
-  state.serializedBytes += bytes;
-  if (state.serializedBytes > JSON_SAFE_MAX_SERIALIZED_BYTES) {
-    fail(
-      "MAX_SERIALIZED_BYTES",
-      `JSON-safe value exceeds ${JSON_SAFE_MAX_SERIALIZED_BYTES} serialized bytes`
-    );
-  }
-}
-function chargeString(state, value) {
-  chargeBytes(state, serializedStringBytes(value));
-}
-function objectPropertyPath(path8, key5) {
-  const boundedKey = key5.length > 128 ? `${stringSlice(key5, 0, 128)}...` : key5;
-  return `${path8}[${stringifyJson(boundedKey)}]`;
-}
-function convertJsonValue(value, state, depth, inArray, path8) {
-  state.nodes += 1;
-  if (state.nodes > JSON_SAFE_MAX_NODES) {
-    fail("MAX_NODES", `JSON-safe value exceeds ${JSON_SAFE_MAX_NODES} total nodes`);
-  }
-  if (typeof value === "string") {
-    chargeString(state, value);
-    return value;
-  }
-  if (value === null) {
-    chargeBytes(state, 4);
-    return value;
-  }
-  if (typeof value === "boolean") {
-    chargeBytes(state, value ? 4 : 5);
-    return value;
-  }
-  if (typeof value === "number") {
-    const normalized = numberIsFinite(value) ? objectIs(value, -0) ? 0 : value : null;
-    chargeBytes(state, normalized === null ? 4 : stringifyJson(normalized).length);
-    return normalized;
-  }
-  if (typeof value === "bigint") {
-    const normalized = bigintToString(value);
-    chargeString(state, normalized);
-    return normalized;
-  }
-  if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") {
-    if (inArray) chargeBytes(state, 4);
-    return inArray ? null : void 0;
-  }
-  const isDate = propertyAccess(() => isPrototypeOf(datePrototype, value), path8);
-  if (isDate) {
-    const time = propertyAccess(() => dateGetTime(value), path8);
-    if (numberIsNaN(time)) {
-      chargeBytes(state, 4);
-      return null;
-    }
-    const normalized = propertyAccess(() => dateToISOString(value), path8);
-    chargeString(state, normalized);
-    return normalized;
-  }
-  if (depth > JSON_SAFE_MAX_DEPTH) {
-    fail("MAX_DEPTH", `JSON-safe value exceeds maximum depth ${JSON_SAFE_MAX_DEPTH}`);
-  }
-  const referenceState = weakMapGet(state.references, value);
-  if (referenceState === "visiting") {
-    chargeString(state, CIRCULAR_VALUE);
-    return CIRCULAR_VALUE;
-  }
-  if (referenceState === "visited") {
-    chargeString(state, REPEATED_VALUE);
-    return REPEATED_VALUE;
-  }
-  weakMapSet(state.references, value, "visiting");
-  if (propertyAccess(() => arrayIsArray(value), path8)) {
-    const arrayValue = value;
-    const length = propertyAccess(
-      () => arrayValue.length,
-      path8
-    );
-    if (typeof length !== "number" || !numberIsSafeInteger(length) || length < 0) {
-      fail("PROPERTY_ACCESS_FAILED", `Unable to inspect JSON-safe array length at ${path8}`);
-    }
-    if (length > JSON_SAFE_MAX_COLLECTION_ENTRIES) {
-      fail(
-        "COLLECTION_TOO_LARGE",
-        `JSON-safe array exceeds ${JSON_SAFE_MAX_COLLECTION_ENTRIES} entries`
-      );
-    }
-    chargeBytes(state, 2 + mathMax(0, length - 1));
-    const result2 = arrayFrom({ length }, (_, index) => {
-      const entryPath = `${path8}[${index}]`;
-      const hasEntry = propertyAccess(
-        () => hasOwnProperty(arrayValue, index),
-        entryPath
-      );
-      if (!hasEntry) {
-        chargeBytes(state, 4);
-        return null;
-      }
-      const entry = propertyAccess(() => arrayValue[index], entryPath);
-      return convertJsonValue(entry, state, depth + 1, true, `${path8}[${index}]`);
-    });
-    objectDefineProperty(result2, "toJSON", {
-      value: void 0,
-      configurable: true,
-      writable: true
-    });
-    weakMapSet(state.references, value, "visited");
-    return result2;
-  }
-  const keys = propertyAccess(() => reflectOwnKeys(value), path8);
-  if (keys.length > JSON_SAFE_MAX_COLLECTION_ENTRIES) {
-    fail(
-      "COLLECTION_TOO_LARGE",
-      `JSON-safe object exceeds ${JSON_SAFE_MAX_COLLECTION_ENTRIES} own keys`
-    );
-  }
-  for (let index = 0; index < keys.length; index += 1) {
-    const key5 = keys[index];
-    if (typeof key5 !== "string") continue;
-    validatePropertyKey(key5);
-    chargePropertyKey(state, key5);
-  }
-  chargeBytes(state, 2);
-  const result = objectCreate(null);
-  let emittedProperties = 0;
-  for (let index = 0; index < keys.length; index += 1) {
-    const key5 = keys[index];
-    const entryPath = typeof key5 === "string" ? objectPropertyPath(path8, key5) : path8;
-    const descriptor = propertyAccess(
-      () => reflectGetOwnPropertyDescriptor(value, key5),
-      entryPath
-    );
-    if (typeof key5 !== "string" || !descriptor?.enumerable) continue;
-    const entry = propertyAccess(() => reflectGet(value, key5), entryPath);
-    const converted = convertJsonValue(entry, state, depth + 1, false, entryPath);
-    if (converted !== void 0) {
-      chargeBytes(state, serializedStringBytes(key5) + 1 + (emittedProperties === 0 ? 0 : 1));
-      propertyAccess(() => objectDefineProperty(result, key5, {
-        value: converted,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      }), entryPath);
-      emittedProperties += 1;
-    }
-  }
-  weakMapSet(state.references, value, "visited");
-  return result;
-}
-function toJsonSafeValue(value) {
-  const state = {
-    nodes: 0,
-    propertyKeyBytes: 0,
-    serializedBytes: 0,
-    references: new WeakMapConstructor()
-  };
-  const converted = convertJsonValue(value, state, 0, false, "$");
-  if (converted === void 0) chargeBytes(state, 4);
-  const result = converted ?? null;
-  const serialized = propertyAccess(() => stringifyJson(result), "$");
-  if (typedArrayByteLength(encodeUtf8(serialized)) > JSON_SAFE_MAX_SERIALIZED_BYTES) {
-    fail(
-      "MAX_SERIALIZED_BYTES",
-      `JSON-safe value exceeds ${JSON_SAFE_MAX_SERIALIZED_BYTES} serialized bytes`
-    );
+    return void 0;
   }
-  return result;
 }
-
-// src/services/TaskExecutionService.ts
-import { GraphInterrupt as GraphInterrupt2 } from "@langchain/langgraph";
 function persistedExecutionObservation(item, attempted) {
   const detail = item.detail;
   const persistedObservation = toJsonSafeValue(detail?.observation);
@@ -38690,10 +39760,26 @@ function createTaskExecutionService(deps) {
   const run = async (plan) => {
     const { tenantId: tenantId2, agentId, actor, parent, completedDependencies } = plan;
     let task = plan.task;
-    const persistedThreadId = (task.status === "interrupted" || task.status === "failed") && typeof task.context?.thread_id === "string" && task.context.thread_id.trim() !== "" ? task.context.thread_id : void 0;
+    const storedThreadId = (task.status === "interrupted" || task.status === "failed") && typeof task.context?.thread_id === "string" && task.context.thread_id.trim() !== "" ? task.context.thread_id : void 0;
+    const storedRunId = typeof task.context?.run_id === "string" && task.context.run_id.trim() !== "" ? task.context.run_id : void 0;
+    let reuseCurrentRun = false;
+    if (task.status === "interrupted" && storedThreadId) {
+      const currentKey = storedRunId ? `execution-result:${storedThreadId}:${storedRunId}` : `execution-result:${storedThreadId}`;
+      try {
+        reuseCurrentRun = await deps.workItemStore.findByEventKey(tenantId2, task.id, currentKey) === null;
+      } catch {
+        reuseCurrentRun = false;
+      }
+    }
     let threadId;
+    let runId;
     try {
-      threadId = persistedThreadId ?? (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 ?? randomUUID11)();
+      }
     } catch (error) {
       return {
         success: false,
@@ -38703,7 +39789,7 @@ function createTaskExecutionService(deps) {
         agentId
       };
     }
-    const eventKey = `execution-result:${threadId}`;
+    const eventKey = runId ? `execution-result:${threadId}:${runId}` : `execution-result:${threadId}`;
     if (!isExecutionResultEventKey2(eventKey)) {
       return {
         success: false,
@@ -38737,7 +39823,10 @@ function createTaskExecutionService(deps) {
         tenantId: tenantId2,
         task,
         actor,
-        threadId
+        threadId,
+        ...runId ? { runId } : {},
+        ...plan.callerThreadId ? { callerThreadId: plan.callerThreadId } : {},
+        ...plan.callerAssistantId ? { callerAssistantId: plan.callerAssistantId } : {}
       });
       if (!begun.success) return { ...begun, taskId: task.id };
       if (!begun.mutated || !begun.transitioned) {
@@ -38751,38 +39840,134 @@ function createTaskExecutionService(deps) {
       task = begun.task;
       warnings.push(...begun.warnings);
     }
-    const invocation = {
-      tenantId: tenantId2,
-      workspaceId: task.workspaceId,
-      projectId: task.projectId,
-      taskId: task.id,
-      agentId,
-      threadId,
-      message: buildWorkerMessage(task, parent, completedDependencies),
-      delegatedTaskId: task.id,
-      taskExecutionRole: "worker"
-    };
-    let observation;
+    taskRunRegistry.register(task.id);
+    let taskRunLease = null;
     try {
-      observation = toJsonSafeValue(await deps.invokeAgent(invocation));
-    } catch (error) {
-      if (error instanceof GraphInterrupt2) {
+      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,
+        projectId: task.projectId,
+        taskId: task.id,
+        agentId,
+        threadId,
+        message: buildWorkerMessage(task, parent, completedDependencies),
+        delegatedTaskId: task.id,
+        taskExecutionRole: "worker"
+      };
+      let observation;
+      try {
+        observation = toJsonSafeValue(await deps.invokeAgent(invocation));
+      } catch (error) {
+        if (error instanceof GraphInterrupt2) {
+          try {
+            await bridge.settleRun({
+              tenantId: tenantId2,
+              task,
+              actor,
+              threadId,
+              outcome: { kind: "interrupted", summary: "Awaiting user input" }
+            });
+          } catch {
+          }
+          throw error;
+        }
+        const normalizationError = error instanceof JsonSafeValueError;
+        const message = normalizationError ? `${error.code}: ${error.message}` : errorMessage(error);
+        const failureCode = normalizationError ? "EXECUTION_RESULT_NORMALIZATION_FAILED" : "AGENT_INVOCATION_FAILED";
         try {
-          await bridge.settleRun({
+          const settled = await bridge.settleRun({
             tenantId: tenantId2,
             task,
             actor,
             threadId,
-            outcome: { kind: "interrupted", summary: "Awaiting user input" }
+            outcome: {
+              kind: "failed",
+              lifecycleHandled: false,
+              error: message.trim() || "Agent invocation failed"
+            }
           });
+          if (!settled.success) {
+            warnings.push({ code: "TASK_FAILED_SETTLE_FAILED", taskId: task.id });
+          }
         } catch {
+          warnings.push({ code: "TASK_FAILED_SETTLE_FAILED", taskId: task.id });
+        }
+        const failedObservation = toJsonSafeValue(normalizationError ? { code: failureCode, error: message } : { error: message });
+        try {
+          const persisted = await deps.workItemStore.createIfAbsentByEventKey({
+            taskId: task.id,
+            tenantId: tenantId2,
+            workspaceId: task.workspaceId,
+            projectId: task.projectId,
+            action: "execution_result",
+            actor,
+            threadId,
+            summary: normalizationError ? `Agent ${agentId} returned an invalid execution observation` : `Agent ${agentId} invocation failed`,
+            detail: {
+              agentId,
+              threadId,
+              observation: failedObservation,
+              success: false
+            },
+            eventKey
+          });
+          const validated = persistedExecutionObservation(persisted, {
+            tenantId: tenantId2,
+            taskId: task.id,
+            agentId,
+            threadId,
+            eventKey,
+            success: false,
+            observation: failedObservation
+          });
+          if (!validated.matches) {
+            return {
+              success: false,
+              code: "EXECUTION_RESULT_IDENTITY_CONFLICT",
+              error: "The execution result identity is already bound to a different execution payload",
+              ...!normalizationError ? { invocationError: message } : {},
+              taskId: task.id,
+              agentId,
+              threadId,
+              ...warnings.length > 0 ? { warnings } : {}
+            };
+          }
+          return {
+            success: false,
+            code: failureCode,
+            error: typeof validated.observation?.error === "string" ? validated.observation.error : message,
+            taskId: task.id,
+            agentId,
+            threadId,
+            executionResultId: eventKey,
+            ...warnings.length > 0 ? { warnings } : {}
+          };
+        } catch (persistenceError) {
+          return {
+            success: false,
+            code: "EXECUTION_RESULT_WRITE_FAILED",
+            error: errorMessage(persistenceError),
+            ...!normalizationError ? { invocationError: message } : {},
+            taskId: task.id,
+            agentId,
+            threadId,
+            ...warnings.length > 0 ? { warnings } : {}
+          };
         }
-        throw error;
       }
-      const normalizationError = error instanceof JsonSafeValueError;
-      const message = normalizationError ? `${error.code}: ${error.message}` : errorMessage(error);
-      const failureCode = normalizationError ? "EXECUTION_RESULT_NORMALIZATION_FAILED" : "AGENT_INVOCATION_FAILED";
-      const failedObservation = toJsonSafeValue(normalizationError ? { code: failureCode, error: message } : { error: message });
       try {
         const persisted = await deps.workItemStore.createIfAbsentByEventKey({
           taskId: task.id,
@@ -38792,13 +39977,8 @@ function createTaskExecutionService(deps) {
           action: "execution_result",
           actor,
           threadId,
-          summary: normalizationError ? `Agent ${agentId} returned an invalid execution observation` : `Agent ${agentId} invocation failed`,
-          detail: {
-            agentId,
-            threadId,
-            observation: failedObservation,
-            success: false
-          },
+          summary: `Agent ${agentId} returned an execution observation`,
+          detail: { agentId, threadId, observation, success: true },
           eventKey
         });
         const validated = persistedExecutionObservation(persisted, {
@@ -38807,15 +39987,14 @@ function createTaskExecutionService(deps) {
           agentId,
           threadId,
           eventKey,
-          success: false,
-          observation: failedObservation
+          success: true,
+          observation
         });
         if (!validated.matches) {
           return {
             success: false,
             code: "EXECUTION_RESULT_IDENTITY_CONFLICT",
             error: "The execution result identity is already bound to a different execution payload",
-            ...!normalizationError ? { invocationError: message } : {},
             taskId: task.id,
             agentId,
             threadId,
@@ -38823,80 +40002,28 @@ function createTaskExecutionService(deps) {
           };
         }
         return {
-          success: false,
-          code: failureCode,
-          error: typeof validated.observation?.error === "string" ? validated.observation.error : message,
+          success: true,
           taskId: task.id,
           agentId,
           threadId,
+          observation: validated.observation,
           executionResultId: eventKey,
           ...warnings.length > 0 ? { warnings } : {}
         };
-      } catch (persistenceError) {
+      } catch (error) {
         return {
           success: false,
           code: "EXECUTION_RESULT_WRITE_FAILED",
-          error: errorMessage(persistenceError),
-          ...!normalizationError ? { invocationError: message } : {},
-          taskId: task.id,
-          agentId,
-          threadId,
-          ...warnings.length > 0 ? { warnings } : {}
-        };
-      }
-    }
-    try {
-      const persisted = await deps.workItemStore.createIfAbsentByEventKey({
-        taskId: task.id,
-        tenantId: tenantId2,
-        workspaceId: task.workspaceId,
-        projectId: task.projectId,
-        action: "execution_result",
-        actor,
-        threadId,
-        summary: `Agent ${agentId} returned an execution observation`,
-        detail: { agentId, threadId, observation, success: true },
-        eventKey
-      });
-      const validated = persistedExecutionObservation(persisted, {
-        tenantId: tenantId2,
-        taskId: task.id,
-        agentId,
-        threadId,
-        eventKey,
-        success: true,
-        observation
-      });
-      if (!validated.matches) {
-        return {
-          success: false,
-          code: "EXECUTION_RESULT_IDENTITY_CONFLICT",
-          error: "The execution result identity is already bound to a different execution payload",
+          error: errorMessage(error),
           taskId: task.id,
           agentId,
           threadId,
           ...warnings.length > 0 ? { warnings } : {}
         };
       }
-      return {
-        success: true,
-        taskId: task.id,
-        agentId,
-        threadId,
-        observation: validated.observation,
-        executionResultId: eventKey,
-        ...warnings.length > 0 ? { warnings } : {}
-      };
-    } catch (error) {
-      return {
-        success: false,
-        code: "EXECUTION_RESULT_WRITE_FAILED",
-        error: errorMessage(error),
-        taskId: task.id,
-        agentId,
-        threadId,
-        ...warnings.length > 0 ? { warnings } : {}
-      };
+    } finally {
+      taskRunRegistry.unregister(task.id);
+      if (taskRunLease) await taskRunLease.release();
     }
   };
   return {
@@ -38909,74 +40036,41 @@ function createTaskExecutionService(deps) {
   };
 }
 
-// src/services/TaskRunRegistry.ts
-var TaskRunRegistry = class {
-  constructor() {
-    this.live = /* @__PURE__ */ new Set();
-  }
-  /** Marks a task as currently held by a live run. */
-  register(taskId) {
-    this.live.add(taskId);
-  }
-  /** Removes a task once its run has ended. */
-  unregister(taskId) {
-    this.live.delete(taskId);
-  }
-  /** Reports whether a task is currently held by a live run. */
-  isLive(taskId) {
-    return this.live.has(taskId);
-  }
-  /** Returns a snapshot of the live task ids (diagnostics/tests). */
-  snapshot() {
-    return [...this.live];
-  }
-  /** Clears all live entries (tests / process teardown). */
-  clear() {
-    this.live.clear();
-  }
-};
-var taskRunRegistry = new TaskRunRegistry();
-async function reconcileStaleTaskRuns(input) {
-  const registry4 = input.registry ?? taskRunRegistry;
-  const converged = [];
-  for (const task of input.tasks) {
-    if (task.status !== "in_progress" || registry4.isLive(task.id)) continue;
-    const result = await input.lifecycle.interruptTask({
-      tenantId: task.tenantId,
-      taskId: task.id,
-      actor: input.actor,
-      type: "missing_input",
-      summary: "Run is no longer executing this task (no_executor)"
-    });
-    if (result.success) converged.push(task.id);
+// 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);
   }
-  return { converged };
 }
-async function reconcileTenantTaskRuns(input) {
-  const tasks = await input.taskStore.list({ tenantId: input.tenantId, status: "in_progress" });
-  const candidates = input.include ? tasks.filter(input.include) : tasks;
-  return reconcileStaleTaskRuns({
-    tasks: candidates,
-    actor: input.actor,
-    lifecycle: input.lifecycle,
-    ...input.registry ? { registry: input.registry } : {}
-  });
+
+// 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 reconcileAllTenantTaskRuns(input) {
-  const tenants = await input.tenantStore.listTenants();
-  const converged = [];
-  for (const tenant of tenants) {
-    const result = await reconcileTenantTaskRuns({
-      tenantId: tenant.id,
-      actor: input.actor,
-      taskStore: input.taskStore,
-      lifecycle: input.lifecycle,
-      ...input.registry ? { registry: input.registry } : {},
-      ...input.include ? { include: input.include } : {}
-    });
-    converged.push(...result.converged);
+async function publishPluginCatalogChanged(tenantId2) {
+  if (!outbox || !tenantId2) return;
+  try {
+    await outbox.append({ topic: PLUGIN_CATALOG_CHANGED_TOPIC, payload: { tenantId: tenantId2 }, originReplicaId: owner });
+  } catch {
   }
-  return { converged };
 }
 
 // src/index.ts
@@ -39121,9 +40215,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;
             }
           }
@@ -39149,8 +40243,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;
@@ -39187,24 +40281,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
@@ -39266,10 +40360,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
@@ -39376,9 +40470,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}".`;
@@ -41178,61 +42272,28 @@ var widgetPlugin = {
 import { createMiddleware as createMiddleware23, tool as tool64 } from "langchain";
 import { z as z70 } from "zod";
 import { GraphInterrupt as GraphInterrupt3, interrupt as interrupt4 } from "@langchain/langgraph";
+import { resolveRunScope as resolveRunScope2 } from "@axiom-lattice/protocols";
 
-// src/util/truncateForJson.ts
-var TRUNCATION_MARKER = "...[truncated]";
-function truncateString(value, cap) {
-  if (value.length <= cap) return value;
-  const budget = Math.max(0, cap - TRUNCATION_MARKER.length);
-  return value.slice(0, budget) + TRUNCATION_MARKER;
+// src/services/taskWorkerRunConfig.ts
+import { firstNonEmptyString, resolveRunScope } from "@axiom-lattice/protocols";
+function resolveWorkerRunScope(input) {
+  const caller = resolveRunScope(input.runConfig);
+  return {
+    workspaceId: firstNonEmptyString(input.invocation.workspaceId) ?? caller.workspaceId,
+    projectId: firstNonEmptyString(input.invocation.projectId) ?? caller.projectId
+  };
 }
-function truncateValue(value, depth, maxDepth, maxEntries, maxStringLength, seen) {
-  if (typeof value === "string") return truncateString(value, maxStringLength);
-  if (value === null || typeof value !== "object") return value;
-  if (depth >= maxDepth) return "[truncated:max-depth]";
-  if (seen.has(value)) return "[Circular]";
-  seen.add(value);
-  try {
-    if (value instanceof Date) return value.toISOString();
-    if (Array.isArray(value)) {
-      const limit2 = Math.min(value.length, maxEntries);
-      const output2 = [];
-      for (let index = 0; index < limit2; index += 1) {
-        output2.push(truncateValue(value[index], depth + 1, maxDepth, maxEntries, maxStringLength, seen));
-      }
-      if (value.length > limit2) output2.push("[truncated:entries]");
-      return output2;
-    }
-    const record = value;
-    const output = {};
-    const keys = Object.keys(record);
-    const limit = Math.min(keys.length, maxEntries);
-    for (let index = 0; index < limit; index += 1) {
-      const key5 = keys[index];
-      output[truncateString(key5, maxStringLength)] = truncateValue(
-        record[key5],
-        depth + 1,
-        maxDepth,
-        maxEntries,
-        maxStringLength,
-        seen
-      );
-    }
-    if (keys.length > limit) output["[truncated]"] = true;
-    return output;
-  } finally {
-    seen.delete(value);
+function applyWorkerRunScope(runConfig, scope) {
+  const next = { ...runConfig };
+  if (scope.workspaceId !== void 0) {
+    next.workspaceId = scope.workspaceId;
+    next["x-workspace-id"] = scope.workspaceId;
   }
-}
-function truncateForJson(value, options = {}) {
-  return truncateValue(
-    value,
-    0,
-    options.maxDepth ?? JSON_SAFE_MAX_DEPTH,
-    options.maxEntries ?? JSON_SAFE_MAX_COLLECTION_ENTRIES,
-    options.maxStringLength ?? JSON_SAFE_MAX_STRING_LENGTH,
-    /* @__PURE__ */ new WeakSet()
-  );
+  if (scope.projectId !== void 0) {
+    next.projectId = scope.projectId;
+    next["x-project-id"] = scope.projectId;
+  }
+  return next;
 }
 
 // src/middlewares/taskMiddleware.ts
@@ -41643,9 +42704,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) {
@@ -42246,8 +43307,9 @@ function createTaskMiddleware(options = {}) {
     const trustedProject = authority.kind === "projectRoom" || authority.kind === "projectTask" ? authority.trusted : void 0;
     const trustedScope = trustedProject?.projectTask ?? trustedProject?.projectRoom;
     const tenantId2 = trustedScope?.tenantId ?? (rc.tenantId || "default");
-    const workspaceId = trustedScope?.workspaceId ?? rc.workspaceId;
-    const projectId = trustedScope?.projectId ?? rc.projectId;
+    const runScope = resolveRunScope2(rc);
+    const workspaceId = trustedScope?.workspaceId ?? runScope.workspaceId;
+    const projectId = trustedScope?.projectId ?? runScope.projectId;
     const revalidateCaller = async () => {
       if (!trustedProject || trustedRosterExempt(trustedProject)) return void 0;
       try {
@@ -43476,15 +44538,16 @@ function createTaskMiddleware(options = {}) {
           assistant_id: invocation.agentId,
           thread_id: invocation.threadId,
           input: { message: invocation.message },
-          runConfig: {
-            ...rc,
-            assistant_id: invocation.agentId,
-            thread_id: invocation.threadId,
-            taskId: invocation.taskId,
-            tenantId: invocation.tenantId,
-            workspaceId: invocation.workspaceId,
-            projectId: invocation.projectId
-          }
+          runConfig: applyWorkerRunScope(
+            {
+              ...rc,
+              assistant_id: invocation.agentId,
+              thread_id: invocation.threadId,
+              taskId: invocation.taskId,
+              tenantId: invocation.tenantId
+            },
+            resolveWorkerRunScope({ invocation, runConfig: rc })
+          )
         });
         const finalState = workerResult?.finalState;
         return boundedWorkerObservation(finalState, void 0);
@@ -43499,7 +44562,7 @@ function createTaskMiddleware(options = {}) {
       agentId,
       actor,
       callerThreadId: rc.thread_id,
-      ...trustedCaller ? { callerMembershipId: trustedCaller.membershipId, callerAssistantId: trustedCaller.assistantId } : {}
+      ...trustedCaller ? { callerMembershipId: trustedCaller.membershipId, callerAssistantId: trustedCaller.assistantId } : rc.assistant_id ? { callerAssistantId: rc.assistant_id } : {}
     }));
   };
   return createMiddleware23({
@@ -43559,7 +44622,14 @@ function createTaskMiddleware(options = {}) {
           task,
           actor: getRuntimeActor2(rc) ?? "system",
           ...threadId ? { threadId } : {},
-          outcome: { kind: "interrupted", summary: "Run ended without a task lifecycle transition" }
+          // A run that ended without its own lifecycle transition is a mechanical
+          // failure, NOT HITL. Human-in-the-loop pauses arrive as GraphInterrupt
+          // and never reach afterAgent.
+          outcome: {
+            kind: "failed",
+            lifecycleHandled: false,
+            error: "Run ended without a task lifecycle transition"
+          }
         });
       }
       taskRunRegistry.unregister(taskId);
@@ -45922,6 +46992,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":
@@ -45941,12 +47012,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": {
@@ -46058,6 +47131,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));
@@ -46519,10 +47612,12 @@ export {
   InMemoryChunkBuffer,
   InMemoryCollectionStore,
   InMemoryDatabaseConfigStore,
+  InMemoryLeaseStore,
   InMemoryMailboxStore,
   InMemoryMenuStore,
   InMemoryModelProviderStore,
   InMemoryOpenAuditStore,
+  InMemoryOutboxStore,
   InMemoryProjectBotMembershipStore,
   InMemoryProjectMembershipStore,
   InMemoryProjectRoomCoordinator,
@@ -46542,6 +47637,7 @@ export {
   LatticeEval,
   LatticeEvalProject,
   LatticeEvalSuite,
+  LeaseAcquisitionTimeoutError,
   LocalSandboxInstance,
   LocalSandboxProvider,
   LoggerLatticeManager,
@@ -46564,7 +47660,10 @@ export {
   MicrosandboxServiceClient,
   ModelLatticeManager,
   MysqlDatabase,
+  OutboxPoller,
   PACK_DIRECTORY_TIMEOUT_SECONDS,
+  PLATFORM_SECRET_ENV_VARS,
+  PLUGIN_CATALOG_CHANGED_TOPIC,
   PersonalAssistantConfig,
   PinoLoggerClient,
   PluginRegistry,
@@ -46585,6 +47684,8 @@ export {
   RepeatedToolCallError,
   RoomAgentMessageService,
   SAFE_PATH_COMPONENT,
+  SANDBOX_OPEN_GATEWAY_URL_ENV,
+  SANDBOX_OPEN_TOKEN_ENV,
   STTModelLattice,
   STTModelLatticeManager,
   SandboxFilesystem,
@@ -46625,11 +47726,13 @@ export {
   appendReconciliationWarning,
   appendUiFence,
   assertSafeUpstreamUrl,
+  buildBundleFromDist,
   buildGrepResultsDict,
   buildInput,
   buildNamedVolumeName,
   buildRemotePackDirectoryCommand,
   buildSandboxMetadataEnv,
+  buildSandboxOpenEnv,
   buildSkillFile,
   buildStateAnnotation,
   buildTableName,
@@ -46638,11 +47741,14 @@ export {
   checkEmptyContent,
   clearEncryptionKeyCache,
   clearEvalRunService,
+  clearSandboxOpenCredentialProviderForTests,
   collectionLatticeManager,
   compileInternal,
   compileSandboxPlugin,
   compileWorkflow,
   computeSandboxName,
+  configureCoordinationLeaseStore,
+  configurePluginCatalogSync,
   configureStores,
   connectAllChannels,
   convertToConnection,
@@ -46674,6 +47780,7 @@ export {
   createSandboxResolver,
   createSchedulerMiddleware,
   createSharePayload,
+  createShellExecTool,
   createTaskExecutionService,
   createTaskLifecycleService,
   createTaskMiddleware,
@@ -46708,6 +47815,7 @@ export {
   generateDirectHumanProjectId,
   generateToken,
   getAgentClient,
+  getAgentClientAsync,
   getAgentConfig,
   getAllAgentConfigs,
   getAllBuiltInSkillMetas,
@@ -46719,6 +47827,7 @@ export {
   getCheckpointSaver,
   getChunkBuffer,
   getCollectionEntryCount,
+  getCoordinationLeaseStore,
   getEmbeddingsClient,
   getEmbeddingsLattice,
   getEncryptionKey,
@@ -46730,15 +47839,18 @@ export {
   getOrCreateCollectionVectorStore,
   getPluginSkillManifestVersion,
   getQueueLattice,
+  getReplicaId,
   getRuntimeCapabilityConfig,
   getRuntimeSkillSelection,
   getSTTClient,
   getSTTClientWithTenant,
   getSTTModelLattice,
   getSandBoxManager,
+  getSandboxOpenCredential,
   getSandboxPluginCatalog,
   getScheduleLattice,
   getStoreLattice,
+  getThreadRunOwner,
   getToolClient,
   getToolClientWithTenant,
   getToolDefinition,
@@ -46792,6 +47904,8 @@ export {
   projectMutationMutex,
   projectRoomPlugin,
   projectTaskAdmissionNotifier,
+  provisionSandboxOpenClient,
+  publishPluginCatalogChanged,
   queueLatticeManager,
   readLoopBreakerConfig,
   reconcileAllTenantTaskRuns,
@@ -46810,6 +47924,7 @@ export {
   registerModelLatticeForTenant,
   registerQueueLattice,
   registerSTTModelLattice,
+  registerSandboxOpenCredentialProvider,
   registerSandboxProviderType,
   registerScheduleLattice,
   registerStoreLattice,
@@ -46820,6 +47935,7 @@ export {
   registerWorkflowRun,
   removeCollectionVectorStore,
   renderTemplate,
+  resetReplicaIdForTests,
   resolveEnabledPluginSkill,
   resolveJudgeModelKey,
   resolvePath,
@@ -46827,6 +47943,7 @@ export {
   resolveSandboxPluginConnections,
   resolveTenantPluginSkill,
   roomCoordinatorConfig,
+  runAsLeader,
   runRemotePackDirectory,
   safeTaskResponseId,
   sandboxLatticeManager,
@@ -46845,11 +47962,15 @@ export {
   storeLatticeManager,
   sttModelLatticeManager,
   taskLifecycleNotifier,
+  taskRunLeaseKey,
   taskRunRegistry,
+  threadRunLeaseKey,
   toJsonSchema,
   toSafeStateExpr,
   toolLatticeManager,
   truncateIfTooLong,
+  tryAcquireTaskRun,
+  tryAcquireThreadRun,
   unregisterTeammateAgent,
   unregisterWorkflowRun,
   updateFileData,
@@ -46865,6 +47986,7 @@ export {
   validateToolInput,
   vectorStoreLatticeManager,
   vectorStoreProviderManager,
+  withLease,
   withTimeout,
   wrapMcpToolWithUi
 };