@tangle-network/agent-runtime 0.52.0 → 0.54.0

package/dist/chunk-7SP2OVYZ.js

@@ -1,908 +0,0 @@
-import {
-  UI_LENSES
-} from "./chunk-WIR4HOOJ.js";
-import {
-  DELEGATE_CODE_DESCRIPTION,
-  DELEGATE_CODE_INPUT_SCHEMA,
-  DELEGATE_CODE_TOOL_NAME,
-  DELEGATE_FEEDBACK_DESCRIPTION,
-  DELEGATE_FEEDBACK_INPUT_SCHEMA,
-  DELEGATE_FEEDBACK_TOOL_NAME,
-  DELEGATE_RESEARCH_DESCRIPTION,
-  DELEGATE_RESEARCH_INPUT_SCHEMA,
-  DELEGATE_RESEARCH_TOOL_NAME,
-  DELEGATION_HISTORY_DESCRIPTION,
-  DELEGATION_HISTORY_INPUT_SCHEMA,
-  DELEGATION_HISTORY_TOOL_NAME,
-  DELEGATION_STATUS_DESCRIPTION,
-  DELEGATION_STATUS_INPUT_SCHEMA,
-  DELEGATION_STATUS_TOOL_NAME,
-  DelegationTaskQueue,
-  InMemoryFeedbackStore,
-  createDelegateCodeHandler,
-  createDelegateFeedbackHandler,
-  createDelegateResearchHandler,
-  createDelegationHistoryHandler,
-  createDelegationStatusHandler,
-  hashIdempotencyInput
-} from "./chunk-BERLUBAP.js";
-import {
-  createFleetWorkspaceExecutor,
-  createSiblingSandboxExecutor
-} from "./chunk-4JI4BCBI.js";
-import {
-  runLocalHarness
-} from "./chunk-GLR25NG7.js";
-import {
-  buildLoopOtelSpans,
-  createOtelExporter
-} from "./chunk-G3RGMA7C.js";
-import {
-  ValidationError
-} from "./chunk-GSUO5QS6.js";
-
-// src/mcp/worktree.ts
-import { spawn } from "child_process";
-async function runGitAsync(args, cwd, runner) {
-  if (runner) return runner(args, { cwd });
-  return new Promise((resolve, reject) => {
-    const proc = spawn("git", args, { cwd, stdio: "pipe" });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout?.on("data", (c) => {
-      stdout += String(c);
-    });
-    proc.stderr?.on("data", (c) => {
-      stderr += String(c);
-    });
-    proc.on("error", reject);
-    proc.on("close", (code) => resolve({ stdout, stderr, exitCode: code ?? -1 }));
-  });
-}
-function ensureGitOk(step, result) {
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `worktree: git ${step} failed (exit ${result.exitCode}): ${result.stderr.slice(0, 400)}`
-    );
-  }
-}
-async function createWorktree(options) {
-  const variants = options.variantsDir ?? ".coder-variants";
-  const baseRef = options.baseRef ?? "HEAD";
-  const branch = `delegate/${options.runId}`;
-  const path2 = `${options.repoRoot.replace(/\/+$/, "")}/${variants}/${options.runId}`;
-  const headSha = await runGitAsync(["rev-parse", baseRef], options.repoRoot, options.runGit);
-  ensureGitOk(`rev-parse ${baseRef}`, headSha);
-  const add = await runGitAsync(
-    ["worktree", "add", "-b", branch, path2, baseRef],
-    options.repoRoot,
-    options.runGit
-  );
-  ensureGitOk(`worktree add ${path2}`, add);
-  return { path: path2, baseSha: headSha.stdout.trim(), branch };
-}
-async function captureWorktreeDiff(options) {
-  const baseRef = options.baseRef ?? options.worktree.baseSha;
-  const patch = await runGitAsync(["diff", baseRef], options.worktree.path, options.runGit);
-  const shortstat = await runGitAsync(
-    ["diff", "--shortstat", baseRef],
-    options.worktree.path,
-    options.runGit
-  );
-  const stats = parseShortstat(shortstat.stdout);
-  return { patch: patch.stdout, stats };
-}
-function parseShortstat(text) {
-  const out = { filesChanged: 0, insertions: 0, deletions: 0 };
-  const filesMatch = text.match(/(\d+)\s+files?\s+changed/);
-  if (filesMatch?.[1]) out.filesChanged = Number(filesMatch[1]);
-  const insertMatch = text.match(/(\d+)\s+insertions?/);
-  if (insertMatch?.[1]) out.insertions = Number(insertMatch[1]);
-  const deleteMatch = text.match(/(\d+)\s+deletions?/);
-  if (deleteMatch?.[1]) out.deletions = Number(deleteMatch[1]);
-  return out;
-}
-async function removeWorktree(options) {
-  const force = options.force ?? true;
-  const args = ["worktree", "remove"];
-  if (force) args.push("--force");
-  args.push(options.worktree.path);
-  const result = await runGitAsync(args, options.repoRoot, options.runGit);
-  if (result.exitCode !== 0 && !/not a working tree/.test(result.stderr)) {
-    await runGitAsync(
-      ["branch", "-D", options.worktree.branch],
-      options.repoRoot,
-      options.runGit
-    ).catch(() => void 0);
-  }
-  await runGitAsync(
-    ["branch", "-D", options.worktree.branch],
-    options.repoRoot,
-    options.runGit
-  ).catch(() => void 0);
-}
-
-// src/mcp/in-process-executor.ts
-import { randomUUID } from "crypto";
-var DEFAULT_HARNESS_TIMEOUT_MS = 5 * 60 * 1e3;
-var DEFAULT_POSTCHECK_TIMEOUT_MS = 2 * 60 * 1e3;
-function createInProcessExecutor(options) {
-  const harnesses = options.harnesses && options.harnesses.length > 0 ? [...options.harnesses] : ["claude"];
-  const runHarness = options.runHarness ?? runLocalHarness;
-  const runPostCheck = options.runPostCheck ?? defaultRunPostCheck;
-  let callIndex = 0;
-  const client = {
-    async create(_opts) {
-      const runId = randomUUID();
-      const harness = harnesses[callIndex % harnesses.length];
-      callIndex += 1;
-      const virtual = {
-        // Synthesize the minimum SandboxInstance surface the kernel touches.
-        // We CAST through unknown because SandboxInstance is a `declare class`
-        // with private fields; we're producing a structural subtype that
-        // satisfies the kernel's narrow usage (`box.id`, `box.streamPrompt`).
-        id: `in-process-${runId}`,
-        __inProcess: { runId, harness },
-        // eslint-disable-next-line require-yield
-        async *streamPrompt(message, promptOpts) {
-          const taskPrompt = typeof message === "string" ? message : message.map(
-            (p) => typeof p === "object" && p && "text" in p ? String(p.text) : ""
-          ).join("\n");
-          let worktree;
-          try {
-            worktree = await createWorktree({
-              repoRoot: options.repoRoot,
-              runId,
-              runGit: options.runGit
-            });
-            this.__inProcess.worktree = worktree;
-            yield {
-              type: "in_process.harness.started",
-              data: {
-                runId,
-                harness,
-                worktreePath: worktree.path,
-                command: harness
-              }
-            };
-            const harnessResult = await runHarness({
-              harness,
-              cwd: worktree.path,
-              taskPrompt,
-              timeoutMs: options.harnessTimeoutMs ?? DEFAULT_HARNESS_TIMEOUT_MS,
-              signal: promptOpts?.signal
-            });
-            yield {
-              type: "in_process.harness.ended",
-              data: {
-                runId,
-                exitCode: harnessResult.exitCode,
-                durationMs: harnessResult.durationMs,
-                killedBySignal: harnessResult.killedBySignal,
-                timedOut: harnessResult.timedOut,
-                stdoutBytes: harnessResult.stdout.length,
-                stderrBytes: harnessResult.stderr.length
-              }
-            };
-            const diff = await captureWorktreeDiff({ worktree, runGit: options.runGit });
-            const testCheck = options.testCmd ? await runPostCheck(options.testCmd, worktree.path, promptOpts?.signal).catch(
-              (err) => ({
-                exitCode: -1,
-                stdout: "",
-                stderr: err instanceof Error ? err.message : String(err)
-              })
-            ) : { exitCode: 0, stdout: "", stderr: "" };
-            const typecheckCheck = options.typecheckCmd ? await runPostCheck(options.typecheckCmd, worktree.path, promptOpts?.signal).catch(
-              (err) => ({
-                exitCode: -1,
-                stdout: "",
-                stderr: err instanceof Error ? err.message : String(err)
-              })
-            ) : { exitCode: 0, stdout: "", stderr: "" };
-            const coderOutput = {
-              branch: worktree.branch,
-              patch: diff.patch,
-              testResult: {
-                passed: !options.testCmd || testCheck.exitCode === 0,
-                output: tail(testCheck.stderr || testCheck.stdout, 4e3)
-              },
-              typecheckResult: {
-                passed: !options.typecheckCmd || typecheckCheck.exitCode === 0,
-                output: tail(typecheckCheck.stderr || typecheckCheck.stdout, 4e3)
-              },
-              diffStats: diff.stats,
-              reviewerNotes: harnessResult.exitCode === 0 ? void 0 : `harness ${harness} exited ${harnessResult.exitCode}${harnessResult.timedOut ? " (timed out)" : ""}`
-            };
-            yield {
-              type: "result",
-              data: {
-                result: coderOutput,
-                source: "in-process-executor",
-                harness,
-                runId
-              }
-            };
-          } finally {
-            if (worktree) {
-              await removeWorktree({
-                worktree,
-                repoRoot: options.repoRoot,
-                runGit: options.runGit
-              }).catch(() => void 0);
-            }
-          }
-        }
-      };
-      return virtual;
-    },
-    describePlacement(box) {
-      const sandboxId = box.id;
-      const meta = box.__inProcess;
-      return {
-        kind: "sibling",
-        sandboxId,
-        worktreePath: meta?.worktree?.path,
-        harness: meta?.harness
-      };
-    }
-  };
-  return {
-    client,
-    placement: "in-process",
-    describe() {
-      return `in-process (repoRoot=${options.repoRoot}, harnesses=[${harnesses.join(",")}]${options.testCmd ? `, testCmd="${options.testCmd}"` : ""}${options.typecheckCmd ? `, typecheckCmd="${options.typecheckCmd}"` : ""})`;
-    }
-  };
-}
-async function defaultRunPostCheck(cmd, cwd, signal) {
-  const { spawn: spawn2 } = await import("child_process");
-  return new Promise((resolve, reject) => {
-    const child = spawn2("sh", ["-c", cmd], { cwd, stdio: "pipe" });
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.on("data", (c) => {
-      stdout += String(c);
-    });
-    child.stderr?.on("data", (c) => {
-      stderr += String(c);
-    });
-    if (signal) {
-      const onAbort = () => {
-        if (!child.killed) child.kill("SIGTERM");
-      };
-      if (signal.aborted) onAbort();
-      else signal.addEventListener("abort", onAbort, { once: true });
-    }
-    const killTimer = setTimeout(() => {
-      if (!child.killed) child.kill("SIGTERM");
-    }, DEFAULT_POSTCHECK_TIMEOUT_MS);
-    if (typeof killTimer.unref === "function") {
-      ;
-      killTimer.unref();
-    }
-    child.on("error", (err) => {
-      clearTimeout(killTimer);
-      reject(err);
-    });
-    child.on("close", (code) => {
-      clearTimeout(killTimer);
-      resolve({ exitCode: code ?? -1, stdout, stderr });
-    });
-  });
-}
-function tail(text, max) {
-  if (text.length <= max) return text;
-  return text.slice(text.length - max);
-}
-
-// src/mcp/bin-helpers.ts
-async function detectExecutor(args) {
-  const env = args.env ?? process.env;
-  if (env.AGENT_RUNTIME_IN_SANDBOX === "1") {
-    const repoRoot = env.AGENT_RUNTIME_REPO_ROOT?.trim();
-    if (!repoRoot) {
-      throw new Error(
-        "agent-runtime-mcp: AGENT_RUNTIME_IN_SANDBOX=1 requires AGENT_RUNTIME_REPO_ROOT to point at the workspace root"
-      );
-    }
-    return createInProcessExecutor({
-      repoRoot,
-      harnesses: parseHarnesses(env.AGENT_RUNTIME_LOCAL_HARNESSES),
-      testCmd: env.AGENT_RUNTIME_TEST_CMD?.trim() || void 0,
-      typecheckCmd: env.AGENT_RUNTIME_TYPECHECK_CMD?.trim() || void 0
-    });
-  }
-  const fleetId = parseFleetId(env.TANGLE_FLEET_ID);
-  if (!fleetId) {
-    return createSiblingSandboxExecutor({ client: args.sandboxClient });
-  }
-  const resolveFleet = args.resolveFleet ?? defaultResolveFleet;
-  const fleet = await resolveFleet(args.sandboxClient, fleetId);
-  const excludeMachineIds = parseList(env.TANGLE_FLEET_EXCLUDE_MACHINES);
-  return createFleetWorkspaceExecutor({
-    fleet,
-    excludeMachineIds
-  });
-}
-var KNOWN_HARNESSES = ["claude", "codex", "opencode"];
-function parseHarnesses(raw) {
-  if (!raw) return void 0;
-  const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
-  if (parts.length === 0) return void 0;
-  for (const part of parts) {
-    if (!KNOWN_HARNESSES.includes(part)) {
-      throw new Error(
-        `agent-runtime-mcp: AGENT_RUNTIME_LOCAL_HARNESSES contains unknown harness "${part}". Expected: ${KNOWN_HARNESSES.join(", ")}.`
-      );
-    }
-  }
-  return parts;
-}
-async function defaultResolveFleet(sandboxClient, fleetId) {
-  const fleets = sandboxClient.fleets;
-  if (!fleets || typeof fleets.get !== "function") {
-    throw new Error(
-      "agent-runtime-mcp: the configured sandbox client does not expose `.fleets.get`; upgrade @tangle-network/sandbox to >= 0.2.1 or unset TANGLE_FLEET_ID."
-    );
-  }
-  const raw = await fleets.get(fleetId);
-  if (!raw || typeof raw !== "object") {
-    throw new Error(`agent-runtime-mcp: fleets.get(${fleetId}) returned no handle`);
-  }
-  const handle = raw;
-  if (typeof handle.fleetId !== "string" || !Array.isArray(handle.ids)) {
-    throw new Error(
-      `agent-runtime-mcp: fleet handle for ${fleetId} is missing fleetId/ids \u2014 incompatible sandbox SDK shape`
-    );
-  }
-  if (typeof handle.sandbox !== "function") {
-    throw new Error(
-      `agent-runtime-mcp: fleet handle for ${fleetId} is missing sandbox(machineId) \u2014 incompatible sandbox SDK shape`
-    );
-  }
-  return handle;
-}
-function parseFleetId(raw) {
-  if (typeof raw !== "string") return void 0;
-  const trimmed = raw.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function parseList(raw) {
-  if (!raw) return void 0;
-  const list = raw.split(",").map((entry) => entry.trim()).filter(Boolean);
-  return list.length > 0 ? list : void 0;
-}
-
-// src/mcp/tools/delegate-ui-audit.ts
-import path from "path";
-var DELEGATE_UI_AUDIT_TOOL_NAME = "delegate_ui_audit";
-var DELEGATE_UI_AUDIT_DESCRIPTION = [
-  "Delegate a UI/UX audit to a vision-driven auditor that produces self-contained",
-  "GitHub-issue-ready Markdown findings \u2014 one file per finding, with embedded",
-  "screenshot evidence and a suggested fix.",
-  "",
-  "Use when: you want a thorough pass over a running web app for consistency,",
-  "hierarchy, layout, ux-flow, duplication, accessibility, responsive, states,",
-  "content, interaction, or perceived-performance issues. The auditor iterates",
-  "lens-by-lens so each pass finds new classes of issues; the workspace registry",
-  "deduplicates across iterations.",
-  "",
-  "Returns immediately with a taskId. Poll delegation_status to retrieve the",
-  "workspace path + indexed findings (typically minutes per audited route).",
-  "Identical inputs return the same taskId \u2014 safe to retry.",
-  "",
-  "Output layout under workspaceDir:",
-  "  registry.json                       \u2014 finding index + capture sidecar",
-  "  index.md                            \u2014 human-readable rollup",
-  "  issues/NNN--<lens>--<slug>.md       \u2014 one self-contained GitHub-issue",
-  "  screenshots/<route>--<viewport>.png \u2014 capture archive",
-  "",
-  "Multi-tenant isolation: every finding is scoped to `namespace` when set.",
-  "Never pass another tenant's namespace."
-].join("\n");
-var VIEWPORT_SCHEMA = {
-  type: "object",
-  properties: {
-    width: { type: "integer", minimum: 1 },
-    height: { type: "integer", minimum: 1 }
-  },
-  required: ["width", "height"],
-  additionalProperties: false
-};
-var ROUTE_SCHEMA = {
-  type: "object",
-  properties: {
-    name: { type: "string", description: "Stable route name (used in screenshot filenames)." },
-    url: { type: "string", description: "Fully-qualified URL." },
-    viewports: {
-      type: "array",
-      items: VIEWPORT_SCHEMA,
-      description: "Viewports to capture at. Default [{1280, 800}]."
-    },
-    fullPage: { type: "boolean" },
-    waitFor: { type: "string", description: "CSS selector to wait for before capturing." }
-  },
-  required: ["name", "url"],
-  additionalProperties: false
-};
-var DELEGATE_UI_AUDIT_INPUT_SCHEMA = {
-  type: "object",
-  properties: {
-    workspaceDir: { type: "string", description: "Absolute path for the audit workspace." },
-    routes: { type: "array", items: ROUTE_SCHEMA, minItems: 1 },
-    namespace: { type: "string", description: "Multi-tenant scope." },
-    config: {
-      type: "object",
-      properties: {
-        lenses: {
-          type: "array",
-          items: { type: "string", enum: [...UI_LENSES] },
-          description: 'Lenses to iterate. Default: every lens except "other".'
-        },
-        maxIterations: { type: "integer", minimum: 1 },
-        maxConcurrency: { type: "integer", minimum: 1 },
-        productContext: { type: "string" }
-      },
-      additionalProperties: false
-    }
-  },
-  required: ["workspaceDir", "routes"],
-  additionalProperties: false
-};
-var PER_LENS_PER_ROUTE_ESTIMATE_MS = 45e3;
-function validateDelegateUiAuditArgs(raw) {
-  if (raw === null || typeof raw !== "object") {
-    throw new TypeError("delegate_ui_audit: arguments must be an object");
-  }
-  const value = raw;
-  const workspaceDir = value.workspaceDir;
-  if (typeof workspaceDir !== "string" || workspaceDir.trim().length === 0) {
-    throw new TypeError("delegate_ui_audit: `workspaceDir` must be a non-empty string");
-  }
-  const trimmedWs = workspaceDir.trim();
-  if (!path.isAbsolute(trimmedWs)) {
-    throw new TypeError(
-      `delegate_ui_audit: \`workspaceDir\` must be an absolute path (got ${JSON.stringify(workspaceDir)})`
-    );
-  }
-  if (trimmedWs.split(path.sep).includes("..")) {
-    throw new TypeError(
-      `delegate_ui_audit: \`workspaceDir\` must not contain '..' segments (got ${JSON.stringify(workspaceDir)})`
-    );
-  }
-  const routesRaw = value.routes;
-  if (!Array.isArray(routesRaw) || routesRaw.length === 0) {
-    throw new TypeError("delegate_ui_audit: `routes` must be a non-empty array");
-  }
-  const routes = routesRaw.map((r, i) => validateRoute(r, i));
-  const args = { workspaceDir: workspaceDir.trim(), routes };
-  if (value.namespace !== void 0) {
-    if (typeof value.namespace !== "string" || value.namespace.trim().length === 0) {
-      throw new TypeError("delegate_ui_audit: `namespace` must be a non-empty string when set");
-    }
-    args.namespace = value.namespace.trim();
-  }
-  if (value.config !== void 0) {
-    args.config = validateConfig(value.config);
-  }
-  return args;
-}
-function validateRoute(raw, index) {
-  if (raw === null || typeof raw !== "object") {
-    throw new TypeError(`delegate_ui_audit: routes[${index}] must be an object`);
-  }
-  const v = raw;
-  if (typeof v.name !== "string" || v.name.trim().length === 0) {
-    throw new TypeError(`delegate_ui_audit: routes[${index}].name must be a non-empty string`);
-  }
-  const trimmedName = v.name.trim();
-  if (/[./\\]/.test(trimmedName) || trimmedName.includes("\0")) {
-    throw new TypeError(
-      `delegate_ui_audit: routes[${index}].name must not contain path separators, dots, or NUL (got ${JSON.stringify(v.name)})`
-    );
-  }
-  if (typeof v.url !== "string" || v.url.trim().length === 0) {
-    throw new TypeError(`delegate_ui_audit: routes[${index}].url must be a non-empty string`);
-  }
-  let parsedUrl;
-  try {
-    parsedUrl = new URL(v.url);
-  } catch {
-    throw new TypeError(
-      `delegate_ui_audit: routes[${index}].url is not a parseable URL (got ${JSON.stringify(v.url)})`
-    );
-  }
-  if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
-    throw new TypeError(
-      `delegate_ui_audit: routes[${index}].url must use http or https (got ${parsedUrl.protocol})`
-    );
-  }
-  const out = { name: v.name.trim(), url: v.url.trim() };
-  if (v.viewports !== void 0) {
-    if (!Array.isArray(v.viewports) || v.viewports.length === 0) {
-      throw new TypeError(
-        `delegate_ui_audit: routes[${index}].viewports must be a non-empty array when set`
-      );
-    }
-    out.viewports = v.viewports.map((vp, j) => validateViewport(vp, index, j));
-  }
-  if (v.fullPage !== void 0) {
-    if (typeof v.fullPage !== "boolean") {
-      throw new TypeError(`delegate_ui_audit: routes[${index}].fullPage must be a boolean`);
-    }
-    out.fullPage = v.fullPage;
-  }
-  if (v.waitFor !== void 0) {
-    if (typeof v.waitFor !== "string" || v.waitFor.trim().length === 0) {
-      throw new TypeError(
-        `delegate_ui_audit: routes[${index}].waitFor must be a non-empty string when set`
-      );
-    }
-    out.waitFor = v.waitFor.trim();
-  }
-  return out;
-}
-function validateViewport(raw, routeIndex, viewportIndex) {
-  if (raw === null || typeof raw !== "object") {
-    throw new TypeError(
-      `delegate_ui_audit: routes[${routeIndex}].viewports[${viewportIndex}] must be an object`
-    );
-  }
-  const v = raw;
-  const w = Number(v.width);
-  const h = Number(v.height);
-  if (!Number.isInteger(w) || w <= 0 || !Number.isInteger(h) || h <= 0) {
-    throw new RangeError(
-      `delegate_ui_audit: routes[${routeIndex}].viewports[${viewportIndex}] must have positive integer width/height`
-    );
-  }
-  return { width: w, height: h };
-}
-function validateConfig(raw) {
-  if (raw === null || typeof raw !== "object") {
-    throw new TypeError("delegate_ui_audit: `config` must be an object");
-  }
-  const v = raw;
-  const out = {};
-  if (v.lenses !== void 0) {
-    if (!Array.isArray(v.lenses) || v.lenses.length === 0) {
-      throw new TypeError("delegate_ui_audit: `config.lenses` must be a non-empty array when set");
-    }
-    const knownSet = new Set(UI_LENSES);
-    const lenses = [];
-    for (let i = 0; i < v.lenses.length; i += 1) {
-      const lens = v.lenses[i];
-      if (typeof lens !== "string" || !knownSet.has(lens)) {
-        throw new TypeError(
-          `delegate_ui_audit: config.lenses[${i}] must be one of ${UI_LENSES.join("|")}`
-        );
-      }
-      lenses.push(lens);
-    }
-    out.lenses = lenses;
-  }
-  if (v.maxIterations !== void 0) {
-    const n = Number(v.maxIterations);
-    if (!Number.isInteger(n) || n < 1) {
-      throw new RangeError("delegate_ui_audit: `config.maxIterations` must be a positive integer");
-    }
-    out.maxIterations = n;
-  }
-  if (v.maxConcurrency !== void 0) {
-    const n = Number(v.maxConcurrency);
-    if (!Number.isInteger(n) || n < 1) {
-      throw new RangeError("delegate_ui_audit: `config.maxConcurrency` must be a positive integer");
-    }
-    out.maxConcurrency = n;
-  }
-  if (v.productContext !== void 0) {
-    if (typeof v.productContext !== "string") {
-      throw new TypeError("delegate_ui_audit: `config.productContext` must be a string");
-    }
-    out.productContext = v.productContext;
-  }
-  return out;
-}
-function createDelegateUiAuditHandler(options) {
-  const estimateDurationMs = options.estimateDurationMs ?? defaultEstimate;
-  return async (raw) => {
-    const args = validateDelegateUiAuditArgs(raw);
-    const idempotencyKey = hashIdempotencyInput({
-      profile: "ui-auditor",
-      workspaceDir: args.workspaceDir,
-      routes: args.routes,
-      namespace: args.namespace,
-      config: args.config
-    });
-    const submitted = options.queue.submit({
-      profile: "ui-auditor",
-      args,
-      namespace: args.namespace,
-      idempotencyKey,
-      run: async (ctx) => options.delegate(args, ctx)
-    });
-    return {
-      taskId: submitted.taskId,
-      estimatedDurationMs: estimateDurationMs(args)
-    };
-  };
-}
-function defaultEstimate(args) {
-  const lenses = args.config?.lenses?.length ?? UI_LENSES.length - 1;
-  const routes = args.routes.length;
-  return PER_LENS_PER_ROUTE_ESTIMATE_MS * lenses * routes;
-}
-
-// 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.22.0";
-function createMcpServer(options = {}) {
-  const queue = options.queue ?? new DelegationTaskQueue(
-    options.traceContext !== void 0 ? { traceContext: options.traceContext } : {}
-  );
-  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,
-        ...options.detachedDispatch !== void 0 ? { detachedDispatch: options.detachedDispatch } : {}
-      })
-    });
-  }
-  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,
-        ...options.detachedDispatch !== void 0 ? { detachedDispatch: options.detachedDispatch } : {}
-      })
-    });
-  }
-  if (options.uiAuditorDelegate) {
-    tools.set(DELEGATE_UI_AUDIT_TOOL_NAME, {
-      name: DELEGATE_UI_AUDIT_TOOL_NAME,
-      description: DELEGATE_UI_AUDIT_DESCRIPTION,
-      inputSchema: DELEGATE_UI_AUDIT_INPUT_SCHEMA,
-      handler: createDelegateUiAuditHandler({ queue, delegate: options.uiAuditorDelegate })
-    });
-  }
-  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 })
-  });
-  for (const tool of options.extraTools ?? []) {
-    if (tools.has(tool.name)) {
-      throw new ValidationError(
-        `createMcpServer: extra tool "${tool.name}" shadows a built-in tool`
-      );
-    }
-    tools.set(tool.name, tool);
-  }
-  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];
-    }
-  };
-}
-
-// src/mcp/trace-propagation.ts
-function readTraceContextFromEnv() {
-  const traceId = process.env.TRACE_ID || generateTraceId();
-  const parentSpanId = process.env.PARENT_SPAN_ID || void 0;
-  return { traceId, parentSpanId };
-}
-function createPropagatingTraceEmitter(ctx) {
-  const exporter = createOtelExporter();
-  const buffers = /* @__PURE__ */ new Map();
-  const emitter = {
-    emit(event) {
-      if (!exporter) return;
-      const buf = buffers.get(event.runId);
-      if (buf) buf.push(event);
-      else buffers.set(event.runId, [event]);
-      if (event.kind === "loop.ended") {
-        const events = buffers.get(event.runId) ?? [event];
-        buffers.delete(event.runId);
-        for (const span of buildLoopOtelSpans(events, ctx.traceId, ctx.parentSpanId)) {
-          exporter.exportSpan(span);
-        }
-      }
-    }
-  };
-  return { emitter, exporter, context: ctx };
-}
-function traceContextToEnv(ctx) {
-  const env = { TRACE_ID: ctx.traceId };
-  if (ctx.parentSpanId) env.PARENT_SPAN_ID = ctx.parentSpanId;
-  return env;
-}
-function generateTraceId() {
-  const bytes = new Uint8Array(16);
-  if (typeof globalThis.crypto?.getRandomValues === "function") {
-    globalThis.crypto.getRandomValues(bytes);
-  } else {
-    for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);
-  }
-  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-
-export {
-  createWorktree,
-  captureWorktreeDiff,
-  removeWorktree,
-  createInProcessExecutor,
-  detectExecutor,
-  DELEGATE_UI_AUDIT_TOOL_NAME,
-  DELEGATE_UI_AUDIT_DESCRIPTION,
-  DELEGATE_UI_AUDIT_INPUT_SCHEMA,
-  validateDelegateUiAuditArgs,
-  createDelegateUiAuditHandler,
-  createMcpServer,
-  createInProcessTransport,
-  readTraceContextFromEnv,
-  createPropagatingTraceEmitter,
-  traceContextToEnv
-};
-//# sourceMappingURL=chunk-7SP2OVYZ.js.map