@axiom-lattice/core 6.1.0 → 6.2.0

package/dist/index.js

@@ -1849,6 +1849,7 @@ __export(index_exports, {
   generateDirectHumanProjectId: () => generateDirectHumanProjectId,
   generateToken: () => generateToken,
   getAgentClient: () => getAgentClient,
+  getAgentClientAsync: () => getAgentClientAsync,
   getAgentConfig: () => getAgentConfig,
   getAllAgentConfigs: () => getAllAgentConfigs,
   getAllBuiltInSkillMetas: () => getAllBuiltInSkillMetas,
@@ -13524,8 +13525,8 @@ function readLoopBreakerConfig(env = process.env) {
     return Math.floor(parsed);
   };
   return {
-    repeatWarn: parse(env.AGENT_REPEATED_TOOL_CALL_WARN, 3),
-    repeatStop: parse(env.AGENT_REPEATED_TOOL_CALL_STOP, 5),
+    repeatWarn: parse(env.AGENT_REPEATED_TOOL_CALL_WARN, 20),
+    repeatStop: parse(env.AGENT_REPEATED_TOOL_CALL_STOP, 25),
     runLimit: parse(env.AGENT_TOOL_CALL_RUN_LIMIT, 300),
     skillRunLimit: parse(env.AGENT_SKILL_CALL_RUN_LIMIT, 8)
   };
@@ -13548,9 +13549,9 @@ var BREAKER_STATE_SCHEMA = import_zod43.z.object({
   repeatedToolCallMemberSignatures: import_zod43.z.array(import_zod43.z.string()).default([])
 });
 function createRepeatedToolCallBreakerMiddleware(options = {}) {
-  const rawWarn = options.warnThreshold ?? 3;
+  const rawWarn = options.warnThreshold ?? 20;
   const warnThreshold = rawWarn > 0 ? Math.max(2, rawWarn) : 0;
-  const stopThreshold = Math.max(1, options.stopThreshold ?? 5);
+  const stopThreshold = Math.max(1, options.stopThreshold ?? 25);
   return (0, import_langchain46.createMiddleware)({
     name: "RepeatedToolCallBreaker",
     stateSchema: BREAKER_STATE_SCHEMA,
@@ -17364,6 +17365,324 @@ var agentWorkerGraph = createAgentWorkerGraph();
 // src/deep_agent_new/middleware/subagents.ts
 init_MemoryLatticeManager();
 
+// 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
 var import_protocols10 = require("@axiom-lattice/protocols");
 var import_langgraph6 = require("@langchain/langgraph");
@@ -18902,6 +19221,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;
@@ -19181,7 +19521,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 }
@@ -19294,7 +19634,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({
@@ -19395,7 +19735,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 }
@@ -19702,12 +20042,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
     };
@@ -20052,7 +20397,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 {
@@ -20368,7 +20721,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", {
@@ -20404,7 +20757,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", {
@@ -20550,8 +20903,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
@@ -20565,6 +20929,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
    */
@@ -20600,55 +20982,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();
 
@@ -37653,6 +37986,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",
@@ -38019,7 +38354,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,
@@ -38116,7 +38452,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(
@@ -38192,7 +38534,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
     });
   }
   /**
@@ -39678,7 +40022,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 {
@@ -39716,6 +40062,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 = {
@@ -39731,7 +40102,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 {
@@ -39917,7 +40288,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") {
@@ -39926,7 +40297,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 {
@@ -40014,7 +40388,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,
@@ -40079,6 +40465,86 @@ 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 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;
+    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 } : {}
+  });
+}
+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 } : {}
+      });
+    } catch {
+      continue;
+    }
+    converged.push(...result.converged);
+    convergedTasks.push(...result.convergedTasks);
+  }
+  return { converged, convergedTasks };
+}
+
 // src/services/ExecutionAuthorityRegistry.ts
 var ManagedTaskStartError = class extends Error {
   /**
@@ -40340,274 +40806,13 @@ 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) {
-  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/services/TaskExecutionService.ts
 var import_langgraph14 = require("@langchain/langgraph");
 function persistedExecutionObservation(item, attempted) {
@@ -40656,10 +40861,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 ?? import_node_crypto9.randomUUID)();
+      threadId = storedThreadId ?? (deps.createThreadId ?? import_node_crypto9.randomUUID)();
+      if (task.status === "interrupted" && reuseCurrentRun) {
+        runId = storedRunId;
+      } else if (task.status === "interrupted" || task.status === "failed") {
+        runId = (deps.createRunId ?? import_node_crypto9.randomUUID)();
+      }
     } catch (error) {
       return {
         success: false,
@@ -40669,7 +40890,7 @@ function createTaskExecutionService(deps) {
         agentId
       };
     }
-    const eventKey = `execution-result:${threadId}`;
+    const eventKey = runId ? `execution-result:${threadId}:${runId}` : `execution-result:${threadId}`;
     if (!(0, import_protocols32.isExecutionResultEventKey)(eventKey)) {
       return {
         success: false,
@@ -40703,7 +40924,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) {
@@ -40717,38 +40941,120 @@ 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);
     try {
-      observation = toJsonSafeValue(await deps.invokeAgent(invocation));
-    } catch (error) {
-      if (error instanceof import_langgraph14.GraphInterrupt) {
+      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 import_langgraph14.GraphInterrupt) {
+          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,
@@ -40758,13 +41064,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, {
@@ -40773,15 +41074,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,
@@ -40789,80 +41089,27 @@ 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);
     }
   };
   return {
@@ -40875,76 +41122,6 @@ 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);
-  }
-  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 } : {}
-  });
-}
-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);
-  }
-  return { converged };
-}
-
 // src/index.ts
 var Protocols = __toESM(require("@axiom-lattice/protocols"));
 
@@ -43144,65 +43321,32 @@ var widgetPlugin = {
 var import_langchain83 = require("langchain");
 var import_zod68 = require("zod");
 var import_langgraph16 = require("@langchain/langgraph");
+var import_protocols34 = require("@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
+var import_protocols33 = require("@axiom-lattice/protocols");
+function resolveWorkerRunScope(input) {
+  const caller = (0, import_protocols33.resolveRunScope)(input.runConfig);
+  return {
+    workspaceId: (0, import_protocols33.firstNonEmptyString)(input.invocation.workspaceId) ?? caller.workspaceId,
+    projectId: (0, import_protocols33.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
-var import_protocols33 = require("@axiom-lattice/protocols");
+var import_protocols35 = require("@axiom-lattice/protocols");
 
 // src/middlewares/taskResponseSerialization.ts
 var TASK_RESPONSE_SCALAR_MAX_BYTES = 4096;
@@ -43670,7 +43814,7 @@ function classifyTaskAuthority(runConfig) {
     return delegatedTaskId ? { kind: "delegated", taskId: delegatedTaskId } : { kind: "ordinary" };
   }
   try {
-    const trusted = (0, import_protocols33.parseTrustedRunContext)(hasProjectTask ? { projectTask: runConfig.projectTask } : { projectRoom: runConfig.projectRoom });
+    const trusted = (0, import_protocols35.parseTrustedRunContext)(hasProjectTask ? { projectTask: runConfig.projectTask } : { projectRoom: runConfig.projectRoom });
     return { kind: hasProjectTask ? "projectTask" : "projectRoom", trusted };
   } catch {
     return { kind: "invalid" };
@@ -44007,7 +44151,7 @@ function getTaskWorkItemStore() {
   return getStoreLattice("default", "taskWorkItem").store;
 }
 function getProjectTaskWorkItemStore() {
-  return (0, import_protocols33.requireProjectTaskWorkItemStore)(getTaskWorkItemStore());
+  return (0, import_protocols35.requireProjectTaskWorkItemStore)(getTaskWorkItemStore());
 }
 function reviewInterruption(task) {
   const value = task.context?.interruption;
@@ -44038,7 +44182,7 @@ var manageTaskSchema = import_zod68.z.object({
   parentId: import_zod68.z.string().optional().describe("Parent task ID for grouping subtasks"),
   sourceId: import_zod68.z.string().optional().describe("Source session/thread ID"),
   context: import_zod68.z.record(import_zod68.z.unknown()).optional().describe("Additional context data"),
-  ownerType: import_zod68.z.enum(["user", "agent"]).optional().describe("Owner type. Defaults to 'user' if omitted"),
+  ownerType: import_zod68.z.enum(["user", "agent"]).optional().describe("Owner type. Defaults to the runtime actor: agent runtime (no user identity) -> 'agent', user runtime -> 'user'."),
   ownerId: import_zod68.z.string().optional().describe("Owner ID. Auto-filled from current user/agent if omitted"),
   requireReview: import_zod68.z.boolean().optional().describe("If true, agent completion pauses as interrupted(review_required) for HITL approval"),
   dependencies: import_zod68.z.array(import_zod68.z.string()).optional().describe("List of task IDs that must be completed before this task can start"),
@@ -44057,7 +44201,7 @@ var manageTaskSchema = import_zod68.z.object({
   })).optional().describe("Structured belief reports required when an agent-owned task completes; existing keys update the belief owner's table, and a brand-new key must be declared with isNew: true"),
   content: import_zod68.z.string().optional().describe("Markdown content required for add_activity"),
   summary: import_zod68.z.string().optional().describe("Brief summary of the operation"),
-  executionResultId: import_zod68.z.string().refine(import_protocols33.isExecutionResultEventKey, {
+  executionResultId: import_zod68.z.string().refine(import_protocols35.isExecutionResultEventKey, {
     message: "executionResultId must be the execution-result:<threadId> event key returned by task()"
   }).optional().describe(
     "Canonical ASCII `execution-result:<suffix>` event key returned by task(); the nonempty suffix allows only A-Z, a-z, 0-9, period, underscore, colon, and hyphen, and is not a database row ID"
@@ -44122,7 +44266,7 @@ async function getPendingExecutionResultIds(store, tenantId2, taskId) {
         order: "desc",
         limit: PENDING_EXECUTION_RESULT_LIMIT + 1
       });
-      const canonicalCandidates = candidates.slice(0, PENDING_EXECUTION_RESULT_LIMIT + 1).filter((item) => (0, import_protocols33.isExecutionResultEventKey)(item.eventKey));
+      const canonicalCandidates = candidates.slice(0, PENDING_EXECUTION_RESULT_LIMIT + 1).filter((item) => (0, import_protocols35.isExecutionResultEventKey)(item.eventKey));
       const reconciliationRows = new Array(canonicalCandidates.length);
       let nextCandidateIndex = 0;
       let firstError;
@@ -44207,8 +44351,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 = (0, import_protocols34.resolveRunScope)(rc);
+    const workspaceId = trustedScope?.workspaceId ?? runScope.workspaceId;
+    const projectId = trustedScope?.projectId ?? runScope.projectId;
     const revalidateCaller = async () => {
       if (!trustedProject || trustedRosterExempt(trustedProject)) return void 0;
       try {
@@ -44225,7 +44370,9 @@ function createTaskMiddleware(options = {}) {
         return projectPolicyError(error);
       }
     }
-    const ownerId = input.ownerId || trustedScope?.assistantId || (input.ownerType === "agent" ? rc.assistant_id : null) || rc.user_id;
+    const runtimeOwnerType = rc.user_id ? "user" : rc.assistant_id ? "agent" : "user";
+    const requestedOwnerType = input.ownerType ?? runtimeOwnerType;
+    const ownerId = input.ownerId || trustedScope?.assistantId || (requestedOwnerType === "agent" ? rc.assistant_id : null) || rc.user_id;
     const store = getTaskStore();
     const deleteOneTask = async (id) => {
       if (delegatedTaskId && id !== delegatedTaskId) {
@@ -44294,7 +44441,7 @@ function createTaskMiddleware(options = {}) {
             createScopeProjectId = createScopeProjectId ?? parentTask.projectId;
           }
         }
-        const effectiveOwnerType = delegatedTaskId ? "agent" : trustedProject ? "agent" : input.ownerType || "user";
+        const effectiveOwnerType = delegatedTaskId ? "agent" : trustedProject ? "agent" : requestedOwnerType;
         const effectiveOwnerId = delegatedTaskId ? rc.assistant_id : ownerId;
         if (delegatedTaskId && !effectiveOwnerId) {
           return delegatedTaskScopeError(delegatedTaskId);
@@ -44320,6 +44467,14 @@ function createTaskMiddleware(options = {}) {
             }
           }
         }
+        if (!delegatedTaskId && (typeof effectiveOwnerId !== "string" || effectiveOwnerId.length === 0)) {
+          return JSON.stringify({
+            success: false,
+            code: "TASK_OWNER_REQUIRED",
+            error: "Cannot resolve task owner: no user or agent identity in this run.",
+            hint: 'Provide an explicit ownerId, or retry with ownerType:"agent" if this run has an agent identity.'
+          });
+        }
         if (effectiveOwnerType === "agent" && (input.result !== void 0 || input.failureReason !== void 0)) {
           return JSON.stringify({
             success: false,
@@ -44758,8 +44913,8 @@ function createTaskMiddleware(options = {}) {
         let reconciliationMetadata = {};
         let descriptionMutated = false;
         if (isAgentTask && input.description !== void 0 && !valuesEqual(input.description, existing.description)) {
-          const oldBelief = (0, import_protocols33.parseTaskBeliefState)(existing.description ?? "");
-          const newBelief = (0, import_protocols33.parseTaskBeliefState)(input.description);
+          const oldBelief = (0, import_protocols35.parseTaskBeliefState)(existing.description ?? "");
+          const newBelief = (0, import_protocols35.parseTaskBeliefState)(input.description);
           const hasBeliefState = oldBelief.success || newBelief.success;
           if (hasBeliefState) {
             await validateExecutionResult();
@@ -45374,13 +45529,22 @@ function createTaskMiddleware(options = {}) {
     try {
       response = await handleManageTaskAction(input, config, validateExecutionResult, markMutation);
     } catch (error) {
-      if (!(error instanceof ExecutionResultNotPendingError)) throw error;
+      if (error instanceof import_langgraph16.GraphInterrupt) throw error;
+      if (error instanceof ExecutionResultNotPendingError) {
+        return JSON.stringify({
+          success: false,
+          code: "EXECUTION_RESULT_NOT_PENDING",
+          taskId: error.taskId,
+          executionResultId: error.executionResultId,
+          error: error.message
+        });
+      }
+      if (input.executionResultId) throw error;
       return JSON.stringify({
         success: false,
-        code: "EXECUTION_RESULT_NOT_PENDING",
-        taskId: error.taskId,
-        executionResultId: error.executionResultId,
-        error: error.message
+        code: "TASK_ACTION_FAILED",
+        error: error instanceof Error ? error.message : String(error),
+        hint: "The action did not complete. Fix the input or retry; do not repeat the identical call."
       });
     }
     return reconcileExplicitExecutionResult(
@@ -45418,15 +45582,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);
@@ -45441,7 +45606,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 (0, import_langchain83.createMiddleware)({
@@ -45501,7 +45666,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);
@@ -45546,8 +45718,8 @@ changes only when acceptance criteria are truly met.
 ${TASK_CONVERGENCE_GUIDANCE}
 
 ### Ownership defaults
-- No params: ownerType defaults to "user" with current user's ID
-- ownerType="agent": auto-fills ownerId from current agent (subtask for yourself)
+- No params: ownerType defaults to the runtime actor (user runtime -> current user's ID; agent runtime -> current agent's ID)
+- ownerType="agent": auto-fills ownerId from the current agent (subtask for yourself)
 - Explicit ownerId: assign to a specific agent or user`;
       const boundTaskId = request.state?.taskId;
       const binding = typeof boundTaskId === "string" && boundTaskId ? renderTaskBinding(boundTaskId) : "";
@@ -45566,7 +45738,7 @@ ${TASK_CONVERGENCE_GUIDANCE}
           description: `Manage persistent tasks and their activity timelines for user and agent tasks.
 
 ## Owner defaults
-- No ownerType/ownerId: auto-assigned to current user
+- No ownerType/ownerId: auto-assigned to the runtime actor (user runtime -> current user; agent runtime -> current agent)
 - ownerType="agent" without ownerId: auto-assigned to current agent
 - Explicit ownerId: assign to a specific agent (cross-agent delegation)
 
@@ -46229,7 +46401,7 @@ function createParseDocumentTool({
 }
 
 // src/middlewares/documentParserMiddleware.ts
-var import_protocols34 = require("@axiom-lattice/protocols");
+var import_protocols36 = require("@axiom-lattice/protocols");
 
 // src/middlewares/documentBenchmarkWorkflow.ts
 var DOCUMENT_PARSER_BENCHMARK_YAML = `name: document-parser-benchmark
@@ -46771,7 +46943,7 @@ var documentParserPlugin = {
   agents: {
     "document-parser": {
       key: "document-parser",
-      type: import_protocols34.AgentType.DEEP_AGENT,
+      type: import_protocols36.AgentType.DEEP_AGENT,
       name: "Document Parser",
       description: "Parse documents (pdf, docx, images, spreadsheets) into clean Markdown. Defaults to local MarkItDown; escalates to remote engines only when quality or format needs it; runs engine benchmarking only on explicit request.",
       prompt: DOCUMENT_PARSER_SYSTEM_PROMPT,
@@ -46821,7 +46993,7 @@ var documentParserPlugin = {
     },
     "document-parser-benchmark": {
       key: "document-parser-benchmark",
-      type: import_protocols34.AgentType.WORKFLOW,
+      type: import_protocols36.AgentType.WORKFLOW,
       name: "Document Parser Benchmark",
       description: "Benchmark document parsing engines. Parses a document with 5 engines in parallel, scores results, and produces a ranking report. Use this when you need to evaluate which parsing engine works best for a given document.",
       prompt: "Benchmark document parsing engines: parse with 5 engines, score, and rank results.",
@@ -46858,7 +47030,7 @@ var documentParserPlugin = {
 
 // src/middlewares/projectRoomMiddleware.ts
 var import_crypto10 = require("crypto");
-var import_protocols35 = require("@axiom-lattice/protocols");
+var import_protocols37 = require("@axiom-lattice/protocols");
 var import_langchain87 = require("langchain");
 var import_zod70 = require("zod");
 var PROJECT_ROOM_CONTEXT_REQUIRED = "PROJECT_ROOM_CONTEXT_REQUIRED";
@@ -46888,7 +47060,7 @@ function ownDataValue2(record, key5) {
   if (typeof record !== "object" || record === null || Array.isArray(record)) return void 0;
   try {
     const descriptor = Object.getOwnPropertyDescriptor(record, key5);
-    return (0, import_protocols35.descriptorDataValue)(descriptor)?.value;
+    return (0, import_protocols37.descriptorDataValue)(descriptor)?.value;
   } catch {
     return void 0;
   }
@@ -46898,14 +47070,14 @@ function readTrustedRoomScope(config) {
   const runConfig = ownDataValue2(configurable, "runConfig");
   const projectRoom = ownDataValue2(runConfig, "projectRoom");
   try {
-    return (0, import_protocols35.parseTrustedRunContext)({ projectRoom }).projectRoom;
+    return (0, import_protocols37.parseTrustedRunContext)({ projectRoom }).projectRoom;
   } catch {
     return void 0;
   }
 }
 function exactValues2(value, required, optional = []) {
   try {
-    return (0, import_protocols35.snapshotExactRecord)(value, required, optional);
+    return (0, import_protocols37.snapshotExactRecord)(value, required, optional);
   } catch {
     return void 0;
   }
@@ -46941,7 +47113,7 @@ function snapshotMembership3(value) {
   return { ...values, joinedAt, updatedAt };
 }
 function snapshotRows(value) {
-  return (0, import_protocols35.snapshotExactArray)(value) ?? [];
+  return (0, import_protocols37.snapshotExactArray)(value) ?? [];
 }
 async function hasActiveCurrentMembership(scope) {
   const memberships = getStoreLattice("default", "projectBotMembership").store;
@@ -47028,7 +47200,7 @@ var projectRoomPlugin = {
 // src/middlewares/sandboxPluginsMiddleware.ts
 var import_langchain88 = require("langchain");
 var import_zod71 = require("zod");
-var import_protocols36 = require("@axiom-lattice/protocols");
+var import_protocols38 = require("@axiom-lattice/protocols");
 
 // src/middlewares/sandboxPluginsSkills.ts
 var PLUGIN_JSON_TEMPLATE = `{
@@ -47778,7 +47950,7 @@ var sandboxPluginsPlugin = {
       key: "plugin-builder",
       name: "Plugin Builder",
       description: "Author and manage tenant plugins in the shared sandbox: clarify goal, inputs/outputs, credentials, and whether a UI is needed; then write the manifest and JS handlers, add an optional HTML MCP App UI, and validate/test with the manage_plugin tool.",
-      type: import_protocols36.AgentType.DEEP_AGENT,
+      type: import_protocols38.AgentType.DEEP_AGENT,
       prompt: PLUGIN_BUILDER_PROMPT,
       middleware: [
         {
@@ -48653,6 +48825,7 @@ registerBuiltinPlugins();
   generateDirectHumanProjectId,
   generateToken,
   getAgentClient,
+  getAgentClientAsync,
   getAgentConfig,
   getAllAgentConfigs,
   getAllBuiltInSkillMetas,