@tangle-network/agent-runtime 0.55.0 → 0.56.1

package/dist/{chunk-JTH2FPCK.js → chunk-4H2FML7G.js}

@@ -1,3 +1,6 @@
+import {
+  runCoderChecks
+} from "./chunk-7QYOXFCD.js";
 import {
   UI_LENSES
 } from "./chunk-WIR4HOOJ.js";
@@ -10,6 +13,10 @@ import {
   ValidationError,
   extractLlmCallEvent
 } from "./chunk-VLF5RHEQ.js";
+import {
+  harnessInvocation,
+  runLocalHarness
+} from "./chunk-GLMFBUKT.js";
 import {
   buildLoopSpanNodes
 } from "./chunk-G3RGMA7C.js";
@@ -2124,7 +2131,7 @@ function createScope(args) {
   let spawnOrdinal = 0;
   let cursorSeq = 0;
   const now = args.now ?? Date.now;
-  function spawn2(agent, task, opts) {
+  function spawn4(agent, task, opts) {
     if (args.maxDepth !== void 0 && args.depth >= args.maxDepth) {
       return { ok: false, reason: "depth-exceeded" };
     }
@@ -2251,7 +2258,7 @@ function createScope(args) {
     return true;
   }
   return {
-    spawn: spawn2,
+    spawn: spawn4,
     next,
     send,
     get view() {
@@ -2531,6 +2538,9 @@ function pipeline(stages) {
   });
 }
 function fanout(items, opts) {
+  if (opts.synthesize && opts.selectWinner) {
+    throw new ValidationError("fanout: pass at most one of `synthesize` or `selectWinner`");
+  }
   return (ctx) => ({
     name: `${ctx.persona.name}/fanout`,
     async act(_task, scope) {
@@ -2538,7 +2548,8 @@ function fanout(items, opts) {
       let opened = 0;
       for (const [i, item] of items.entries()) {
         const label = opts.label ? opts.label(item, i) : `item:${i}`;
-        const child = ctx.spawnChild(label, ctx.persona.root);
+        const spec = opts.itemSpec ? opts.itemSpec(item, i, ctx) : ctx.persona.root;
+        const child = ctx.spawnChild(label, spec);
         const res = scope.spawn(child, opts.itemTask(item, i, ctx), {
           budget: ctx.budget.perChild,
           label
@@ -2562,7 +2573,8 @@ function fanout(items, opts) {
         );
       }
       if (!opts.synthesize) {
-        const winner = defaultSelectWinner(drained.iterations);
+        const select = opts.selectWinner ?? defaultSelectWinner;
+        const winner = select(drained.iterations);
         if (!winner || winner.output === void 0) {
           return blocked(
             orderedBlockers(drained.blockers, rejected, "fanout: no item survived selection")
@@ -3180,7 +3192,7 @@ function isAgent(value) {
 }
 
 // src/runtime/supervise/runtime.ts
-import { spawn } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { estimateCost as estimateCost2, isModelPriced as isModelPriced2 } from "@tangle-network/agent-eval";
 
 // src/runtime/router-client.ts
@@ -3314,11 +3326,262 @@ async function routerToolLoop(cfg, system, user, tools, execute, opts) {
   return { final: lastText, turns: maxTurns, toolCalls, toolTrace, usage, messages };
 }
 
+// src/runtime/supervise/worktree-cli-executor.ts
+import { spawn as spawn2 } from "child_process";
+import { randomUUID } from "crypto";
+
+// 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/runtime/supervise/worktree-cli-executor.ts
+var checkOutputCap = 16e3;
+function createWorktreeCliExecutor(options) {
+  if (!options.repoRoot) {
+    throw new ValidationError("createWorktreeCliExecutor: repoRoot required");
+  }
+  if (!options.harness) {
+    throw new ValidationError("createWorktreeCliExecutor: harness required");
+  }
+  if (typeof options.taskPrompt !== "string" || options.taskPrompt.length === 0) {
+    throw new ValidationError("createWorktreeCliExecutor: taskPrompt required");
+  }
+  const runId = options.runId ?? randomUUID();
+  const runHarness = options.runHarness ?? runLocalHarness;
+  const runCommand = options.runCommand ?? defaultRunCommand;
+  const checkTimeoutMs = options.checkTimeoutMs ?? options.harnessTimeoutMs ?? 5 * 60 * 1e3;
+  const controller = new AbortController();
+  let worktree;
+  let artifact;
+  const removeIfPresent = async () => {
+    if (!worktree) return;
+    const wt = worktree;
+    worktree = void 0;
+    await removeWorktree({
+      worktree: wt,
+      repoRoot: options.repoRoot,
+      ...options.runGit ? { runGit: options.runGit } : {}
+    }).catch(() => void 0);
+  };
+  return {
+    runtime: "cli",
+    // A harness CLI cannot account tokens — exclude it from the conserved pool + equal-k.
+    budgetExempt: true,
+    async execute(_task, signal) {
+      const linked = linkSignals(signal, controller.signal);
+      const started = Date.now();
+      worktree = await createWorktree({
+        repoRoot: options.repoRoot,
+        runId,
+        ...options.baseRef ? { baseRef: options.baseRef } : {},
+        ...options.runGit ? { runGit: options.runGit } : {}
+      });
+      const { command, args } = harnessInvocation(
+        options.harness,
+        options.profile,
+        options.taskPrompt
+      );
+      const harnessResult = await runHarness({
+        harness: options.harness,
+        cwd: worktree.path,
+        taskPrompt: options.taskPrompt,
+        invocation: { command, args },
+        ...options.harnessTimeoutMs !== void 0 ? { timeoutMs: options.harnessTimeoutMs } : {},
+        ...linked ? { signal: linked } : {}
+      });
+      const checks = await runWorktreeChecks({
+        worktreePath: worktree.path,
+        ...options.testCmd !== void 0 ? { testCmd: options.testCmd } : {},
+        ...options.typecheckCmd !== void 0 ? { typecheckCmd: options.typecheckCmd } : {},
+        timeoutMs: checkTimeoutMs,
+        runCommand,
+        ...linked ? { signal: linked } : {}
+      });
+      const diff = await captureWorktreeDiff({
+        worktree,
+        ...options.runGit ? { runGit: options.runGit } : {}
+      });
+      const out = {
+        branch: worktree.branch,
+        patch: diff.patch,
+        stats: diff.stats,
+        harness: {
+          name: options.harness,
+          exitCode: harnessResult.exitCode,
+          timedOut: harnessResult.timedOut,
+          killedBySignal: harnessResult.killedBySignal,
+          durationMs: harnessResult.durationMs,
+          stdout: harnessResult.stdout,
+          stderr: harnessResult.stderr
+        },
+        ...checks ? { checks } : {}
+      };
+      const spent = {
+        iterations: 1,
+        // budgetExempt: spend is recorded zero (not metered), never a fabricated cost.
+        tokens: zeroTokenUsage(),
+        usd: 0,
+        ms: Date.now() - started
+      };
+      artifact = { outRef: contentAddress(out), out, spent };
+      return artifact;
+    },
+    async teardown(_grace) {
+      controller.abort();
+      await removeIfPresent();
+      return { destroyed: true };
+    },
+    resultArtifact() {
+      if (!artifact) {
+        throw new ValidationError(
+          "createWorktreeCliExecutor: resultArtifact() read before execute() resolved"
+        );
+      }
+      return artifact;
+    }
+  };
+}
+async function runWorktreeChecks(opts) {
+  if (opts.testCmd === void 0 && opts.typecheckCmd === void 0) return void 0;
+  const run = async (command) => {
+    const res = await opts.runCommand({
+      command,
+      cwd: opts.worktreePath,
+      timeoutMs: opts.timeoutMs,
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+    return {
+      command,
+      passed: res.exitCode === 0,
+      exitCode: res.exitCode,
+      output: res.output.length > checkOutputCap ? res.output.slice(-checkOutputCap) : res.output
+    };
+  };
+  const checks = {};
+  if (opts.testCmd !== void 0) checks.tests = await run(opts.testCmd);
+  if (opts.typecheckCmd !== void 0) checks.typecheck = await run(opts.typecheckCmd);
+  return checks;
+}
+function defaultRunCommand(opts) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2("/bin/sh", ["-c", opts.command], {
+      cwd: opts.cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const chunks = [];
+    let settled = false;
+    const timer = setTimeout(() => child.kill("SIGTERM"), opts.timeoutMs);
+    const onAbort = () => child.kill("SIGTERM");
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout?.on("data", (d) => chunks.push(String(d)));
+    child.stderr?.on("data", (d) => chunks.push(String(d)));
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      opts.signal?.removeEventListener("abort", onAbort);
+      fn();
+    };
+    child.on("error", (err) => finish(() => reject(err)));
+    child.on("close", (code) => finish(() => resolve({ exitCode: code, output: chunks.join("") })));
+  });
+}
+function linkSignals(a, b) {
+  if (a.aborted || b.aborted) {
+    const c2 = new AbortController();
+    c2.abort();
+    return c2.signal;
+  }
+  const c = new AbortController();
+  const onAbort = () => c.abort();
+  a.addEventListener("abort", onAbort, { once: true });
+  b.addEventListener("abort", onAbort, { once: true });
+  return c.signal;
+}
+
 // src/runtime/supervise/runtime.ts
 var routerSeamKey = "router";
 var sandboxSeamKey = "sandbox";
 var cliSeamKey = "cli";
 var bridgeSeamKey = "bridge";
+var cliWorktreeSeamKey = "cli-worktree";
 function contentRef(prefix, value) {
   let str;
   try {
@@ -3359,7 +3622,7 @@ var routerInlineExecutor = (spec, ctx) => {
     async execute(task, signal) {
       const messages = taskToMessages(task, spec);
       const started = Date.now();
-      const linked = linkSignals(signal, controller.signal);
+      const linked = linkSignals2(signal, controller.signal);
       const r = await routerChatWithUsage(
         { routerBaseUrl: seam.routerBaseUrl, routerKey: seam.routerKey, model },
         messages,
@@ -3413,7 +3676,7 @@ var routerToolsInlineExecutor = (spec, ctx) => {
     runtime: "router",
     async execute(task, signal) {
       const started = Date.now();
-      const linked = linkSignals(signal, controller.signal);
+      const linked = linkSignals2(signal, controller.signal);
       const messages = [
         ...taskToMessages(task, spec)
       ];
@@ -3654,7 +3917,7 @@ var cliExecutor = (_spec, ctx) => {
 };
 async function* streamCliLeaf(args) {
   const prompt = taskToPrompt(args.task);
-  const proc = spawn(args.seam.bin, args.seam.args ?? [], {
+  const proc = spawn3(args.seam.bin, args.seam.args ?? [], {
     ...args.seam.cwd ? { cwd: args.seam.cwd } : {},
     env: { ...process.env, ...args.seam.env ?? {} },
     stdio: ["pipe", "pipe", "pipe"]
@@ -3732,7 +3995,7 @@ var bridgeExecutor = (spec, ctx) => {
     async execute(task, signal) {
       const messages = taskToMessages(task, spec);
       const started = Date.now();
-      const linked = linkSignals(signal, controller.signal);
+      const linked = linkSignals2(signal, controller.signal);
       const timer = seam.timeoutMs ? setTimeout(() => controller.abort(), seam.timeoutMs) : void 0;
       try {
         const res = await fetch(`${seam.bridgeUrl.replace(/\/$/, "")}/v1/chat/completions`, {
@@ -3785,6 +4048,23 @@ var bridgeExecutor = (spec, ctx) => {
     }
   };
 };
+var cliWorktreeExecutor = (spec, ctx) => {
+  const seam = readSeam(ctx, cliWorktreeSeamKey, "cli-worktree");
+  if (!seam.repoRoot || !seam.harness || !seam.taskPrompt) {
+    throw new ValidationError(
+      "cliWorktreeExecutor: CliWorktreeSeam.repoRoot + harness + taskPrompt required"
+    );
+  }
+  return createWorktreeCliExecutor({
+    repoRoot: seam.repoRoot,
+    profile: spec.profile,
+    harness: seam.harness,
+    taskPrompt: seam.taskPrompt,
+    ...seam.runId ? { runId: seam.runId } : {},
+    ...seam.baseRef ? { baseRef: seam.baseRef } : {},
+    ...seam.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: seam.harnessTimeoutMs } : {}
+  });
+};
 function createExecutor(config) {
   return (spec, ctx) => {
     const { backend, ...seam } = config;
@@ -3798,6 +4078,8 @@ function createExecutor(config) {
         return bridgeExecutor(spec, seamed);
       case "cli":
         return cliExecutor(spec, seamed);
+      case "cli-worktree":
+        return cliWorktreeExecutor(spec, seamed);
       case "sandbox": {
         const harness = spec.harness ?? config.harness ?? null;
         return sandboxExecutor({ ...spec, harness }, seamed);
@@ -3877,7 +4159,7 @@ function singleShotDriver(maxIterations) {
     }
   };
 }
-function linkSignals(a, b) {
+function linkSignals2(a, b) {
   if (a.aborted || b.aborted) {
     const c2 = new AbortController();
     c2.abort();
@@ -6334,6 +6616,98 @@ function authoredWorker(profile, opts) {
   return { name: profile.name, act: async () => "", executorSpec: spec };
 }
 
+// src/runtime/supervise/coder-deliverable.ts
+function coderDeliverable(options = {}) {
+  const require2 = new Set(options.require ?? []);
+  const constraints = {
+    ...options.maxDiffLines !== void 0 ? { maxDiffLines: options.maxDiffLines } : {},
+    ...options.forbiddenPaths !== void 0 ? { forbiddenPaths: options.forbiddenPaths } : {}
+  };
+  return {
+    describe: "coder patch: no-op/secret/forbidden/diff-size + required test/typecheck pass",
+    check(artifact) {
+      const input = {
+        patch: artifact.patch,
+        testsPassed: signalPass(artifact.checks?.tests?.passed, require2.has("tests")),
+        typecheckPassed: signalPass(artifact.checks?.typecheck?.passed, require2.has("typecheck"))
+      };
+      return runCoderChecks(input, constraints).valid === true;
+    }
+  };
+}
+function signalPass(value, required) {
+  if (value !== void 0) return value;
+  return !required;
+}
+
+// src/runtime/supervise/coder-fanout.ts
+function worktreeCoderFanout(options) {
+  const deliverable = coderDeliverable({
+    ...options.maxDiffLines !== void 0 ? { maxDiffLines: options.maxDiffLines } : {},
+    ...options.forbiddenPaths !== void 0 ? { forbiddenPaths: options.forbiddenPaths } : {},
+    ...options.require !== void 0 ? { require: options.require } : {}
+  });
+  const itemSpec = (item) => {
+    const executor = gateOnDeliverable(
+      createWorktreeCliExecutor({
+        repoRoot: options.repoRoot,
+        profile: item.profile,
+        harness: item.harness,
+        taskPrompt: options.taskPrompt,
+        ...item.runId ? { runId: item.runId } : {},
+        ...item.baseRef ? { baseRef: item.baseRef } : {},
+        ...options.testCmd !== void 0 ? { testCmd: options.testCmd } : {},
+        ...options.typecheckCmd !== void 0 ? { typecheckCmd: options.typecheckCmd } : {},
+        ...options.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: options.harnessTimeoutMs } : {},
+        ...options.runGit ? { runGit: options.runGit } : {},
+        ...options.runHarness ? { runHarness: options.runHarness } : {},
+        ...options.runCommand ? { runCommand: options.runCommand } : {}
+      }),
+      deliverable
+    );
+    return { profile: item.profile, harness: null, executor };
+  };
+  const selectWinner = winnerSelectorFor(options.winnerStrategy ?? "highest-score");
+  return fanout(options.harnesses, {
+    itemTask: () => options.taskPrompt,
+    label: (item, i) => `${item.name}:${i}`,
+    itemSpec: (item) => itemSpec(item),
+    selectWinner
+  });
+}
+function winnerSelectorFor(strategy) {
+  return (iterations) => {
+    const valid = iterations.filter(
+      (iter) => iter.output !== void 0 && !iter.error && iter.verdict?.valid === true
+    );
+    if (valid.length === 0) return void 0;
+    switch (strategy) {
+      case "first-valid":
+        return [...valid].sort((a, b) => a.index - b.index)[0];
+      case "smallest-diff":
+        return [...valid].sort((a, b) => diffLines(a) - diffLines(b) || a.index - b.index)[0];
+      default:
+        return [...valid].sort(
+          (a, b) => (b.verdict?.score ?? 0) - (a.verdict?.score ?? 0) || a.index - b.index
+        )[0];
+    }
+  };
+}
+function diffLines(iter) {
+  const artifact = artifactOf(iter.output);
+  if (!artifact) return Number.POSITIVE_INFINITY;
+  return artifact.stats.insertions + artifact.stats.deletions;
+}
+function artifactOf(output) {
+  if (!output) return void 0;
+  if (isArtifact(output)) return output;
+  if (output.kind === "done" && isArtifact(output.deliverable)) return output.deliverable;
+  return void 0;
+}
+function isArtifact(value) {
+  return value !== null && typeof value === "object" && typeof value.patch === "string" && typeof value.stats === "object";
+}
+
 // src/mcp/tools/coordination.ts
 var idArg = { type: "string", description: "The workerId returned by spawn_worker." };
 function createCoordinationTools(opts) {
@@ -9244,6 +9618,11 @@ export {
   routerChatWithUsage,
   routerChatWithTools,
   routerToolLoop,
+  createWorktree,
+  captureWorktreeDiff,
+  removeWorktree,
+  createWorktreeCliExecutor,
+  cliWorktreeExecutor,
   createExecutor,
   createExecutorRegistry,
   spendFromUsageEvents,
@@ -9280,6 +9659,8 @@ export {
   asAuthoredProfile,
   supervisorSkill,
   authoredWorker,
+  coderDeliverable,
+  worktreeCoderFanout,
   createCoordinationTools,
   coordinationDriverAgent,
   InMemoryFeedbackStore,
@@ -9341,4 +9722,4 @@ export {
   jjWorkspace,
   runInWorkspace
 };
-//# sourceMappingURL=chunk-JTH2FPCK.js.map
+//# sourceMappingURL=chunk-4H2FML7G.js.map