@tangle-network/agent-runtime 0.19.0 → 0.20.0

package/dist/chunk-LPPM7EGS.js

@@ -0,0 +1,1141 @@
+import {
+  runLoop
+} from "./chunk-VFUEE6DF.js";
+import {
+  coderProfile,
+  multiHarnessCoderFanout
+} from "./chunk-Z5LKAYAS.js";
+import {
+  NotFoundError
+} from "./chunk-RZAOYKCO.js";
+
+// src/mcp/delegates.ts
+function createDefaultCoderDelegate(options) {
+  const sandboxClient = options.sandboxClient;
+  const fanoutHarnesses = options.fanoutHarnesses;
+  const maxConcurrency = options.maxConcurrency ?? 4;
+  return async (args, ctx) => {
+    const task = {
+      goal: buildCoderGoal(args),
+      repoRoot: args.repoRoot,
+      testCmd: args.config?.testCmd,
+      typecheckCmd: args.config?.typecheckCmd,
+      forbiddenPaths: args.config?.forbiddenPaths,
+      maxDiffLines: args.config?.maxDiffLines
+    };
+    const variants = Math.max(1, Math.trunc(args.variants ?? 1));
+    ctx.report({ iteration: 0, phase: "starting" });
+    if (variants <= 1) {
+      const { agentRunSpec, output, validator } = coderProfile({ task });
+      const result2 = await runLoop({
+        driver: singleShotDriver,
+        agentRun: agentRunSpec,
+        output,
+        validator,
+        task,
+        ctx: { sandboxClient, signal: ctx.signal },
+        maxIterations: 1,
+        maxConcurrency
+      });
+      const winner2 = result2.winner;
+      if (!winner2) {
+        throw new Error("coder delegate produced no winner");
+      }
+      ctx.report({ iteration: 1, phase: "completed" });
+      return winner2.output;
+    }
+    const fanout = multiHarnessCoderFanout(
+      fanoutHarnesses && fanoutHarnesses.length > 0 ? { harnesses: fanoutHarnesses.slice(0, variants) } : { harnesses: void 0 }
+    );
+    const agentRuns = fanout.agentRuns.slice(0, variants);
+    const result = await runLoop({
+      driver: fanout.driver,
+      agentRuns,
+      output: fanout.output,
+      validator: fanout.validator,
+      task,
+      ctx: { sandboxClient, signal: ctx.signal },
+      maxIterations: variants,
+      maxConcurrency: Math.min(maxConcurrency, variants)
+    });
+    const winner = result.winner;
+    if (!winner) {
+      throw new Error("coder delegate fanout produced no winner");
+    }
+    ctx.report({ iteration: agentRuns.length, phase: "completed" });
+    return winner.output;
+  };
+}
+function buildCoderGoal(args) {
+  if (!args.contextHint) return args.goal;
+  return [args.goal, "", "## Context", args.contextHint].join("\n");
+}
+var singleShotDriver = {
+  name: "mcp-single-shot",
+  async plan(task, history) {
+    return history.length === 0 ? [task] : [];
+  },
+  decide(history) {
+    return history.length > 0 ? "pick-winner" : "fail";
+  }
+};
+
+// 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/task-queue.ts
+var DelegationTaskQueue = class {
+  records = /* @__PURE__ */ new Map();
+  controllers = /* @__PURE__ */ new Map();
+  byIdempotencyKey = /* @__PURE__ */ new Map();
+  generateId;
+  now;
+  constructor(options = {}) {
+    this.generateId = options.generateId ?? randomTaskId;
+    this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  }
+  /**
+   * Kick off a delegation in the background. Returns immediately. The
+   * `taskId` is queryable via `status` once this method returns.
+   */
+  submit(input) {
+    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
+    };
+    this.records.set(taskId, record);
+    this.controllers.set(taskId, controller);
+    if (input.idempotencyKey) this.byIdempotencyKey.set(input.idempotencyKey, taskId);
+    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.
+   */
+  status(taskId) {
+    const record = this.records.get(taskId);
+    if (!record) return void 0;
+    return toStatusResult(record);
+  }
+  /**
+   * 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" };
+    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);
+    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);
+  }
+  /** 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";
+    try {
+      const output = await input.run({
+        signal: controller.signal,
+        report: (progress) => {
+          if (record.status === "running") record.progress = progress;
+        }
+      });
+      if (currentStatus(record) === "cancelled") return;
+      record.status = "completed";
+      record.completedAt = this.now();
+      record.result = { profile: input.profile, output };
+    } catch (err) {
+      if (currentStatus(record) === "cancelled") return;
+      record.status = "failed";
+      record.completedAt = this.now();
+      record.error = errorToShape(err);
+    } finally {
+      this.controllers.delete(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 toStatusResult(record) {
+  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;
+  return out;
+}
+function toHistoryEntry(record) {
+  const entry = {
+    taskId: record.taskId,
+    profile: record.profile,
+    args: record.args,
+    status: record.status,
+    startedAt: record.startedAt
+  };
+  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];
+  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 submitted = options.queue.submit({
+      profile: "coder",
+      args,
+      namespace: args.namespace,
+      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/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 submitted = options.queue.submit({
+      profile: "researcher",
+      args,
+      namespace: args.namespace,
+      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.",
+  "",
+  '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.",
+  "",
+  "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." }
+  },
+  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");
+  }
+  return { taskId: taskId.trim() };
+}
+function createDelegationStatusHandler(options) {
+  return async (raw) => {
+    const args = validateDelegationStatusArgs(raw);
+    const status = options.queue.status(args.taskId);
+    if (!status) {
+      throw new NotFoundError(`delegation_status: unknown taskId "${args.taskId}"`);
+    }
+    return status;
+  };
+}
+
+// src/mcp/server.ts
+import { createInterface } from "readline";
+import { Readable, Writable } from "stream";
+var PROTOCOL_VERSION = "2024-11-05";
+var DEFAULT_SERVER_NAME = "agent-runtime-mcp";
+var DEFAULT_SERVER_VERSION = "0.20.0";
+function createMcpServer(options = {}) {
+  const queue = options.queue ?? new DelegationTaskQueue();
+  const feedbackStore = options.feedbackStore ?? new InMemoryFeedbackStore();
+  const serverName = options.serverName ?? DEFAULT_SERVER_NAME;
+  const serverVersion = options.serverVersion ?? DEFAULT_SERVER_VERSION;
+  const tools = /* @__PURE__ */ new Map();
+  if (options.coderDelegate) {
+    tools.set(DELEGATE_CODE_TOOL_NAME, {
+      name: DELEGATE_CODE_TOOL_NAME,
+      description: DELEGATE_CODE_DESCRIPTION,
+      inputSchema: DELEGATE_CODE_INPUT_SCHEMA,
+      handler: createDelegateCodeHandler({ queue, delegate: options.coderDelegate })
+    });
+  }
+  if (options.researcherDelegate) {
+    tools.set(DELEGATE_RESEARCH_TOOL_NAME, {
+      name: DELEGATE_RESEARCH_TOOL_NAME,
+      description: DELEGATE_RESEARCH_DESCRIPTION,
+      inputSchema: DELEGATE_RESEARCH_INPUT_SCHEMA,
+      handler: createDelegateResearchHandler({ queue, delegate: options.researcherDelegate })
+    });
+  }
+  tools.set(DELEGATE_FEEDBACK_TOOL_NAME, {
+    name: DELEGATE_FEEDBACK_TOOL_NAME,
+    description: DELEGATE_FEEDBACK_DESCRIPTION,
+    inputSchema: DELEGATE_FEEDBACK_INPUT_SCHEMA,
+    handler: createDelegateFeedbackHandler({ queue, store: feedbackStore })
+  });
+  tools.set(DELEGATION_STATUS_TOOL_NAME, {
+    name: DELEGATION_STATUS_TOOL_NAME,
+    description: DELEGATION_STATUS_DESCRIPTION,
+    inputSchema: DELEGATION_STATUS_INPUT_SCHEMA,
+    handler: createDelegationStatusHandler({ queue })
+  });
+  tools.set(DELEGATION_HISTORY_TOOL_NAME, {
+    name: DELEGATION_HISTORY_TOOL_NAME,
+    description: DELEGATION_HISTORY_DESCRIPTION,
+    inputSchema: DELEGATION_HISTORY_INPUT_SCHEMA,
+    handler: createDelegationHistoryHandler({ queue })
+  });
+  let stopped = false;
+  let activeReadline;
+  async function handle(message) {
+    if (stopped) {
+      return rpcError(message.id ?? null, -32099, "server stopped");
+    }
+    if (message.method === "initialize") {
+      return rpcResult(message.id ?? null, {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: { name: serverName, version: serverVersion }
+      });
+    }
+    if (message.method === "notifications/initialized") {
+      return null;
+    }
+    if (message.method === "tools/list") {
+      return rpcResult(message.id ?? null, {
+        tools: [...tools.values()].map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema
+        }))
+      });
+    }
+    if (message.method === "tools/call") {
+      const params = message.params ?? {};
+      const name = typeof params.name === "string" ? params.name : "";
+      const tool = tools.get(name);
+      if (!tool) {
+        return rpcError(message.id ?? null, -32601, `unknown tool: ${name}`);
+      }
+      try {
+        const output = await tool.handler(params.arguments ?? {});
+        return rpcResult(message.id ?? null, {
+          content: [{ type: "text", text: JSON.stringify(output) }],
+          structuredContent: output,
+          isError: false
+        });
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        const code = err instanceof TypeError || err instanceof RangeError ? -32602 : -32e3;
+        return rpcError(message.id ?? null, code, reason);
+      }
+    }
+    if (message.id === void 0 || message.id === null) return null;
+    return rpcError(message.id, -32601, `unknown method: ${message.method}`);
+  }
+  async function serve(transport) {
+    const input = transport?.input ?? process.stdin;
+    const output = transport?.output ?? process.stdout;
+    const rl = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
+    activeReadline = rl;
+    return new Promise((resolve, reject) => {
+      rl.on("line", (line) => {
+        const trimmed = line.trim();
+        if (!trimmed) return;
+        let parsed;
+        try {
+          parsed = JSON.parse(trimmed);
+        } catch (err) {
+          writeResponse(output, rpcError(null, -32700, `parse error: ${err.message}`));
+          return;
+        }
+        if (!parsed || parsed.jsonrpc !== "2.0" || typeof parsed.method !== "string") {
+          writeResponse(output, rpcError(parsed?.id ?? null, -32600, "invalid request"));
+          return;
+        }
+        void handle(parsed).then((response) => {
+          if (response) writeResponse(output, response);
+        });
+      });
+      rl.on("close", () => resolve());
+      rl.on("error", (err) => reject(err));
+      if (stopped) {
+        rl.close();
+        resolve();
+      }
+    });
+  }
+  function stop() {
+    stopped = true;
+    activeReadline?.close();
+    activeReadline = void 0;
+  }
+  return {
+    tools,
+    queue,
+    feedbackStore,
+    handle,
+    serve,
+    stop
+  };
+}
+function rpcResult(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function rpcError(id, code, message, data) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: data === void 0 ? { code, message } : { code, message, data }
+  };
+}
+function writeResponse(output, response) {
+  output.write(`${JSON.stringify(response)}
+`);
+}
+function createInProcessTransport() {
+  const responses = [];
+  const input = new Readable({ read() {
+  } });
+  const output = new Writable({
+    write(chunk, _enc, cb) {
+      const text = chunk.toString("utf8");
+      for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          responses.push(JSON.parse(trimmed));
+        } catch {
+        }
+      }
+      cb();
+    }
+  });
+  return {
+    transport: { input, output },
+    clientWrite(line) {
+      input.push(`${line}
+`);
+    },
+    clientClose() {
+      input.push(null);
+    },
+    async readServer() {
+      for (let i = 0; i < 5; i += 1) await new Promise((r) => setImmediate(r));
+      return [...responses];
+    }
+  };
+}
+
+export {
+  createDefaultCoderDelegate,
+  InMemoryFeedbackStore,
+  eventToSnapshot,
+  DelegationTaskQueue,
+  hashIdempotencyInput,
+  DELEGATE_CODE_TOOL_NAME,
+  DELEGATE_CODE_DESCRIPTION,
+  DELEGATE_CODE_INPUT_SCHEMA,
+  validateDelegateCodeArgs,
+  createDelegateCodeHandler,
+  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,
+  createMcpServer,
+  createInProcessTransport
+};
+//# sourceMappingURL=chunk-LPPM7EGS.js.map