@tangle-network/agent-runtime 0.52.0 → 0.54.0

package/dist/chunk-BERLUBAP.js

@@ -1,1356 +0,0 @@
-import {
-  capDelegationTrace,
-  createDelegationTraceCollector,
-  formatDetachedSessionRef,
-  generateDelegationSpanId
-} from "./chunk-4JI4BCBI.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 _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. 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)) {
-        return { taskId: existing, reused: true };
-      }
-    }
-    const taskId = this.generateId();
-    const controller = new AbortController();
-    const record = {
-      taskId,
-      profile: input.profile,
-      namespace: input.namespace,
-      args: input.args,
-      status: "pending",
-      startedAt: this.now(),
-      feedback: [],
-      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);
-    });
-    return { taskId, reused: false };
-  }
-  /**
-   * 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, opts) {
-    const record = this.records.get(taskId);
-    if (!record) return void 0;
-    return toStatusResult(record, opts);
-  }
-  /**
-   * Abort an in-flight delegation. Returns `false` if the task is unknown
-   * or already terminal. The underlying `run` function MUST honor the
-   * abort signal for the cancel to take effect; the queue marks the
-   * record `cancelled` regardless so a misbehaving runner cannot pin the
-   * UI on `running` forever.
-   */
-  cancel(taskId) {
-    const record = this.records.get(taskId);
-    if (!record) return false;
-    if (isTerminal(record.status)) return false;
-    const controller = this.controllers.get(taskId);
-    controller?.abort();
-    record.status = "cancelled";
-    record.completedAt = this.now();
-    record.error = { message: "cancelled by caller", kind: "CancelledError" };
-    this.persist(record);
-    this.enforceRetention();
-    return true;
-  }
-  /**
-   * Append a feedback event to the matching delegation. Returns `false`
-   * when `ref` does not name a known taskId — the caller should still
-   * record the feedback through a different surface (artifact/outcome
-   * kinds are not queue-bound).
-   */
-  attachFeedback(taskId, snapshot) {
-    const record = this.records.get(taskId);
-    if (!record) return false;
-    record.feedback.push(snapshot);
-    this.persist(record);
-    return true;
-  }
-  /**
-   * Query the recorded delegations. Returns entries newest-first (by
-   * `startedAt`), truncated to `limit`.
-   */
-  history(args = {}) {
-    const limit = clampLimit(args.limit);
-    const since = args.since ? Date.parse(args.since) : Number.NEGATIVE_INFINITY;
-    const out = [];
-    for (const record of this.records.values()) {
-      if (args.namespace && record.namespace !== args.namespace) continue;
-      if (args.profile && record.profile !== args.profile) continue;
-      if (Number.isFinite(since) && Date.parse(record.startedAt) < since) continue;
-      out.push(toHistoryEntry(record));
-    }
-    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;
-    for (const record of this.records.values()) {
-      if (!isTerminal(record.status)) n += 1;
-    }
-    return n;
-  }
-  async execute(taskId, input, controller) {
-    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;
-            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";
-}
-function currentStatus(record) {
-  return record.status;
-}
-function clampLimit(raw) {
-  if (!Number.isFinite(raw)) return 50;
-  const n = Math.trunc(raw);
-  if (n <= 0) return 50;
-  return Math.min(n, 500);
-}
-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,
-    status: record.status,
-    startedAt: record.startedAt
-  };
-  if (record.progress) out.progress = record.progress;
-  if (record.result) out.result = record.result;
-  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) {
-  const entry = {
-    taskId: record.taskId,
-    profile: record.profile,
-    args: record.args,
-    status: record.status,
-    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) {
-  if (err instanceof Error) {
-    return { message: err.message, kind: err.name || "Error" };
-  }
-  return { message: String(err), kind: "NonError" };
-}
-function randomTaskId() {
-  const t = Date.now().toString(36);
-  const r = Math.random().toString(36).slice(2, 10);
-  return `dlg-${t}-${r}`;
-}
-function hashIdempotencyInput(value) {
-  let str;
-  try {
-    str = JSON.stringify(canonicalize(value));
-  } catch {
-    str = String(value);
-  }
-  let h = 2166136261;
-  for (let i = 0; i < str.length; i += 1) {
-    h ^= str.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return (h >>> 0).toString(16).padStart(8, "0");
-}
-function canonicalize(value) {
-  if (value === null || typeof value !== "object") return value;
-  if (Array.isArray(value)) return value.map(canonicalize);
-  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a.localeCompare(b));
-  const out = {};
-  for (const [k, v] of entries) out[k] = canonicalize(v);
-  return out;
-}
-
-// src/mcp/tools/delegate-code.ts
-var DELEGATE_CODE_TOOL_NAME = "delegate_code";
-var DELEGATE_CODE_DESCRIPTION = [
-  "Delegate a coding task to specialist coder agents that produce a validated patch.",
-  "",
-  "Use when: you need code written, fixed, refactored, or extended to satisfy a",
-  "user goal that touches a real repository. The coder runs in an isolated",
-  "sandbox, opens a fresh branch, keeps the diff minimal, runs the supplied",
-  "test + typecheck commands, and emits a unified-diff patch.",
-  "",
-  "Returns immediately with a taskId. Poll delegation_status to retrieve the",
-  "patch + validator verdict (typically minutes-to-hours, longer for large",
-  "changes). Identical inputs return the same taskId \u2014 safe to retry.",
-  "",
-  "When variants > 1, multiple coder harnesses (claude-code, codex, opencode)",
-  "attempt the task in parallel and the highest-scoring patch wins (smallest",
-  "passing diff). Use variants for high-stakes changes; single variant for",
-  "routine ones.",
-  "",
-  "Capability scope: the coder cannot modify paths outside repoRoot and cannot",
-  "touch paths in config.forbiddenPaths. The validator hard-fails on a",
-  "forbidden-path violation, diff above config.maxDiffLines, test failure, or",
-  "typecheck failure \u2014 none of those make it past the gate."
-].join("\n");
-var DELEGATE_CODE_INPUT_SCHEMA = {
-  type: "object",
-  properties: {
-    goal: {
-      type: "string",
-      description: "Natural-language description of what the coder must accomplish."
-    },
-    repoRoot: {
-      type: "string",
-      description: "Absolute path inside the sandbox where the repo lives."
-    },
-    contextHint: {
-      type: "string",
-      description: "Optional free-form context the coder sees in the prompt prelude."
-    },
-    variants: {
-      type: "integer",
-      minimum: 1,
-      maximum: 8,
-      description: "Number of parallel coder harnesses. Default 1."
-    },
-    config: {
-      type: "object",
-      properties: {
-        testCmd: { type: "string" },
-        typecheckCmd: { type: "string" },
-        forbiddenPaths: { type: "array", items: { type: "string" } },
-        maxDiffLines: { type: "integer", minimum: 1 }
-      },
-      additionalProperties: false
-    },
-    namespace: {
-      type: "string",
-      description: "Multi-tenant scope (customer-id, workspace-id)."
-    }
-  },
-  required: ["goal", "repoRoot"],
-  additionalProperties: false
-};
-var SINGLE_VARIANT_ESTIMATE_MS = 6 * 60 * 1e3;
-var FANOUT_PER_VARIANT_ESTIMATE_MS = 8 * 60 * 1e3;
-function validateDelegateCodeArgs(raw) {
-  if (raw === null || typeof raw !== "object") {
-    throw new TypeError("delegate_code: arguments must be an object");
-  }
-  const value = raw;
-  const goal = value.goal;
-  if (typeof goal !== "string" || goal.trim().length === 0) {
-    throw new TypeError("delegate_code: `goal` must be a non-empty string");
-  }
-  const repoRoot = value.repoRoot;
-  if (typeof repoRoot !== "string" || repoRoot.trim().length === 0) {
-    throw new TypeError("delegate_code: `repoRoot` must be a non-empty string");
-  }
-  const args = { goal: goal.trim(), repoRoot: repoRoot.trim() };
-  if (typeof value.contextHint === "string") args.contextHint = value.contextHint;
-  if (value.variants !== void 0) {
-    const variants = Number(value.variants);
-    if (!Number.isFinite(variants) || variants < 1 || variants > 8) {
-      throw new RangeError("delegate_code: `variants` must be an integer in [1, 8]");
-    }
-    args.variants = Math.trunc(variants);
-  }
-  if (value.config !== void 0) {
-    args.config = validateConfig(value.config);
-  }
-  if (typeof value.namespace === "string") args.namespace = value.namespace;
-  return args;
-}
-function validateConfig(raw) {
-  if (raw === null || typeof raw !== "object") {
-    throw new TypeError("delegate_code: `config` must be an object");
-  }
-  const value = raw;
-  const out = {};
-  if (value.testCmd !== void 0) {
-    if (typeof value.testCmd !== "string") {
-      throw new TypeError("delegate_code: `config.testCmd` must be a string");
-    }
-    out.testCmd = value.testCmd;
-  }
-  if (value.typecheckCmd !== void 0) {
-    if (typeof value.typecheckCmd !== "string") {
-      throw new TypeError("delegate_code: `config.typecheckCmd` must be a string");
-    }
-    out.typecheckCmd = value.typecheckCmd;
-  }
-  if (value.forbiddenPaths !== void 0) {
-    if (!Array.isArray(value.forbiddenPaths)) {
-      throw new TypeError("delegate_code: `config.forbiddenPaths` must be a string array");
-    }
-    out.forbiddenPaths = value.forbiddenPaths.map((entry, i) => {
-      if (typeof entry !== "string") {
-        throw new TypeError(`delegate_code: forbiddenPaths[${i}] must be a string`);
-      }
-      return entry;
-    });
-  }
-  if (value.maxDiffLines !== void 0) {
-    const n = Number(value.maxDiffLines);
-    if (!Number.isFinite(n) || n < 1) {
-      throw new RangeError("delegate_code: `config.maxDiffLines` must be a positive integer");
-    }
-    out.maxDiffLines = Math.trunc(n);
-  }
-  return out;
-}
-function createDelegateCodeHandler(options) {
-  const estimateDurationMs = options.estimateDurationMs ?? defaultEstimate;
-  return async (raw) => {
-    const args = validateDelegateCodeArgs(raw);
-    const idempotencyKey = hashIdempotencyInput({
-      profile: "coder",
-      goal: args.goal,
-      repoRoot: args.repoRoot,
-      contextHint: args.contextHint,
-      variants: args.variants ?? 1,
-      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 {
-      taskId: submitted.taskId,
-      estimatedDurationMs: estimateDurationMs(args)
-    };
-  };
-}
-function defaultEstimate(args) {
-  const variants = Math.max(1, args.variants ?? 1);
-  if (variants === 1) return SINGLE_VARIANT_ESTIMATE_MS;
-  return FANOUT_PER_VARIANT_ESTIMATE_MS;
-}
-
-// src/mcp/feedback-store.ts
-var InMemoryFeedbackStore = class {
-  events = [];
-  async put(event) {
-    this.events.push({ ...event });
-  }
-  async list(filter = {}) {
-    let out = this.events;
-    if (filter.namespace !== void 0) {
-      out = out.filter((event) => event.namespace === filter.namespace);
-    }
-    if (filter.refersToRef !== void 0) {
-      out = out.filter((event) => event.refersTo.ref === filter.refersToRef);
-    }
-    return out.map((event) => ({ ...event }));
-  }
-};
-function eventToSnapshot(event) {
-  const snap = {
-    id: event.id,
-    score: event.rating.score,
-    by: event.by,
-    notes: event.rating.notes,
-    capturedAt: event.capturedAt
-  };
-  if (event.rating.label) snap.label = event.rating.label;
-  return snap;
-}
-
-// src/mcp/tools/delegate-feedback.ts
-var DELEGATE_FEEDBACK_TOOL_NAME = "delegate_feedback";
-var DELEGATE_FEEDBACK_DESCRIPTION = [
-  "Record feedback on a delegation, artifact, or outcome. Synchronous \u2014 the",
-  "event is durably stored when this call returns.",
-  "",
-  "Use when: you (the agent), the user, or a downstream judge has formed an",
-  "opinion about a piece of work and want it persisted for calibration,",
-  "pricing, or future routing. Every call is a new event \u2014 multiple ratings",
-  "on the same target are expected and never deduped.",
-  "",
-  "`refersTo.kind`:",
-  '  - "delegation": ref is a taskId returned by delegate_code/delegate_research',
-  '  - "artifact":   ref is a URI/path/git-sha \u2014 anything you can dereference',
-  '  - "outcome":    ref is a free-form description of a downstream result',
-  "",
-  "`by`:",
-  '  - "agent":            the agent itself rated the work',
-  '  - "user":             the human user rated it',
-  '  - "downstream-judge": an automated evaluator emitted the rating',
-  "",
-  "When ref names a known taskId, the rating is also attached to the",
-  "delegation record so delegation_history surfaces it inline."
-].join("\n");
-var DELEGATE_FEEDBACK_INPUT_SCHEMA = {
-  type: "object",
-  properties: {
-    refersTo: {
-      type: "object",
-      properties: {
-        kind: { type: "string", enum: ["delegation", "artifact", "outcome"] },
-        ref: { type: "string" }
-      },
-      required: ["kind", "ref"],
-      additionalProperties: false
-    },
-    rating: {
-      type: "object",
-      properties: {
-        score: { type: "number", minimum: 0, maximum: 1 },
-        label: { type: "string", enum: ["good", "bad", "neutral", "mixed"] },
-        notes: { type: "string" }
-      },
-      required: ["score", "notes"],
-      additionalProperties: false
-    },
-    by: { type: "string", enum: ["agent", "user", "downstream-judge"] },
-    capturedAt: { type: "string" },
-    namespace: { type: "string" }
-  },
-  required: ["refersTo", "rating", "by"],
-  additionalProperties: false
-};
-function validateDelegateFeedbackArgs(raw) {
-  if (raw === null || typeof raw !== "object") {
-    throw new TypeError("delegate_feedback: arguments must be an object");
-  }
-  const value = raw;
-  const refersTo = validateRefersTo(value.refersTo);
-  const rating = validateRating(value.rating);
-  const by = value.by;
-  if (by !== "agent" && by !== "user" && by !== "downstream-judge") {
-    throw new TypeError(
-      'delegate_feedback: `by` must be one of "agent" | "user" | "downstream-judge"'
-    );
-  }
-  const args = { refersTo, rating, by };
-  if (value.capturedAt !== void 0) {
-    if (typeof value.capturedAt !== "string" || Number.isNaN(Date.parse(value.capturedAt))) {
-      throw new TypeError("delegate_feedback: `capturedAt` must be an ISO datetime");
-    }
-    args.capturedAt = value.capturedAt;
-  }
-  if (typeof value.namespace === "string") args.namespace = value.namespace;
-  return args;
-}
-function validateRefersTo(raw) {
-  if (raw === null || typeof raw !== "object") {
-    throw new TypeError("delegate_feedback: `refersTo` must be an object");
-  }
-  const value = raw;
-  const kind = value.kind;
-  if (kind !== "delegation" && kind !== "artifact" && kind !== "outcome") {
-    throw new TypeError(
-      'delegate_feedback: `refersTo.kind` must be one of "delegation" | "artifact" | "outcome"'
-    );
-  }
-  const ref = value.ref;
-  if (typeof ref !== "string" || ref.trim().length === 0) {
-    throw new TypeError("delegate_feedback: `refersTo.ref` must be a non-empty string");
-  }
-  return { kind, ref: ref.trim() };
-}
-function validateRating(raw) {
-  if (raw === null || typeof raw !== "object") {
-    throw new TypeError("delegate_feedback: `rating` must be an object");
-  }
-  const value = raw;
-  const score = Number(value.score);
-  if (!Number.isFinite(score) || score < 0 || score > 1) {
-    throw new RangeError("delegate_feedback: `rating.score` must be a number in [0, 1]");
-  }
-  const notes = value.notes;
-  if (typeof notes !== "string") {
-    throw new TypeError("delegate_feedback: `rating.notes` must be a string");
-  }
-  const rating = { score, notes };
-  const label = value.label;
-  if (label !== void 0) {
-    if (label !== "good" && label !== "bad" && label !== "neutral" && label !== "mixed") {
-      throw new TypeError(
-        'delegate_feedback: `rating.label` must be one of "good" | "bad" | "neutral" | "mixed"'
-      );
-    }
-    rating.label = label;
-  }
-  return rating;
-}
-function createDelegateFeedbackHandler(options) {
-  const generateId = options.generateId ?? randomFeedbackId;
-  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  return async (raw) => {
-    const args = validateDelegateFeedbackArgs(raw);
-    const id = generateId();
-    const event = {
-      id,
-      refersTo: args.refersTo,
-      rating: args.rating,
-      by: args.by,
-      capturedAt: args.capturedAt ?? now(),
-      namespace: args.namespace
-    };
-    await options.store.put(event);
-    if (args.refersTo.kind === "delegation") {
-      options.queue.attachFeedback(args.refersTo.ref, eventToSnapshot(event));
-    }
-    return { recorded: true, id };
-  };
-}
-function randomFeedbackId() {
-  const t = Date.now().toString(36);
-  const r = Math.random().toString(36).slice(2, 10);
-  return `fbk-${t}-${r}`;
-}
-
-// src/mcp/tools/delegate-research.ts
-var DELEGATE_RESEARCH_TOOL_NAME = "delegate_research";
-var DELEGATE_RESEARCH_DESCRIPTION = [
-  "Delegate a research question to specialist researcher agents that produce",
-  "source-grounded, evidence-bearing knowledge items.",
-  "",
-  "Use when: you need to answer a factual question with external evidence \u2014",
-  "audience research, competitive intelligence, recency-bound web searches,",
-  "corpus / docs lookups. The researcher emits items[] with provenance, a",
-  "citations[] index, and proposedWrites[] you decide whether to persist.",
-  "",
-  "Returns immediately with a taskId. Poll delegation_status to retrieve the",
-  "items + verdict. Identical inputs return the same taskId \u2014 safe to retry.",
-  "",
-  "When variants > 1, multiple researcher harnesses run in parallel and the",
-  "highest-scoring valid output wins (citation density \xD7 source diversity \xD7",
-  "recency match \xD7 gap coverage). Use variants when answers might disagree.",
-  "",
-  "Multi-tenant isolation: every item carries `namespace`. The validator",
-  "hard-fails when any item is scoped outside `namespace`. Never pass another",
-  "tenant's namespace."
-].join("\n");
-var VALID_SOURCES = ["web", "corpus", "twitter", "github", "docs"];
-var DELEGATE_RESEARCH_INPUT_SCHEMA = {
-  type: "object",
-  properties: {
-    question: {
-      type: "string",
-      description: "The research question to answer."
-    },
-    namespace: {
-      type: "string",
-      description: "Multi-tenant scope (customer-id, workspace-id). REQUIRED."
-    },
-    scope: { type: "string", description: 'Bound, e.g. "audience for cpg-founder ICP".' },
-    sources: {
-      type: "array",
-      items: { type: "string", enum: [...VALID_SOURCES] }
-    },
-    variants: { type: "integer", minimum: 1, maximum: 8 },
-    config: {
-      type: "object",
-      properties: {
-        recencyWindow: {
-          type: "object",
-          properties: {
-            since: { type: "string", description: "ISO datetime" },
-            until: { type: "string", description: "ISO datetime" }
-          },
-          additionalProperties: false
-        },
-        maxItems: { type: "integer", minimum: 1 },
-        minConfidence: { type: "number", minimum: 0, maximum: 1 }
-      },
-      additionalProperties: false
-    }
-  },
-  required: ["question", "namespace"],
-  additionalProperties: false
-};
-var SINGLE_VARIANT_ESTIMATE_MS2 = 4 * 60 * 1e3;
-var FANOUT_PER_VARIANT_ESTIMATE_MS2 = 6 * 60 * 1e3;
-function validateDelegateResearchArgs(raw) {
-  if (raw === null || typeof raw !== "object") {
-    throw new TypeError("delegate_research: arguments must be an object");
-  }
-  const value = raw;
-  const question = value.question;
-  if (typeof question !== "string" || question.trim().length === 0) {
-    throw new TypeError("delegate_research: `question` must be a non-empty string");
-  }
-  const namespace = value.namespace;
-  if (typeof namespace !== "string" || namespace.trim().length === 0) {
-    throw new TypeError("delegate_research: `namespace` is required");
-  }
-  const args = { question: question.trim(), namespace: namespace.trim() };
-  if (typeof value.scope === "string") args.scope = value.scope;
-  if (value.sources !== void 0) {
-    if (!Array.isArray(value.sources)) {
-      throw new TypeError("delegate_research: `sources` must be a string array");
-    }
-    const sources = value.sources.map((src, i) => {
-      if (typeof src !== "string" || !VALID_SOURCES.includes(src)) {
-        throw new TypeError(
-          `delegate_research: sources[${i}] must be one of ${VALID_SOURCES.join("|")}`
-        );
-      }
-      return src;
-    });
-    args.sources = sources;
-  }
-  if (value.variants !== void 0) {
-    const variants = Number(value.variants);
-    if (!Number.isFinite(variants) || variants < 1 || variants > 8) {
-      throw new RangeError("delegate_research: `variants` must be an integer in [1, 8]");
-    }
-    args.variants = Math.trunc(variants);
-  }
-  if (value.config !== void 0) {
-    args.config = validateConfig2(value.config);
-  }
-  return args;
-}
-function validateConfig2(raw) {
-  if (raw === null || typeof raw !== "object") {
-    throw new TypeError("delegate_research: `config` must be an object");
-  }
-  const value = raw;
-  const out = {};
-  if (value.recencyWindow !== void 0) {
-    if (value.recencyWindow === null || typeof value.recencyWindow !== "object") {
-      throw new TypeError("delegate_research: `config.recencyWindow` must be an object");
-    }
-    const window = value.recencyWindow;
-    const windowOut = {};
-    if (window.since !== void 0) {
-      if (typeof window.since !== "string" || Number.isNaN(Date.parse(window.since))) {
-        throw new TypeError("delegate_research: `recencyWindow.since` must be an ISO datetime");
-      }
-      windowOut.since = window.since;
-    }
-    if (window.until !== void 0) {
-      if (typeof window.until !== "string" || Number.isNaN(Date.parse(window.until))) {
-        throw new TypeError("delegate_research: `recencyWindow.until` must be an ISO datetime");
-      }
-      windowOut.until = window.until;
-    }
-    out.recencyWindow = windowOut;
-  }
-  if (value.maxItems !== void 0) {
-    const n = Number(value.maxItems);
-    if (!Number.isFinite(n) || n < 1) {
-      throw new RangeError("delegate_research: `config.maxItems` must be a positive integer");
-    }
-    out.maxItems = Math.trunc(n);
-  }
-  if (value.minConfidence !== void 0) {
-    const n = Number(value.minConfidence);
-    if (!Number.isFinite(n) || n < 0 || n > 1) {
-      throw new RangeError("delegate_research: `config.minConfidence` must be in [0, 1]");
-    }
-    out.minConfidence = n;
-  }
-  return out;
-}
-function createDelegateResearchHandler(options) {
-  const estimateDurationMs = options.estimateDurationMs ?? defaultEstimate2;
-  return async (raw) => {
-    const args = validateDelegateResearchArgs(raw);
-    const idempotencyKey = hashIdempotencyInput({
-      profile: "researcher",
-      question: args.question,
-      namespace: args.namespace,
-      scope: args.scope,
-      sources: args.sources,
-      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 {
-      taskId: submitted.taskId,
-      estimatedDurationMs: estimateDurationMs(args)
-    };
-  };
-}
-function defaultEstimate2(args) {
-  const variants = Math.max(1, args.variants ?? 1);
-  if (variants === 1) return SINGLE_VARIANT_ESTIMATE_MS2;
-  return FANOUT_PER_VARIANT_ESTIMATE_MS2;
-}
-
-// src/mcp/tools/delegation-history.ts
-var DELEGATION_HISTORY_TOOL_NAME = "delegation_history";
-var DELEGATION_HISTORY_DESCRIPTION = [
-  "Read past delegations newest-first. Each entry carries the original",
-  "arguments, current status, cost, and any feedback attached via",
-  "delegate_feedback.",
-  "",
-  'Use when: you want to introspect prior decisions \u2014 "have I asked this',
-  "question before?",
-  "did the last patch land?",
-  "what's the historical",
-  '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."
-].join("\n");
-var DELEGATION_HISTORY_INPUT_SCHEMA = {
-  type: "object",
-  properties: {
-    namespace: { type: "string" },
-    profile: { type: "string", enum: ["coder", "researcher"] },
-    since: { type: "string", description: "ISO datetime \u2014 earliest startedAt to include." },
-    limit: { type: "integer", minimum: 1, maximum: 500 }
-  },
-  additionalProperties: false
-};
-function validateDelegationHistoryArgs(raw) {
-  if (raw === void 0 || raw === null) return {};
-  if (typeof raw !== "object") {
-    throw new TypeError("delegation_history: arguments must be an object");
-  }
-  const value = raw;
-  const out = {};
-  if (value.namespace !== void 0) {
-    if (typeof value.namespace !== "string") {
-      throw new TypeError("delegation_history: `namespace` must be a string");
-    }
-    out.namespace = value.namespace;
-  }
-  if (value.profile !== void 0) {
-    if (value.profile !== "coder" && value.profile !== "researcher") {
-      throw new TypeError('delegation_history: `profile` must be "coder" or "researcher"');
-    }
-    out.profile = value.profile;
-  }
-  if (value.since !== void 0) {
-    if (typeof value.since !== "string" || Number.isNaN(Date.parse(value.since))) {
-      throw new TypeError("delegation_history: `since` must be an ISO datetime");
-    }
-    out.since = value.since;
-  }
-  if (value.limit !== void 0) {
-    const n = Number(value.limit);
-    if (!Number.isFinite(n) || n < 1 || n > 500) {
-      throw new RangeError("delegation_history: `limit` must be an integer in [1, 500]");
-    }
-    out.limit = Math.trunc(n);
-  }
-  return out;
-}
-function createDelegationHistoryHandler(options) {
-  return async (raw) => {
-    const args = validateDelegationHistoryArgs(raw);
-    return { delegations: options.queue.history(args) };
-  };
-}
-
-// src/mcp/tools/delegation-status.ts
-var DELEGATION_STATUS_TOOL_NAME = "delegation_status";
-var DELEGATION_STATUS_DESCRIPTION = [
-  "Poll the status of an async delegation. Returns the current state",
-  "(pending | running | completed | failed | cancelled), optional progress,",
-  'and the final result when status === "completed".',
-  "",
-  "Use when: you previously called delegate_code or delegate_research and",
-  "need to know whether the work is done. The agent's right rhythm is to",
-  "call this every minute or two while waiting; do not busy-poll.",
-  "",
-  "For a completed coder task, `result.output` is a CoderOutput with branch,",
-  "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." },
-    includeTrace: {
-      type: "boolean",
-      description: "Also return the journaled loop-trace span tree for this delegation. Default false."
-    }
-  },
-  required: ["taskId"],
-  additionalProperties: false
-};
-function validateDelegationStatusArgs(raw) {
-  if (raw === null || typeof raw !== "object") {
-    throw new TypeError("delegation_status: arguments must be an object");
-  }
-  const value = raw;
-  const taskId = value.taskId;
-  if (typeof taskId !== "string" || taskId.trim().length === 0) {
-    throw new TypeError("delegation_status: `taskId` must be a non-empty string");
-  }
-  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,
-      args.includeTrace !== void 0 ? { includeTrace: args.includeTrace } : void 0
-    );
-    if (!status) {
-      throw new NotFoundError(`delegation_status: unknown taskId "${args.taskId}"`);
-    }
-    return status;
-  };
-}
-
-export {
-  DelegationStateCorruptError,
-  DelegationPersistenceError,
-  InMemoryDelegationStore,
-  FileDelegationStore,
-  DelegationTaskQueue,
-  hashIdempotencyInput,
-  DELEGATE_CODE_TOOL_NAME,
-  DELEGATE_CODE_DESCRIPTION,
-  DELEGATE_CODE_INPUT_SCHEMA,
-  validateDelegateCodeArgs,
-  createDelegateCodeHandler,
-  InMemoryFeedbackStore,
-  eventToSnapshot,
-  DELEGATE_FEEDBACK_TOOL_NAME,
-  DELEGATE_FEEDBACK_DESCRIPTION,
-  DELEGATE_FEEDBACK_INPUT_SCHEMA,
-  validateDelegateFeedbackArgs,
-  createDelegateFeedbackHandler,
-  DELEGATE_RESEARCH_TOOL_NAME,
-  DELEGATE_RESEARCH_DESCRIPTION,
-  DELEGATE_RESEARCH_INPUT_SCHEMA,
-  validateDelegateResearchArgs,
-  createDelegateResearchHandler,
-  DELEGATION_HISTORY_TOOL_NAME,
-  DELEGATION_HISTORY_DESCRIPTION,
-  DELEGATION_HISTORY_INPUT_SCHEMA,
-  validateDelegationHistoryArgs,
-  createDelegationHistoryHandler,
-  DELEGATION_STATUS_TOOL_NAME,
-  DELEGATION_STATUS_DESCRIPTION,
-  DELEGATION_STATUS_INPUT_SCHEMA,
-  validateDelegationStatusArgs,
-  createDelegationStatusHandler
-};
-//# sourceMappingURL=chunk-BERLUBAP.js.map