@loops-adk/core 0.1.0

package/dist/chunk-3BPU34DE.js

@@ -0,0 +1,2163 @@
+import { redactSecrets } from './chunk-JFTXJ7I2.js';
+import { isEngine } from './chunk-XC46B4FD.js';
+import { isLimitError, waitMsFor } from './chunk-Y2SD7GBL.js';
+import { LoopError } from './chunk-I3STY7U6.js';
+import { readFileSync, mkdtempSync, existsSync, writeFileSync, appendFileSync, mkdirSync, rmSync } from 'fs';
+import { execa } from 'execa';
+import { tmpdir } from 'os';
+import { join, dirname } from 'path';
+
+// src/core/describe.ts
+var META = /* @__PURE__ */ new WeakMap();
+var LABEL = /* @__PURE__ */ new WeakMap();
+function setMeta(target, meta) {
+  META.set(target, meta);
+  return target;
+}
+function jobMeta(job) {
+  return typeof job === "function" ? META.get(job) : void 0;
+}
+function setLabel(cond, label) {
+  LABEL.set(cond, label);
+  return cond;
+}
+function condLabel(input) {
+  if (typeof input === "function") {
+    const l = LABEL.get(input);
+    if (l) return l;
+  }
+  return "check";
+}
+function describeConditions(input) {
+  if (input == null) return [];
+  if (Array.isArray(input)) return input.flatMap(describeConditions);
+  return [condLabel(input)];
+}
+var count = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+function renderPlan(meta, indent = "") {
+  if (!meta) return [`${indent}(a runnable job, shape not introspectable)`];
+  const nm = meta.name ? ` "${meta.name}"` : "";
+  const out = [];
+  switch (meta.kind) {
+    case "loop": {
+      const max = typeof meta.max === "number" ? ` (max ${meta.max})` : "";
+      out.push(`${indent}loop${nm}${max}`);
+      const start = meta.start;
+      const gate = meta.gate;
+      const stopOn = meta.stopOn;
+      if (start?.length) out.push(`${indent}  start: ${start.join(", ")}`);
+      if (gate?.length) out.push(`${indent}  gate: ${gate.join(", ")}`);
+      if (stopOn?.length) out.push(`${indent}  stopOn: ${stopOn.join(", ")}`);
+      const tail = [meta.review ? "review" : null, meta.commit ? "commit" : null].filter(Boolean);
+      if (tail.length) out.push(`${indent}  on convergence: ${tail.join(" + ")}`);
+      out.push(`${indent}  body:`);
+      out.push(...renderPlan(meta.body, `${indent}    `));
+      break;
+    }
+    case "dag": {
+      const nodes = meta.nodes ?? [];
+      out.push(`${indent}dag${nm} (${count(nodes.length, "node")})`);
+      for (const node of nodes) {
+        const bits = [];
+        if (node.needs?.length) bits.push(`needs ${node.needs.join(", ")}`);
+        if (node.isolate) bits.push("isolated");
+        out.push(`${indent}  - ${node.name}${bits.length ? ` (${bits.join("; ")})` : ""}`);
+        out.push(...renderPlan(node.job, `${indent}      `));
+      }
+      break;
+    }
+    case "agent":
+      out.push(`${indent}agent${nm}${meta.ground ? " (grounded)" : ""}`);
+      break;
+    case "fn":
+      out.push(`${indent}fn${nm}`);
+      break;
+    default:
+      out.push(`${indent}${meta.kind}${nm}`);
+  }
+  return out;
+}
+
+// src/core/budget.ts
+var Budget = class {
+  limit;
+  headroom;
+  soft;
+  tokens = 0;
+  constructor(config) {
+    this.limit = config.limit;
+    this.headroom = config.headroom ?? 0;
+    this.soft = config.soft ?? false;
+  }
+  /** Record consumed tokens. Non-finite or non-positive values are ignored. */
+  add(tokens) {
+    if (Number.isFinite(tokens) && tokens > 0) this.tokens += tokens;
+  }
+  spent() {
+    return this.tokens;
+  }
+  remaining() {
+    return Math.max(0, this.limit - this.tokens);
+  }
+  /** True once the next call would breach the cap (accounting for headroom). */
+  exceeded() {
+    return this.tokens + this.headroom >= this.limit;
+  }
+};
+function assertBudget(ctx) {
+  const budget = ctx.budget;
+  if (!budget || !budget.exceeded()) return;
+  if (budget.soft) {
+    ctx.log(
+      `token budget reached (${budget.spent()}/${budget.limit}) \u2014 continuing (soft)`,
+      "warn"
+    );
+    return;
+  }
+  throw new LoopError({
+    code: "BUDGET",
+    phase: "engine",
+    message: `token budget exhausted: ${budget.spent()}/${budget.limit} tokens spent`
+  });
+}
+function fromFile(path) {
+  return readFileSync(path, "utf8").trim();
+}
+function defineSkill(skill) {
+  if (!skill.name) throw new Error("defineSkill: `name` is required");
+  if (!skill.instructions?.trim()) throw new Error(`defineSkill "${skill.name}": empty instructions`);
+  return skill;
+}
+function defineAgent(def) {
+  if (!def.name) throw new Error("defineAgent: `name` is required");
+  if (!def.system?.trim()) throw new Error(`defineAgent "${def.name}": empty system prompt`);
+  def.skills?.forEach((s) => defineSkill(s));
+  return def;
+}
+function resolveSystem(agent) {
+  if (!agent.skills?.length) return agent.system;
+  const methods = agent.skills.map((s) => `### ${s.name}
+
+${s.instructions.trim()}`).join("\n\n");
+  return `${agent.system.trim()}
+
+## Methodologies you apply
+
+${methods}`;
+}
+function isForge(value) {
+  return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.createPr === "function";
+}
+function buildViewArgs(branch) {
+  return ["pr", "view", branch, "--json", "number,url,headRefName"];
+}
+function buildCreateArgs(input) {
+  const args = [
+    "pr",
+    "create",
+    "--base",
+    input.base,
+    "--head",
+    input.branch,
+    "--title",
+    input.title,
+    "--body-file",
+    "-"
+  ];
+  if (input.draft) args.push("--draft");
+  return args;
+}
+function buildEditArgs(pr, patch) {
+  const args = ["pr", "edit", String(pr.number)];
+  if (patch.title) args.push("--title", patch.title);
+  if (patch.body !== void 0) args.push("--body-file", "-");
+  return args;
+}
+function buildMergeArgs(pr, opts) {
+  const args = ["pr", "merge", String(pr.number)];
+  args.push(opts.squash === false ? "--merge" : "--squash");
+  if (opts.auto) args.push("--auto");
+  if (opts.subject) args.push("--subject", opts.subject);
+  if (opts.body !== void 0) args.push("--body-file", "-");
+  if (opts.deleteBranch) args.push("--delete-branch");
+  return args;
+}
+function buildChecksArgs(pr) {
+  return ["pr", "checks", String(pr.number), "--required"];
+}
+async function gh(bin, args, opts, input) {
+  let r;
+  try {
+    r = await execa(bin, args, {
+      cwd: opts.cwd,
+      cancelSignal: opts.signal,
+      reject: false,
+      all: true,
+      stdin: input === void 0 ? "ignore" : void 0,
+      input
+    });
+  } catch (e) {
+    throw new LoopError({
+      code: "CONFIG",
+      message: `the GitHub CLI (gh) is required for PR operations but could not be run (install it and run \`gh auth login\`): ${e.message}`
+    });
+  }
+  return {
+    stdout: r.stdout ?? "",
+    all: r.all ?? r.stdout ?? "",
+    exitCode: r.exitCode ?? 1
+  };
+}
+function ghOrThrow(r, action) {
+  if (r.exitCode !== 0)
+    throw new LoopError({
+      code: "CONFIG",
+      message: `gh ${action} failed (exit ${r.exitCode}): ${redactSecrets(String(r.all).slice(0, 400))}`
+    });
+}
+var GhForge = class {
+  constructor(bin = "gh") {
+    this.bin = bin;
+  }
+  bin;
+  name = "gh";
+  async viewPr(branch, opts) {
+    const r = await gh(this.bin, buildViewArgs(branch), opts);
+    if (r.exitCode !== 0) return void 0;
+    try {
+      const j = JSON.parse(r.stdout);
+      return { number: j.number, url: j.url, branch: j.headRefName };
+    } catch {
+      return void 0;
+    }
+  }
+  async createPr(input, opts) {
+    const r = await gh(this.bin, buildCreateArgs(input), opts, input.body);
+    ghOrThrow(r, "pr create");
+    const url = r.stdout.trim().split("\n").pop() ?? "";
+    const m = url.match(/\/pull\/(\d+)/);
+    return { number: m ? Number(m[1]) : 0, url, branch: input.branch };
+  }
+  async editPr(pr, patch, opts) {
+    const r = await gh(this.bin, buildEditArgs(pr, patch), opts, patch.body);
+    ghOrThrow(r, "pr edit");
+  }
+  async mergePr(pr, opts) {
+    const r = await gh(this.bin, buildMergeArgs(pr, opts), opts, opts.body);
+    ghOrThrow(r, "pr merge");
+  }
+  async checksPass(pr, opts) {
+    const r = await gh(this.bin, buildChecksArgs(pr), opts);
+    return r.exitCode === 0;
+  }
+};
+var MockForge = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.prs = new Map(Object.entries(opts.existing ?? {}));
+  }
+  opts;
+  name = "mock-forge";
+  calls = [];
+  prs;
+  seq = 100;
+  async viewPr(branch) {
+    this.calls.push({ method: "viewPr", args: { branch } });
+    return this.prs.get(branch);
+  }
+  async createPr(input) {
+    this.calls.push({ method: "createPr", args: { ...input } });
+    const number = this.seq += 1;
+    const pr = {
+      number,
+      url: `https://example.test/pull/${number}`,
+      branch: input.branch
+    };
+    this.prs.set(input.branch, pr);
+    return pr;
+  }
+  async editPr(pr, patch) {
+    this.calls.push({ method: "editPr", args: { pr, patch } });
+  }
+  async mergePr(pr, opts) {
+    this.calls.push({
+      method: "mergePr",
+      args: {
+        pr,
+        squash: opts.squash,
+        auto: opts.auto,
+        subject: opts.subject,
+        body: opts.body,
+        deleteBranch: opts.deleteBranch
+      }
+    });
+  }
+  async checksPass() {
+    this.calls.push({ method: "checksPass", args: {} });
+    return this.opts.checks ?? true;
+  }
+};
+function toCondition(input, combine = "all") {
+  if (Array.isArray(input)) {
+    const conds = input.map((i) => toCondition(i, combine));
+    return combine === "any" ? any(...conds) : all(...conds);
+  }
+  return coerceOne(input);
+}
+function coerceOne(fn) {
+  return async (ctx, last) => {
+    const r = await fn(
+      ctx,
+      last
+    );
+    if (typeof r === "boolean") {
+      return { met: r, reason: `predicate: ${r}` };
+    }
+    if (r && typeof r === "object" && "met" in r) {
+      const res = r;
+      if (typeof res.met !== "boolean") {
+        throw new LoopError({
+          code: "VALIDATION",
+          message: `condition returned a non-boolean "met": ${String(res.met)}`
+        });
+      }
+      return r;
+    }
+    return { met: Boolean(r), reason: `coerced: ${String(r)}` };
+  };
+}
+function predicate(fn, reason = "predicate") {
+  return async (ctx, last) => {
+    const met = await fn(ctx, last);
+    return { met, reason: met ? `${reason}: true` : `${reason}: false` };
+  };
+}
+function bodyPassed() {
+  return async (_ctx, last) => ({
+    met: last?.status === "pass",
+    confidence: last?.confidence,
+    reason: `last body status = ${last?.status ?? "none"}`
+  });
+}
+function minConfidence(threshold) {
+  return async (_ctx, last) => {
+    const c = last?.confidence ?? 0;
+    return {
+      met: c >= threshold,
+      confidence: c,
+      reason: `confidence ${c.toFixed(2)} ${c >= threshold ? ">=" : "<"} ${threshold}`
+    };
+  };
+}
+function commandSucceeds(command, args = [], opts = {}) {
+  return setLabel(async (ctx) => {
+    try {
+      const r = await execa(command, args, {
+        cwd: opts.cwd ?? ctx.workspace.dir,
+        timeout: opts.timeoutMs,
+        cancelSignal: ctx.signal,
+        reject: false,
+        stdin: "ignore",
+        // Inherit the running environment's vars (BASE_URL, …) so the gate can
+        // test the live preview, not just static files on disk.
+        env: ctx.environment?.env
+      });
+      return {
+        met: r.exitCode === 0,
+        reason: `\`${command}\` exited ${r.exitCode ?? "?"}`
+      };
+    } catch (e) {
+      return {
+        met: false,
+        reason: `\`${command}\` failed to run: ${e instanceof Error ? e.message : String(e)}`
+      };
+    }
+  }, `${command}${args.length ? ` ${args.join(" ")}` : ""}`);
+}
+function forgeChecks() {
+  return async (ctx) => {
+    const branch = ctx.workspace.branch;
+    if (!branch) return { met: false, reason: "no branch checked out" };
+    const forge = ctx.forge ?? new GhForge();
+    const fopts = { cwd: ctx.workspace.dir, signal: ctx.signal };
+    const pr = await forge.viewPr(branch, fopts);
+    if (!pr) return { met: false, reason: `no open PR for "${branch}"` };
+    const ok = await forge.checksPass(pr, fopts);
+    return {
+      met: ok,
+      reason: ok ? "required checks pass" : "required checks not green"
+    };
+  };
+}
+var always = async () => ({ met: true, reason: "always" });
+var never = async () => ({ met: false, reason: "never" });
+function not(c) {
+  const cond = toCondition(c);
+  return async (ctx, last) => {
+    const r = await cond(ctx, last);
+    return {
+      met: !r.met,
+      confidence: r.confidence,
+      reason: `not(${r.reason})`
+    };
+  };
+}
+function all(...inputs) {
+  const conds = inputs.map((i) => toCondition(i));
+  return async (ctx, last) => {
+    const results = [];
+    for (const c of conds) {
+      const r = await c(ctx, last);
+      results.push(r);
+      if (!r.met) return { met: false, reason: `all -> failed: ${r.reason}` };
+    }
+    return {
+      met: true,
+      reason: `all(${results.map((r) => r.reason).join(" & ")})`
+    };
+  };
+}
+function any(...inputs) {
+  const conds = inputs.map((i) => toCondition(i));
+  return async (ctx, last) => {
+    const reasons = [];
+    for (const c of conds) {
+      const r = await c(ctx, last);
+      reasons.push(r.reason);
+      if (r.met)
+        return {
+          met: true,
+          confidence: r.confidence,
+          reason: `any -> ${r.reason}`
+        };
+    }
+    return { met: false, reason: `any(${reasons.join(" | ")})` };
+  };
+}
+function quorum(k, ...inputs) {
+  if (k < 1 || k > inputs.length)
+    throw new LoopError({
+      code: "CONFIG",
+      message: `quorum requires 1 <= k <= inputs (got k=${k}, n=${inputs.length})`
+    });
+  const conds = inputs.map((i) => toCondition(i));
+  return setLabel(async (ctx, last) => {
+    const settled = await Promise.allSettled(conds.map((c) => c(ctx, last)));
+    const results = settled.map(
+      (s) => s.status === "fulfilled" ? s.value : {
+        met: false,
+        reason: `judge errored: ${s.reason instanceof Error ? s.reason.message : String(s.reason)}`
+      }
+    );
+    const held = results.filter((r) => r.met);
+    const confs = held.map((r) => r.confidence).filter((c) => typeof c === "number");
+    const confidence = confs.length ? confs.reduce((a, b) => a + b, 0) / confs.length : void 0;
+    return {
+      met: held.length >= k,
+      confidence,
+      reason: `quorum ${held.length}/${inputs.length} held (need ${k})`
+    };
+  }, `quorum ${k}/${inputs.length}`);
+}
+function defaultContext(ctx, last) {
+  const parts = [];
+  if (last?.summary) parts.push(`Last outcome summary: ${last.summary}`);
+  if (last?.status) parts.push(`Last outcome status: ${last.status}`);
+  if (last?.data !== void 0)
+    parts.push(`Last outcome data: ${safeJson(last.data)}`);
+  const stateKeys = Object.keys(ctx.state);
+  if (stateKeys.length) parts.push(`Shared state: ${safeJson(ctx.state)}`);
+  return parts.join("\n") || "(no prior context)";
+}
+function safeJson(value, limit = 4e3) {
+  try {
+    const s = JSON.stringify(value, null, 2) ?? String(value);
+    return s.length > limit ? `${s.slice(0, limit)}\u2026 (truncated)` : s;
+  } catch {
+    return String(value);
+  }
+}
+function* balancedObjects(text) {
+  let cursor = 0;
+  while (cursor < text.length) {
+    const start = text.indexOf("{", cursor);
+    if (start === -1) return;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    let end = -1;
+    for (let i = start; i < text.length; i += 1) {
+      const ch = text[i];
+      if (inString) {
+        if (escaped) escaped = false;
+        else if (ch === "\\") escaped = true;
+        else if (ch === '"') inString = false;
+        continue;
+      }
+      if (ch === '"') inString = true;
+      else if (ch === "{") depth += 1;
+      else if (ch === "}" && --depth === 0) {
+        end = i;
+        break;
+      }
+    }
+    if (end === -1) return;
+    yield text.slice(start, end + 1);
+    cursor = end + 1;
+  }
+}
+function toVerdict(obj) {
+  const verdict = obj.verdict === "yes" ? "yes" : "no";
+  const confidence = typeof obj.confidence === "number" ? clamp01(obj.confidence) : 0;
+  const reason = typeof obj.reason === "string" ? obj.reason : "(no reason given)";
+  return { verdict, confidence, reason };
+}
+function parseVerdict(text) {
+  let fallback;
+  for (const candidate of balancedObjects(text)) {
+    let parsed;
+    try {
+      parsed = JSON.parse(candidate);
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      continue;
+    const obj = parsed;
+    if ("verdict" in obj) return toVerdict(obj);
+    fallback ??= obj;
+  }
+  if (fallback) return toVerdict(fallback);
+  throw new LoopError({
+    code: "VALIDATION",
+    message: `validator returned no JSON verdict: ${text.slice(0, 200)}`
+  });
+}
+function clamp01(n) {
+  return Number.isFinite(n) ? Math.min(1, Math.max(0, n)) : 0;
+}
+var VALIDATOR_SYSTEM = 'You are a strict, sceptical evaluator. You judge whether a stated condition is truly met given the evidence. Do not be generous. The `confidence` field is MANDATORY: always include a number in 0..1 for how sure you are, and when in doubt give a LOW number \u2014 never omit it (an omitted confidence is treated as zero). Respond with ONLY a single JSON object and no other text:\n{"verdict":"yes"|"no","confidence":<number 0..1>,"reason":"<one sentence>"}';
+var CONFIDENCE_TAG_SYSTEM = "You are a rigorous, report-only reviewer. Do not edit anything and do not imply you will. Assess the evidence against the stated condition, listing each concern tied to a concrete location and a concrete failure scenario (not a vibe). Judge against the stated contract, not an ideal: do not penalise the absence of hardening the contract does not require, and when the evidence meets the contract and you cannot name a concrete fault, say so plainly. Close with a single final line and nothing after it: `<confidence>N%</confidence>` \u2014 N is an integer 0-100, where 100 means you found no genuine contract violation or real bug, and below 100 means at least one concrete, addressable concern is open.";
+function parseConfidenceTag(text) {
+  const re = /<confidence>\s*([0-9]+(?:\.[0-9]+)?)\s*%?\s*<\/confidence>/gi;
+  let m;
+  let last = null;
+  while ((m = re.exec(text)) !== null) last = m;
+  if (!last) return null;
+  let n = parseFloat(last[1]);
+  if (n > 1) n = n / 100;
+  return { confidence: clamp01(n), findings: text.slice(0, last.index).trim() };
+}
+function validatorScoreSystem(dimensions) {
+  return `You are a strict, sceptical evaluator. Score how well the condition is met on EACH named dimension, from 0 (not at all) to 1 (fully). Do not be generous; when in doubt score low. Respond with ONLY a single JSON object and no other text:
+{"scores":{${dimensions.map((d) => `"${d}":<0..1>`).join(",")}},"reason":"<one sentence>"}`;
+}
+function geometricMean(values) {
+  if (!values.length) return 0;
+  if (values.some((v) => v <= 0)) return 0;
+  return Math.exp(values.reduce((a, b) => a + Math.log(b), 0) / values.length);
+}
+function parseScores(text, dimensions) {
+  for (const candidate of balancedObjects(text)) {
+    let parsed;
+    try {
+      parsed = JSON.parse(candidate);
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      continue;
+    const raw = parsed.scores;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+    const scoreObj = raw;
+    const scores = {};
+    for (const d of dimensions) {
+      const val = scoreObj[d];
+      scores[d] = typeof val === "number" ? clamp01(val) : 0;
+    }
+    const reasonField = parsed.reason;
+    return {
+      score: geometricMean(dimensions.map((d) => scores[d])),
+      scores,
+      reason: typeof reasonField === "string" ? reasonField : "(no reason given)"
+    };
+  }
+  throw new LoopError({
+    code: "VALIDATION",
+    message: `validator returned no JSON scores: ${text.slice(0, 200)}`
+  });
+}
+function agentCheck(config) {
+  const threshold = config.threshold ?? 0.8;
+  const confidenceTag = config.confidenceTag === true;
+  const dimensions = !confidenceTag && config.dimensions?.length ? config.dimensions : void 0;
+  return setLabel(async (ctx, last) => {
+    const engine = config.engine ? ctx.resolveEngine(config.engine) : ctx.engine;
+    const contextText = await (config.context ?? defaultContext)(ctx, last);
+    const closing = confidenceTag ? "Write your review now, then close with `<confidence>N%</confidence>`." : `Return the JSON ${dimensions ? "scores" : "verdict"} now.`;
+    const prompt = `CONDITION TO EVALUATE:
+${config.question}
+
+EVIDENCE:
+${contextText}
+
+` + closing;
+    const baseSystem = confidenceTag ? CONFIDENCE_TAG_SYSTEM : dimensions ? validatorScoreSystem(dimensions) : VALIDATOR_SYSTEM;
+    const system = config.agent ? `${resolveSystem(config.agent)}
+
+${baseSystem}` : baseSystem;
+    let result;
+    try {
+      assertBudget(ctx);
+      result = await engine.run(
+        {
+          prompt,
+          system,
+          model: config.model ?? config.agent?.model,
+          // A report-then-rate reviewer needs room for findings before the tag.
+          maxTokens: config.maxTokens ?? (confidenceTag ? 2048 : 512)
+        },
+        (e) => {
+          if (e.type === "usage") {
+            ctx.emit({
+              kind: "engine:usage",
+              ts: Date.now(),
+              path: [...ctx.path],
+              model: e.model,
+              usage: e.usage
+            });
+          }
+        },
+        ctx.signal
+      );
+    } catch (e) {
+      throw LoopError.from(e, { code: "ENGINE", path: ctx.path });
+    }
+    if (confidenceTag) {
+      const parsed = parseConfidenceTag(result.text);
+      if (!parsed)
+        return {
+          met: false,
+          confidence: 0,
+          reason: `no <confidence> tag: ${result.text.slice(0, 140)}`
+        };
+      const pct = Math.round(parsed.confidence * 100);
+      const need = Math.round(threshold * 100);
+      return {
+        met: parsed.confidence >= threshold,
+        confidence: parsed.confidence,
+        reason: `confidence ${pct}% (need ${need}%)${parsed.findings ? ` \u2014 ${parsed.findings.slice(0, 280)}` : ""}`
+      };
+    }
+    if (dimensions) {
+      let sv;
+      try {
+        sv = parseScores(result.text, dimensions);
+      } catch {
+        return {
+          met: false,
+          confidence: 0,
+          reason: `unparseable scores: ${result.text.slice(0, 120)}`
+        };
+      }
+      const detail = dimensions.map((d) => `${d}=${sv.scores[d].toFixed(2)}`).join(", ");
+      return {
+        met: sv.score >= threshold,
+        confidence: sv.score,
+        reason: `geo ${sv.score.toFixed(2)} (need ${threshold}) [${detail}] \u2014 ${sv.reason}`
+      };
+    }
+    let v;
+    try {
+      v = parseVerdict(result.text);
+    } catch {
+      return {
+        met: false,
+        confidence: 0,
+        reason: `unparseable verdict: ${result.text.slice(0, 120)}`
+      };
+    }
+    const met = v.verdict === "yes" && v.confidence >= threshold;
+    return {
+      met,
+      confidence: v.confidence,
+      reason: `${v.verdict} @ ${v.confidence.toFixed(2)} (need ${threshold}) \u2014 ${v.reason}`
+    };
+  }, `judge "${config.question}" >=${threshold}`);
+}
+function gateJob(label, condition) {
+  const cond = toCondition(condition);
+  return setMeta(async (ctx) => {
+    ctx.emit({ kind: "job:start", ts: Date.now(), path: [...ctx.path], label });
+    const r = await cond(ctx, ctx.lastOutcome);
+    const outcome = {
+      status: r.met ? "pass" : "fail",
+      confidence: r.confidence,
+      summary: r.reason
+    };
+    ctx.emit({
+      kind: "job:end",
+      ts: Date.now(),
+      path: [...ctx.path],
+      label,
+      outcome
+    });
+    return outcome;
+  }, { kind: "gate", name: label });
+}
+var FS = "";
+var RS = "";
+var LOG_FORMAT = `%H${FS}%aI${FS}%s${FS}%b${RS}`;
+async function git(args, { cwd, signal }, input) {
+  const r = await execa("git", args, {
+    cwd,
+    cancelSignal: signal,
+    reject: false,
+    stdin: input === void 0 ? "ignore" : void 0,
+    input
+  });
+  return { stdout: r.stdout ?? "", exitCode: r.exitCode ?? 1 };
+}
+async function isRepo(opts) {
+  try {
+    const r = await git(["rev-parse", "--is-inside-work-tree"], opts);
+    return r.exitCode === 0 && r.stdout.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+async function currentBranch(opts) {
+  const r = await git(["rev-parse", "--abbrev-ref", "HEAD"], opts);
+  if (r.exitCode !== 0) return void 0;
+  const name = r.stdout.trim();
+  return name && name !== "HEAD" ? name : void 0;
+}
+async function headSha(opts) {
+  const r = await git(["rev-parse", "HEAD"], opts);
+  return r.exitCode === 0 ? r.stdout.trim() || void 0 : void 0;
+}
+async function stageAll(opts) {
+  await git(["add", "-A"], opts);
+}
+async function hasStagedChanges(opts) {
+  const r = await git(["diff", "--cached", "--quiet"], opts);
+  return r.exitCode === 1;
+}
+async function isDirty(opts) {
+  const r = await git(["status", "--porcelain"], opts);
+  return r.stdout.trim().length > 0;
+}
+async function commit(input, opts) {
+  if (!input.allowEmpty && !await hasStagedChanges(opts)) return void 0;
+  const message = input.body ? `${input.subject}
+
+${input.body}
+` : `${input.subject}
+`;
+  const args = ["commit", "-F", "-"];
+  if (input.allowEmpty) args.push("--allow-empty");
+  const r = await git(args, opts, message);
+  if (r.exitCode !== 0) {
+    throw new Error(
+      `git commit failed (exit ${r.exitCode}): ${r.stdout}`.trim()
+    );
+  }
+  return headSha(opts);
+}
+async function log(query) {
+  const { cwd, signal, since, max } = query;
+  const ref = query.ref ?? "HEAD";
+  const args = ["log", `--format=${LOG_FORMAT}`];
+  if (max != null) args.push(`-n${max}`);
+  args.push(since ? `${since}..${ref}` : ref);
+  const r = await git(args, { cwd, signal });
+  if (r.exitCode !== 0) return [];
+  return parseLog(r.stdout);
+}
+function parseLog(stdout) {
+  const records = [];
+  for (const chunk of stdout.split(RS)) {
+    const fields = chunk.replace(/^\n+/, "").split(FS);
+    if (fields.length < 4 || !fields[0].trim()) continue;
+    records.push({
+      sha: fields[0].trim(),
+      date: fields[1].trim(),
+      subject: fields[2],
+      body: fields[3].trim()
+    });
+  }
+  return records;
+}
+async function addWorktree(repoDir, opts) {
+  const dir = mkdtempSync(join(tmpdir(), "loops-wt-"));
+  const r = await git(
+    ["worktree", "add", "-b", opts.branch, dir, opts.base ?? "HEAD"],
+    { cwd: repoDir, signal: opts.signal }
+  );
+  if (r.exitCode !== 0)
+    throw new Error(
+      `git worktree add failed (exit ${r.exitCode}): ${r.stdout}`.trim()
+    );
+  return { dir, branch: opts.branch };
+}
+async function removeWorktree(repoDir, dir, opts = {}) {
+  await git(["worktree", "remove", "--force", dir], {
+    cwd: repoDir,
+    signal: opts.signal
+  });
+}
+async function deleteBranch(repoDir, branch, opts = {}) {
+  await git(["branch", "-D", branch], { cwd: repoDir, signal: opts.signal });
+}
+async function mergeBranch(repoDir, branch, opts = {}) {
+  const r = await git(
+    ["merge", "--no-ff", "-m", opts.message ?? `merge ${branch}`, branch],
+    { cwd: repoDir, signal: opts.signal }
+  );
+  if (r.exitCode === 0) return { ok: true, conflict: false };
+  await git(["merge", "--abort"], { cwd: repoDir, signal: opts.signal });
+  return { ok: false, conflict: true };
+}
+async function mergeNoCommit(repoDir, branch, opts = {}) {
+  const r = await git(["merge", "--no-ff", "--no-commit", branch], {
+    cwd: repoDir,
+    signal: opts.signal
+  });
+  if (r.exitCode === 0) return { clean: true, conflicted: [] };
+  return { clean: false, conflicted: await conflictedFiles(repoDir, opts) };
+}
+async function conflictedFiles(repoDir, opts = {}) {
+  const r = await git(["diff", "--name-only", "--diff-filter=U"], {
+    cwd: repoDir,
+    signal: opts.signal
+  });
+  return r.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+}
+async function mergeAbort(repoDir, opts = {}) {
+  await git(["merge", "--abort"], { cwd: repoDir, signal: opts.signal });
+}
+async function push(opts) {
+  const branch = opts.branch ?? await currentBranch(opts);
+  const args = ["push"];
+  if (opts.setUpstream ?? true) args.push("-u");
+  if (opts.force) args.push("--force-with-lease");
+  args.push(opts.remote ?? "origin");
+  if (branch) args.push(branch);
+  const r = await execa("git", args, {
+    cwd: opts.cwd,
+    cancelSignal: opts.signal,
+    reject: false,
+    stdin: "ignore",
+    all: true
+  });
+  return { ok: (r.exitCode ?? 1) === 0, output: (r.all ?? r.stdout ?? "").trim() };
+}
+var SCRATCH_DIR = ".loops";
+var LEDGER_FILE = "ledger.md";
+var PROMPT_FILE = "prompt.md";
+function ledgerPath(workspace) {
+  return join(workspace.dir, SCRATCH_DIR, LEDGER_FILE);
+}
+function promptPath(workspace) {
+  return join(workspace.dir, SCRATCH_DIR, PROMPT_FILE);
+}
+function ensureDir(workspace) {
+  mkdirSync(join(workspace.dir, SCRATCH_DIR), { recursive: true });
+  ensureIgnored(workspace);
+}
+function ensureIgnored(workspace) {
+  const dir = join(workspace.dir, SCRATCH_DIR);
+  if (!existsSync(dir)) return;
+  const ignore = join(dir, ".gitignore");
+  if (!existsSync(ignore)) writeFileSync(ignore, "*\n");
+}
+function read(path) {
+  try {
+    return readFileSync(path, "utf8").trim();
+  } catch {
+    return "";
+  }
+}
+function reset(path) {
+  try {
+    rmSync(path, { force: true });
+  } catch {
+  }
+}
+function appendPrompt(workspace, note) {
+  ensureDir(workspace);
+  const n = typeof note === "string" ? { body: note } : note;
+  const header = n.heading ? `## ${n.heading}${n.author ? ` \u2014 ${n.author}` : ""}
+
+` : n.author ? `_${n.author}:_ ` : "";
+  appendFileSync(promptPath(workspace), `${header}${n.body.trim()}
+
+`);
+}
+function readPrompt(workspace) {
+  return read(promptPath(workspace));
+}
+function resetPrompt(workspace) {
+  reset(promptPath(workspace));
+}
+function appendLedger(workspace, entry) {
+  ensureDir(workspace);
+  const path = ledgerPath(workspace);
+  if (typeof entry === "string") {
+    const body = entry.trim();
+    if (body) appendFileSync(path, `${body}
+
+`);
+    return;
+  }
+  const head = entry.label ? `### ${entry.label}${entry.iteration ? `  \xB7  iteration ${entry.iteration}` : ""}` : entry.iteration ? `### iteration ${entry.iteration}` : "";
+  const lines = [];
+  if (head) lines.push(head);
+  if (entry.text?.trim()) lines.push(entry.text.trim());
+  if (entry.tools?.length) lines.push(`_actions: ${entry.tools.join(", ")}_`);
+  if (!lines.length) return;
+  appendFileSync(path, `${lines.join("\n\n")}
+
+`);
+}
+function readLedger(workspace) {
+  return read(ledgerPath(workspace));
+}
+function resetLedger(workspace) {
+  reset(ledgerPath(workspace));
+}
+
+// src/core/consolidate.ts
+var CONSOLIDATE_SYSTEM = "You maintain a project's CONSOLIDATED LEDGER from its commit history \u2014 the bounded coarse memory a fresh context reads to continue safely. Capture the current state and the open threads, and PRESERVE every binding decision, convention and constraint with its exact values verbatim (downstream work must honour them, so dropping or generalising even one is a failure). Tight markdown; MERGE new commits into the prior ledger, deduplicate, omit only narrative \u2014 never omit a decision.";
+function digest(body, n = 280) {
+  const text = body.split("\n").filter((l) => l.trim() && !l.trimStart().startsWith("#")).join(" ").replace(/\s+/g, " ").trim();
+  return text.length > n ? `${text.slice(0, n).trimEnd()}\u2026` : text;
+}
+async function consolidate(ctx, opts = {}) {
+  const records = await log({
+    cwd: ctx.workspace.dir,
+    max: opts.max ?? 30,
+    since: opts.since,
+    signal: ctx.signal
+  });
+  const entries = records.map(
+    (r) => `- ${r.sha.slice(0, 7)} ${r.subject}${r.body ? `
+  ${digest(r.body)}` : ""}`
+  ).join("\n");
+  const engine = opts.engine ? ctx.resolveEngine(opts.engine) : ctx.engine;
+  const result = await engine.run(
+    {
+      prompt: (opts.prior ? `CURRENT LEDGER:
+${opts.prior}
+
+` : "") + `COMMITS (newest first):
+${entries || "(none)"}
+
+Output the updated consolidated ledger.`,
+      system: CONSOLIDATE_SYSTEM,
+      model: opts.model,
+      maxTokens: 1e3
+    },
+    () => {
+    },
+    ctx.signal
+  );
+  return result.text.trim();
+}
+var COMPACT_SYSTEM = "You write the HANDOFF a future agent reads if it lost ALL memory of this work. Include EVERYTHING it needs to continue safely, as structured markdown: ## Why (the problem and the root cause), ## What (exactly what changed, and where \u2014 names, paths, signatures), ## Alternatives (what was ruled out and why), ## Constraints (the invariants and limits that shaped it), ## Next (what is left or to watch). Preserve every decision and specific value verbatim. Completeness matters more than brevity \u2014 drop only literal repetition and play-by-play narration, never a decision or a detail. Omit a section only if it truly has nothing. No preamble.";
+function truncate(s, n) {
+  const t = s.trim();
+  return t.length > n ? `${t.slice(0, n).trimEnd()}
+\u2026` : t;
+}
+async function compactLedger(ctx, text, opts = {}) {
+  const trimmed = text.trim();
+  if (!trimmed) return "";
+  const max = opts.maxChars ?? 2e3;
+  if (trimmed.length <= max) return trimmed;
+  try {
+    const engine = opts.engine ? ctx.resolveEngine(opts.engine) : ctx.engine;
+    const result = await engine.run(
+      {
+        prompt: `WORKING LOG:
+${trimmed}
+
+Write the complete handoff.`,
+        system: COMPACT_SYSTEM,
+        model: opts.model,
+        maxTokens: 1200
+      },
+      () => {
+      },
+      ctx.signal
+    );
+    return result.text.trim() || truncate(trimmed, max);
+  } catch {
+    return truncate(trimmed, max);
+  }
+}
+async function composeCommitBody(ctx, workspace, opts = {}) {
+  const material = [readPrompt(workspace), readLedger(workspace)].map((s) => s.trim()).filter(Boolean).join("\n\n");
+  return material ? await compactLedger(ctx, material, opts) : "";
+}
+function consolidateJob(config = {}) {
+  return async (ctx) => {
+    const label = config.label ?? "consolidate";
+    const subject = config.subject ?? "consolidate: ledger";
+    const path = [...ctx.path];
+    ctx.emit({ kind: "job:start", ts: Date.now(), path, label });
+    try {
+      const recent = await log({ cwd: ctx.workspace.dir, max: 50, signal: ctx.signal });
+      const prior = recent.find((r) => r.subject === subject)?.body || void 0;
+      const ledger = await consolidate(ctx, { ...config, prior });
+      const sha = await commit(
+        { subject, body: ledger, allowEmpty: true },
+        { cwd: ctx.workspace.dir, signal: ctx.signal }
+      );
+      const outcome = {
+        status: "pass",
+        summary: sha ? `ledger ${sha.slice(0, 7)}` : "ledger unchanged",
+        data: { sha: sha ?? null }
+      };
+      ctx.emit({ kind: "job:end", ts: Date.now(), path, label, outcome });
+      return outcome;
+    } catch (e) {
+      const error = LoopError.from(e, { code: "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;
+    }
+  };
+}
+
+// src/core/ground.ts
+function truncate2(s, n) {
+  return s.length > n ? `${s.slice(0, n).trimEnd()}
+\u2026` : s;
+}
+async function groundingText(workspace, opts = {}) {
+  const records = await log({
+    cwd: workspace.dir,
+    since: opts.since,
+    max: opts.max ?? 10,
+    signal: opts.signal
+  });
+  if (!records.length) return "";
+  const where = workspace.branch ? `\`${workspace.branch}\`` : "this branch";
+  const header = `## Recent work on ${where} (the commit log)
+What prior iterations already did and why \u2014 read it before working so you do not repeat a dead end. Most recent first.`;
+  const bodyChars = opts.bodyChars ?? 1200;
+  const entries = records.map((r) => {
+    const head = `### ${r.sha.slice(0, 7)}  ${r.subject}`;
+    return r.body ? `${head}
+
+${truncate2(r.body, bodyChars)}` : head;
+  });
+  return `${header}
+
+${entries.join("\n\n")}`;
+}
+var SELECT_SYSTEM = "You select which past commits are relevant CONTEXT for a task. Be selective: return only genuinely relevant commits, fewer is better. Output ONLY shas, comma-separated, most relevant first \u2014 or the single word NONE.";
+function pickShas(text, records) {
+  const ids = text.toLowerCase().match(/[0-9a-f]{7,40}/g) ?? [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    const rec = records.find((r) => r.sha.startsWith(id));
+    if (rec && !seen.has(rec.sha)) {
+      seen.add(rec.sha);
+      out.push(rec);
+    }
+  }
+  return out;
+}
+async function retrieveLedger(ctx, opts) {
+  const records = await log({
+    cwd: ctx.workspace.dir,
+    max: opts.candidates ?? 100,
+    signal: ctx.signal
+  });
+  if (!records.length) return "";
+  const list = records.map((r) => `${r.sha.slice(0, 9)}: ${r.subject}`).join("\n");
+  const engine = opts.engine ? ctx.resolveEngine(opts.engine) : ctx.engine;
+  const result = await engine.run(
+    {
+      prompt: `TASK:
+${opts.intent}
+
+CANDIDATE COMMITS (sha: subject):
+${list}
+
+Return the shas relevant to the TASK (up to ${opts.max ?? 8}), or NONE.`,
+      system: SELECT_SYSTEM,
+      model: opts.model,
+      maxTokens: 200
+    },
+    () => {
+    },
+    ctx.signal
+  );
+  const picked = pickShas(result.text, records).slice(0, opts.max ?? 8);
+  if (!picked.length) return "";
+  const where = ctx.workspace.branch ? `\`${ctx.workspace.branch}\`` : "this branch";
+  const header = `## Relevant prior work on ${where} (retrieved for this task)
+Commits a search judged relevant \u2014 read them before working.`;
+  const bodyChars = opts.bodyChars ?? 1200;
+  const entries = picked.map((r) => {
+    const head = `### ${r.sha.slice(0, 7)}  ${r.subject}`;
+    return r.body ? `${head}
+
+${truncate2(r.body, bodyChars)}` : head;
+  });
+  return `${header}
+
+${entries.join("\n\n")}`;
+}
+
+// src/core/job.ts
+var HANDOFF_MARK = "===HANDOFF===";
+function recordBlock() {
+  return `## Before you finish: the handoff
+Answer one question for whoever continues this: **what is everything future-you needs to know about this if you lost all memory of it?** The harness keeps your answer as the memory the next agent reads and as the commit body, so carry the WHY, not just the what \u2014 write it so they cannot repeat your dead ends or break your decisions.
+End your reply with this block (keep the \`${HANDOFF_MARK}\` marker exactly; drop a section only if it truly has nothing):
+
+${HANDOFF_MARK}
+## Why
+<the problem and the root cause you found>
+## What
+<the change you made>
+## Alternatives
+<what you ruled out, and why>
+## Constraints
+<the invariants and limits that shaped it>
+## Next
+<what is left, or what to watch>`;
+}
+function splitTurn(text) {
+  const lines = text.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].trim().replace(/\s+/g, "").toUpperCase() === HANDOFF_MARK) {
+      return {
+        work: lines.slice(0, i).join("\n").trim(),
+        handoff: lines.slice(i + 1).join("\n").trim() || void 0
+      };
+    }
+  }
+  return { work: text.trim() };
+}
+async function withGrounding(ctx, userPrompt, ground) {
+  const opts = typeof ground === "object" ? ground : {};
+  const parts = [];
+  const committed = opts.retrieve ? await retrieveLedger(ctx, {
+    intent: userPrompt,
+    max: opts.max,
+    bodyChars: opts.bodyChars,
+    candidates: typeof opts.retrieve === "object" ? opts.retrieve.candidates : void 0,
+    model: typeof opts.retrieve === "object" ? opts.retrieve.model : void 0
+  }) : await groundingText(ctx.workspace, {
+    max: opts.max,
+    bodyChars: opts.bodyChars,
+    signal: ctx.signal
+  });
+  if (committed) parts.push(committed);
+  if (opts.includeScratch !== false) {
+    const working = readLedger(ctx.workspace);
+    if (working)
+      parts.push(
+        `## Working memory (this run so far)
+
+What earlier turns in this run tried and found \u2014 build on it.
+
+${working}`
+      );
+    const handoff = readPrompt(ctx.workspace);
+    if (handoff)
+      parts.push(
+        `## Handoff so far (what earlier work distilled for the next agent)
+
+${handoff}`
+      );
+  }
+  if (opts.recordInstruction !== false) parts.push(recordBlock());
+  parts.push(userPrompt);
+  return parts.join("\n\n---\n\n");
+}
+function summariseTools(uses) {
+  return [...uses].map(([name, n]) => n > 1 ? `${name}\xD7${n}` : name);
+}
+var TERMINAL = (text) => ({
+  status: "pass",
+  summary: text.trim().slice(0, 280),
+  data: text
+});
+function agentJob(config) {
+  const job = async (ctx) => {
+    const path = [...ctx.path];
+    const label = config.label ?? config.agent?.name ?? "agent";
+    ctx.emit({ kind: "job:start", ts: Date.now(), path, label });
+    const engine = ctx.resolveEngine(config.engine);
+    const userPrompt = typeof config.prompt === "function" ? await config.prompt(ctx) : config.prompt;
+    const prompt = config.ground ? await withGrounding(ctx, userPrompt, config.ground) : userPrompt;
+    const system = config.system !== void 0 ? typeof config.system === "function" ? config.system(ctx) : config.system : config.agent ? resolveSystem(config.agent) : void 0;
+    let result;
+    const toolUses = /* @__PURE__ */ new Map();
+    try {
+      assertBudget(ctx);
+      result = await engine.run(
+        {
+          prompt,
+          system,
+          model: config.model ?? config.agent?.model,
+          maxTokens: config.maxTokens,
+          allowedTools: config.allowedTools ?? config.agent?.tools,
+          leaf: config.leaf ?? config.agent?.leaf,
+          cwd: config.cwd ?? ctx.workspace.dir,
+          timeoutMs: config.timeoutMs
+        },
+        (e) => {
+          const ts = Date.now();
+          switch (e.type) {
+            case "text":
+              ctx.emit({ kind: "engine:text", ts, path, delta: e.delta });
+              break;
+            case "thinking":
+              ctx.emit({ kind: "engine:thinking", ts, path, delta: e.delta });
+              break;
+            case "tool":
+              if (e.phase === "use")
+                toolUses.set(e.name, (toolUses.get(e.name) ?? 0) + 1);
+              ctx.emit({
+                kind: "engine:tool",
+                ts,
+                path,
+                name: e.name,
+                phase: e.phase
+              });
+              break;
+            case "usage":
+              ctx.emit({
+                kind: "engine:usage",
+                ts,
+                path,
+                model: e.model,
+                usage: e.usage
+              });
+              break;
+          }
+        },
+        ctx.signal
+      );
+    } catch (e) {
+      const error = LoopError.from(e, {
+        code: ctx.signal.aborted ? "ABORTED" : "ENGINE",
+        phase: "body",
+        path: ctx.path,
+        iteration: ctx.iteration
+      });
+      ctx.emit({
+        kind: "error",
+        ts: Date.now(),
+        path,
+        message: error.message,
+        code: error.code
+      });
+      const outcome2 = {
+        status: ctx.signal.aborted ? "aborted" : "fail",
+        summary: error.message,
+        error
+      };
+      ctx.emit({
+        kind: "job:end",
+        ts: Date.now(),
+        path,
+        label,
+        outcome: outcome2
+      });
+      return outcome2;
+    }
+    if (config.ground) {
+      const { work, handoff } = splitTurn(result.text);
+      appendLedger(ctx.workspace, {
+        label,
+        iteration: ctx.iteration,
+        text: work,
+        tools: summariseTools(toolUses)
+      });
+      if (handoff) appendPrompt(ctx.workspace, handoff);
+    }
+    const outcome = config.outcome ? await config.outcome(result.text, ctx) : TERMINAL(result.text);
+    ctx.emit({
+      kind: "job:end",
+      ts: Date.now(),
+      path,
+      label,
+      outcome
+    });
+    return outcome;
+  };
+  return setMeta(job, {
+    kind: "agent",
+    name: config.label ?? config.agent?.name ?? "agent",
+    ground: !!config.ground
+  });
+}
+function composeWay(ctx, last) {
+  const sections = [];
+  const head = [];
+  if (ctx.iteration) head.push(`iteration: ${ctx.iteration}`);
+  if (last?.status) head.push(`status: ${last.status}`);
+  if (typeof last?.confidence === "number")
+    head.push(`confidence: ${last.confidence.toFixed(2)}`);
+  if (head.length) sections.push(`## Outcome
+${head.join("\n")}`);
+  if (last?.summary) sections.push(`## Summary
+${last.summary.trim()}`);
+  if (ctx.lastReview?.summary)
+    sections.push(`## Next
+${ctx.lastReview.summary.trim()}`);
+  return sections.join("\n\n");
+}
+function commitJob(config) {
+  return async (ctx) => {
+    const label = config.label ?? "commit";
+    const path = [...ctx.path];
+    const cwd = ctx.workspace.dir;
+    ctx.emit({ kind: "job:start", ts: Date.now(), path, label });
+    try {
+      if (!await isRepo({ cwd, signal: ctx.signal })) {
+        throw new LoopError({
+          code: "CONFIG",
+          message: `commitJob "${label}" requires a git repository (cwd: ${cwd})`
+        });
+      }
+      const last = ctx.lastOutcome;
+      const subject = typeof config.subject === "function" ? await config.subject(ctx, last) : config.subject;
+      const body = config.body !== void 0 ? typeof config.body === "function" ? await config.body(ctx, last) : config.body : await composeCommitBody(ctx, ctx.workspace, {
+        model: config.compactModel
+      }) || composeWay(ctx, last);
+      if (config.stageAll ?? true) {
+        ensureIgnored(ctx.workspace);
+        await stageAll({ cwd, signal: ctx.signal });
+      }
+      const sha = await commit(
+        { subject, body, allowEmpty: config.allowEmpty },
+        { cwd, signal: ctx.signal }
+      );
+      if (sha) {
+        resetPrompt(ctx.workspace);
+        resetLedger(ctx.workspace);
+      }
+      const outcome = sha ? {
+        status: "pass",
+        summary: `committed ${sha.slice(0, 7)}: ${subject}`,
+        data: { sha }
+      } : { status: "pass", summary: "nothing to commit", data: { sha: null } };
+      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,
+        iteration: ctx.iteration
+      });
+      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 kickback(to, reason, over) {
+  return {
+    status: "fail",
+    summary: reason,
+    ...over,
+    kickback: { to, reason }
+  };
+}
+function fnJob(label, fn) {
+  const job = async (ctx) => {
+    const path = [...ctx.path];
+    ctx.emit({ kind: "job:start", ts: Date.now(), path, label });
+    let outcome;
+    try {
+      outcome = await fn(ctx);
+    } catch (e) {
+      const error = LoopError.from(e, {
+        code: "BODY",
+        phase: "body",
+        path: ctx.path,
+        iteration: ctx.iteration
+      });
+      outcome = { status: "fail", summary: error.message, error };
+      ctx.emit({
+        kind: "error",
+        ts: Date.now(),
+        path,
+        message: error.message,
+        code: error.code
+      });
+    }
+    ctx.emit({ kind: "job:end", ts: Date.now(), path, label, outcome });
+    return outcome;
+  };
+  return setMeta(job, { kind: "fn", name: label });
+}
+
+// src/core/context.ts
+function childContext(parent, over) {
+  return {
+    engine: parent.engine,
+    resolveEngine: parent.resolveEngine,
+    signal: parent.signal,
+    emit: parent.emit,
+    state: parent.state,
+    // A child inherits the parent's workspace by default; a concurrency
+    // boundary forks it into an isolated worktree by passing `workspace`.
+    workspace: over.workspace ?? parent.workspace,
+    environment: over.environment ?? parent.environment,
+    forge: parent.forge,
+    budget: parent.budget,
+    onLimit: parent.onLimit,
+    maxWaitMs: parent.maxWaitMs,
+    resumeCommand: parent.resumeCommand,
+    log: parent.log,
+    depth: over.depth,
+    path: over.path,
+    // Inherit the enclosing iteration by default. A `loop` always passes one
+    // explicitly; a `dag`/`sequence` does not, so without this a node nested in a
+    // loop would reset to 0 — the "Attempt 0" confound where a retry body could not
+    // see which attempt it was on. A top-level dag still gets 0 (the root's value).
+    iteration: over.iteration ?? parent.iteration,
+    lastOutcome: over.lastOutcome,
+    lastReview: over.lastReview
+  };
+}
+
+// src/core/loop.ts
+var VALID_STATUS = /* @__PURE__ */ new Set([
+  "pass",
+  "fail",
+  "aborted",
+  "exhausted",
+  "paused"
+]);
+function decideLimit(error, ctx) {
+  const reason = error.message;
+  if (ctx.onLimit === "exit-resume") return { kind: "pause", reason };
+  const waitMs = waitMsFor(error);
+  if (waitMs == null) return { kind: "pause", reason };
+  if (ctx.onLimit === "wait") return { kind: "wait", waitMs };
+  if (waitMs <= ctx.maxWaitMs) return { kind: "wait", waitMs };
+  return {
+    kind: "pause",
+    reason: `${reason} (reset in ${Math.round(waitMs / 1e3)}s exceeds maxWait ${Math.round(ctx.maxWaitMs / 1e3)}s)`
+  };
+}
+var yieldToLoop = () => new Promise((r) => setImmediate(r));
+function loop(config) {
+  if (!config.name)
+    throw new LoopError({
+      code: "CONFIG",
+      message: "loop() requires a non-empty name"
+    });
+  const start = config.start ? toCondition(config.start) : void 0;
+  const until = config.until ? toCondition(config.until) : void 0;
+  const stopOn = config.stopOn ? toCondition(config.stopOn) : void 0;
+  const onError = config.retry?.onError ?? "continue";
+  const job = async (parent) => {
+    const path = [...parent.path, config.name];
+    const depth = parent.depth + 1;
+    const ts = () => Date.now();
+    let lastReview;
+    let iteration = 0;
+    const ctxAt = (iter, lastOutcome) => childContext(parent, {
+      depth,
+      path,
+      iteration: iter,
+      lastOutcome,
+      lastReview
+    });
+    parent.emit({ kind: "loop:start", ts: ts(), path, depth, max: config.max });
+    const commitCfg = config.commit ? config.commit === true ? {
+      label: `${config.name}:checkpoint`,
+      subject: (_c, l) => l?.summary?.split("\n")[0]?.trim().slice(0, 72) || `chore(${config.name}): checkpoint`
+    } : { label: `${config.name}:checkpoint`, ...config.commit } : void 0;
+    const checkpoint = commitCfg ? commitJob(commitCfg) : void 0;
+    const recordMilestone = async (ctx) => {
+      if (!checkpoint) return;
+      const outcome = await checkpoint(ctx);
+      if (outcome.status !== "pass") {
+        parent.emit({
+          kind: "error",
+          ts: ts(),
+          path,
+          message: `checkpoint commit did not pass: ${outcome.summary ?? outcome.status}`,
+          code: outcome.error?.code ?? "UNKNOWN"
+        });
+      }
+    };
+    const finish = async (outcome, iterations) => {
+      parent.emit({ kind: "loop:end", ts: ts(), path, outcome, iterations });
+      if (config.onComplete) {
+        try {
+          await config.onComplete(outcome, ctxAt(iterations));
+        } catch (e) {
+          const error = LoopError.from(e, {
+            code: "BODY",
+            phase: "review",
+            path,
+            iteration: iterations
+          });
+          parent.emit({
+            kind: "error",
+            ts: ts(),
+            path,
+            message: `onComplete threw: ${error.message}`,
+            code: error.code
+          });
+        }
+      }
+      return outcome;
+    };
+    const gate = async (cond, which, ctx, last) => {
+      try {
+        return await cond(ctx, last);
+      } catch (e) {
+        throw LoopError.from(e, {
+          code: "VALIDATION",
+          phase: which,
+          path,
+          iteration
+        });
+      }
+    };
+    try {
+      if (start) {
+        const r = await gate(start, "start", ctxAt(0), void 0);
+        parent.emit({
+          kind: "loop:condition",
+          ts: ts(),
+          path,
+          which: "start",
+          result: r
+        });
+        if (!r.met)
+          return finish(
+            { status: "aborted", summary: `start gate not met: ${r.reason}` },
+            0
+          );
+      }
+      let last;
+      let consecutiveErrors = 0;
+      let consecutiveReviewFails = 0;
+      while (true) {
+        await yieldToLoop();
+        if (parent.signal.aborted)
+          return finish(
+            { status: "aborted", summary: "aborted by signal" },
+            iteration
+          );
+        if (config.max != null && iteration >= config.max) {
+          return finish(
+            {
+              status: "exhausted",
+              summary: last?.summary ?? `reached max iterations (${config.max})`,
+              confidence: last?.confidence,
+              data: last?.data
+            },
+            iteration
+          );
+        }
+        iteration += 1;
+        const ctx = ctxAt(iteration, last);
+        parent.emit({ kind: "loop:iteration", ts: ts(), path, iteration });
+        let bodyThrew = false;
+        try {
+          last = await config.body(ctx);
+          consecutiveErrors = 0;
+        } catch (e) {
+          bodyThrew = true;
+          const error = LoopError.from(e, {
+            code: "BODY",
+            phase: "body",
+            path,
+            iteration
+          });
+          parent.emit({
+            kind: "error",
+            ts: ts(),
+            path,
+            message: error.message,
+            code: error.code
+          });
+          consecutiveErrors += 1;
+          const tooMany = config.retry?.maxConsecutive != null && consecutiveErrors >= config.retry.maxConsecutive;
+          if (onError === "fail" || tooMany)
+            return finish(
+              { status: "fail", summary: error.message, error },
+              iteration
+            );
+          last = { status: "fail", summary: error.message, error };
+          if (config.retry?.backoffMs)
+            await delay(config.retry.backoffMs, parent.signal);
+        }
+        if (!last || !VALID_STATUS.has(last.status)) {
+          const error = new LoopError({
+            code: "VALIDATION",
+            phase: "body",
+            path,
+            iteration,
+            message: `body returned an Outcome with no valid "status" (got ${JSON.stringify(last?.status)})`
+          });
+          parent.emit({
+            kind: "error",
+            ts: ts(),
+            path,
+            message: error.message,
+            code: error.code
+          });
+          return finish(
+            { status: "fail", summary: error.message, error },
+            iteration
+          );
+        }
+        if (last.status === "fail" && isLimitError(last.error) && ctx.onLimit !== "fail") {
+          const action = decideLimit(last.error, ctx);
+          if (action.kind === "wait") {
+            const now = ts();
+            parent.emit({
+              kind: "limit:wait",
+              ts: now,
+              path,
+              code: last.error.code,
+              waitMs: action.waitMs,
+              resumeAt: now + action.waitMs
+            });
+            await delay(action.waitMs, parent.signal);
+            iteration -= 1;
+            last = void 0;
+            continue;
+          }
+          parent.emit({
+            kind: "limit:pause",
+            ts: ts(),
+            path,
+            code: last.error.code,
+            reason: action.reason,
+            resumeCommand: ctx.resumeCommand
+          });
+          return finish(
+            {
+              status: "paused",
+              summary: action.reason,
+              error: last.error,
+              data: last.data
+            },
+            iteration
+          );
+        }
+        if (!bodyThrew && last.status === "fail" && last.error && !last.error.retryable) {
+          return finish(
+            { status: "fail", summary: last.summary, error: last.error },
+            iteration
+          );
+        }
+        if (config.onIteration) {
+          try {
+            await config.onIteration(last, ctx);
+          } catch (e) {
+            throw LoopError.from(e, {
+              code: "VALIDATION",
+              phase: "body",
+              path,
+              iteration
+            });
+          }
+        }
+        if (stopOn) {
+          const r = await gate(stopOn, "stopOn", ctx, last);
+          parent.emit({
+            kind: "loop:condition",
+            ts: ts(),
+            path,
+            which: "stopOn",
+            result: r
+          });
+          if (r.met)
+            return finish(
+              {
+                status: "aborted",
+                summary: `stopOn met: ${r.reason}`,
+                data: last.data
+              },
+              iteration
+            );
+        }
+        const conv = until ? await gate(until, "until", ctx, last) : {
+          met: last.status === "pass",
+          confidence: last.confidence,
+          reason: `body status = ${last.status}`
+        };
+        if (until)
+          parent.emit({
+            kind: "loop:condition",
+            ts: ts(),
+            path,
+            which: "until",
+            result: conv
+          });
+        if (conv.met) {
+          if (!config.review) {
+            await recordMilestone(ctxAt(iteration, last));
+            return finish(
+              {
+                status: "pass",
+                confidence: conv.confidence ?? last.confidence,
+                summary: last.summary,
+                data: last.data
+              },
+              iteration
+            );
+          }
+          let reviewOutcome;
+          try {
+            reviewOutcome = await config.review(ctxAt(iteration, last));
+          } catch (e) {
+            throw LoopError.from(e, {
+              code: "VALIDATION",
+              phase: "review",
+              path,
+              iteration
+            });
+          }
+          parent.emit({
+            kind: "loop:review",
+            ts: ts(),
+            path,
+            outcome: reviewOutcome
+          });
+          if (reviewOutcome.status === "pass") {
+            await recordMilestone(ctxAt(iteration, last));
+            return finish(
+              {
+                status: "pass",
+                confidence: reviewOutcome.confidence ?? conv.confidence,
+                summary: reviewOutcome.summary ?? last.summary,
+                data: last.data
+              },
+              iteration
+            );
+          }
+          consecutiveReviewFails += 1;
+          lastReview = reviewOutcome;
+          parent.log(
+            `review did not pass (${reviewOutcome.summary ?? reviewOutcome.status}); re-entering ${config.name}`,
+            "warn"
+          );
+          if (config.maxReviewRestarts != null && consecutiveReviewFails >= config.maxReviewRestarts) {
+            return finish(
+              {
+                status: "exhausted",
+                summary: `review rejected ${consecutiveReviewFails}\xD7 (maxReviewRestarts)`,
+                data: last.data
+              },
+              iteration
+            );
+          }
+        }
+        if (config.delayMs) await delay(config.delayMs, parent.signal);
+      }
+    } catch (e) {
+      const error = LoopError.from(e, { code: "UNKNOWN", path, iteration });
+      parent.emit({
+        kind: "error",
+        ts: ts(),
+        path,
+        message: error.message,
+        code: error.code
+      });
+      return finish(
+        { status: "fail", summary: error.message, error },
+        iteration
+      );
+    }
+  };
+  return setMeta(job, {
+    kind: "loop",
+    name: config.name,
+    max: config.max,
+    start: describeConditions(config.start),
+    gate: describeConditions(config.until),
+    stopOn: describeConditions(config.stopOn),
+    review: !!config.review,
+    commit: !!config.commit,
+    body: jobMeta(config.body)
+  });
+}
+function delay(ms, signal) {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const t = setTimeout(done, ms);
+    const onAbort = () => done();
+    function done() {
+      clearTimeout(t);
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/engines/registry.ts
+var EngineRegistry = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.registerBuiltins();
+  }
+  opts;
+  factories = /* @__PURE__ */ new Map();
+  cache = /* @__PURE__ */ new Map();
+  /** Add or override an engine. The key is what you pass as an `EngineRef`. */
+  register(name, factory) {
+    this.factories.set(name, factory);
+    this.cache.delete(name);
+    return this;
+  }
+  has(name) {
+    return this.factories.has(name);
+  }
+  names() {
+    return [...this.factories.keys()];
+  }
+  /** Resolve a ref to an `Engine`: instance → as-is; name → built/cached. */
+  create(ref, fallback) {
+    if (isEngine(ref)) return ref;
+    const name = ref ?? fallback;
+    const cached = this.cache.get(name);
+    if (cached) return cached;
+    const factory = this.factories.get(name);
+    if (!factory) {
+      throw new LoopError({
+        code: "CONFIG",
+        message: `unknown engine "${name}" (have: ${this.names().join(", ")})`
+      });
+    }
+    const engine = factory(this.opts);
+    this.cache.set(name, engine);
+    return engine;
+  }
+  registerBuiltins() {
+    this.register(
+      "agent-sdk",
+      (o) => lazy(
+        () => import('./agent-sdk-RF5VJZAT.js').then((m) => new m.AgentSdkEngine(o)),
+        "agent-sdk"
+      )
+    );
+    this.register(
+      "claude-cli",
+      (o) => lazy(
+        () => import('./claude-cli-U7WEVAOL.js').then((m) => new m.ClaudeCliEngine(o)),
+        "claude-cli"
+      )
+    );
+    this.register(
+      "anthropic-api",
+      (o) => lazy(
+        () => import('./anthropic-api-XJY6Y4T2.js').then((m) => new m.AnthropicApiEngine(o)),
+        "anthropic-api"
+      )
+    );
+    this.register(
+      "codex",
+      (o) => lazy(() => import('./codex-6I5UZ2HM.js').then((m) => new m.CodexEngine(o)), "codex")
+    );
+  }
+};
+function lazy(load, name) {
+  let inner;
+  return {
+    name,
+    run(req, onEvent, signal) {
+      inner ??= load();
+      return inner.then((engine) => engine.run(req, onEvent, signal));
+    }
+  };
+}
+
+// src/core/stats.ts
+var Stats = class {
+  startedAt = Date.now();
+  loops = /* @__PURE__ */ new Map();
+  models = /* @__PURE__ */ new Map();
+  errors = [];
+  record(event) {
+    const key = event.path.join(" / ") || "(root)";
+    switch (event.kind) {
+      case "loop:start":
+        this.loopFor(key);
+        break;
+      case "loop:iteration":
+        this.loopFor(key).iterations = event.iteration;
+        break;
+      case "loop:review": {
+        const s = this.loopFor(key);
+        if (event.outcome.status === "pass") s.reviewsPassed += 1;
+        else s.reviewsFailed += 1;
+        break;
+      }
+      case "loop:end":
+        this.loopFor(key).lastStatus = event.outcome.status;
+        break;
+      case "engine:usage": {
+        const m = this.modelFor(event.model);
+        m.calls += 1;
+        m.inputTokens += event.usage.inputTokens;
+        m.outputTokens += event.usage.outputTokens;
+        break;
+      }
+      case "error":
+        this.errors.push({
+          path: key,
+          code: event.code,
+          message: event.message,
+          ts: event.ts
+        });
+        break;
+    }
+  }
+  snapshot() {
+    const models = [...this.models.values()];
+    return {
+      startedAt: this.startedAt,
+      elapsedMs: Date.now() - this.startedAt,
+      loops: [...this.loops.values()],
+      models,
+      totalInputTokens: models.reduce((a, m) => a + m.inputTokens, 0),
+      totalOutputTokens: models.reduce((a, m) => a + m.outputTokens, 0),
+      agentCalls: models.reduce((a, m) => a + m.calls, 0),
+      errors: this.errors
+    };
+  }
+  loopFor(path) {
+    let s = this.loops.get(path);
+    if (!s) {
+      s = { path, iterations: 0, reviewsPassed: 0, reviewsFailed: 0 };
+      this.loops.set(path, s);
+    }
+    return s;
+  }
+  modelFor(model) {
+    let m = this.models.get(model);
+    if (!m) {
+      m = { model, calls: 0, inputTokens: 0, outputTokens: 0 };
+      this.models.set(model, m);
+    }
+    return m;
+  }
+};
+var NOISE = /* @__PURE__ */ new Set([
+  "engine:text",
+  "engine:thinking"
+]);
+var CHECKPOINT_AT = /* @__PURE__ */ new Set([
+  "loop:iteration",
+  "loop:end",
+  "dag:end",
+  "job:end"
+]);
+function ensureDir2(path) {
+  const dir = dirname(path);
+  if (dir && dir !== ".") mkdirSync(dir, { recursive: true });
+}
+function makeRecorder(path) {
+  ensureDir2(path);
+  writeFileSync(path, "");
+  return (event) => {
+    if (NOISE.has(event.kind)) return;
+    try {
+      appendFileSync(path, `${JSON.stringify(event)}
+`);
+    } catch {
+    }
+  };
+}
+function makeCheckpointer(path, state) {
+  ensureDir2(path);
+  return (event) => {
+    if (!CHECKPOINT_AT.has(event.kind)) return;
+    flushCheckpoint(path, state);
+  };
+}
+function flushCheckpoint(path, state) {
+  ensureDir2(path);
+  try {
+    writeFileSync(path, JSON.stringify({ ts: Date.now(), state }, null, 2));
+  } catch {
+  }
+}
+function loadCheckpoint(path) {
+  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  if (parsed && typeof parsed === "object" && "state" in parsed && parsed.state && typeof parsed.state === "object") {
+    return parsed.state;
+  }
+  return {};
+}
+
+// src/runtime/runner.ts
+var DEFAULT_MAX_WAIT_MS = 3e5;
+var EXIT_PAUSED = 75;
+async function run(job, options = {}) {
+  const registry = new EngineRegistry(options.engineOptions ?? {});
+  for (const [name, value] of Object.entries(options.engines ?? {})) {
+    registry.register(name, typeof value === "function" ? value : () => value);
+  }
+  const defaultEngine = options.engine ?? "agent-sdk";
+  const stats = new Stats();
+  const controller = new AbortController();
+  if (options.signal) {
+    if (options.signal.aborted) controller.abort();
+    else
+      options.signal.addEventListener("abort", () => controller.abort(), {
+        once: true
+      });
+  }
+  const budget = options.budget != null ? new Budget(
+    typeof options.budget === "number" ? { limit: options.budget } : options.budget
+  ) : void 0;
+  let initialState = options.state ?? {};
+  if (options.resumeFrom) {
+    try {
+      initialState = { ...loadCheckpoint(options.resumeFrom), ...initialState };
+    } catch (e) {
+      throw new LoopError({
+        code: "CONFIG",
+        message: `cannot resume from "${options.resumeFrom}": ${e instanceof Error ? e.message : String(e)}`
+      });
+    }
+  }
+  const sinks = [];
+  if (options.recordTo) sinks.push(makeRecorder(options.recordTo));
+  if (options.checkpoint)
+    sinks.push(makeCheckpointer(options.checkpoint, initialState));
+  const emit = (event) => {
+    stats.record(event);
+    if (budget && event.kind === "engine:usage")
+      budget.add(event.usage.inputTokens + event.usage.outputTokens);
+    options.onEvent?.(event);
+    for (const sink of sinks) sink(event);
+  };
+  const resolveEngine = (ref) => registry.create(ref, defaultEngine);
+  const dir = options.cwd ?? process.cwd();
+  const workspace = {
+    dir,
+    branch: await currentBranch({ cwd: dir, signal: controller.signal })
+  };
+  let environment;
+  if (options.environment) {
+    try {
+      environment = await options.environment.up(workspace, controller.signal);
+    } catch (e) {
+      const error = LoopError.from(e, { code: "CONFIG" });
+      emit({
+        kind: "error",
+        ts: Date.now(),
+        path: [],
+        message: `environment "${options.environment.name}" failed to start: ${error.message}`,
+        code: error.code
+      });
+      return {
+        outcome: {
+          status: "fail",
+          summary: `environment failed to start: ${error.message}`,
+          error
+        },
+        stats: stats.snapshot(),
+        budget: budget ? {
+          limit: budget.limit,
+          spent: budget.spent(),
+          remaining: budget.remaining()
+        } : void 0
+      };
+    }
+  }
+  const rootCtx = {
+    engine: resolveEngine(defaultEngine),
+    resolveEngine,
+    signal: controller.signal,
+    emit,
+    state: initialState,
+    workspace,
+    environment,
+    forge: options.forge,
+    budget,
+    onLimit: options.onLimit ?? "auto",
+    maxWaitMs: options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS,
+    resumeCommand: options.resumeCommand,
+    iteration: 0,
+    depth: 0,
+    path: [],
+    log: (message, level = "info") => emit({ kind: "log", ts: Date.now(), path: [], level, message })
+  };
+  let outcome;
+  try {
+    outcome = await job(rootCtx);
+  } catch (e) {
+    const error = LoopError.from(e, { code: "UNKNOWN" });
+    emit({
+      kind: "error",
+      ts: Date.now(),
+      path: [],
+      message: error.message,
+      code: error.code
+    });
+    outcome = { status: "fail", summary: error.message, error };
+  } finally {
+    if (environment) await environment.down(controller.signal).catch(() => {
+    });
+  }
+  if (outcome.status === "paused" && options.checkpoint)
+    flushCheckpoint(options.checkpoint, initialState);
+  return {
+    outcome,
+    stats: stats.snapshot(),
+    budget: budget ? {
+      limit: budget.limit,
+      spent: budget.spent(),
+      remaining: budget.remaining()
+    } : void 0
+  };
+}
+function exitCodeFor(outcome) {
+  switch (outcome.status) {
+    case "pass":
+      return 0;
+    case "fail":
+      return 1;
+    case "exhausted":
+      return 2;
+    case "aborted":
+      return 130;
+    case "paused":
+      return EXIT_PAUSED;
+  }
+}
+
+export { Budget, EXIT_PAUSED, EngineRegistry, GhForge, MockForge, Stats, addWorktree, agentCheck, agentJob, all, always, any, appendLedger, appendPrompt, bodyPassed, buildChecksArgs, buildCreateArgs, buildEditArgs, buildMergeArgs, buildViewArgs, childContext, 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, setMeta, stageAll, toCondition };
+//# sourceMappingURL=chunk-3BPU34DE.js.map
+//# sourceMappingURL=chunk-3BPU34DE.js.map