@axiom-lattice/core 6.1.0 → 6.2.0

package/dist/index.mjs

@@ -11551,8 +11551,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)
   };
@@ -11575,9 +11575,9 @@ var BREAKER_STATE_SCHEMA = z41.object({
   repeatedToolCallMemberSignatures: z41.array(z41.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 createMiddleware10({
     name: "RepeatedToolCallBreaker",
     stateSchema: BREAKER_STATE_SCHEMA,
@@ -15404,6 +15404,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";
@@ -16945,6 +17263,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;
@@ -17224,7 +17563,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 +17676,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 +17777,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 +18084,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
     };
@@ -18095,7 +18439,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 {
@@ -18411,7 +18763,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 +18799,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", {
@@ -18593,8 +18945,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 +18971,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 +19024,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();
 
@@ -35687,6 +36019,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",
@@ -36053,7 +36387,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 +36485,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 +36567,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
     });
   }
   /**
@@ -37712,7 +38055,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 +38095,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 +38135,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 {
@@ -37951,7 +38321,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 +38330,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 +38421,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 +38498,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 {
   /**
@@ -38374,274 +38839,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
 import { GraphInterrupt as GraphInterrupt2 } from "@langchain/langgraph";
 function persistedExecutionObservation(item, attempted) {
@@ -38690,10 +38894,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 ?? randomUUID8)();
+      if (task.status === "interrupted" && reuseCurrentRun) {
+        runId = storedRunId;
+      } else if (task.status === "interrupted" || task.status === "failed") {
+        runId = (deps.createRunId ?? randomUUID8)();
+      }
     } catch (error) {
       return {
         success: false,
@@ -38703,7 +38923,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 +38957,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 +38974,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 GraphInterrupt2) {
+      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 +39097,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 +39107,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 +39122,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 {
@@ -38909,76 +39155,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
 import * as Protocols from "@axiom-lattice/protocols";
 
@@ -41178,61 +41354,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
@@ -42077,7 +42220,7 @@ var manageTaskSchema = z70.object({
   parentId: z70.string().optional().describe("Parent task ID for grouping subtasks"),
   sourceId: z70.string().optional().describe("Source session/thread ID"),
   context: z70.record(z70.unknown()).optional().describe("Additional context data"),
-  ownerType: z70.enum(["user", "agent"]).optional().describe("Owner type. Defaults to 'user' if omitted"),
+  ownerType: z70.enum(["user", "agent"]).optional().describe("Owner type. Defaults to the runtime actor: agent runtime (no user identity) -> 'agent', user runtime -> 'user'."),
   ownerId: z70.string().optional().describe("Owner ID. Auto-filled from current user/agent if omitted"),
   requireReview: z70.boolean().optional().describe("If true, agent completion pauses as interrupted(review_required) for HITL approval"),
   dependencies: z70.array(z70.string()).optional().describe("List of task IDs that must be completed before this task can start"),
@@ -42246,8 +42389,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 {
@@ -42264,7 +42408,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) {
@@ -42333,7 +42479,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);
@@ -42359,6 +42505,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,
@@ -43413,13 +43567,22 @@ function createTaskMiddleware(options = {}) {
     try {
       response = await handleManageTaskAction(input, config, validateExecutionResult, markMutation);
     } catch (error) {
-      if (!(error instanceof ExecutionResultNotPendingError)) throw error;
+      if (error instanceof GraphInterrupt3) 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(
@@ -43457,15 +43620,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);
@@ -43480,7 +43644,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({
@@ -43540,7 +43704,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);
@@ -43585,8 +43756,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) : "";
@@ -43605,7 +43776,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)
 
@@ -46689,6 +46860,7 @@ export {
   generateDirectHumanProjectId,
   generateToken,
   getAgentClient,
+  getAgentClientAsync,
   getAgentConfig,
   getAllAgentConfigs,
   getAllBuiltInSkillMetas,