@loops-adk/core 0.1.0

package/dist/api.js

@@ -0,0 +1,898 @@
+import { mergeNoCommit, stageAll, commit, mergeAbort, log, setMeta, jobMeta, isRepo, addWorktree, childContext, composeCommitBody, mergeBranch, removeWorktree, deleteBranch, push, consolidate, toCondition, GhForge } from './chunk-3BPU34DE.js';
+export { Budget, EXIT_PAUSED, EngineRegistry, GhForge, MockForge, Stats, addWorktree, agentCheck, agentJob, all, always, any, appendLedger, appendPrompt, bodyPassed, buildChecksArgs, buildCreateArgs, buildEditArgs, buildMergeArgs, buildViewArgs, commandSucceeds, commit, commitJob, compactLedger, composeCommitBody, conflictedFiles, consolidate, consolidateJob, currentBranch, defineAgent, defineSkill, deleteBranch, describeConditions, ensureIgnored, exitCodeFor, fnJob, forgeChecks, fromFile, gateJob, groundingText, hasStagedChanges, headSha, isDirty, isForge, isRepo, jobMeta, kickback, ledgerPath, log, loop, mergeAbort, mergeBranch, mergeNoCommit, minConfidence, never, not, predicate, promptPath, push, quorum, readLedger, readPrompt, removeWorktree, renderPlan, resetLedger, resetPrompt, resolveSystem, retrieveLedger, run, stageAll, toCondition } from './chunk-3BPU34DE.js';
+import './chunk-JFTXJ7I2.js';
+export { SUBAGENT_TOOLS, isEngine } from './chunk-XC46B4FD.js';
+import './chunk-Y2SD7GBL.js';
+import { LoopError } from './chunk-I3STY7U6.js';
+export { LoopError } from './chunk-I3STY7U6.js';
+import pLimit from 'p-limit';
+import toposort from 'toposort';
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+function stripFence(s) {
+  const m = /^```[^\n]*\n([\s\S]*?)\n```$/.exec(s.trim());
+  return `${(m ? m[1] : s).replace(/\s+$/, "")}
+`;
+}
+function firstLine(s) {
+  return s.split("\n").find((l) => l.trim()) ?? "";
+}
+async function mergeSynthesis(ctx, config) {
+  const cwd = ctx.workspace.dir;
+  const engine = config.engine ? ctx.resolveEngine(config.engine) : ctx.engine;
+  const merge = await mergeNoCommit(cwd, config.branch, { signal: ctx.signal });
+  try {
+    if (!merge.clean) {
+      for (const file of merge.conflicted) {
+        const conflicted = readFileSync(join(cwd, file), "utf8");
+        const out = await engine.run(
+          {
+            prompt: `Resolve this git merge conflict in \`${file}\`. Combine both sides coherently, preserving the intent of each. Output ONLY the fully resolved file content \u2014 no conflict markers, no commentary, no code fence.
+
+${conflicted}`,
+            model: config.model,
+            maxTokens: 4e3
+          },
+          () => {
+          },
+          ctx.signal
+        );
+        writeFileSync(join(cwd, file), stripFence(out.text));
+      }
+      await stageAll({ cwd, signal: ctx.signal });
+    }
+    const body = await synthesiseBody(ctx, engine, config);
+    const sha = await commit(
+      {
+        subject: config.message ?? `merge: ${config.branch} (synthesis)`,
+        body,
+        allowEmpty: true
+        // a merge commit may have an empty diff after resolution
+      },
+      { cwd, signal: ctx.signal }
+    );
+    return { ok: true, conflict: !merge.clean, sha };
+  } catch (e) {
+    await mergeAbort(cwd, { signal: ctx.signal }).catch(() => {
+    });
+    throw LoopError.from(e, { code: "BODY", path: ctx.path });
+  }
+}
+async function synthesiseBody(ctx, engine, config) {
+  const ways = await log({
+    cwd: ctx.workspace.dir,
+    ref: config.branch,
+    max: 8,
+    signal: ctx.signal
+  });
+  const summary = ways.map((w) => `- ${w.subject}${w.body ? `: ${firstLine(w.body)}` : ""}`).join("\n");
+  const out = await engine.run(
+    {
+      prompt: `A branch is being merged. Its commits:
+${summary || "(none)"}
+
+Write a concise MERGE SYNTHESIS for the commit body: what this line of work accomplished, how it integrates, and any tradeoff reconciled. A few sentences, no preamble.`,
+      system: "You write merge synthesis commit bodies that capture intent.",
+      model: config.model,
+      maxTokens: 600
+    },
+    () => {
+    },
+    ctx.signal
+  );
+  return out.text.trim();
+}
+
+// src/core/dag.ts
+function slug(s) {
+  return s.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/(^-+|-+$)/g, "") || "node";
+}
+function normalize(node) {
+  return typeof node === "function" ? { job: node } : node;
+}
+function dag(config) {
+  if (!config.name)
+    throw new LoopError({
+      code: "CONFIG",
+      message: "dag() requires a non-empty name"
+    });
+  const names = Object.keys(config.nodes);
+  const nodes = new Map(
+    names.map((n) => [n, normalize(config.nodes[n])])
+  );
+  const edges = [];
+  for (const [name, node] of nodes) {
+    for (const dep of node.needs ?? []) {
+      if (!nodes.has(dep)) {
+        throw new LoopError({
+          code: "CONFIG",
+          message: `dag "${config.name}": node "${name}" needs unknown node "${dep}"`
+        });
+      }
+      edges.push([dep, name]);
+    }
+  }
+  let order;
+  try {
+    order = toposort.array(names, edges);
+  } catch (e) {
+    throw new LoopError({
+      code: "CONFIG",
+      message: `dag "${config.name}": dependency cycle detected`,
+      cause: e
+    });
+  }
+  const stopOnError = config.stopOnError ?? true;
+  const maxKickbacks = config.maxKickbacks ?? 0;
+  const dependents = new Map(names.map((n) => [n, []]));
+  for (const [dep, name] of edges) dependents.get(dep).push(name);
+  const ancestorsOf = (name) => {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [...nodes.get(name).needs ?? []];
+    while (stack.length) {
+      const n = stack.pop();
+      if (seen.has(n)) continue;
+      seen.add(n);
+      stack.push(...nodes.get(n).needs ?? []);
+    }
+    return seen;
+  };
+  const dirtyFrom = (target) => {
+    const seen = /* @__PURE__ */ new Set([target]);
+    const stack = [target];
+    while (stack.length) {
+      const n = stack.pop();
+      for (const d of dependents.get(n))
+        if (!seen.has(d)) {
+          seen.add(d);
+          stack.push(d);
+        }
+    }
+    return seen;
+  };
+  const limitN = config.concurrency && config.concurrency > 0 ? config.concurrency : names.length || 1;
+  const job = async (parent) => {
+    const path = [...parent.path, config.name];
+    const depth = parent.depth + 1;
+    const ts = () => Date.now();
+    parent.emit({ kind: "dag:start", ts: ts(), path, depth, nodes: names });
+    const limit = pLimit(limitN);
+    const results = /* @__PURE__ */ new Map();
+    const memo = /* @__PURE__ */ new Map();
+    let stopped = false;
+    const pendingKickback = /* @__PURE__ */ new Map();
+    const nodeCtx = (name, workspace, environment) => childContext(parent, {
+      depth,
+      path: [...path, name],
+      workspace,
+      environment,
+      lastReview: pendingKickback.get(name)
+    });
+    const mergeLimit = pLimit(1);
+    let forkSeq2 = 0;
+    const runNodeJob = async (name, node) => {
+      const isolated2 = node.isolate ?? config.isolation === "worktree";
+      if (!isolated2) return node.job(nodeCtx(name));
+      const base = parent.workspace;
+      if (!await isRepo({ cwd: base.dir, signal: parent.signal })) {
+        parent.log(
+          `node "${name}" requested worktree isolation but ${base.dir} is not a git repo; running in the shared workspace`,
+          "warn"
+        );
+        return node.job(nodeCtx(name));
+      }
+      const branch = `loops/${slug(config.name)}-${slug(name)}-${forkSeq2 += 1}`;
+      const wt = await addWorktree(base.dir, {
+        branch,
+        base: "HEAD",
+        signal: parent.signal
+      });
+      const wtWs = { dir: wt.dir, branch };
+      let envHandle;
+      try {
+        if (config.environment)
+          envHandle = await config.environment.up(wtWs, parent.signal);
+        const outcome2 = await node.job(nodeCtx(name, wtWs, envHandle));
+        if (outcome2.status === "pass") {
+          await stageAll({ cwd: wt.dir, signal: parent.signal });
+          await commit(
+            {
+              subject: `chore(${slug(name)}): worktree changes`,
+              body: await composeCommitBody(parent, wtWs)
+            },
+            { cwd: wt.dir, signal: parent.signal }
+          );
+          const merged = await mergeLimit(
+            () => mergeBranch(base.dir, branch, {
+              signal: parent.signal,
+              message: `merge ${branch} (node ${name})`
+            })
+          );
+          if (!merged.ok) {
+            if (config.onConflict !== "synthesize") {
+              return {
+                status: "fail",
+                summary: `node "${name}" landed with a merge conflict; needs resolution`,
+                error: new LoopError({
+                  code: "BODY",
+                  message: `merge conflict landing node "${name}"`,
+                  path: [...path, name]
+                })
+              };
+            }
+            try {
+              await mergeLimit(
+                () => mergeSynthesis(parent, {
+                  branch,
+                  message: `merge: ${branch} (node ${name}, synthesis)`
+                })
+              );
+            } catch (e) {
+              const error = LoopError.from(e, {
+                code: "BODY",
+                path: [...path, name]
+              });
+              return {
+                status: "fail",
+                summary: `node "${name}" merge synthesis failed: ${error.message}`,
+                error
+              };
+            }
+          }
+          await deleteBranch(base.dir, branch, { signal: parent.signal }).catch(
+            () => {
+            }
+          );
+        }
+        return outcome2;
+      } finally {
+        if (envHandle)
+          await envHandle.down(parent.signal).catch(() => {
+          });
+        await removeWorktree(base.dir, wt.dir, {
+          signal: parent.signal
+        }).catch(() => {
+        });
+      }
+    };
+    const record = (name, outcome2, phase) => {
+      results.set(name, outcome2);
+      parent.emit({
+        kind: "dag:node",
+        ts: ts(),
+        path,
+        node: name,
+        phase,
+        outcome: outcome2
+      });
+      if (phase === "done" && outcome2.status !== "pass" && nodes.get(name).optional !== true && stopOnError && // A node requesting a kickback is going to be re-run — don't let its
+      // (provisional) non-pass abort siblings before the feedback is resolved.
+      !(maxKickbacks > 0 && outcome2.kickback)) {
+        stopped = true;
+      }
+      return outcome2;
+    };
+    const run2 = (name) => {
+      const existing = memo.get(name);
+      if (existing) return existing;
+      const node = nodes.get(name);
+      const promise = (async () => {
+        try {
+          const needs = node.needs ?? [];
+          const deps = await Promise.all(needs.map(run2));
+          const blocked = needs.some((_, i) => deps[i].status !== "pass");
+          if (blocked)
+            return record(
+              name,
+              { status: "aborted", summary: "blocked by a failed dependency" },
+              "done"
+            );
+          if (parent.signal.aborted || stopped)
+            return record(
+              name,
+              { status: "aborted", summary: "aborted before start" },
+              "done"
+            );
+          const result = await limit(
+            async () => {
+              if (parent.signal.aborted || stopped)
+                return {
+                  outcome: {
+                    status: "aborted",
+                    summary: "aborted before start"
+                  },
+                  phase: "done"
+                };
+              if (node.when) {
+                const r = await toCondition(node.when)(
+                  nodeCtx(name),
+                  void 0
+                );
+                if (!r.met)
+                  return {
+                    outcome: {
+                      status: "pass",
+                      summary: `skipped: ${r.reason}`,
+                      data: { skipped: true }
+                    },
+                    phase: "skip"
+                  };
+              }
+              parent.emit({
+                kind: "dag:node",
+                ts: ts(),
+                path,
+                node: name,
+                phase: "start"
+              });
+              return { outcome: await runNodeJob(name, node), phase: "done" };
+            }
+          );
+          return record(name, result.outcome, result.phase);
+        } catch (e) {
+          const error = LoopError.from(e, {
+            code: "BODY",
+            phase: "body",
+            path: [...path, name]
+          });
+          parent.emit({
+            kind: "error",
+            ts: ts(),
+            path: [...path, name],
+            message: error.message,
+            code: error.code
+          });
+          return record(
+            name,
+            { status: "fail", summary: error.message, error },
+            "done"
+          );
+        }
+      })();
+      memo.set(name, promise);
+      return promise;
+    };
+    await Promise.all(names.map(run2));
+    if (maxKickbacks > 0) {
+      let used = 0;
+      const rejected = /* @__PURE__ */ new Set();
+      const emitKickback = (from, to, reason, accepted, note) => parent.emit({
+        kind: "dag:kickback",
+        ts: ts(),
+        path,
+        from,
+        to,
+        reason,
+        accepted,
+        note
+      });
+      for (; ; ) {
+        const from = order.find(
+          (n) => results.get(n)?.kickback && !rejected.has(n)
+        );
+        if (!from) break;
+        const { to, reason } = results.get(from).kickback;
+        const allow = nodes.get(from).acceptsKickbackTo;
+        const note = !nodes.has(to) ? `unknown node "${to}"` : !ancestorsOf(from).has(to) ? `"${to}" is not an ancestor of "${from}"` : allow && !allow.includes(to) ? `"${from}" does not accept kickback to "${to}"` : void 0;
+        if (note) {
+          rejected.add(from);
+          emitKickback(from, to, reason, false, note);
+          continue;
+        }
+        if (used >= maxKickbacks) {
+          emitKickback(
+            from,
+            to,
+            reason,
+            false,
+            `kickback budget (${maxKickbacks}) exhausted`
+          );
+          break;
+        }
+        used += 1;
+        emitKickback(from, to, reason, true);
+        const dirty = dirtyFrom(to);
+        for (const d of dirty) {
+          memo.delete(d);
+          results.delete(d);
+          rejected.delete(d);
+        }
+        pendingKickback.set(to, {
+          status: "fail",
+          summary: `Kicked back from "${from}": ${reason}`,
+          data: { kickback: true, from }
+        });
+        stopped = false;
+        await Promise.all(names.map(run2));
+      }
+    }
+    const requiredFailed = names.filter(
+      (n) => results.get(n)?.status === "fail" && nodes.get(n).optional !== true
+    );
+    const requiredAborted = names.filter(
+      (n) => results.get(n)?.status === "aborted" && nodes.get(n).optional !== true
+    );
+    const data = Object.fromEntries(results);
+    let outcome;
+    if (parent.signal.aborted) {
+      outcome = {
+        status: "aborted",
+        summary: `dag "${config.name}" aborted`,
+        data
+      };
+    } else if (requiredFailed.length > 0 || requiredAborted.length > 0) {
+      outcome = {
+        status: "fail",
+        summary: `dag "${config.name}": ${requiredFailed.length + requiredAborted.length} required node(s) did not complete`,
+        data
+      };
+    } else {
+      outcome = {
+        status: "pass",
+        summary: `dag "${config.name}": all ${names.length} node(s) green`,
+        data
+      };
+    }
+    parent.emit({ kind: "dag:end", ts: ts(), path, outcome });
+    return outcome;
+  };
+  return setMeta(job, {
+    kind: "dag",
+    name: config.name,
+    nodes: Object.entries(config.nodes).map(([name, v]) => {
+      const node = typeof v === "function" ? void 0 : v;
+      const nodeJob = node ? node.job : v;
+      return {
+        name,
+        needs: node?.needs ?? [],
+        isolate: node?.isolate ?? false,
+        job: jobMeta(nodeJob)
+      };
+    })
+  });
+}
+function sequence(name, ...jobs) {
+  const nodes = {};
+  jobs.forEach((job, i) => {
+    nodes[`step-${i}`] = { job, needs: i > 0 ? [`step-${i - 1}`] : [] };
+  });
+  return dag({ name, nodes, concurrency: 1, stopOnError: true });
+}
+function parallel(name, jobs, concurrency) {
+  const record = Array.isArray(jobs) ? Object.fromEntries(jobs.map((j, i) => [`task-${i}`, j])) : jobs;
+  return dag({ name, nodes: record, concurrency, stopOnError: false });
+}
+function slug2(s) {
+  return s.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/(^-+|-+$)/g, "") || "x";
+}
+function tournament(config) {
+  if (!config.name)
+    throw new LoopError({
+      code: "CONFIG",
+      message: "tournament() requires a non-empty name"
+    });
+  if (config.n < 1)
+    throw new LoopError({ code: "CONFIG", message: "tournament() needs n >= 1" });
+  return async (parent) => {
+    const path = [...parent.path, config.name];
+    const base = parent.workspace;
+    parent.emit({
+      kind: "job:start",
+      ts: Date.now(),
+      path,
+      label: config.name
+    });
+    if (!await isRepo({ cwd: base.dir, signal: parent.signal })) {
+      const error = new LoopError({
+        code: "CONFIG",
+        message: `tournament "${config.name}" requires a git repository (cwd: ${base.dir})`
+      });
+      return { status: "fail", summary: error.message, error };
+    }
+    const limit = pLimit(config.concurrency ?? config.n);
+    const attempts = await Promise.all(
+      Array.from(
+        { length: config.n },
+        (_, i) => limit(async () => {
+          const branch = `loops/${slug2(config.name)}-cand-${i}`;
+          const wt = await addWorktree(base.dir, {
+            branch,
+            base: "HEAD",
+            signal: parent.signal
+          });
+          const ws = { dir: wt.dir, branch };
+          try {
+            const ctx = childContext(parent, {
+              depth: parent.depth + 1,
+              path: [...path, `#${i}`],
+              workspace: ws
+            });
+            const outcome2 = await config.candidate(i)(ctx);
+            await stageAll({ cwd: wt.dir, signal: parent.signal });
+            await commit(
+              {
+                subject: `${config.name}: candidate ${i}`,
+                body: await composeCommitBody(ctx, ws)
+              },
+              { cwd: wt.dir, signal: parent.signal }
+            );
+            const score = outcome2.status === "pass" ? await config.judge(outcome2, ctx) : -1;
+            parent.log(`${config.name} candidate ${i}: score ${score}`);
+            return { i, branch, dir: wt.dir, outcome: outcome2, score };
+          } catch (e) {
+            const error = LoopError.from(e, { code: "BODY", path });
+            return {
+              i,
+              branch,
+              dir: wt.dir,
+              outcome: { status: "fail", summary: error.message, error },
+              score: -1
+            };
+          }
+        })
+      )
+    );
+    const winner = [...attempts].filter((a) => a.outcome.status === "pass" && a.score >= 0).sort((a, b) => b.score - a.score || a.i - b.i)[0];
+    let landed = false;
+    if (winner) {
+      const merged = await mergeBranch(base.dir, winner.branch, {
+        signal: parent.signal,
+        message: `${config.name}: land candidate ${winner.i} (score ${winner.score})`
+      });
+      landed = merged.ok;
+    }
+    for (const a of attempts) {
+      await removeWorktree(base.dir, a.dir, { signal: parent.signal }).catch(
+        () => {
+        }
+      );
+      if (a !== winner || landed)
+        await deleteBranch(base.dir, a.branch, {
+          signal: parent.signal
+        }).catch(() => {
+        });
+    }
+    const outcome = winner ? {
+      status: landed ? "pass" : "fail",
+      confidence: winner.outcome.confidence,
+      summary: landed ? `tournament "${config.name}": landed candidate ${winner.i} (score ${winner.score}) of ${config.n}` : `tournament "${config.name}": winner ${winner.i} failed to land`,
+      data: {
+        winner: winner.i,
+        score: winner.score,
+        scores: attempts.map((a) => ({ i: a.i, score: a.score }))
+      }
+    } : {
+      status: "fail",
+      summary: `tournament "${config.name}": no candidate passed`,
+      data: { scores: attempts.map((a) => ({ i: a.i, score: a.score })) }
+    };
+    parent.emit({ kind: "job:end", ts: Date.now(), path, label: config.name, outcome });
+    return outcome;
+  };
+}
+
+// src/core/pr.ts
+function resolveForge(ctx) {
+  return ctx.forge ?? new GhForge();
+}
+async function derive(value, ctx, last) {
+  if (value === void 0) return void 0;
+  return typeof value === "function" ? await value(
+    ctx,
+    last
+  ) : value;
+}
+function pushJob(config = {}) {
+  return async (ctx) => {
+    const label = config.label ?? "push";
+    const path = [...ctx.path];
+    ctx.emit({ kind: "job:start", ts: Date.now(), path, label });
+    const branch = config.branch ?? ctx.workspace.branch;
+    const res = await push({
+      cwd: ctx.workspace.dir,
+      signal: ctx.signal,
+      remote: config.remote,
+      branch,
+      setUpstream: config.setUpstream,
+      force: config.force
+    });
+    const outcome = res.ok ? { status: "pass", summary: `pushed ${branch ?? "HEAD"}` } : {
+      status: "fail",
+      summary: `push failed: ${res.output}`,
+      error: new LoopError({ code: "BODY", message: res.output })
+    };
+    ctx.emit({ kind: "job:end", ts: Date.now(), path, label, outcome });
+    return outcome;
+  };
+}
+function pullRequestJob(config = {}) {
+  return async (ctx) => {
+    const label = config.label ?? "pull-request";
+    const path = [...ctx.path];
+    ctx.emit({ kind: "job:start", ts: Date.now(), path, label });
+    try {
+      const branch = ctx.workspace.branch;
+      if (!branch)
+        throw new LoopError({
+          code: "CONFIG",
+          message: `pullRequestJob "${label}" needs a branch checked out (detached HEAD or non-repo)`
+        });
+      const base = config.base ?? "main";
+      const last = ctx.lastOutcome;
+      if (config.push !== false) {
+        const res = await push({
+          cwd: ctx.workspace.dir,
+          signal: ctx.signal,
+          branch,
+          ...typeof config.push === "object" ? config.push : {}
+        });
+        if (!res.ok)
+          throw new LoopError({
+            code: "BODY",
+            message: `push failed: ${res.output}`
+          });
+      }
+      const body = await derive(config.body, ctx, last) ?? await consolidate(ctx, {
+        since: base,
+        max: config.max ?? 50,
+        model: config.model
+      });
+      const title = await derive(config.title, ctx, last) ?? last?.summary ?? branch;
+      const forge = resolveForge(ctx);
+      const fopts = { cwd: ctx.workspace.dir, signal: ctx.signal };
+      const existing = await forge.viewPr(branch, fopts);
+      let pr;
+      if (existing) {
+        await forge.editPr(existing, { body }, fopts);
+        pr = existing;
+      } else {
+        pr = await forge.createPr(
+          { title, body, base, branch, draft: config.draft },
+          fopts
+        );
+      }
+      const outcome = {
+        status: "pass",
+        summary: `${existing ? "updated" : "opened"} PR #${pr.number}`,
+        data: { pr }
+      };
+      ctx.emit({ kind: "job:end", ts: Date.now(), path, label, outcome });
+      return outcome;
+    } catch (e) {
+      const error = LoopError.from(e, {
+        code: "BODY",
+        phase: "body",
+        path: ctx.path
+      });
+      ctx.emit({
+        kind: "error",
+        ts: Date.now(),
+        path,
+        message: error.message,
+        code: error.code
+      });
+      const outcome = { status: "fail", summary: error.message, error };
+      ctx.emit({ kind: "job:end", ts: Date.now(), path, label, outcome });
+      return outcome;
+    }
+  };
+}
+function mergeJob(config = {}) {
+  return async (ctx) => {
+    const label = config.label ?? "merge";
+    const path = [...ctx.path];
+    ctx.emit({ kind: "job:start", ts: Date.now(), path, label });
+    try {
+      const branch = ctx.workspace.branch;
+      if (!branch)
+        throw new LoopError({
+          code: "CONFIG",
+          message: `mergeJob "${label}" needs a branch checked out`
+        });
+      const forge = resolveForge(ctx);
+      const fopts = { cwd: ctx.workspace.dir, signal: ctx.signal };
+      const pr = await forge.viewPr(branch, fopts);
+      if (!pr)
+        throw new LoopError({
+          code: "CONFIG",
+          message: `mergeJob "${label}": no open PR for branch "${branch}" \u2014 run pullRequestJob first`
+        });
+      if (config.when) {
+        const r = await toCondition(config.when)(ctx, ctx.lastOutcome);
+        if (!r.met) {
+          const outcome2 = {
+            status: "fail",
+            summary: `merge gate not met: ${r.reason}`,
+            data: { pr }
+          };
+          ctx.emit({ kind: "job:end", ts: Date.now(), path, label, outcome: outcome2 });
+          return outcome2;
+        }
+      }
+      const last = ctx.lastOutcome;
+      const base = config.base ?? "main";
+      const body = await derive(config.body, ctx, last) ?? await consolidate(ctx, {
+        since: base,
+        max: config.max ?? 50,
+        model: config.model
+      });
+      const subject = await derive(config.subject, ctx, last);
+      await forge.mergePr(pr, {
+        ...fopts,
+        squash: config.squash,
+        auto: config.auto,
+        subject,
+        body,
+        deleteBranch: config.deleteBranch
+      });
+      const outcome = {
+        status: "pass",
+        summary: `${config.auto ? "enqueued" : "merged"} PR #${pr.number}`,
+        data: { pr }
+      };
+      ctx.emit({ kind: "job:end", ts: Date.now(), path, label, outcome });
+      return outcome;
+    } catch (e) {
+      const error = LoopError.from(e, {
+        code: "BODY",
+        phase: "body",
+        path: ctx.path
+      });
+      ctx.emit({
+        kind: "error",
+        ts: Date.now(),
+        path,
+        message: error.message,
+        code: error.code
+      });
+      const outcome = { status: "fail", summary: error.message, error };
+      ctx.emit({ kind: "job:end", ts: Date.now(), path, label, outcome });
+      return outcome;
+    }
+  };
+}
+var slug3 = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "job";
+var mergeLock = pLimit(1);
+var forkSeq = 0;
+function isolated(job, opts = {}) {
+  const label = opts.label ?? "isolated";
+  return async (parent) => {
+    const base = parent.workspace;
+    if (!await isRepo({ cwd: base.dir, signal: parent.signal })) {
+      parent.log(
+        `isolated("${label}") requested a worktree but ${base.dir} is not a git repo; running in the shared workspace`,
+        "warn"
+      );
+      return job(parent);
+    }
+    const branch = `loops/${slug3(label)}-${forkSeq += 1}`;
+    const wt = await addWorktree(base.dir, {
+      branch,
+      base: "HEAD",
+      signal: parent.signal
+    });
+    const wtWs = { dir: wt.dir, branch };
+    try {
+      const ctx = childContext(parent, {
+        workspace: wtWs,
+        depth: parent.depth + 1,
+        path: [...parent.path, label]
+      });
+      const outcome = await job(ctx);
+      if (outcome.status === "pass") {
+        await stageAll({ cwd: wt.dir, signal: parent.signal });
+        await commit(
+          {
+            subject: `chore(${slug3(label)}): worktree changes`,
+            body: await composeCommitBody(ctx, wtWs)
+          },
+          { cwd: wt.dir, signal: parent.signal }
+        );
+        const merged = await mergeLock(
+          () => mergeBranch(base.dir, branch, {
+            signal: parent.signal,
+            message: `merge ${branch}`
+          })
+        );
+        if (!merged.ok) {
+          if (opts.onConflict !== "synthesize") {
+            return {
+              status: "fail",
+              summary: `isolated("${label}") landed with a merge conflict; needs resolution`,
+              error: new LoopError({
+                code: "BODY",
+                message: `merge conflict landing isolated("${label}")`,
+                path: [...parent.path, label]
+              })
+            };
+          }
+          try {
+            await mergeLock(
+              () => mergeSynthesis(parent, {
+                branch,
+                message: `merge: ${branch} (synthesis)`
+              })
+            );
+          } catch (e) {
+            const error = LoopError.from(e, { code: "BODY", path: [...parent.path, label] });
+            return {
+              status: "fail",
+              summary: `isolated("${label}") merge synthesis failed: ${error.message}`,
+              error
+            };
+          }
+        }
+        await deleteBranch(base.dir, branch, { signal: parent.signal }).catch(() => {
+        });
+      }
+      return outcome;
+    } finally {
+      await removeWorktree(base.dir, wt.dir, { signal: parent.signal }).catch(() => {
+      });
+    }
+  };
+}
+
+// src/engines/mock.ts
+var MockEngine = class {
+  constructor(responder) {
+    this.responder = responder;
+  }
+  responder;
+  name = "mock";
+  async run(req, onEvent, signal) {
+    if (signal.aborted) {
+      throw Object.assign(new Error("aborted"), { name: "AbortError" });
+    }
+    const raw = this.responder(req);
+    const out = typeof raw === "string" ? { text: raw } : raw;
+    const model = out.model ?? "mock";
+    const usage = out.usage ?? { inputTokens: 10, outputTokens: 5 };
+    if (out.text) onEvent({ type: "text", delta: out.text });
+    onEvent({ type: "usage", usage, model });
+    return { text: out.text, usage, model, stopReason: "end_turn" };
+  }
+};
+function mockVerdict(verdict, confidence, reason = "mock") {
+  return new MockEngine(() => JSON.stringify({ verdict, confidence, reason }));
+}
+
+// src/env/environment.ts
+function isEnvironment(value) {
+  return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.up === "function";
+}
+
+// src/env/mock.ts
+var MockEnvironment = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  opts;
+  name = "mock-env";
+  upCount = 0;
+  downCount = 0;
+  async up(workspace) {
+    this.upCount += 1;
+    const url = typeof this.opts.url === "function" ? this.opts.url(workspace) : this.opts.url ?? `http://localhost/${workspace.branch ?? "main"}`;
+    this.opts.onUp?.(workspace);
+    const onDown = this.opts.onDown;
+    return {
+      url,
+      env: { BASE_URL: url, ...this.opts.env },
+      down: async () => {
+        this.downCount += 1;
+        onDown?.();
+      }
+    };
+  }
+};
+
+// src/api.ts
+function defineJob(job) {
+  return job;
+}
+
+export { MockEngine, MockEnvironment, dag, defineJob, isEnvironment, isolated, mergeJob, mergeSynthesis, mockVerdict, parallel, pullRequestJob, pushJob, sequence, tournament };
+//# sourceMappingURL=api.js.map
+//# sourceMappingURL=api.js.map