@tangle-network/agent-runtime 0.48.0 → 0.50.0

package/dist/{chunk-JNPK46YH.js → chunk-RHW75JW5.js}

@@ -1,23 +1,236 @@
 import {
-  NotFoundError
+  capDelegationTrace,
+  createDelegationTraceCollector,
+  formatDetachedSessionRef,
+  generateDelegationSpanId
+} from "./chunk-OM3YNZIW.js";
+import {
+  AgentEvalError,
+  NotFoundError,
+  ValidationError
 } from "./chunk-GSUO5QS6.js";
 
+// src/mcp/delegation-store.ts
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname } from "path";
+var DelegationStateCorruptError = class extends AgentEvalError {
+  constructor(message, options) {
+    super("validation", message, options);
+  }
+};
+var DelegationPersistenceError = class extends AgentEvalError {
+  constructor(message, options) {
+    super("config", message, options);
+  }
+};
+var InMemoryDelegationStore = class {
+  records = /* @__PURE__ */ new Map();
+  async loadAll() {
+    return [...this.records.values()].map(cloneRecord);
+  }
+  async upsert(record) {
+    this.records.set(record.taskId, cloneRecord(record));
+  }
+  async lookupIdempotencyKey(key) {
+    for (const record of this.records.values()) {
+      if (record.idempotencyKey === key) return record.taskId;
+    }
+    return void 0;
+  }
+  async remove(taskIds) {
+    for (const taskId of taskIds) this.records.delete(taskId);
+  }
+};
+var STATE_FORMAT_VERSION = 1;
+var FileDelegationStore = class {
+  filePath;
+  recoverCorrupt;
+  records = /* @__PURE__ */ new Map();
+  loaded = false;
+  writeTail = Promise.resolve();
+  tmpSeq = 0;
+  constructor(options) {
+    this.filePath = options.filePath;
+    this.recoverCorrupt = options.recoverCorrupt ?? false;
+  }
+  async loadAll() {
+    let raw;
+    try {
+      raw = await readFile(this.filePath, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        this.loaded = true;
+        return [];
+      }
+      throw new DelegationPersistenceError(
+        `FileDelegationStore: failed to read ${this.filePath}: ${errorMessage(err)}`,
+        { cause: err }
+      );
+    }
+    let state;
+    try {
+      state = parsePersistedState(raw);
+    } catch (err) {
+      if (!this.recoverCorrupt) {
+        throw new DelegationStateCorruptError(
+          `FileDelegationStore: state file ${this.filePath} is corrupt (${errorMessage(err)}). Repair or archive the file, or opt into automatic recovery (recoverCorrupt / AGENT_RUNTIME_DELEGATION_STATE_RECOVER=1) to archive it and start empty.`,
+          { cause: err }
+        );
+      }
+      const archivePath = `${this.filePath}.corrupt-${Date.now()}`;
+      await rename(this.filePath, archivePath);
+      this.loaded = true;
+      return [];
+    }
+    this.records.clear();
+    for (const record of state.records) this.records.set(record.taskId, record);
+    this.loaded = true;
+    return [...this.records.values()].map(cloneRecord);
+  }
+  async upsert(record) {
+    this.assertLoaded("upsert");
+    this.records.set(record.taskId, cloneRecord(record));
+    await this.enqueueWrite();
+  }
+  async lookupIdempotencyKey(key) {
+    this.assertLoaded("lookupIdempotencyKey");
+    for (const record of this.records.values()) {
+      if (record.idempotencyKey === key) return record.taskId;
+    }
+    return void 0;
+  }
+  async remove(taskIds) {
+    this.assertLoaded("remove");
+    let changed = false;
+    for (const taskId of taskIds) {
+      if (this.records.delete(taskId)) changed = true;
+    }
+    if (changed) await this.enqueueWrite();
+  }
+  assertLoaded(op) {
+    if (this.loaded) return;
+    throw new DelegationPersistenceError(
+      `FileDelegationStore: ${op} called before loadAll() \u2014 the on-disk state has not been read yet`
+    );
+  }
+  enqueueWrite() {
+    const write = this.writeTail.then(() => this.writeSnapshot());
+    this.writeTail = write.catch(() => {
+    });
+    return write;
+  }
+  async writeSnapshot() {
+    const state = {
+      version: STATE_FORMAT_VERSION,
+      records: [...this.records.values()]
+    };
+    const payload = `${JSON.stringify(state)}
+`;
+    this.tmpSeq += 1;
+    const tmpPath = `${this.filePath}.tmp-${process.pid}-${this.tmpSeq}`;
+    try {
+      await mkdir(dirname(this.filePath), { recursive: true });
+      await writeFile(tmpPath, payload, "utf8");
+      await rename(tmpPath, this.filePath);
+    } catch (err) {
+      throw new DelegationPersistenceError(
+        `FileDelegationStore: failed to write ${this.filePath}: ${errorMessage(err)}`,
+        { cause: err }
+      );
+    }
+  }
+};
+function parsePersistedState(raw) {
+  const parsed = JSON.parse(raw);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("top-level value is not an object");
+  }
+  const state = parsed;
+  if (state.version !== STATE_FORMAT_VERSION) {
+    throw new Error(`unsupported state version ${JSON.stringify(state.version)}`);
+  }
+  if (!Array.isArray(state.records)) {
+    throw new Error("`records` is not an array");
+  }
+  for (const record of state.records) {
+    if (record === null || typeof record !== "object") {
+      throw new Error("a record entry is not an object");
+    }
+    const candidate = record;
+    if (typeof candidate.taskId !== "string" || typeof candidate.status !== "string") {
+      throw new Error("a record entry is missing `taskId`/`status`");
+    }
+  }
+  return { version: STATE_FORMAT_VERSION, records: state.records };
+}
+function cloneRecord(record) {
+  return structuredClone(record);
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
 // src/mcp/task-queue.ts
-var DelegationTaskQueue = class {
+var DelegationTaskQueue = class _DelegationTaskQueue {
   records = /* @__PURE__ */ new Map();
   controllers = /* @__PURE__ */ new Map();
   byIdempotencyKey = /* @__PURE__ */ new Map();
   generateId;
   now;
+  store;
+  resumeDelegate;
+  maxTerminalRecords;
+  onPersistError;
+  traceContext;
+  persistTail = Promise.resolve();
+  persistFailure;
   constructor(options = {}) {
     this.generateId = options.generateId ?? randomTaskId;
     this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    this.store = options.store ?? new InMemoryDelegationStore();
+    this.resumeDelegate = options.resumeDelegate;
+    if (options.maxTerminalRecords !== void 0) {
+      if (!Number.isInteger(options.maxTerminalRecords) || options.maxTerminalRecords < 1) {
+        throw new ValidationError(
+          `DelegationTaskQueue: maxTerminalRecords must be a positive integer, got ${String(options.maxTerminalRecords)}`
+        );
+      }
+    }
+    this.maxTerminalRecords = options.maxTerminalRecords ?? Number.POSITIVE_INFINITY;
+    this.traceContext = options.traceContext;
+    this.onPersistError = options.onPersistError ?? ((error) => {
+      queueMicrotask(() => {
+        throw error;
+      });
+    });
+  }
+  /**
+   * Construct a queue from previously-persisted state. Loads every record
+   * from `options.store`, rebuilds the idempotency index (so a re-submitted
+   * identical task returns the prior taskId and its terminal state), then:
+   *
+   *   - terminal records stay queryable via `status()` / `history()`
+   *   - in-flight records with a `detachedSessionRef` re-attach through
+   *     `options.resumeDelegate` and report `running`
+   *   - other in-flight records settle as failed — their driver died with
+   *     the previous process and the result is unrecoverable
+   *
+   * The retention cap applies to the loaded set as well.
+   */
+  static async restore(options = {}) {
+    const queue = new _DelegationTaskQueue(options);
+    const loaded = await queue.store.loadAll();
+    queue.rehydrate(loaded);
+    return queue;
   }
   /**
    * Kick off a delegation in the background. Returns immediately. The
-   * `taskId` is queryable via `status` once this method returns.
+   * `taskId` is queryable via `status` once this method returns. Throws
+   * the recorded `DelegationPersistenceError` once the store has failed —
+   * the queue does not accept work it cannot journal.
    */
   submit(input) {
+    if (this.persistFailure) throw this.persistFailure;
     if (input.idempotencyKey) {
       const existing = this.byIdempotencyKey.get(input.idempotencyKey);
       if (existing && this.records.has(existing)) {
@@ -34,11 +247,17 @@ var DelegationTaskQueue = class {
       status: "pending",
       startedAt: this.now(),
       feedback: [],
-      idempotencyKey: input.idempotencyKey
+      idempotencyKey: input.idempotencyKey,
+      detachedSessionRef: input.detachedSessionRef,
+      ...this.traceContext !== void 0 ? {
+        traceId: this.traceContext.traceId,
+        ...this.traceContext.parentSpanId !== void 0 ? { parentSpanId: this.traceContext.parentSpanId } : {}
+      } : {}
     };
     this.records.set(taskId, record);
     this.controllers.set(taskId, controller);
     if (input.idempotencyKey) this.byIdempotencyKey.set(input.idempotencyKey, taskId);
+    this.persist(record);
     queueMicrotask(() => {
       this.execute(taskId, input, controller);
     });
@@ -47,11 +266,13 @@ var DelegationTaskQueue = class {
   /**
    * Snapshot the current state of a delegation. Returns `undefined` for
    * unknown ids so callers can distinguish missing from terminal.
+   * `includeTrace` attaches the journaled loop-trace span tree — off by
+   * default so status polls stay light.
    */
-  status(taskId) {
+  status(taskId, opts) {
     const record = this.records.get(taskId);
     if (!record) return void 0;
-    return toStatusResult(record);
+    return toStatusResult(record, opts);
   }
   /**
    * Abort an in-flight delegation. Returns `false` if the task is unknown
@@ -69,6 +290,8 @@ var DelegationTaskQueue = class {
     record.status = "cancelled";
     record.completedAt = this.now();
     record.error = { message: "cancelled by caller", kind: "CancelledError" };
+    this.persist(record);
+    this.enforceRetention();
     return true;
   }
   /**
@@ -81,6 +304,7 @@ var DelegationTaskQueue = class {
     const record = this.records.get(taskId);
     if (!record) return false;
     record.feedback.push(snapshot);
+    this.persist(record);
     return true;
   }
   /**
@@ -100,6 +324,15 @@ var DelegationTaskQueue = class {
     out.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
     return out.slice(0, limit);
   }
+  /**
+   * Await every journal write issued so far. Rejects with the recorded
+   * `DelegationPersistenceError` when any of them failed. Call before
+   * handing the store's backing file to another process.
+   */
+  async flush() {
+    await this.persistTail;
+    if (this.persistFailure) throw this.persistFailure;
+  }
   /** Test-only — number of in-flight (non-terminal) records. */
   inflightCount() {
     let n = 0;
@@ -112,26 +345,215 @@ var DelegationTaskQueue = class {
     const record = this.records.get(taskId);
     if (!record) return;
     record.status = "running";
+    this.persist(record);
+    const traceCollector = createDelegationTraceCollector((spans) => {
+      if (isTerminal(currentStatus(record))) return;
+      this.appendTrace(record, spans);
+      this.persist(record);
+    });
     try {
       const output = await input.run({
         signal: controller.signal,
         report: (progress) => {
-          if (record.status === "running") record.progress = progress;
+          if (record.status === "running") {
+            record.progress = progress;
+            this.persist(record);
+          }
+        },
+        traceEmitter: traceCollector.emitter,
+        ...record.detachedSessionRef !== void 0 ? { detachedSessionRef: record.detachedSessionRef } : {},
+        updateDetachedSessionRef: (ref) => {
+          if (typeof ref !== "string" || ref.length === 0) {
+            throw new ValidationError(
+              "DelegationTaskQueue: updateDetachedSessionRef requires a non-empty ref"
+            );
+          }
+          if (isTerminal(currentStatus(record))) return;
+          record.detachedSessionRef = ref;
+          this.persist(record);
         }
       });
+      traceCollector.settle();
       if (currentStatus(record) === "cancelled") return;
       record.status = "completed";
       record.completedAt = this.now();
       record.result = { profile: input.profile, output };
+      this.persist(record);
+      this.enforceRetention();
     } catch (err) {
+      traceCollector.settle();
       if (currentStatus(record) === "cancelled") return;
       record.status = "failed";
       record.completedAt = this.now();
       record.error = errorToShape(err);
+      this.persist(record);
+      this.enforceRetention();
     } finally {
       this.controllers.delete(taskId);
     }
   }
+  appendTrace(record, spans) {
+    if (spans.length === 0) return;
+    const { trace, truncated } = capDelegationTrace([...record.trace ?? [], ...spans]);
+    record.trace = trace;
+    if (truncated) record.traceTruncated = true;
+  }
+  rehydrate(loaded) {
+    const records = [...loaded].sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+    for (const record of records) {
+      this.records.set(record.taskId, record);
+      if (record.idempotencyKey) this.byIdempotencyKey.set(record.idempotencyKey, record.taskId);
+    }
+    for (const record of this.records.values()) {
+      if (isTerminal(record.status)) continue;
+      if (record.detachedSessionRef && this.resumeDelegate) {
+        record.status = "running";
+        this.persist(record);
+        this.startResume(record, record.detachedSessionRef, this.resumeDelegate);
+        continue;
+      }
+      record.status = "failed";
+      record.completedAt = this.now();
+      record.error = {
+        message: record.detachedSessionRef ? `delegation driver restarted while the task was in flight; detached session "${record.detachedSessionRef}" needs a resumeDelegate to be resumed` : "delegation driver restarted while the task was in flight; the run was not detached and cannot be resumed",
+        kind: "DriverRestartError"
+      };
+      this.persist(record);
+    }
+    this.enforceRetention();
+  }
+  startResume(record, detachedSessionRef, driver) {
+    const controller = new AbortController();
+    this.controllers.set(record.taskId, controller);
+    void this.driveResume(record, detachedSessionRef, driver, controller);
+  }
+  async driveResume(record, detachedSessionRef, driver, controller) {
+    const intervalMs = driver.intervalMs ?? 5e3;
+    const resumeStartMs = Date.parse(this.now());
+    const ctx = {
+      signal: controller.signal,
+      report: (progress) => {
+        if (currentStatus(record) !== "running") return;
+        record.progress = progress;
+        this.persist(record);
+      }
+    };
+    try {
+      while (!controller.signal.aborted && currentStatus(record) === "running") {
+        const tick = await driver.tick({ record: structuredClone(record), detachedSessionRef }, ctx);
+        if (currentStatus(record) === "cancelled") return;
+        if (tick.state === "completed") {
+          this.appendResumeSpan(record, detachedSessionRef, resumeStartMs);
+          record.status = "completed";
+          record.completedAt = this.now();
+          record.result = {
+            profile: record.profile,
+            output: tick.output
+          };
+          if (tick.costUsd !== void 0) record.costUsd = tick.costUsd;
+          this.persist(record);
+          this.enforceRetention();
+          return;
+        }
+        if (tick.state === "failed") {
+          this.appendResumeSpan(record, detachedSessionRef, resumeStartMs, tick.error.message);
+          record.status = "failed";
+          record.completedAt = this.now();
+          record.error = tick.error;
+          this.persist(record);
+          this.enforceRetention();
+          return;
+        }
+        await abortableDelay(intervalMs, controller.signal);
+      }
+    } catch (err) {
+      if (currentStatus(record) === "cancelled") return;
+      this.appendResumeSpan(record, detachedSessionRef, resumeStartMs, errorToShape(err).message);
+      record.status = "failed";
+      record.completedAt = this.now();
+      record.error = errorToShape(err);
+      this.persist(record);
+      this.enforceRetention();
+    } finally {
+      this.controllers.delete(record.taskId);
+    }
+  }
+  /**
+   * Journal the resumed segment of a detached run as one compact span. The
+   * resume driver re-attaches after a process restart, so the original
+   * process's loop events are gone — this span records the post-restart
+   * observation window (re-attach → terminal tick) under the
+   * `'detached-resume'` driver tag, keeping restored delegations observable
+   * in the journal alongside trace-carrying live runs.
+   */
+  appendResumeSpan(record, detachedSessionRef, startMs, error) {
+    this.appendTrace(record, [
+      {
+        spanId: generateDelegationSpanId(),
+        name: "loop",
+        kind: "loop",
+        startMs,
+        endMs: Date.parse(this.now()),
+        meta: {
+          "tangle.loop.driver": "detached-resume",
+          "tangle.loop.detached_session_ref": detachedSessionRef,
+          ...error !== void 0 ? { "tangle.loop.error": error } : {}
+        }
+      }
+    ]);
+  }
+  persist(record) {
+    if (this.persistFailure) return;
+    const snapshot = structuredClone(record);
+    this.persistTail = this.persistTail.then(async () => {
+      if (this.persistFailure) return;
+      try {
+        await this.store.upsert(snapshot);
+      } catch (err) {
+        this.failPersistence(err);
+      }
+    });
+  }
+  persistRemoval(taskIds) {
+    if (this.persistFailure || taskIds.length === 0) return;
+    this.persistTail = this.persistTail.then(async () => {
+      if (this.persistFailure) return;
+      try {
+        await this.store.remove(taskIds);
+      } catch (err) {
+        this.failPersistence(err);
+      }
+    });
+  }
+  failPersistence(cause) {
+    if (this.persistFailure) return;
+    const error = cause instanceof DelegationPersistenceError ? cause : new DelegationPersistenceError(
+      `DelegationTaskQueue: store write failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+      { cause }
+    );
+    this.persistFailure = error;
+    this.onPersistError(error);
+  }
+  enforceRetention() {
+    if (!Number.isFinite(this.maxTerminalRecords)) return;
+    const terminal = [];
+    for (const record of this.records.values()) {
+      if (isTerminal(record.status)) terminal.push(record);
+    }
+    const excess = terminal.length - this.maxTerminalRecords;
+    if (excess <= 0) return;
+    terminal.sort(
+      (a, b) => (a.completedAt ?? a.startedAt).localeCompare(b.completedAt ?? b.startedAt)
+    );
+    const evicted = terminal.slice(0, excess);
+    for (const record of evicted) {
+      this.records.delete(record.taskId);
+      if (record.idempotencyKey && this.byIdempotencyKey.get(record.idempotencyKey) === record.taskId) {
+        this.byIdempotencyKey.delete(record.idempotencyKey);
+      }
+    }
+    this.persistRemoval(evicted.map((record) => record.taskId));
+  }
 };
 function isTerminal(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
@@ -145,7 +567,24 @@ function clampLimit(raw) {
   if (n <= 0) return 50;
   return Math.min(n, 500);
 }
-function toStatusResult(record) {
+function abortableDelay(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function toStatusResult(record, opts) {
   const out = {
     taskId: record.taskId,
     profile: record.profile,
@@ -157,6 +596,12 @@ function toStatusResult(record) {
   if (record.error) out.error = record.error;
   if (record.costUsd !== void 0) out.costUsd = record.costUsd;
   if (record.completedAt) out.completedAt = record.completedAt;
+  if (record.traceId !== void 0) out.traceId = record.traceId;
+  if (record.parentSpanId !== void 0) out.parentSpanId = record.parentSpanId;
+  if (opts?.includeTrace === true && record.trace && record.trace.length > 0) {
+    out.trace = record.trace.map((span) => ({ ...span }));
+    if (record.traceTruncated) out.traceTruncated = true;
+  }
   return out;
 }
 function toHistoryEntry(record) {
@@ -165,12 +610,14 @@ function toHistoryEntry(record) {
     profile: record.profile,
     args: record.args,
     status: record.status,
-    startedAt: record.startedAt
+    startedAt: record.startedAt,
+    hasTrace: record.trace !== void 0 && record.trace.length > 0
   };
   if (record.namespace) entry.namespace = record.namespace;
   if (record.completedAt) entry.completedAt = record.completedAt;
   if (record.costUsd !== void 0) entry.costUsd = record.costUsd;
   if (record.feedback.length > 0) entry.feedback = [...record.feedback];
+  if (record.traceId !== void 0) entry.traceId = record.traceId;
   return entry;
 }
 function errorToShape(err) {
@@ -351,11 +798,17 @@ function createDelegateCodeHandler(options) {
       config: args.config,
       namespace: args.namespace
     });
+    const detached = options.detachedDispatch === true && (args.variants ?? 1) <= 1;
     const submitted = options.queue.submit({
       profile: "coder",
       args,
       namespace: args.namespace,
       idempotencyKey,
+      ...detached ? {
+        detachedSessionRef: formatDetachedSessionRef({
+          sessionId: `dlg-turn-coder-${idempotencyKey}`
+        })
+      } : {},
       run: async (ctx) => options.delegate(args, ctx)
     });
     return {
@@ -702,11 +1155,17 @@ function createDelegateResearchHandler(options) {
       variants: args.variants ?? 1,
       config: args.config
     });
+    const detached = options.detachedDispatch === true && (args.variants ?? 1) <= 1;
     const submitted = options.queue.submit({
       profile: "researcher",
       args,
       namespace: args.namespace,
       idempotencyKey,
+      ...detached ? {
+        detachedSessionRef: formatDetachedSessionRef({
+          sessionId: `dlg-turn-research-${idempotencyKey}`
+        })
+      } : {},
       run: async (ctx) => options.delegate(args, ctx)
     });
     return {
@@ -735,6 +1194,9 @@ var DELEGATION_HISTORY_DESCRIPTION = [
   'success rate of coder delegations on this repo?". Feed the results back',
   "into your own routing and calibration.",
   "",
+  "Each entry carries `hasTrace` \u2014 when true, the full loop-trace span tree",
+  "is retrievable via delegation_status { taskId, includeTrace: true }.",
+  "",
   'Filters: `namespace` (multi-tenant scope), `profile` ("coder" | "researcher"),',
   "`since` (ISO date \u2014 only delegations started at-or-after). `limit` defaults",
   "to 50, capped at 500."
@@ -805,13 +1267,21 @@ var DELEGATION_STATUS_DESCRIPTION = [
   "patch, test/typecheck results, and diff stats. For a completed research",
   "task, `result.output` is the items + citations + proposedWrites bundle.",
   "",
+  "Pass includeTrace: true to also receive the journaled loop-trace span",
+  "tree (loop \u2192 round \u2192 iteration, with placement/cost/verdict metadata).",
+  "Default false \u2014 keep routine polls light.",
+  "",
   "Throws NotFoundError when taskId is unknown \u2014 never silently returns",
   "`pending` for a typo."
 ].join("\n");
 var DELEGATION_STATUS_INPUT_SCHEMA = {
   type: "object",
   properties: {
-    taskId: { type: "string", description: "Returned by delegate_code / delegate_research." }
+    taskId: { type: "string", description: "Returned by delegate_code / delegate_research." },
+    includeTrace: {
+      type: "boolean",
+      description: "Also return the journaled loop-trace span tree for this delegation. Default false."
+    }
   },
   required: ["taskId"],
   additionalProperties: false
@@ -825,12 +1295,22 @@ function validateDelegationStatusArgs(raw) {
   if (typeof taskId !== "string" || taskId.trim().length === 0) {
     throw new TypeError("delegation_status: `taskId` must be a non-empty string");
   }
-  return { taskId: taskId.trim() };
+  const out = { taskId: taskId.trim() };
+  if (value.includeTrace !== void 0) {
+    if (typeof value.includeTrace !== "boolean") {
+      throw new TypeError("delegation_status: `includeTrace` must be a boolean");
+    }
+    out.includeTrace = value.includeTrace;
+  }
+  return out;
 }
 function createDelegationStatusHandler(options) {
   return async (raw) => {
     const args = validateDelegationStatusArgs(raw);
-    const status = options.queue.status(args.taskId);
+    const status = options.queue.status(
+      args.taskId,
+      args.includeTrace !== void 0 ? { includeTrace: args.includeTrace } : void 0
+    );
     if (!status) {
       throw new NotFoundError(`delegation_status: unknown taskId "${args.taskId}"`);
     }
@@ -838,338 +1318,11 @@ function createDelegationStatusHandler(options) {
   };
 }
 
-// src/otel-export.ts
-var SCOPE = { name: "@tangle-network/agent-runtime", version: "0.33.0" };
-var GEN_AI = {
-  operation: "gen_ai.operation.name",
-  agentName: "gen_ai.agent.name",
-  conversationId: "gen_ai.conversation.id",
-  inputTokens: "gen_ai.usage.input_tokens",
-  outputTokens: "gen_ai.usage.output_tokens"
-};
-function createOtelExporter(config) {
-  const resolvedEndpoint = config?.endpoint ?? (typeof process !== "undefined" ? process.env.OTEL_EXPORTER_OTLP_ENDPOINT : void 0);
-  if (!resolvedEndpoint) return void 0;
-  const endpoint = resolvedEndpoint;
-  const headers = config?.headers ?? parseHeadersFromEnv();
-  const batchSize = config?.batchSize ?? 64;
-  const flushIntervalMs = config?.flushIntervalMs ?? 5e3;
-  const serviceName = config?.serviceName ?? "agent-runtime";
-  const resourceAttrs = config?.resourceAttributes ?? {};
-  const pending = [];
-  let timer;
-  let stopped = false;
-  const exporter = {
-    exportSpan(span) {
-      if (stopped) return;
-      pending.push(span);
-      if (pending.length >= batchSize) {
-        void doFlush();
-      }
-    },
-    async flush() {
-      await doFlush();
-    },
-    async shutdown() {
-      stopped = true;
-      if (timer !== void 0) {
-        clearInterval(timer);
-        timer = void 0;
-      }
-      await doFlush();
-    }
-  };
-  timer = setInterval(() => {
-    if (pending.length > 0) void doFlush();
-  }, flushIntervalMs);
-  if (typeof timer === "object" && "unref" in timer) {
-    ;
-    timer.unref();
-  }
-  async function doFlush() {
-    if (pending.length === 0) return;
-    const batch = pending.splice(0);
-    const body = {
-      resourceSpans: [
-        {
-          resource: {
-            attributes: toAttributes({
-              "service.name": serviceName,
-              ...resourceAttrs
-            })
-          },
-          scopeSpans: [{ scope: SCOPE, spans: batch }]
-        }
-      ]
-    };
-    const url = `${endpoint.replace(/\/+$/, "")}/v1/traces`;
-    try {
-      await fetch(url, {
-        method: "POST",
-        headers: { "content-type": "application/json", ...headers },
-        body: JSON.stringify(body)
-      });
-    } catch {
-    }
-  }
-  return exporter;
-}
-function loopEventToOtelSpan(event, traceId, parentSpanId) {
-  const spanId = generateSpanId();
-  const attrs = {
-    "loop.event_kind": event.kind,
-    "loop.run_id": event.runId
-  };
-  for (const [k, v] of Object.entries(event.payload)) {
-    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
-      attrs[`loop.${k}`] = v;
-    }
-  }
-  const ts = msToNs(event.timestamp);
-  return {
-    traceId: padTraceId(traceId),
-    spanId,
-    parentSpanId: parentSpanId ? padSpanId(parentSpanId) : void 0,
-    name: event.kind,
-    kind: 1,
-    startTimeUnixNano: ts,
-    endTimeUnixNano: ts,
-    attributes: toAttributes(attrs),
-    status: { code: 1 }
-  };
-}
-function buildLoopOtelSpans(events, traceId, rootParentSpanId) {
-  if (events.length === 0) return [];
-  const tid = padTraceId(traceId);
-  const out = [];
-  const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
-  const str = (v) => typeof v === "string" && v.length > 0 ? v : void 0;
-  const rec = (v) => v && typeof v === "object" ? v : {};
-  const started = events.find((e) => e.kind === "loop.started");
-  const ended = events.find((e) => e.kind === "loop.ended");
-  const runId = events[0]?.runId ?? "";
-  const rootStart = started?.timestamp ?? events[0].timestamp;
-  const rootEnd = ended?.timestamp ?? events[events.length - 1].timestamp;
-  const rootId = generateSpanId();
-  const make = (spanId, parentSpanId, name, startMs, endMs, attrs, statusCode = 1) => ({
-    traceId: tid,
-    spanId,
-    parentSpanId: parentSpanId ? padSpanId(parentSpanId) : void 0,
-    name,
-    kind: 1,
-    startTimeUnixNano: msToNs(startMs),
-    endTimeUnixNano: msToNs(endMs),
-    attributes: toAttributes(attrs),
-    status: { code: statusCode }
-  });
-  const sp = rec(started?.payload);
-  const rootAttrs = {
-    [GEN_AI.operation]: "invoke_workflow",
-    [GEN_AI.conversationId]: runId,
-    "tangle.loop.driver": str(sp.driver) ?? "driver"
-  };
-  if (Array.isArray(sp.agentRunNames) && sp.agentRunNames.length > 0) {
-    rootAttrs["tangle.loop.agents"] = sp.agentRunNames.map(String).join(",");
-  }
-  if (ended) {
-    const ep = rec(ended.payload);
-    const win = num(ep.winnerIterationIndex);
-    if (win !== void 0) rootAttrs["tangle.loop.winner.iteration_index"] = win;
-    const cost = num(ep.totalCostUsd);
-    if (cost !== void 0) rootAttrs["tangle.cost.usd"] = cost;
-    const dur = num(ep.durationMs);
-    if (dur !== void 0) rootAttrs["tangle.loop.duration_ms"] = dur;
-    const iters = num(ep.iterations);
-    if (iters !== void 0) rootAttrs["tangle.loop.iterations"] = iters;
-  }
-  out.push(make(rootId, rootParentSpanId, "loop", rootStart, rootEnd, rootAttrs));
-  const iterStartTs = /* @__PURE__ */ new Map();
-  const placementByIdx = /* @__PURE__ */ new Map();
-  let currentRoundId;
-  let pendingRound;
-  const flushRound = (endMs) => {
-    if (!pendingRound) return;
-    out.push(
-      make(pendingRound.id, rootId, "loop.round", pendingRound.start, endMs, pendingRound.attrs)
-    );
-    pendingRound = void 0;
-  };
-  for (const e of events) {
-    const p = rec(e.payload);
-    switch (e.kind) {
-      case "loop.plan": {
-        flushRound(e.timestamp);
-        const id = generateSpanId();
-        const roundIdx = num(p.roundIndex) ?? 0;
-        const attrs = {
-          [GEN_AI.operation]: "invoke_workflow",
-          "tangle.loop.round.index": roundIdx,
-          "tangle.loop.move.kind": str(p.moveKind) ?? "unknown",
-          "tangle.loop.move.round": roundIdx,
-          "tangle.loop.move.width": num(p.plannedCount) ?? 0
-        };
-        const r = str(p.rationale);
-        if (r) attrs["tangle.loop.move.rationale"] = r;
-        const parent = num(p.parentIndex);
-        if (parent !== void 0) attrs["tangle.loop.move.parent_index"] = parent;
-        if (Array.isArray(p.childIndices) && p.childIndices.length > 0) {
-          attrs["tangle.loop.move.child_indices"] = p.childIndices.map(String).join(",");
-        }
-        pendingRound = { id, start: e.timestamp, attrs };
-        currentRoundId = id;
-        break;
-      }
-      case "loop.iteration.started": {
-        const idx = num(p.iterationIndex);
-        if (idx !== void 0) iterStartTs.set(idx, e.timestamp);
-        break;
-      }
-      case "loop.iteration.dispatch": {
-        const idx = num(p.iterationIndex);
-        if (idx === void 0) break;
-        const place = {};
-        const kind = str(p.placement);
-        if (kind) place["tangle.loop.placement.kind"] = kind;
-        const sid = str(p.sandboxId);
-        if (sid) place["tangle.sandbox.id"] = sid;
-        const fid = str(p.fleetId);
-        if (fid) place["tangle.fleet.id"] = fid;
-        const mid = str(p.machineId);
-        if (mid) place["tangle.machine.id"] = mid;
-        placementByIdx.set(idx, place);
-        break;
-      }
-      case "loop.iteration.ended": {
-        const idx = num(p.iterationIndex) ?? 0;
-        const start = iterStartTs.get(idx) ?? e.timestamp;
-        const err = str(p.error);
-        const attrs = {
-          [GEN_AI.operation]: "invoke_agent",
-          "tangle.loop.iteration.index": idx
-        };
-        const agent = str(p.agentRunName);
-        if (agent) attrs[GEN_AI.agentName] = agent;
-        const tu = rec(p.tokenUsage);
-        const inTok = num(tu.input);
-        if (inTok !== void 0) attrs[GEN_AI.inputTokens] = inTok;
-        const outTok = num(tu.output);
-        if (outTok !== void 0) attrs[GEN_AI.outputTokens] = outTok;
-        const cost = num(p.costUsd);
-        if (cost !== void 0) attrs["tangle.cost.usd"] = cost;
-        const verdict = rec(p.verdict);
-        if (typeof verdict.valid === "boolean") attrs["tangle.loop.verdict.valid"] = verdict.valid;
-        const score = num(verdict.score);
-        if (score !== void 0) attrs["tangle.loop.verdict.score"] = score;
-        if (err) attrs["tangle.loop.error"] = err;
-        const gid = num(p.groupId);
-        if (gid !== void 0) attrs["tangle.loop.iteration.group_id"] = gid;
-        const par = num(p.parentIndex);
-        if (par !== void 0) attrs["tangle.loop.iteration.parent_index"] = par;
-        const dur = num(p.durationMs);
-        if (dur !== void 0) attrs["tangle.loop.iteration.duration_ms"] = dur;
-        const preview = str(p.outputPreview);
-        if (preview) attrs["tangle.loop.iteration.output_preview"] = preview;
-        Object.assign(attrs, placementByIdx.get(idx) ?? {});
-        out.push(
-          make(
-            generateSpanId(),
-            currentRoundId ?? rootId,
-            "loop.iteration",
-            start,
-            e.timestamp,
-            attrs,
-            err ? 2 : 1
-          )
-        );
-        break;
-      }
-      case "loop.decision": {
-        if (pendingRound) {
-          const dec = str(p.decision);
-          if (dec) pendingRound.attrs["tangle.loop.decision"] = dec;
-          flushRound(e.timestamp);
-        }
-        currentRoundId = void 0;
-        break;
-      }
-    }
-  }
-  flushRound(rootEnd);
-  return out;
-}
-function parseHeadersFromEnv() {
-  if (typeof process === "undefined") return {};
-  const raw = process.env.OTEL_EXPORTER_OTLP_HEADERS;
-  if (!raw) return {};
-  const out = {};
-  for (const pair of raw.split(",")) {
-    const eq = pair.indexOf("=");
-    if (eq < 0) continue;
-    const key = pair.slice(0, eq).trim();
-    const value = pair.slice(eq + 1).trim();
-    if (key) out[key] = value;
-  }
-  return out;
-}
-function toAttributes(record) {
-  return Object.entries(record).map(([key, value]) => ({
-    key,
-    value: typeof value === "number" ? Number.isInteger(value) ? { intValue: value.toString() } : { doubleValue: value } : typeof value === "boolean" ? { boolValue: value } : { stringValue: value }
-  }));
-}
-function msToNs(ms) {
-  return (BigInt(Math.floor(ms)) * 1000000n).toString();
-}
-function padSpanId(id) {
-  const cleaned = id.replace(/-/g, "");
-  return cleaned.slice(0, 16).padEnd(16, "0");
-}
-function padTraceId(id) {
-  const cleaned = id.replace(/-/g, "");
-  return cleaned.slice(0, 32).padEnd(32, "0");
-}
-function generateSpanId() {
-  const bytes = new Uint8Array(8);
-  if (typeof globalThis.crypto?.getRandomValues === "function") {
-    globalThis.crypto.getRandomValues(bytes);
-  } else {
-    for (let i = 0; i < 8; i++) bytes[i] = Math.floor(Math.random() * 256);
-  }
-  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-var INTELLIGENCE_WIRE_VERSION = "2026-05-26.v1";
-var DEFAULT_INTELLIGENCE_BASE = "https://intelligence.tangle.tools";
-async function exportEvalRuns(events, config) {
-  if (events.length === 0) return { ok: true, status: 0, accepted: 0, rejected: [] };
-  const apiKey = config?.apiKey ?? (typeof process !== "undefined" ? process.env.TANGLE_API_KEY : void 0);
-  if (!apiKey)
-    throw new Error("exportEvalRuns: apiKey required (pass config.apiKey or set TANGLE_API_KEY)");
-  const base = config?.base ?? (typeof process !== "undefined" ? process.env.INTELLIGENCE_BASE : void 0) ?? DEFAULT_INTELLIGENCE_BASE;
-  const url = `${base.replace(/\/+$/, "")}/v1/ingest/eval-runs`;
-  const res = await fetch(url, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      authorization: `Bearer ${apiKey}`,
-      "X-Tangle-Wire-Version": INTELLIGENCE_WIRE_VERSION,
-      ...config?.idempotencyKey ? { "Idempotency-Key": config.idempotencyKey } : {}
-    },
-    body: JSON.stringify({ wireVersion: INTELLIGENCE_WIRE_VERSION, events })
-  });
-  let parsed = {};
-  try {
-    parsed = await res.json();
-  } catch {
-  }
-  return {
-    ok: res.ok,
-    status: res.status,
-    accepted: parsed.accepted ?? (res.ok ? events.length : 0),
-    rejected: parsed.rejected ?? []
-  };
-}
-
 export {
+  DelegationStateCorruptError,
+  DelegationPersistenceError,
+  InMemoryDelegationStore,
+  FileDelegationStore,
   DelegationTaskQueue,
   hashIdempotencyInput,
   DELEGATE_CODE_TOOL_NAME,
@@ -1198,11 +1351,6 @@ export {
   DELEGATION_STATUS_DESCRIPTION,
   DELEGATION_STATUS_INPUT_SCHEMA,
   validateDelegationStatusArgs,
-  createDelegationStatusHandler,
-  createOtelExporter,
-  loopEventToOtelSpan,
-  buildLoopOtelSpans,
-  INTELLIGENCE_WIRE_VERSION,
-  exportEvalRuns
+  createDelegationStatusHandler
 };
-//# sourceMappingURL=chunk-JNPK46YH.js.map
+//# sourceMappingURL=chunk-RHW75JW5.js.map