@tangle-network/agent-runtime 0.79.2 → 0.79.3

package/dist/{chunk-TSDKBFZP.js → chunk-KRULXIWS.js}

@@ -1620,10 +1620,129 @@ function errMessage(err) {
   return String(err);
 }
 
+// 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 ?? ".agent-worktrees";
+  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;
+  await runGitAsync(["add", "-A"], options.worktree.path, options.runGit);
+  const patch = await runGitAsync(
+    ["diff", "--cached", baseRef],
+    options.worktree.path,
+    options.runGit
+  );
+  const shortstat = await runGitAsync(
+    ["diff", "--cached", "--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/router-client.ts
 import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
 
 // src/runtime/tool-loop.ts
+function estimateConversationTokens(messages) {
+  let chars = 0;
+  for (const m of messages) {
+    const content = m.content;
+    chars += typeof content === "string" ? content.length : safeJsonLength(content);
+    const calls = m.tool_calls;
+    if (calls) for (const c of calls) chars += c.function?.arguments?.length ?? 0;
+  }
+  return Math.ceil(chars / 4);
+}
+function safeJsonLength(value) {
+  if (value === void 0 || value === null) return 0;
+  try {
+    return JSON.stringify(value)?.length ?? 0;
+  } catch {
+    return String(value).length;
+  }
+}
+async function maybeCompact(messages, c, turn) {
+  const head = c.preserveHead !== void 0 && c.preserveHead > 0 ? c.preserveHead : 2;
+  if (messages.length <= head + 1) return false;
+  const estimate = c.estimateTokens ?? estimateConversationTokens;
+  const before = estimate(messages);
+  if (before <= c.thresholdTokens) return false;
+  const digest = await c.distill([...messages]);
+  messages.splice(head, messages.length - head, {
+    role: "user",
+    content: `[earlier work compacted to save context \u2014 progress so far]
+${digest}`
+  });
+  c.onCompact?.({ turn, beforeTokens: before, afterTokens: estimate(messages) });
+  return true;
+}
 async function runBrainLoop(opts) {
   const maxTurns = opts.maxTurns ?? 4;
   const messages = [...opts.initialMessages];
@@ -1634,6 +1753,7 @@ async function runBrainLoop(opts) {
   for (let turn = 1; turn <= maxTurns; turn += 1) {
     if (opts.hooks?.stopBefore?.(turn)) break;
     await opts.hooks?.beforeTurn?.(turn, messages);
+    if (opts.compaction) await maybeCompact(messages, opts.compaction, turn);
     const r = await opts.chat(messages, opts.tools);
     if (r.usage) {
       usage.input += r.usage.input;
@@ -1821,92 +1941,6 @@ ${lines.join("\n")}`;
   };
 }
 
-// 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 ?? ".agent-worktrees";
-  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;
-  await runGitAsync(["add", "-A"], options.worktree.path, options.runGit);
-  const patch = await runGitAsync(
-    ["diff", "--cached", baseRef],
-    options.worktree.path,
-    options.runGit
-  );
-  const shortstat = await runGitAsync(
-    ["diff", "--cached", "--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
 import { randomUUID } from "crypto";
 
@@ -1943,7 +1977,7 @@ async function runWorktreeHarness(opts) {
       worktree,
       ...opts.runGit ? { runGit: opts.runGit } : {}
     });
-    const checks = await runChecks({
+    const checks = await runWorktreeChecks({
       worktreePath: worktree.path,
       ...opts.testCmd !== void 0 ? { testCmd: opts.testCmd } : {},
       ...opts.typecheckCmd !== void 0 ? { typecheckCmd: opts.typecheckCmd } : {},
@@ -1973,10 +2007,11 @@ async function runWorktreeHarness(opts) {
     throw err;
   }
 }
-async function runChecks(opts) {
+async function runWorktreeChecks(opts) {
   if (opts.testCmd === void 0 && opts.typecheckCmd === void 0) return void 0;
+  const runCommand = opts.runCommand ?? defaultRunCommand;
   const run = async (command) => {
-    const res = await opts.runCommand({
+    const res = await runCommand({
       command,
       cwd: opts.worktreePath,
       timeoutMs: opts.timeoutMs,
@@ -2052,6 +2087,7 @@ function createWorktreeCliExecutor(options) {
         ...options.typecheckCmd !== void 0 ? { typecheckCmd: options.typecheckCmd } : {},
         ...options.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: options.harnessTimeoutMs } : {},
         ...options.checkTimeoutMs !== void 0 ? { checkTimeoutMs: options.checkTimeoutMs } : {},
+        ...options.checkOutputCap !== void 0 ? { checkOutputCap: options.checkOutputCap } : {},
         ...linked ? { signal: linked } : {},
         ...options.runGit ? { runGit: options.runGit } : {},
         ...options.runHarness ? { runHarness: options.runHarness } : {},
@@ -2651,6 +2687,7 @@ ${folded}` : folded;
           model: seam.model,
           stream: true,
           session_id: args.sessionId,
+          ...seam.cwd ? { cwd: seam.cwd } : {},
           ...seam.agentProfile ? { agent_profile: seam.agentProfile } : {},
           messages
         }),
@@ -2767,11 +2804,182 @@ function parseSseFrame(frame) {
   if (typeof u?.cost === "number") out.cost = u.cost;
   return Object.keys(out).length > 0 ? out : void 0;
 }
+function bridgeWorktreeExecutor(spec, ctx, seam) {
+  const bridge = seam.bridge;
+  if (!bridge) {
+    throw new ValidationError("cliWorktreeExecutor: bridge transport missing");
+  }
+  if (!bridge.bridgeUrl || !bridge.bridgeBearer) {
+    throw new ValidationError(
+      "cliWorktreeExecutor: bridge.bridgeUrl + bridge.bridgeBearer required"
+    );
+  }
+  const runId = seam.runId ?? randomUUID2();
+  const sessionId = bridge.sessionId ?? `bridge-worktree-${runId}`;
+  const controller = new AbortController();
+  const pending = [];
+  let inner;
+  let worktree;
+  let removed = false;
+  let artifact;
+  const cleanupWorktree = async () => {
+    if (!worktree || removed) return;
+    const target = worktree;
+    removed = true;
+    worktree = void 0;
+    await removeWorktree({
+      worktree: target,
+      repoRoot: seam.repoRoot,
+      ...seam.runGit ? { runGit: seam.runGit } : {}
+    }).catch(() => void 0);
+  };
+  const deliver = (msg) => {
+    if (inner?.deliver) {
+      inner.deliver(msg);
+      return;
+    }
+    pending.push(msg);
+  };
+  return {
+    runtime: "cli",
+    budgetExempt: seam.budgetExempt ?? false,
+    deliver,
+    execute(_task, signal) {
+      return (async function* bridgeWorktreeStream() {
+        const started = Date.now();
+        const linked = mergeAbortSignals(signal, controller.signal);
+        let bridgeArtifact;
+        try {
+          worktree = await createWorktree({
+            repoRoot: seam.repoRoot,
+            runId,
+            ...seam.baseRef ? { baseRef: seam.baseRef } : {},
+            ...seam.runGit ? { runGit: seam.runGit } : {}
+          });
+          removed = false;
+          const bridgeSeam = {
+            bridgeUrl: bridge.bridgeUrl,
+            bridgeBearer: bridge.bridgeBearer,
+            model: resolveBridgeWorktreeModel(spec, bridge),
+            cwd: worktree.path,
+            sessionId,
+            ...bridge.agentProfile ? { agentProfile: bridge.agentProfile } : { agentProfile: spec.profile },
+            ...bridge.timeoutMs !== void 0 ? { timeoutMs: bridge.timeoutMs } : {},
+            ...bridge.maxTurns !== void 0 ? { maxTurns: bridge.maxTurns } : {}
+          };
+          const bridgeCtx = {
+            ...ctx,
+            signal: linked,
+            seams: { ...ctx.seams, [bridgeSeamKey]: bridgeSeam }
+          };
+          inner = bridgeExecutor(spec, bridgeCtx);
+          for (const msg of pending.splice(0)) inner.deliver?.(msg);
+          const run = inner.execute(seam.taskPrompt, linked);
+          if (isAsyncIterable2(run)) {
+            for await (const event of run) yield event;
+            bridgeArtifact = inner.resultArtifact();
+          } else {
+            bridgeArtifact = await run;
+          }
+          const diff = await captureWorktreeDiff({
+            worktree,
+            ...seam.runGit ? { runGit: seam.runGit } : {}
+          });
+          const checks = await runWorktreeChecks({
+            worktreePath: worktree.path,
+            ...seam.testCmd !== void 0 ? { testCmd: seam.testCmd } : {},
+            ...seam.typecheckCmd !== void 0 ? { typecheckCmd: seam.typecheckCmd } : {},
+            timeoutMs: seam.checkTimeoutMs ?? seam.harnessTimeoutMs ?? bridge.timeoutMs ?? 5 * 60 * 1e3,
+            cap: seam.checkOutputCap ?? 16e3,
+            ...seam.runCommand ? { runCommand: seam.runCommand } : {},
+            signal: linked
+          });
+          const result = {
+            branch: worktree.branch,
+            patch: diff.patch,
+            stats: diff.stats,
+            harness: {
+              name: "bridge",
+              exitCode: null,
+              timedOut: false,
+              killedBySignal: null,
+              durationMs: bridgeArtifact.spent.ms || Date.now() - started,
+              stdout: bridgeOutputText(bridgeArtifact.out),
+              stderr: ""
+            },
+            ...checks ? { checks } : {}
+          };
+          const spent = {
+            ...bridgeArtifact.spent,
+            ms: bridgeArtifact.spent.ms || Date.now() - started
+          };
+          artifact = {
+            outRef: contentRef("bridge-worktree", { sessionId, result }),
+            out: result,
+            spent
+          };
+        } catch (err) {
+          controller.abort();
+          await inner?.teardown("brutalKill").catch(() => void 0);
+          await cleanupWorktree();
+          throw err;
+        }
+      })();
+    },
+    async teardown(grace) {
+      controller.abort();
+      let destroyed = true;
+      try {
+        if (inner) {
+          destroyed = (await inner.teardown(grace)).destroyed;
+        }
+      } finally {
+        await cleanupWorktree();
+      }
+      return { destroyed };
+    },
+    resultArtifact() {
+      if (!artifact) {
+        throw new ValidationError(
+          "cliWorktreeExecutor: bridge resultArtifact() read before stream drained"
+        );
+      }
+      return artifact;
+    }
+  };
+}
+function resolveBridgeWorktreeModel(spec, bridge) {
+  if (bridge.model) return bridge.model;
+  const model = spec.profile.model?.default;
+  if (typeof model === "string" && model.length > 0) return model;
+  throw new ValidationError(
+    "cliWorktreeExecutor: bridge.model or AgentProfile.model.default required"
+  );
+}
+function bridgeOutputText(out) {
+  if (typeof out === "string") return out;
+  if (out && typeof out === "object") {
+    const content = out.content;
+    if (typeof content === "string") return content;
+  }
+  try {
+    return JSON.stringify(out) ?? String(out);
+  } catch {
+    return String(out);
+  }
+}
+function isAsyncIterable2(value) {
+  return value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
+}
 var cliWorktreeExecutor = (spec, ctx) => {
   const seam = readSeam(ctx, cliWorktreeSeamKey, "cli-worktree");
-  if (!seam.repoRoot || !seam.harness || !seam.taskPrompt) {
+  if (!seam.repoRoot || !seam.taskPrompt) {
+    throw new ValidationError("cliWorktreeExecutor: CliWorktreeSeam.repoRoot + taskPrompt required");
+  }
+  if (seam.bridge) return bridgeWorktreeExecutor(spec, ctx, seam);
+  if (!seam.harness) {
     throw new ValidationError(
-      "cliWorktreeExecutor: CliWorktreeSeam.repoRoot + harness + taskPrompt required"
+      "cliWorktreeExecutor: CliWorktreeSeam.harness required when bridge is not set"
     );
   }
   return createWorktreeCliExecutor({
@@ -2781,7 +2989,14 @@ var cliWorktreeExecutor = (spec, ctx) => {
     taskPrompt: seam.taskPrompt,
     ...seam.runId ? { runId: seam.runId } : {},
     ...seam.baseRef ? { baseRef: seam.baseRef } : {},
-    ...seam.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: seam.harnessTimeoutMs } : {}
+    ...seam.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: seam.harnessTimeoutMs } : {},
+    ...seam.testCmd !== void 0 ? { testCmd: seam.testCmd } : {},
+    ...seam.typecheckCmd !== void 0 ? { typecheckCmd: seam.typecheckCmd } : {},
+    ...seam.checkTimeoutMs !== void 0 ? { checkTimeoutMs: seam.checkTimeoutMs } : {},
+    ...seam.checkOutputCap !== void 0 ? { checkOutputCap: seam.checkOutputCap } : {},
+    ...seam.runGit ? { runGit: seam.runGit } : {},
+    ...seam.runCommand ? { runCommand: seam.runCommand } : {},
+    ...seam.budgetExempt !== void 0 ? { budgetExempt: seam.budgetExempt } : {}
   });
 };
 function createExecutor(config) {
@@ -3275,7 +3490,7 @@ function gateOnDeliverable(inner, deliverable) {
     ...inner.deliver ? { deliver: (m) => inner.deliver?.(m) } : {},
     execute(task, signal) {
       const r = inner.execute(task, signal);
-      if (isAsyncIterable2(r)) {
+      if (isAsyncIterable3(r)) {
         return (async function* () {
           for await (const ev of r) yield ev;
           const art = inner.resultArtifact();
@@ -3295,7 +3510,7 @@ function gateOnDeliverable(inner, deliverable) {
     }
   };
 }
-function isAsyncIterable2(v) {
+function isAsyncIterable3(v) {
   return v != null && typeof v[Symbol.asyncIterator] === "function";
 }
 
@@ -3953,6 +4168,18 @@ function createCoordinationTools(opts) {
 }
 
 // src/runtime/supervise/coordination-driver.ts
+var distillInstruction = "CONTEXT COMPACTION. Your detailed turn-by-turn history is about to be discarded to free your context window. Write a COMPLETE, compact handoff note for your future self so you can keep going without it. Cover: (1) what you have accomplished; (2) every worker you spawned and its current status/result; (3) what subtasks remain unfinished, failing, or unverified \u2014 be specific and exhaustive here, this is the part you must not lose; (4) your immediate next action. Do not call any tools; respond with the note only.";
+function summarizeRoster(view, settled) {
+  if (view.nodes.length === 0) return "Workers in current live scope: none yet.";
+  const settledById = new Map(settled.map((w) => [w.id, w]));
+  const lines = view.nodes.map((node) => formatRosterNode(node, settledById.get(node.id)));
+  return `Workers in current live scope (ground truth from the run, ${view.nodes.length} total, ${view.inFlight} in flight):
+${lines.join("\n")}`;
+}
+function formatRosterNode(node, settled) {
+  const result = settled?.status === "done" ? `, delivered=${settled.valid ?? false}${settled.score !== void 0 ? `, score=${settled.score}` : ""}${settled.outRef ? `, outRef=${settled.outRef}` : ""}` : settled?.status === "down" ? `, reason=${settled.reason ?? "unknown"}` : node.outRef ? `, outRef=${node.outRef}` : "";
+  return `- ${node.id}: ${node.status}, label=${node.label}, runtime=${node.runtime}${result}`;
+}
 var runawayTripwireTurns = 2e3;
 function poolStarved(scope, perWorker) {
   const b = scope.budget;
@@ -3974,6 +4201,11 @@ function driverAgent(opts) {
       "driverAgent: extraTools requires executeExtraTool (how to run a work-tool call)"
     );
   }
+  if ((opts.analyzeOnSettle?.length ?? 0) > 0 && !opts.analysts) {
+    throw new ValidationError(
+      "driverAgent: analyzeOnSettle requires analysts (the lens registry the kinds resolve against)"
+    );
+  }
   const reserved = new Set(coordinationVerbNames);
   for (const t of opts.extraTools ?? []) {
     if (reserved.has(t.name)) {
@@ -3997,7 +4229,9 @@ function driverAgent(opts) {
         blobs: opts.blobs,
         makeWorkerAgent: opts.makeWorkerAgent,
         perWorker: opts.perWorker,
-        ...opts.maxLiveWorkers !== void 0 ? { maxLiveWorkers: opts.maxLiveWorkers } : {}
+        ...opts.maxLiveWorkers !== void 0 ? { maxLiveWorkers: opts.maxLiveWorkers } : {},
+        ...opts.analysts ? { analysts: opts.analysts } : {},
+        ...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {}
       });
       const byName = new Map(coord.tools.map((t) => [t.name, t]));
       const toolSpecs = [
@@ -4012,8 +4246,8 @@ function driverAgent(opts) {
         }))
       ];
       const system = typeof opts.systemPrompt === "function" ? opts.systemPrompt(task) : opts.systemPrompt;
-      let turn = 0;
-      const chat = async (messages, tools) => {
+      let driverTurn = 0;
+      const meteredBrain = async (messages, tools, detail) => {
         const res = await opts.brain(messages, tools);
         if (res.usage || res.costUsd !== void 0) {
           const turnSpend = {
@@ -4023,18 +4257,52 @@ function driverAgent(opts) {
             ms: 0
           };
           await scope.meter(turnSpend, {
-            kind: "driver-inference",
             driver: opts.name,
-            turn,
-            toolCalls: (res.toolCalls ?? []).map((c) => c.name)
+            toolCalls: (res.toolCalls ?? []).map((c) => c.name),
+            ...detail
           });
         }
-        turn += 1;
         return res;
       };
+      const chat = async (messages, tools) => {
+        const turn = driverTurn;
+        const res = await meteredBrain(messages, tools, {
+          kind: "driver-inference",
+          turn
+        });
+        driverTurn += 1;
+        return res;
+      };
+      const compaction = opts.compaction ? {
+        thresholdTokens: opts.compaction.thresholdTokens,
+        distill: opts.compaction.distill ?? (async (msgs) => {
+          const roster = summarizeRoster(scope.view, coord.settled());
+          try {
+            const res = await meteredBrain(
+              [...msgs, { role: "user", content: distillInstruction }],
+              [],
+              { kind: "driver-compaction", compactingTurn: driverTurn }
+            );
+            const narrative = (res.content ?? "").trim();
+            return narrative ? `${roster}
+
+## Progress notes
+${narrative}` : roster;
+          } catch (e) {
+            return `${roster}
+
+## Progress notes
+Summary unavailable: ${errMessage2(e)}`;
+          }
+        }),
+        ...opts.compaction.onCompact ? { onCompact: opts.compaction.onCompact } : {},
+        ...opts.compaction.preserveHead !== void 0 ? { preserveHead: opts.compaction.preserveHead } : {},
+        ...opts.compaction.estimateTokens ? { estimateTokens: opts.compaction.estimateTokens } : {}
+      } : void 0;
       await runBrainLoop({
         chat,
         tools: toolSpecs,
+        ...compaction ? { compaction } : {},
         execute: async (name, args) => {
           if (opts.executeExtraTool) {
             const worked = await runExtraTool(opts.executeExtraTool, name, args);
@@ -4094,6 +4362,9 @@ function safeJson(v) {
     return String(v);
   }
 }
+function errMessage2(e) {
+  return e instanceof Error ? e.message : String(e);
+}
 
 // src/mcp/feedback-store.ts
 var InMemoryFeedbackStore = class {
@@ -5093,7 +5364,10 @@ function supervise(profile, task, opts) {
     ...opts.driveHarness ? { driveHarness: opts.driveHarness } : {},
     ...opts.extraTools ? { extraTools: opts.extraTools } : {},
     ...opts.executeExtraTool ? { executeExtraTool: opts.executeExtraTool } : {},
-    ...opts.maxTurns !== void 0 ? { maxTurns: opts.maxTurns } : {}
+    ...opts.analysts ? { analysts: opts.analysts } : {},
+    ...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {},
+    ...opts.maxTurns !== void 0 ? { maxTurns: opts.maxTurns } : {},
+    ...opts.compaction ? { compaction: opts.compaction } : {}
   });
   return createSupervisor().run(agent, task, {
     budget: opts.budget,
@@ -6031,10 +6305,32 @@ async function serveCoordinationMcp(opts) {
 }
 
 // src/runtime/supervise/supervisor-agent.ts
+var defaultSupervisorPrompt = [
+  "You are a supervisor accountable for DELIVERING the task \u2014 not for looking busy. You succeed only",
+  'when the deliverable is actually produced and verified, never on a worker reporting "done".',
+  "",
+  "Spawning a worker spends the shared, conserved budget \u2014 so delegate with intent, not by reflex:",
+  "- Do small, sequential work YOURSELF when you have work tools; spawn a worker when a sub-task is",
+  "  large, independent (parallelizable), or needs a clean context the current one has filled.",
+  "- Prefer the FEWEST workers that deliver. Over-spawning burns the budget and rarely helps.",
+  "",
+  "Manage the context lifecycle on long work: give each spawned worker a BOUNDED brief \u2014 the specific",
+  "sub-task plus only the interfaces/state it needs \u2014 never your whole history. When one chapter is",
+  "done, distill what the next chapter needs and spawn fresh, rather than steering one worker until",
+  "its context fills and degrades.",
+  "",
+  "Wait on real signals (await a settle, answer a blocking question), integrate the result, and stop",
+  "as soon as the deliverable is met."
+].join("\n");
 function supervisorAgent(profile, deps) {
   const name = profile.name ?? "supervisor";
-  const systemPrompt = profile.systemPrompt ?? "";
+  const systemPrompt = profile.systemPrompt ?? defaultSupervisorPrompt;
   const harness = profile.harness ?? null;
+  if (harness !== null && deps.compaction) {
+    throw new ValidationError(
+      "supervisorAgent: compaction is only supported for router-brained supervisors (profile.harness null)"
+    );
+  }
   if (harness === null) {
     const brain = deps.brain ?? routerBrainFromProfile(profile, deps);
     return driverAgent({
@@ -6047,7 +6343,10 @@ function supervisorAgent(profile, deps) {
       ...deps.maxLiveWorkers !== void 0 ? { maxLiveWorkers: deps.maxLiveWorkers } : {},
       ...deps.extraTools ? { extraTools: deps.extraTools } : {},
       ...deps.executeExtraTool ? { executeExtraTool: deps.executeExtraTool } : {},
-      ...deps.maxTurns !== void 0 ? { maxTurns: deps.maxTurns } : {}
+      ...deps.analysts ? { analysts: deps.analysts } : {},
+      ...deps.analyzeOnSettle ? { analyzeOnSettle: deps.analyzeOnSettle } : {},
+      ...deps.maxTurns !== void 0 ? { maxTurns: deps.maxTurns } : {},
+      ...deps.compaction ? { compaction: deps.compaction } : {}
     });
   }
   const driveHarness = deps.driveHarness;
@@ -6064,7 +6363,9 @@ function supervisorAgent(profile, deps) {
         blobs: deps.blobs,
         makeWorkerAgent: deps.makeWorkerAgent,
         perWorker: deps.perWorker,
-        ...deps.maxLiveWorkers !== void 0 ? { maxLiveWorkers: deps.maxLiveWorkers } : {}
+        ...deps.maxLiveWorkers !== void 0 ? { maxLiveWorkers: deps.maxLiveWorkers } : {},
+        ...deps.analysts ? { analysts: deps.analysts } : {},
+        ...deps.analyzeOnSettle ? { analyzeOnSettle: deps.analyzeOnSettle } : {}
       });
       try {
         await driveHarness({ profile, task, scope, coordinationMcpUrl: mcp.url });
@@ -6102,15 +6403,15 @@ export {
   createScope,
   settledToIteration,
   withDriverExecutor,
+  createWorktree,
+  captureWorktreeDiff,
+  removeWorktree,
+  runWorktreeHarness,
   routerChatWithUsage,
   routerChatWithTools,
   routerToolLoop,
   routerBrain,
   createInbox,
-  createWorktree,
-  captureWorktreeDiff,
-  removeWorktree,
-  runWorktreeHarness,
   createWorktreeCliExecutor,
   cliWorktreeExecutor,
   createExecutor,
@@ -6178,4 +6479,4 @@ export {
   createInProcessTransport,
   serveCoordinationMcp
 };
-//# sourceMappingURL=chunk-TSDKBFZP.js.map
+//# sourceMappingURL=chunk-KRULXIWS.js.map