@obversa/runtime 0.1.0

package/dist/chunk-DV5P4QLI.js

@@ -0,0 +1,3056 @@
+import { runRuntimeProcess, processText } from './chunk-NIBHM5I5.js';
+import { cloneFrozenJson } from './chunk-5GLEABOU.js';
+import { createHash } from 'crypto';
+import { stat, readFile, lstat, readlink, realpath } from 'fs/promises';
+import { relative, resolve, join, isAbsolute } from 'path';
+import { readFileSync, existsSync, mkdtempSync } from 'fs';
+import { setTimeout } from 'timers/promises';
+import { EngineError, requireFinalResultText, createCallbackGate } from '@obversa/api';
+export { callbackRequestDigest, createCallbackGate, engineSelection, finalResultPart, finalResultText, reportedUsage, requireFinalResultText, validateAgentResult, validateCallbackRequest, validateCallbackResponse, validateIncompleteResultEvidence } from '@obversa/api';
+import { scrubCapture, redactEnvValues, redactSecrets } from '@obversa/core/command';
+export { scrubCapture } from '@obversa/core/command';
+import pLimit from 'p-limit';
+import { tmpdir } from 'os';
+
+// 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 copyJobMeta(target, source) {
+  const meta = jobMeta(source);
+  return meta ? setMeta(target, meta) : target;
+}
+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 renderContract(value) {
+  const c = value;
+  if (!c || typeof c !== "object") return void 0;
+  const bits = [];
+  if (c.tier) bits.push(`tier ${c.tier}`);
+  if (c.outputs?.length) bits.push(`outputs ${c.outputs.join(", ")}`);
+  if (c.capabilities?.length) bits.push(`capabilities ${c.capabilities.join(", ")}`);
+  if (c.requiresSkills?.length) bits.push(`requires ${c.requiresSkills.join(", ")}`);
+  if (c.usesSkills?.length) bits.push(`uses ${c.usesSkills.join(", ")}`);
+  if (c.failureModes?.length) bits.push(`failure modes ${c.failureModes.join(", ")}`);
+  return bits.join("; ");
+}
+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 caps = [];
+      if (typeof meta.max === "number") caps.push(`max ${meta.max}`);
+      if (typeof meta.noProgress === "number")
+        caps.push(`stall after ${meta.noProgress} flat`);
+      if (meta.checkFirst) caps.push("check first");
+      const max = caps.length ? ` (${caps.join("; ")})` : "";
+      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].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")})`);
+      const kickbacks = meta.maxKickbacks;
+      if (typeof kickbacks === "number") {
+        out.push(`${indent}  kickbacks: ${kickbacks}`);
+      } else if (kickbacks && typeof kickbacks === "object" && !Array.isArray(kickbacks)) {
+        const limits = Object.entries(kickbacks).map(([target, limit]) => `${target} ${String(limit)}`).join(", ");
+        out.push(`${indent}  kickbacks: ${limits}`);
+      }
+      for (const node of nodes) {
+        const bits = [];
+        if (node.needs?.length) bits.push(`needs ${node.needs.join(", ")}`);
+        if (node.optional) bits.push("optional");
+        if (node.when?.length) bits.push(`when: ${node.when.join(", ")}`);
+        if (node.isolate) bits.push("isolated");
+        out.push(`${indent}  - ${node.name}${bits.length ? ` (${bits.join("; ")})` : ""}`);
+        if (node.desc) out.push(`${indent}      desc: ${node.desc}`);
+        if (node.gate) out.push(`${indent}      gate: ${node.gate}`);
+        out.push(...renderPlan(node.job, `${indent}      `));
+      }
+      break;
+    }
+    case "agent":
+      out.push(`${indent}agent${nm}`);
+      {
+        const contract = renderContract(meta.contract);
+        if (contract) out.push(`${indent}  contract: ${contract}`);
+      }
+      break;
+    case "fn":
+      out.push(`${indent}fn${nm}`);
+      break;
+    default:
+      out.push(`${indent}${meta.kind}${nm}`);
+  }
+  return out;
+}
+
+// src/core/context.ts
+function criterionFor(ctx) {
+  if (ctx.stageGate !== void 0) return ctx.stageGate ?? void 0;
+  if (ctx.reviewerGate !== void 0) return ctx.reviewerGate ?? void 0;
+  return ctx.graph?.gate;
+}
+function childContext(parent, over) {
+  return {
+    engine: parent.engine,
+    resolveEngine: parent.resolveEngine,
+    signal: parent.signal,
+    runId: parent.runId,
+    fingerprintExcludePaths: parent.fingerprintExcludePaths,
+    emit: parent.emit,
+    params: parent.params,
+    state: parent.state,
+    memory: parent.memory,
+    callbacks: parent.callbacks,
+    onCallback: parent.onCallback,
+    // 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,
+    // Inherited, not override-only: pinning deliberately survives the dag
+    // worktree boundary, where a node ctx REPLACES `environment` with a
+    // per-team handle. An explicit `withEnv` wins over a per-team stack's vars.
+    envOverlay: over.envOverlay ?? parent.envOverlay,
+    budget: parent.budget,
+    onLimit: parent.onLimit,
+    maxWaitMs: parent.maxWaitMs,
+    log: parent.log,
+    depth: over.depth,
+    path: over.path,
+    graph: over.graph ?? parent.graph,
+    reviewerGate: over.reviewerGate !== void 0 ? over.reviewerGate : parent.reviewerGate,
+    stageGate: over.stageGate !== void 0 ? over.stageGate : parent.stageGate,
+    timeoutMs: over.timeoutMs ?? parent.timeoutMs,
+    timeoutGraceMs: over.timeoutGraceMs ?? parent.timeoutGraceMs,
+    // 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,
+    lastGate: over.lastGate,
+    // Not inherited: a nested job sees its own dag node's needs, never an ancestor's.
+    needs: over.needs
+  };
+}
+var LoopError = class _LoopError extends Error {
+  code;
+  phase;
+  path;
+  iteration;
+  retryable;
+  /** Suggested wait before retry, in ms (e.g. a `retry-after` header). */
+  retryAfterMs;
+  /** When the limit resets, as epoch ms. The wait policy prefers this. */
+  resetAt;
+  constructor(init) {
+    super(
+      init.message,
+      init.cause !== void 0 ? { cause: init.cause } : void 0
+    );
+    this.name = "LoopError";
+    this.code = init.code;
+    this.phase = init.phase;
+    this.path = init.path;
+    this.iteration = init.iteration;
+    this.retryAfterMs = init.retryAfterMs;
+    this.resetAt = init.resetAt;
+    this.retryable = init.retryable ?? defaultRetryable(init);
+  }
+  /** Wrap an arbitrary thrown value, preserving a `LoopError` as-is. */
+  static from(value, fallback) {
+    if (value instanceof _LoopError) return value;
+    if (value instanceof EngineError) {
+      return new _LoopError({
+        ...fallback,
+        code: loopCodeForEngineFailure(value.kind, fallback.code),
+        message: value.message,
+        cause: value,
+        retryAfterMs: value.retryAfterMs,
+        resetAt: value.resetAt
+      });
+    }
+    const message = value instanceof Error ? value.message : String(value);
+    return new _LoopError({ ...fallback, message, cause: value });
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      phase: this.phase,
+      path: this.path,
+      iteration: this.iteration,
+      retryable: this.retryable,
+      retryAfterMs: this.retryAfterMs,
+      resetAt: this.resetAt
+    };
+  }
+};
+function loopCodeForEngineFailure(kind, fallback) {
+  switch (kind) {
+    case "rate-limit":
+      return "RATE_LIMIT";
+    case "quota":
+      return "QUOTA";
+    case "timeout":
+      return "TIMEOUT";
+    case "aborted":
+      return "ABORTED";
+    case "invalid-config":
+      return "CONFIG";
+    default:
+      return fallback;
+  }
+}
+var INFRASTRUCTURE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ENGINE",
+  "TIMEOUT",
+  "RATE_LIMIT",
+  "QUOTA",
+  "BUDGET"
+]);
+function isInfrastructureError(error) {
+  return error instanceof LoopError && INFRASTRUCTURE_ERROR_CODES.has(error.code);
+}
+function defaultRetryable(init) {
+  switch (init.code) {
+    case "ENGINE":
+    case "TIMEOUT":
+    case "RATE_LIMIT":
+      return true;
+    case "QUOTA":
+      return init.resetAt != null || init.retryAfterMs != null;
+    default:
+      return false;
+  }
+}
+
+// src/core/approval-job.ts
+var NODE_JOBS = /* @__PURE__ */ new WeakMap();
+function nodeJobContext(ctx, job) {
+  const scoped = { ...ctx };
+  if (job !== void 0) NODE_JOBS.set(scoped, job);
+  return scoped;
+}
+function delegateNodeJob(ctx, owner, job, child) {
+  return job(nodeJobContext(child, NODE_JOBS.get(ctx) === owner ? job : void 0));
+}
+var RESPONSE_SCHEMA = {
+  type: "object",
+  properties: { approved: { type: "boolean" }, note: { type: "string" } },
+  required: ["approved"]
+};
+function aboutOf(ctx) {
+  if (ctx.needs !== void 0) {
+    return Object.fromEntries(
+      Object.entries(ctx.needs).map(([name, outcome]) => [name, outcome.summary ?? outcome.status])
+    );
+  }
+  return ctx.lastOutcome?.summary ?? null;
+}
+function toAnswer(response) {
+  const record = response !== null && typeof response === "object" && !Array.isArray(response) ? response : void 0;
+  if (record === void 0 || typeof record.approved !== "boolean") {
+    throw new LoopError({ code: "VALIDATION", message: 'an approval answer needs a boolean "approved"' });
+  }
+  return {
+    approved: record.approved,
+    ...typeof record.note === "string" ? { note: record.note } : {}
+  };
+}
+function stateOf(events) {
+  let state = "absent";
+  let answer;
+  for (const event of events) {
+    switch (event.kind) {
+      case "callback-requested":
+        state = "pending";
+        break;
+      case "callback-claimed":
+        state = "claimed";
+        break;
+      case "callback-released":
+        state = "pending";
+        break;
+      case "callback-submitted":
+        state = "answered";
+        answer = toAnswer(event.response);
+        break;
+      case "callback-superseded":
+        state = "superseded";
+        break;
+    }
+  }
+  return answer === void 0 ? { state } : { state, answer };
+}
+function approval(label, opts) {
+  const job = async (ctx) => {
+    const path = [...ctx.path];
+    ctx.emit({ kind: "job:start", ts: Date.now(), path, label, timeoutMs: ctx.timeoutMs });
+    let outcome;
+    try {
+      outcome = await decide(ctx, label, opts, NODE_JOBS.get(ctx) === job);
+    } 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: "approval",
+    name: label,
+    question: opts.question,
+    ...opts.target !== void 0 ? { target: opts.target } : {}
+  });
+}
+async function decide(ctx, label, opts, ownsNode) {
+  const client = ctx.callbacks;
+  if (client === void 0) {
+    throw new LoopError({
+      code: "VALIDATION",
+      message: `approval "${label}" needs the run's callbacks client; run it through run()`
+    });
+  }
+  const request = createCallbackGate({
+    gateId: label,
+    gateVersion: 1,
+    decisionText: opts.question,
+    responseSchema: RESPONSE_SCHEMA,
+    input: opts.input ?? aboutOf(ctx)
+  });
+  let { state, answer } = stateOf(await client.history(request.requestId));
+  if (answer === void 0) {
+    await client.post(request);
+    ({ state, answer } = stateOf(await client.history(request.requestId)));
+    if (answer === void 0 && state !== "pending" && state !== "claimed") {
+      return {
+        status: "fail",
+        summary: `the question "${opts.question}" is not pending and not answered after it was asked (${state}); nobody can answer it`,
+        data: request
+      };
+    }
+  }
+  if (answer === void 0 && opts.answer !== void 0) {
+    answer = await answerInProcess(client, request, `${label}:answer`, opts.answer);
+  }
+  const paused = { status: "paused", summary: `waiting for a person: ${opts.question}`, data: request };
+  if (ownsNode && answer === void 0 && ctx.onCallback === "wait" && !ctx.signal.aborted && ctx.graph !== void 0) {
+    ctx.emit({
+      kind: "dag:node",
+      ts: Date.now(),
+      path: ctx.graph.path.slice(0, -1),
+      node: ctx.graph.node,
+      phase: "done",
+      attempt: ctx.graph.attempt,
+      needs: [...ctx.graph.needs],
+      ...ctx.graph.desc === void 0 ? {} : { desc: ctx.graph.desc },
+      ...ctx.graph.gate === void 0 ? {} : { gate: ctx.graph.gate },
+      timeoutMs: ctx.timeoutMs,
+      outcome: paused
+    });
+  }
+  while (answer === void 0 && ctx.onCallback === "wait" && !ctx.signal.aborted && (state === "pending" || state === "claimed")) {
+    try {
+      await setTimeout(1e3, void 0, { signal: ctx.signal });
+    } catch (error) {
+      if (!ctx.signal.aborted) throw error;
+      break;
+    }
+    ({ state, answer } = stateOf(await client.history(request.requestId)));
+  }
+  if (answer === void 0) {
+    return paused;
+  }
+  if (answer.approved) {
+    const accepted = {
+      approved: true,
+      ...typeof answer.note === "string" && answer.note !== "" ? { note: redactSecrets(answer.note) } : {}
+    };
+    return { status: "pass", summary: `approved: ${opts.question}`, data: accepted };
+  }
+  const note = typeof answer.note === "string" && answer.note !== "" ? redactSecrets(answer.note) : `refused: ${opts.question}`;
+  const scrubbed = { approved: false, note };
+  if (opts.target === void 0) {
+    return { status: "fail", summary: note, data: scrubbed };
+  }
+  return {
+    status: "fail",
+    summary: note,
+    data: scrubbed,
+    revision: {
+      target: opts.target,
+      reason: note,
+      findings: [{ evidence: note, severity: "block" }],
+      rerun: "target-and-dependents"
+    }
+  };
+}
+async function answerInProcess(client, request, routerId, respond) {
+  const claim = await client.claim(request.requestId, routerId);
+  if (!claim.ok) {
+    throw new LoopError({
+      code: "VALIDATION",
+      message: `the question "${request.decisionText}" could not be claimed to answer it (${claim.kind})`
+    });
+  }
+  let response;
+  try {
+    response = await respond(request);
+  } catch (error) {
+    await client.release(request.requestId, claim.claimToken);
+    throw error;
+  }
+  const submission = {
+    approved: response.approved,
+    ...typeof response.note === "string" ? { note: response.note } : {}
+  };
+  let submitted;
+  try {
+    submitted = await client.submit(
+      request.requestId,
+      claim.claimToken,
+      routerId,
+      request.digest,
+      submission
+    );
+  } catch (error) {
+    await client.release(request.requestId, claim.claimToken);
+    throw error;
+  }
+  if (!submitted.ok) {
+    await client.release(request.requestId, claim.claimToken);
+    throw new LoopError({
+      code: "VALIDATION",
+      message: `the answer to "${request.decisionText}" was refused: ${submitted.reason}`
+    });
+  }
+  return toAnswer(submitted.response);
+}
+
+// src/core/env-overlay.ts
+function mergeEnv(...layers) {
+  let merged;
+  for (const layer of layers) {
+    if (!layer) continue;
+    for (const [k, v] of Object.entries(layer)) {
+      (merged ??= /* @__PURE__ */ Object.create(null))[k] = v;
+    }
+  }
+  return merged;
+}
+function resolveEnv(ctx, perCall) {
+  return mergeEnv(ctx.environment?.env, ctx.envOverlay, perCall);
+}
+function withEnv(overlay, job) {
+  if (!overlay || typeof overlay !== "object" || Array.isArray(overlay)) {
+    throw new LoopError({
+      code: "CONFIG",
+      message: `withEnv requires a plain object of string values (got ${Array.isArray(overlay) ? "an array" : typeof overlay})`
+    });
+  }
+  for (const [k, v] of Object.entries(overlay)) {
+    if (!k || k.includes("=")) {
+      throw new LoopError({
+        code: "CONFIG",
+        message: `withEnv key ${JSON.stringify(k)} is not a valid env var name (empty, or contains "=")`
+      });
+    }
+    if (typeof v !== "string") {
+      throw new LoopError({
+        code: "CONFIG",
+        message: `withEnv value for "${k}" must be a string (got ${typeof v})`
+      });
+    }
+  }
+  const wrapper = (ctx) => delegateNodeJob(
+    ctx,
+    wrapper,
+    job,
+    // Transparent: same depth and path (no new tree segment, no events of
+    // its own), and the loop-feedback fields are carried through so wrapping
+    // a loop body does not hide the previous iteration from it.
+    childContext(ctx, {
+      depth: ctx.depth,
+      path: ctx.path,
+      lastOutcome: ctx.lastOutcome,
+      lastReview: ctx.lastReview,
+      lastGate: ctx.lastGate,
+      envOverlay: { ...ctx.envOverlay, ...overlay }
+    })
+  );
+  const meta = jobMeta(job);
+  return meta ? setMeta(wrapper, meta) : wrapper;
+}
+
+// src/core/budget.ts
+var Budget = class {
+  limit;
+  headroom;
+  soft;
+  tokens = 0;
+  unknownCalls = 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;
+  }
+  addUsage(usage) {
+    if (usage.kind === "unknown") {
+      this.unknownCalls += 1;
+      return;
+    }
+    this.add(usage.inputTokens + usage.outputTokens);
+  }
+  unknownUsageCalls() {
+    return this.unknownCalls;
+  }
+  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) return;
+  if (budget.unknownUsageCalls() > 0) {
+    if (budget.soft) {
+      ctx.log(
+        `token usage is unknown for ${budget.unknownUsageCalls()} call(s) \u2014 continuing (soft)`,
+        "warn"
+      );
+      return;
+    }
+    throw new LoopError({
+      code: "BUDGET",
+      phase: "engine",
+      message: `token budget cannot continue: usage is unknown for ${budget.unknownUsageCalls()} call(s)`
+    });
+  }
+  if (!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 skillRefName(ref) {
+  return typeof ref === "string" ? ref : ref.name;
+}
+function validateName(value, label) {
+  if (!value?.trim()) throw new Error(`${label}: \`name\` is required`);
+}
+function validateSkillRef(ref, label) {
+  if (typeof ref === "string") {
+    if (!ref.trim()) throw new Error(`${label}: empty skill name`);
+    return;
+  }
+  defineSkill(ref);
+}
+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));
+  def.requiresSkills?.forEach(
+    (s) => validateSkillRef(s, `defineAgent "${def.name}" requiresSkills`)
+  );
+  def.usesSkills?.forEach(
+    (s) => validateSkillRef(s, `defineAgent "${def.name}" usesSkills`)
+  );
+  def.outputs?.forEach(
+    (o) => validateName(o.name, `defineAgent "${def.name}" outputs`)
+  );
+  def.failureModes?.forEach((f) => {
+    if (!f.mode?.trim())
+      throw new Error(`defineAgent "${def.name}" failureModes: \`mode\` is required`);
+    if (!f.recovery?.trim())
+      throw new Error(`defineAgent "${def.name}" failureModes "${f.mode}": \`recovery\` is required`);
+  });
+  return def;
+}
+function agentContract(agent) {
+  if (!agent) return void 0;
+  const summary = {};
+  if (agent.tier) summary.tier = agent.tier;
+  if (agent.capabilities?.length) summary.capabilities = [...agent.capabilities];
+  if (agent.outputs?.length) summary.outputs = agent.outputs.map((o) => o.name);
+  if (agent.requiresSkills?.length)
+    summary.requiresSkills = agent.requiresSkills.map(skillRefName);
+  if (agent.usesSkills?.length)
+    summary.usesSkills = agent.usesSkills.map(skillRefName);
+  if (agent.failureModes?.length)
+    summary.failureModes = agent.failureModes.map((f) => f.mode);
+  return Object.keys(summary).length ? summary : void 0;
+}
+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}`;
+}
+
+// src/core/text.ts
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  const marker = max > 1 ? "\n\u2026" : "\u2026".slice(0, Math.max(0, max));
+  return `${s.slice(0, Math.max(0, max - marker.length)).trimEnd()}${marker}`;
+}
+
+// src/core/engine-meta.ts
+function leafId(ctx, label) {
+  const raw = [...ctx.path, label, String(ctx.iteration)].join("/");
+  return raw.replace(/[^A-Za-z0-9._/-]+/g, "-").replace(/(^-+|-+$)/g, "") || "leaf";
+}
+function attemptRequestMeta(ctx, label) {
+  return {
+    leaf: true,
+    runId: ctx.runId,
+    leafId: leafId(ctx, label),
+    path: [...ctx.path],
+    label,
+    iteration: ctx.iteration
+  };
+}
+function logEngineTransportFailure(ctx, result, env) {
+  if (!result.transportFailure) return;
+  ctx.log(scrubCapture(result.transportFailure.message, env, 1e3), "warn");
+}
+
+// src/core/condition.ts
+var COMMAND_FAILURE_TAIL_MAX = 3e3;
+var COMMAND_FAILURE_TAIL_MARKER = "\u2026 [output truncated]\n";
+function commandFailureTail(text, env) {
+  const scrubbed = scrubCapture(text, env);
+  if (scrubbed.length <= COMMAND_FAILURE_TAIL_MAX) return scrubbed;
+  return COMMAND_FAILURE_TAIL_MARKER + scrubbed.slice(
+    -(COMMAND_FAILURE_TAIL_MAX - COMMAND_FAILURE_TAIL_MARKER.length)
+  );
+}
+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);
+}
+var conditionPreparations = /* @__PURE__ */ new WeakMap();
+function withConditionPreparation(condition, prepare) {
+  conditionPreparations.set(condition, prepare);
+  return condition;
+}
+async function prepareCondition(input, ctx, combine = "all") {
+  if (Array.isArray(input)) {
+    const prepared = await Promise.all(
+      input.map((item) => prepareCondition(item, ctx, combine))
+    );
+    return combine === "any" ? any(...prepared) : all(...prepared);
+  }
+  const prepare = conditionPreparations.get(input);
+  return prepare ? prepare(ctx) : toCondition(input, combine);
+}
+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 env = resolveEnv(ctx, opts.env);
+      const r = await runRuntimeProcess({
+        executable: command,
+        args,
+        cwd: opts.cwd ?? ctx.workspace.dir,
+        timeoutMs: opts.timeoutMs,
+        signal: ctx.signal,
+        env
+      });
+      const stdout = processText(r.stdout);
+      const stderr = processText(r.stderr);
+      const all2 = `${stdout}${stderr}`;
+      if (r.exitCode === 0 && !r.timedOut) {
+        return { met: true, reason: `\`${command}\` exited 0` };
+      }
+      const baseReason = r.timedOut ? `\`${command}\` timed out after ${opts.timeoutMs} ms` : `\`${command}\` exited ${r.exitCode ?? "?"}`;
+      const tail = opts.captureOutput ? commandFailureTail(all2, env) : "";
+      return {
+        met: false,
+        reason: tail ? `${baseReason}
+
+command output (tail):
+${tail}` : baseReason,
+        // The evidence behind the failure, in the same shape `reviewContext`
+        // gives a judge. Scrubbed (`scrubCapture`) because it flows into JSONL
+        // event records — a failing command often echoes its config, and a
+        // pinned credential's shape is unknowable to pattern scrubbing.
+        output: `exit: ${r.exitCode ?? "(command did not run)"}
+
+stdout:
+${scrubCapture(stdout, env, 4e3)}
+
+stderr:
+${scrubCapture(stderr, env, 4e3)}`
+      };
+    } catch (e) {
+      return {
+        met: false,
+        reason: `\`${command}\` failed to run: ${e instanceof Error ? e.message : String(e)}`
+      };
+    }
+  }, `${command}${args.length ? ` ${args.join(" ")}` : ""}`);
+}
+var always = async () => ({ met: true, reason: "always" });
+var never = async () => ({ met: false, reason: "never" });
+function not(c) {
+  const cond = toCondition(c);
+  const condition = async (ctx, last) => {
+    const r = await cond(ctx, last);
+    return {
+      met: !r.met,
+      confidence: r.confidence,
+      reason: `not(${r.reason})`,
+      output: r.output
+    };
+  };
+  setMeta(condition, { kind: "condition", name: "not", inputs: [c] });
+  return withConditionPreparation(
+    condition,
+    async (ctx) => not(await prepareCondition(c, ctx))
+  );
+}
+function all(...inputs) {
+  const conds = inputs.map((i) => toCondition(i));
+  const condition = 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}`,
+          output: r.output
+        };
+    }
+    return {
+      met: true,
+      reason: `all(${results.map((r) => r.reason).join(" & ")})`
+    };
+  };
+  setMeta(condition, { kind: "condition", name: "all", inputs });
+  return withConditionPreparation(
+    condition,
+    async (ctx) => all(...await Promise.all(inputs.map((input) => prepareCondition(input, ctx))))
+  );
+}
+function any(...inputs) {
+  const conds = inputs.map((i) => toCondition(i));
+  const condition = async (ctx, last) => {
+    const reasons = [];
+    let output;
+    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}`,
+          output: r.output
+        };
+      output ??= r.output;
+    }
+    return { met: false, reason: `any(${reasons.join(" | ")})`, output };
+  };
+  setMeta(condition, { kind: "condition", name: "any", inputs });
+  return withConditionPreparation(
+    condition,
+    async (ctx) => any(...await Promise.all(inputs.map((input) => prepareCondition(input, ctx))))
+  );
+}
+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));
+  const condition = setLabel(async (ctx, last) => {
+    const settled = await Promise.allSettled(conds.map((c) => c(ctx, last)));
+    const engineErrors = settled.filter(
+      (s) => s.status === "rejected" && isInfrastructureError(s.reason)
+    ).map((s) => s.reason);
+    const results = settled.map((s) => {
+      if (s.status === "fulfilled") return s.value;
+      return {
+        met: false,
+        reason: `judge errored: ${s.reason instanceof Error ? s.reason.message : String(s.reason)}`
+      };
+    });
+    const held = results.filter((r) => r.met);
+    const output = results.find((r) => !r.met && r.output !== void 0)?.output;
+    if (held.length < k && held.length + engineErrors.length >= k) {
+      const first = engineErrors[0];
+      if (!output) throw first;
+      throw new LoopError({
+        code: first.code,
+        message: first.message,
+        phase: first.phase,
+        path: first.path,
+        iteration: first.iteration,
+        retryable: first.retryable,
+        retryAfterMs: first.retryAfterMs,
+        resetAt: first.resetAt,
+        cause: { error: first, output }
+      });
+    }
+    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;
+    const met = held.length >= k;
+    return {
+      met,
+      confidence,
+      reason: `quorum ${held.length}/${inputs.length} held (need ${k})`,
+      output: met ? void 0 : output
+    };
+  }, `quorum ${k}/${inputs.length}`);
+  setMeta(condition, { kind: "condition", name: "quorum", inputs });
+  return withConditionPreparation(
+    condition,
+    async (ctx) => quorum(
+      k,
+      ...await Promise.all(inputs.map((input) => prepareCondition(input, ctx)))
+    )
+  );
+}
+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);
+}
+var JUDGE_OUTPUT_CAP = 2e4;
+function judgeOutput(text) {
+  return scrubCapture(text, void 0, JUDGE_OUTPUT_CAP);
+}
+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 maxReasonChars = config.maxReasonChars ?? 280;
+  const dimensions = !confidenceTag && config.dimensions?.length ? config.dimensions : void 0;
+  return setLabel(async (ctx, last) => {
+    const engine = ctx.resolveEngine(config.engine);
+    const contextText = await (config.context ?? defaultContext)(ctx, last);
+    const acceptanceCriterion = ctx.reviewerGate ? `
+
+ACCEPTANCE CRITERION:
+${ctx.reviewerGate}` : "";
+    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}${acceptanceCriterion}
+
+` + closing;
+    const baseSystem = confidenceTag ? CONFIDENCE_TAG_SYSTEM : dimensions ? validatorScoreSystem(dimensions) : VALIDATOR_SYSTEM;
+    const system = config.agent ? `${resolveSystem(config.agent)}
+
+${baseSystem}` : baseSystem;
+    const env = resolveEnv(ctx);
+    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),
+          cwd: config.cwd,
+          timeoutMs: config.timeoutMs ?? ctx.timeoutMs,
+          timeoutGraceMs: ctx.timeoutGraceMs,
+          env,
+          leaf: true,
+          attempt: attemptRequestMeta(ctx, config.agent?.name ?? "agent-check")
+        },
+        (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 });
+    }
+    logEngineTransportFailure(ctx, result, env);
+    const text = redactEnvValues(requireFinalResultText(result), env);
+    if (confidenceTag) {
+      const parsed = parseConfidenceTag(text);
+      if (!parsed)
+        return {
+          met: false,
+          confidence: 0,
+          reason: `no <confidence> tag: ${redactSecrets(text).slice(0, 140)}`,
+          output: judgeOutput(text)
+        };
+      const pct = Math.round(parsed.confidence * 100);
+      const need = Math.round(threshold * 100);
+      const findings = redactSecrets(parsed.findings);
+      return {
+        met: parsed.confidence >= threshold,
+        confidence: parsed.confidence,
+        reason: `confidence ${pct}% (need ${need}%)${findings ? ` \u2014 ${findings.slice(0, maxReasonChars)}` : ""}`,
+        // The FULL findings — what lets a failing check brief a fix-up body
+        // without re-running the judge. A tag-only reply has no evidence to carry.
+        output: findings ? truncate(findings, JUDGE_OUTPUT_CAP) : void 0
+      };
+    }
+    if (dimensions) {
+      let sv;
+      try {
+        sv = parseScores(text, dimensions);
+      } catch {
+        return {
+          met: false,
+          confidence: 0,
+          reason: `unparseable scores: ${redactSecrets(text).slice(0, 120)}`,
+          output: judgeOutput(text)
+        };
+      }
+      const detail = dimensions.map((d) => `${d}=${sv.scores[d].toFixed(2)}`).join(", ");
+      return {
+        met: sv.score >= threshold,
+        confidence: sv.score,
+        // The judge's free-prose reason gets the same scrub as `output` — it
+        // flows into the same persisted records.
+        reason: `geo ${sv.score.toFixed(2)} (need ${threshold}) [${detail}] \u2014 ${redactSecrets(sv.reason)}`,
+        output: judgeOutput(text)
+      };
+    }
+    let v;
+    try {
+      v = parseVerdict(text);
+    } catch {
+      return {
+        met: false,
+        confidence: 0,
+        reason: `unparseable verdict: ${redactSecrets(text).slice(0, 120)}`,
+        output: judgeOutput(text)
+      };
+    }
+    const met = v.verdict === "yes" && v.confidence >= threshold;
+    return {
+      met,
+      confidence: v.confidence,
+      reason: `${v.verdict} @ ${v.confidence.toFixed(2)} (need ${threshold}) \u2014 ${redactSecrets(v.reason)}`,
+      output: judgeOutput(text)
+    };
+  }, `judge "${config.question}" >=${threshold}`);
+}
+function gateJob(label, condition, opts = {}) {
+  const cond = toCondition(condition);
+  return setMeta(async (ctx) => {
+    ctx.emit({
+      kind: "job:start",
+      ts: Date.now(),
+      path: [...ctx.path],
+      label,
+      timeoutMs: ctx.timeoutMs
+    });
+    const r = await cond(ctx, ctx.lastOutcome);
+    ctx.emit({
+      kind: "condition:result",
+      ts: Date.now(),
+      path: [...ctx.path],
+      label,
+      iteration: ctx.iteration,
+      result: r
+    });
+    const outcome = !r.met && opts.target !== void 0 ? {
+      status: "fail",
+      confidence: r.confidence,
+      summary: r.reason,
+      data: r.output,
+      revision: {
+        target: opts.target,
+        reason: r.reason,
+        findings: [{ evidence: r.output ?? r.reason, severity: "block" }],
+        rerun: "target-and-dependents"
+      }
+    } : {
+      status: r.met ? "pass" : "fail",
+      confidence: r.confidence,
+      summary: r.reason
+    };
+    if (r.output !== void 0 && outcome.data === void 0) outcome.data = r.output;
+    ctx.emit({
+      kind: "job:end",
+      ts: Date.now(),
+      path: [...ctx.path],
+      label,
+      outcome
+    });
+    return outcome;
+  }, { kind: "gate", name: label });
+}
+function commandJob(label, command, opts = {}) {
+  const [executable, ...args] = splitCommand(command);
+  return gateJob(
+    label,
+    commandSucceeds(executable, args, {
+      ...opts.cwd !== void 0 ? { cwd: opts.cwd } : {},
+      ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
+      ...opts.env !== void 0 ? { env: opts.env } : {},
+      captureOutput: opts.capture ?? true
+    }),
+    opts.target !== void 0 ? { target: opts.target } : {}
+  );
+}
+function splitCommand(command) {
+  if (typeof command === "string" && /["']/.test(command)) {
+    throw new LoopError({
+      code: "VALIDATION",
+      message: `commandJob: "${command}" has a quote in it; pass the command as an array, one argument per entry`
+    });
+  }
+  if (typeof command === "string" && /[|&;<>$`()]/.test(command)) {
+    throw new LoopError({
+      code: "VALIDATION",
+      message: `commandJob: "${command}" has shell syntax in it, and nothing here runs through a shell; give one command as an array, one argument per entry, or run a script`
+    });
+  }
+  const parts = typeof command === "string" ? command.trim().split(/\s+/) : [...command];
+  const [executable, ...args] = parts;
+  if (executable === void 0 || executable === "") {
+    throw new LoopError({ code: "VALIDATION", message: "commandJob needs a command to run" });
+  }
+  return [executable, ...args];
+}
+function needOutcome(ctx, name, caller) {
+  const outcome = ctx.needs?.[name];
+  if (outcome === void 0) {
+    throw new LoopError({
+      code: "VALIDATION",
+      message: `${caller}("${name}"): "${name}" is not a dependency of this node; add it to the node's needs`
+    });
+  }
+  return outcome;
+}
+function passed(name) {
+  const cond = async (ctx) => {
+    const outcome = needOutcome(ctx, name, "passed");
+    const met = outcome.status === "pass";
+    return { met, reason: `${name} ${outcome.status}` };
+  };
+  setMeta(cond, { kind: "condition", name: "passed", need: name });
+  return setLabel(cond, `passed ${name}`);
+}
+function failed(name) {
+  const cond = async (ctx) => {
+    const outcome = needOutcome(ctx, name, "failed");
+    const met = outcome.status === "fail";
+    return { met, reason: `${name} ${outcome.status}` };
+  };
+  setMeta(cond, { kind: "condition", name: "failed", need: name });
+  return setLabel(cond, `failed ${name}`);
+}
+function needDecisionsOf(input) {
+  if (Array.isArray(input)) return input.flatMap((item) => needDecisionsOf(item));
+  if (typeof input !== "function") return [];
+  const meta = jobMeta(input);
+  if (meta?.kind !== "condition") return [];
+  if ((meta.name === "passed" || meta.name === "failed") && typeof meta.need === "string") {
+    return [{ on: meta.name, need: meta.need }];
+  }
+  if (meta.name === "all" && Array.isArray(meta.inputs)) {
+    return meta.inputs.flatMap((item) => needDecisionsOf(item));
+  }
+  return [];
+}
+var DEFAULT_FANOUT_CONCURRENCY = 4;
+async function mapWithConcurrency(items, concurrency, fn) {
+  const limit = pLimit(concurrency);
+  return Promise.all(items.map((item, index) => limit(() => fn(item, index))));
+}
+async function git(args, { cwd, signal }, input) {
+  const r = await runRuntimeProcess({
+    executable: "git",
+    args,
+    cwd,
+    signal,
+    ...input === void 0 ? {} : { stdin: input }
+  });
+  return {
+    stdout: processText(r.stdout).replace(/\r?\n$/u, ""),
+    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 gitRoot(opts) {
+  const r = await git(["rev-parse", "--show-toplevel"], opts);
+  return r.exitCode === 0 ? r.stdout.trim() || void 0 : 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 workspaceFingerprint(opts) {
+  try {
+    if (!await isRepo(opts)) return void 0;
+    const excluded = (opts.excludePaths ?? []).map((p) => relative(opts.cwd, resolve(opts.cwd, p)).replace(/\\/g, "/")).filter((p) => p && !p.startsWith("..") && p !== ".");
+    const included = [...new Set(opts.includePaths ?? [])].map((p) => p.trim()).filter(Boolean).sort();
+    const scoped = included.length > 0;
+    const pathspec = scoped || excluded.length ? [
+      "--",
+      ...scoped ? included : ["."],
+      ...excluded.map((p) => `:(exclude)${p}`)
+    ] : [];
+    const output = async (args) => {
+      const result = await git(args, opts);
+      if (result.exitCode !== 0)
+        throw new Error(`git ${args[0] ?? "command"} failed`);
+      return result.stdout;
+    };
+    const hash = createHash("sha256");
+    const feed = (label, value) => {
+      hash.update(label);
+      hash.update("");
+      hash.update(value);
+      hash.update("");
+    };
+    if (scoped) {
+      feed("scope", included.join("\n"));
+      feed(
+        "tracked",
+        await output(["ls-files", "--stage", ...pathspec])
+      );
+    } else {
+      feed("head", await headSha(opts) ?? "");
+    }
+    feed(
+      "status",
+      await output(["status", "--porcelain", ...pathspec])
+    );
+    feed("unstaged", await output(["diff", ...pathspec]));
+    feed("staged", await output(["diff", "--cached", ...pathspec]));
+    const untracked = (await output([
+      "ls-files",
+      "--others",
+      ...scoped ? [] : ["--exclude-standard"],
+      ...pathspec
+    ])).split("\n").filter(Boolean);
+    for (let i = 0; i < untracked.length; i += 500) {
+      const chunk = untracked.slice(i, i + 500);
+      feed(`untracked-paths:${i}`, chunk.join("\n"));
+      feed(
+        `untracked-content:${i}`,
+        await output(["hash-object", "--", ...chunk])
+      );
+    }
+    return hash.digest("hex");
+  } catch {
+    return void 0;
+  }
+}
+function parseDirtyStatus(output) {
+  const records = output.split("\0");
+  const entries = [];
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (!record) continue;
+    if (record.length < 4 || record[2] !== " ") {
+      throw new Error("git status returned an invalid porcelain record");
+    }
+    const status = record.slice(0, 2);
+    entries.push({ status, path: record.slice(3) });
+    if (status.includes("R") || status.includes("C")) {
+      const source = records[index + 1];
+      if (!source) throw new Error("git status omitted a rename source");
+      entries.push({ status: `${status}:source`, path: source });
+      index += 1;
+    }
+  }
+  return entries;
+}
+function parseIndexState(output) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const record of output.split("\0")) {
+    if (!record) continue;
+    const match = /^(\d{6}) ([0-9a-f]+) (\d)\t(.+)$/u.exec(record);
+    if (!match) throw new Error("git index returned an invalid entry");
+    const [, mode, oid, stage, path] = match;
+    if (stage !== "0") {
+      throw new Error(`git index has an unresolved entry at ${path}`);
+    }
+    if (entries.has(path)) {
+      throw new Error(`git index returned a duplicate entry at ${path}`);
+    }
+    entries.set(path, { mode, oid });
+  }
+  return entries;
+}
+function lineDigests(bytes) {
+  if (bytes.byteLength === 0) return Object.freeze([]);
+  const lines = [];
+  let start = 0;
+  for (let index = 0; index < bytes.byteLength; index += 1) {
+    if (bytes[index] !== 10) continue;
+    lines.push(
+      createHash("sha256").update(bytes.subarray(start, index + 1)).digest("hex")
+    );
+    start = index + 1;
+  }
+  if (start < bytes.byteLength) {
+    lines.push(createHash("sha256").update(bytes.subarray(start)).digest("hex"));
+  }
+  return Object.freeze(lines);
+}
+async function dirtyState(root, entry) {
+  const path = join(root, entry.path);
+  try {
+    const stat2 = await lstat(path);
+    let bytes;
+    let kind;
+    if (stat2.isFile()) {
+      kind = "file";
+      bytes = await readFile(path);
+    } else if (stat2.isSymbolicLink()) {
+      kind = "symlink";
+      bytes = await readlink(path, { encoding: "buffer" });
+    } else {
+      throw new Error(
+        `git workspace contains an unsupported dirty entry at ${entry.path}`
+      );
+    }
+    return {
+      status: entry.status,
+      kind,
+      mode: stat2.mode,
+      digest: createHash("sha256").update(bytes).digest("hex"),
+      lines: lineDigests(bytes)
+    };
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") {
+      return {
+        status: entry.status,
+        kind: "missing",
+        mode: 0,
+        digest: null,
+        lines: Object.freeze([])
+      };
+    }
+    throw error;
+  }
+}
+async function captureGitWorkspaceSnapshot(opts) {
+  const root = await gitRoot(opts);
+  if (!root) throw new Error("not a git repository");
+  const commandOpts = { ...opts, cwd: root };
+  const included = [...new Set(opts.includePaths ?? [])].map((path) => path.trim()).filter(Boolean).sort();
+  const pathspec = included.length > 0 ? ["--", ...included] : [];
+  const [head, indexResult, statusResult] = await Promise.all([
+    headSha(commandOpts),
+    git([
+      ...pathspec.length === 0 ? ["--literal-pathspecs"] : [],
+      "ls-files",
+      "--stage",
+      "-z",
+      ...pathspec
+    ], commandOpts),
+    git(
+      ["status", "--porcelain=v1", "-z", "--untracked-files=all", ...pathspec],
+      commandOpts
+    )
+  ]);
+  if (indexResult.exitCode !== 0) throw new Error("git index inspection failed");
+  if (statusResult.exitCode !== 0) throw new Error("git status inspection failed");
+  const index = parseIndexState(indexResult.stdout);
+  const dirtyEntries = parseDirtyStatus(statusResult.stdout);
+  const dirty = /* @__PURE__ */ new Map();
+  for (const entry of dirtyEntries) {
+    dirty.set(entry.path, await dirtyState(root, entry));
+  }
+  const paths = [.../* @__PURE__ */ new Set([...index.keys(), ...dirty.keys()])].sort();
+  const files = paths.map((path) => Object.freeze({
+    path,
+    index: index.get(path) ?? null,
+    dirty: dirty.get(path) ?? null
+  }));
+  return Object.freeze({
+    root,
+    head: head ?? null,
+    files: Object.freeze(files)
+  });
+}
+function fileStateKey(value) {
+  if (!value) return "[absent]";
+  return JSON.stringify({ index: value.index, dirty: value.dirty });
+}
+function lineEditCount(before, after) {
+  if (before.length === after.length && before.every((line, index) => line === after[index])) {
+    return 0;
+  }
+  const maximum = before.length + after.length;
+  let frontier = /* @__PURE__ */ new Map([[1, 0]]);
+  for (let distance = 0; distance <= maximum; distance += 1) {
+    const next = /* @__PURE__ */ new Map();
+    for (let diagonal = -distance; diagonal <= distance; diagonal += 2) {
+      const down = frontier.get(diagonal + 1) ?? -1;
+      const right = (frontier.get(diagonal - 1) ?? -1) + 1;
+      let x = diagonal === -distance || diagonal !== distance && right < down ? down : right;
+      let y = x - diagonal;
+      while (x < before.length && y < after.length && before[x] === after[y]) {
+        x += 1;
+        y += 1;
+      }
+      if (x >= before.length && y >= after.length) return distance;
+      next.set(diagonal, x);
+    }
+    frontier = next;
+  }
+  return maximum;
+}
+async function blobLines(root, oid, cache, signal) {
+  if (!oid) return Object.freeze([]);
+  const cached = cache.get(oid);
+  if (cached) return cached;
+  const result = await runRuntimeProcess({
+    executable: "git",
+    args: ["cat-file", "blob", oid],
+    cwd: root,
+    signal
+  });
+  if (result.exitCode !== 0) throw new Error(`git cannot read workspace blob ${oid}`);
+  const lines = lineDigests(result.stdout);
+  cache.set(oid, lines);
+  return lines;
+}
+async function worktreeLines(root, state, cache, signal) {
+  if (!state) return Object.freeze([]);
+  if (state.dirty) return state.dirty.lines;
+  return await blobLines(root, state.index?.oid, cache, signal);
+}
+async function compareGitWorkspaceSnapshots(before, after, signal) {
+  if (before.root !== after.root) {
+    throw new Error("git workspace root changed during the attempt");
+  }
+  const beforeFiles = new Map(before.files.map((file) => [file.path, file]));
+  const afterFiles = new Map(after.files.map((file) => [file.path, file]));
+  const changedPaths = [.../* @__PURE__ */ new Set([
+    ...beforeFiles.keys(),
+    ...afterFiles.keys()
+  ])].filter(
+    (path) => fileStateKey(beforeFiles.get(path)) !== fileStateKey(afterFiles.get(path))
+  ).sort();
+  const cache = /* @__PURE__ */ new Map();
+  let linesChanged = 0;
+  for (const path of changedPaths) {
+    const beforeState = beforeFiles.get(path);
+    const afterState = afterFiles.get(path);
+    const [beforeWorktree, afterWorktree, beforeIndex, afterIndex] = await Promise.all([
+      worktreeLines(before.root, beforeState, cache, signal),
+      worktreeLines(after.root, afterState, cache, signal),
+      blobLines(before.root, beforeState?.index?.oid, cache, signal),
+      blobLines(after.root, afterState?.index?.oid, cache, signal)
+    ]);
+    linesChanged += Math.max(
+      lineEditCount(beforeWorktree, afterWorktree),
+      lineEditCount(beforeIndex, afterIndex)
+    );
+    if (!Number.isSafeInteger(linesChanged)) {
+      throw new Error("workspace line count exceeded the safe integer range");
+    }
+  }
+  return Object.freeze({
+    headChanged: before.head !== after.head,
+    changedPaths: Object.freeze(changedPaths),
+    filesChanged: changedPaths.length,
+    linesChanged
+  });
+}
+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 branchCommits(opts) {
+  const field = "";
+  const record = "";
+  const result = await git(
+    ["log", `-n${opts.max}`, `--format=%s${field}%b${record}`, opts.ref],
+    opts
+  );
+  if (result.exitCode !== 0) return [];
+  return result.stdout.split(record).map((value) => value.replace(/^\n+/, "").split(field)).filter((fields) => fields[0]?.trim()).map(([subject, body]) => ({
+    subject: subject.trim(),
+    body: (body ?? "").trim()
+  }));
+}
+var worktreeQueues = /* @__PURE__ */ new Map();
+async function withWorktreeQueue(repoDir, signal, operation) {
+  const common = await git(["rev-parse", "--git-common-dir"], { cwd: repoDir, signal });
+  if (common.exitCode !== 0) throw new Error("git common directory unavailable");
+  const key = await realpath(resolve(repoDir, common.stdout.trim()));
+  const result = (worktreeQueues.get(key) ?? Promise.resolve()).then(operation);
+  const tail = result.then(() => void 0, () => void 0);
+  worktreeQueues.set(key, tail);
+  try {
+    return await result;
+  } finally {
+    if (worktreeQueues.get(key) === tail) worktreeQueues.delete(key);
+  }
+}
+async function addWorktree(repoDir, opts) {
+  return withWorktreeQueue(repoDir, opts.signal, async () => {
+    const dir = mkdtempSync(join(tmpdir(), "lines-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 withWorktreeQueue(repoDir, opts.signal, () => 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 });
+}
+
+// src/core/feedback.ts
+function normalizeFeedbackSeverity(severity) {
+  return severity ?? "block";
+}
+function findingLine(finding) {
+  const reviewer = finding.reviewer ? `${finding.reviewer} ` : "";
+  const severity = normalizeFeedbackSeverity(finding.severity);
+  const decision = finding.decision ? ` Decision: ${finding.decision}.` : "";
+  const recommendation = finding.recommendation ? ` Recommendation: ${oneLine(finding.recommendation)}` : "";
+  return `- ${reviewer}[${severity}]: ${oneLine(finding.evidence)}${decision}${recommendation}`;
+}
+function defaultReason(findings) {
+  if (!findings?.length) return "Revision requested";
+  if (findings.length === 1) return oneLine(findings[0].evidence);
+  return `${findings.length} findings require another pass`;
+}
+function normalizeRevision(input) {
+  const reason = input.reason?.trim() || defaultReason(input.findings);
+  return {
+    reason,
+    target: input.target,
+    findings: input.findings,
+    rerun: input.rerun ?? (input.target ? "target-and-dependents" : void 0),
+    source: input.source,
+    decision: input.decision
+  };
+}
+function revisionRequest(input, over = {}) {
+  const revision = normalizeRevision(input);
+  return {
+    status: over.status ?? "fail",
+    confidence: over.confidence,
+    summary: over.summary ?? revision.reason,
+    data: over.data,
+    error: over.error,
+    revision
+  };
+}
+function kickback(to, reason, over = {}) {
+  return revisionRequest({ target: to, reason }, over);
+}
+function revisionFromOutcome(outcome) {
+  return outcome.revision;
+}
+function feedbackBlock(outcome) {
+  const revision = revisionFromOutcome(outcome);
+  const parts = [
+    "## Feedback to address",
+    "A review or downstream stage requested another pass. Address this before unrelated work."
+  ];
+  if (revision?.target) parts.push(`Target: ${revision.target}`);
+  if (revision?.source) parts.push(`Source: ${revision.source}`);
+  if (revision?.decision) parts.push(`Caller decision: ${revision.decision}`);
+  const reason = revision?.reason ?? outcome.summary;
+  if (reason) parts.push(`Reason: ${reason}`);
+  const findings = revision?.findings ?? [];
+  if (findings.length) {
+    parts.push("Findings:");
+    parts.push(findings.map(findingLine).join("\n"));
+  }
+  return parts.join("\n\n");
+}
+function graphPositionBlock(graph, reviewerGate) {
+  return [
+    "## Graph position",
+    `DAG: ${graph.dag}`,
+    `Current node: ${graph.node}`,
+    ...graph.desc ? [`Description: ${graph.desc}`] : [],
+    ...reviewerGate ? [`Gate: ${reviewerGate}`] : [],
+    `Path: ${graph.path.join(" > ")}`,
+    `Depends on: ${graph.needs.length ? graph.needs.join(", ") : "none"}`,
+    `Direct dependents: ${graph.dependents.length ? graph.dependents.join(", ") : "none"}`
+  ].join("\n");
+}
+var SHA256_FINGERPRINT = /^[0-9a-f]{64}$/;
+function reviewerCacheIdentity(reviewer, reviewerGate) {
+  const invalidateOn = [...new Set(reviewer.invalidateOn ?? [])].map((path) => path.trim()).filter(Boolean).sort();
+  return createHash("sha256").update(
+    JSON.stringify({
+      name: reviewer.name.trim(),
+      cacheVersion: reviewer.cacheVersion.trim(),
+      kind: "job" in reviewer ? "job" : "review",
+      scope: reviewer.scope ?? null,
+      invalidateOn,
+      reviewerGate: reviewerGate ?? null
+    })
+  ).digest("hex");
+}
+function reviewPassCacheKey(ctx, label) {
+  return `lines:review-panel:${JSON.stringify([...ctx.path, label])}`;
+}
+function reviewPassCache(value) {
+  const cache = {};
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return cache;
+  for (const [name, entry] of Object.entries(value))
+    Object.defineProperty(cache, name, {
+      value: entry,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  return cache;
+}
+function setReviewPass(cache, name, pass) {
+  Object.defineProperty(cache, name, {
+    value: pass,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
+function reusableReviewPass(value, minConfidence2, identity) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const pass = value;
+  return pass.identity === identity && typeof pass.fingerprint === "string" && SHA256_FINGERPRINT.test(pass.fingerprint) && typeof pass.confidence === "number" && Number.isFinite(pass.confidence) && pass.confidence >= minConfidence2 && pass.confidence <= 1;
+}
+var REVIEW_PANEL_DEFAULT_CONCURRENCY = DEFAULT_FANOUT_CONCURRENCY;
+function isReviewInfrastructureError(error) {
+  return isInfrastructureError(error);
+}
+function isReviewBoundaryError(error) {
+  return error?.code === "WRITE_BOUNDARY";
+}
+function findingFromOutput(reviewer, scope, output) {
+  const evidence = output?.trim();
+  if (!evidence) return void 0;
+  return [{ reviewer, severity: "block", scope, evidence }];
+}
+function outputFromInfrastructureError(error) {
+  const cause = error.cause;
+  if (typeof cause !== "object" || cause === null) return void 0;
+  const output = cause.output;
+  return typeof output === "string" ? output : void 0;
+}
+async function runReviewer(reviewer, index, ctx) {
+  const name = reviewer.name ?? `reviewer-${index + 1}`;
+  const reviewerCtx = {
+    ...ctx,
+    reviewerGate: criterionFor(ctx)
+  };
+  try {
+    if ("job" in reviewer) {
+      const outcome = await reviewer.job(reviewerCtx);
+      const outcomeError = outcome.error;
+      if (isReviewInfrastructureError(outcomeError) || isReviewBoundaryError(outcomeError)) {
+        return {
+          kind: "engine-error",
+          name,
+          scope: reviewer.scope,
+          reason: outcome.summary ?? outcomeError.message,
+          error: outcomeError,
+          blocking: isReviewBoundaryError(outcomeError)
+        };
+      }
+      return {
+        kind: "verdict",
+        name,
+        met: outcome.status === "pass",
+        confidence: outcome.confidence,
+        reason: outcome.summary ?? outcome.status,
+        scope: reviewer.scope,
+        findings: revisionFromOutcome(outcome)?.findings
+      };
+    }
+    const result = await toCondition(reviewer.review)(
+      reviewerCtx,
+      ctx.lastOutcome
+    );
+    return {
+      kind: "verdict",
+      name,
+      met: result.met,
+      confidence: result.confidence,
+      reason: result.reason,
+      scope: reviewer.scope,
+      findings: result.met ? void 0 : findingFromOutput(name, reviewer.scope, result.output)
+    };
+  } catch (e) {
+    if (ctx.signal.aborted) throw e;
+    const error = e instanceof LoopError ? e : void 0;
+    if (error && (isReviewInfrastructureError(error) || isReviewBoundaryError(error))) {
+      return {
+        kind: "engine-error",
+        name,
+        scope: reviewer.scope,
+        reason: error.message,
+        error,
+        blocking: isReviewBoundaryError(error),
+        findings: findingFromOutput(
+          name,
+          reviewer.scope,
+          outputFromInfrastructureError(error)
+        )
+      };
+    }
+    return {
+      kind: "verdict",
+      name,
+      met: false,
+      scope: reviewer.scope,
+      reason: `reviewer errored: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+}
+async function runPersistedReviewer(reviewer, index, ctx, cache, minConfidence2) {
+  const name = reviewer.name;
+  const identity = reviewerCacheIdentity(
+    reviewer,
+    criterionFor(ctx)
+  );
+  const before = await workspaceFingerprint({
+    cwd: ctx.workspace.dir,
+    signal: ctx.signal,
+    excludePaths: ctx.fingerprintExcludePaths,
+    includePaths: reviewer.invalidateOn
+  });
+  const cached = cache[name];
+  if (before !== void 0 && reusableReviewPass(cached, minConfidence2, identity) && cached.fingerprint === before) {
+    return {
+      result: {
+        kind: "verdict",
+        name,
+        met: true,
+        confidence: cached.confidence,
+        reason: "reused persisted pass",
+        scope: reviewer.scope
+      },
+      reusedFingerprint: before
+    };
+  }
+  delete cache[name];
+  const result = await runReviewer(reviewer, index, ctx);
+  if (before === void 0 || result.kind !== "verdict" || !result.met || result.confidence === void 0 || !Number.isFinite(result.confidence) || result.confidence < minConfidence2 || result.confidence > 1)
+    return { result };
+  const after = await workspaceFingerprint({
+    cwd: ctx.workspace.dir,
+    signal: ctx.signal,
+    excludePaths: ctx.fingerprintExcludePaths,
+    includePaths: reviewer.invalidateOn
+  });
+  if (after !== void 0 && after === before)
+    setReviewPass(cache, name, {
+      identity,
+      fingerprint: after,
+      confidence: result.confidence
+    });
+  return { result };
+}
+async function settlePersistedReviewers(reviewers, initial, ctx, cache, minConfidence2, concurrency) {
+  const staleIndices = (await mapWithConcurrency(initial, concurrency, async (run, index) => {
+    if (run.reusedFingerprint === void 0) return void 0;
+    const current = await workspaceFingerprint({
+      cwd: ctx.workspace.dir,
+      signal: ctx.signal,
+      excludePaths: ctx.fingerprintExcludePaths,
+      includePaths: reviewers[index].invalidateOn
+    });
+    return current === run.reusedFingerprint ? void 0 : index;
+  })).filter((index) => index !== void 0);
+  for (const index of staleIndices) delete cache[reviewers[index].name];
+  const reruns = await mapWithConcurrency(
+    staleIndices,
+    concurrency,
+    async (index) => ({
+      index,
+      run: await runPersistedReviewer(
+        reviewers[index],
+        index,
+        ctx,
+        cache,
+        minConfidence2
+      )
+    })
+  );
+  const results = initial.map((run) => run.result);
+  for (const { index, run } of reruns) results[index] = run.result;
+  await mapWithConcurrency(results, concurrency, async (result, index) => {
+    if (result.kind !== "verdict" || !result.met) return;
+    const reviewer = reviewers[index];
+    const name = reviewer.name;
+    const cached = cache[name];
+    if (!reusableReviewPass(
+      cached,
+      minConfidence2,
+      reviewerCacheIdentity(
+        reviewer,
+        criterionFor(ctx)
+      )
+    ))
+      return;
+    const current = await workspaceFingerprint({
+      cwd: ctx.workspace.dir,
+      signal: ctx.signal,
+      excludePaths: ctx.fingerprintExcludePaths,
+      includePaths: reviewer.invalidateOn
+    });
+    if (current !== cached.fingerprint) {
+      delete cache[name];
+      results[index] = {
+        ...result,
+        met: false,
+        reason: "review evidence changed during panel"
+      };
+    }
+  });
+  return results;
+}
+function reviewFindings(result) {
+  const findings = result.findings?.length ? result.findings : [
+    {
+      reviewer: result.name,
+      severity: "block",
+      scope: result.scope,
+      evidence: result.reason
+    }
+  ];
+  return findings.map((finding) => ({
+    ...finding,
+    reviewer: finding.reviewer ?? result.name,
+    severity: finding.severity ?? "block",
+    scope: finding.scope ?? result.scope
+  }));
+}
+function isActionableFinding(finding, actionableScopes) {
+  if (!actionableScopes?.length) return true;
+  return !finding.scope || actionableScopes.includes(finding.scope);
+}
+function escalatedFinding(finding) {
+  return { ...finding, decision: "escalated" };
+}
+function findingSeverityCounts(findings) {
+  const counts = {};
+  for (const finding of findings) {
+    const severity = normalizeFeedbackSeverity(finding.severity);
+    counts[severity] = (counts[severity] ?? 0) + 1;
+  }
+  return counts;
+}
+function reviewPanel(config) {
+  const label = config.label ?? "review-panel";
+  if (!config.reviewers.length)
+    throw new LoopError({
+      code: "CONFIG",
+      message: `reviewPanel "${label}": at least one reviewer is required`
+    });
+  if (typeof config.pass === "number" && (!Number.isInteger(config.pass) || config.pass < 1 || config.pass > config.reviewers.length))
+    throw new LoopError({
+      code: "CONFIG",
+      message: `reviewPanel "${label}": pass must be an integer from 1 to ${config.reviewers.length} (got ${config.pass})`
+    });
+  const concurrency = config.concurrency ?? REVIEW_PANEL_DEFAULT_CONCURRENCY;
+  if (!Number.isInteger(concurrency) || concurrency <= 0)
+    throw new LoopError({
+      code: "CONFIG",
+      message: `reviewPanel "${label}": concurrency must be a positive integer`
+    });
+  if (config.persistPasses) {
+    const minConfidence2 = config.persistPasses.minConfidence;
+    if (!Number.isFinite(minConfidence2) || minConfidence2 < 0 || minConfidence2 > 1)
+      throw new LoopError({
+        code: "CONFIG",
+        message: `reviewPanel "${label}": persistPasses.minConfidence must be from 0 to 1`
+      });
+    if (!config.label?.trim())
+      throw new LoopError({
+        code: "CONFIG",
+        message: "reviewPanel persistPasses requires an explicit label"
+      });
+    const names = config.reviewers.map((reviewer) => reviewer.name?.trim());
+    if (names.some((name) => !name))
+      throw new LoopError({
+        code: "CONFIG",
+        message: `reviewPanel "${label}" persistPasses requires every reviewer to have an explicit name`
+      });
+    if (new Set(names).size !== names.length)
+      throw new LoopError({
+        code: "CONFIG",
+        message: `reviewPanel "${label}" persistPasses requires unique reviewer names`
+      });
+    if (config.reviewers.some((reviewer) => !reviewer.cacheVersion?.trim()))
+      throw new LoopError({
+        code: "CONFIG",
+        message: `reviewPanel "${label}" persistPasses requires every reviewer to have an explicit cacheVersion`
+      });
+  }
+  const job = async (ctx) => {
+    ctx.emit({
+      kind: "job:start",
+      ts: Date.now(),
+      path: [...ctx.path],
+      label,
+      timeoutMs: ctx.timeoutMs
+    });
+    const cacheKey = config.persistPasses ? reviewPassCacheKey(ctx, label) : void 0;
+    const cache = cacheKey ? reviewPassCache(ctx.state[cacheKey]) : void 0;
+    if (cache) {
+      const names = new Set(config.reviewers.map((reviewer) => reviewer.name));
+      for (const name of Object.keys(cache))
+        if (!names.has(name)) delete cache[name];
+    }
+    if (cacheKey && cache) ctx.state[cacheKey] = cache;
+    let results;
+    if (cache && config.persistPasses) {
+      const initial = await mapWithConcurrency(
+        config.reviewers,
+        concurrency,
+        (reviewer, i) => runPersistedReviewer(
+          reviewer,
+          i,
+          ctx,
+          cache,
+          config.persistPasses.minConfidence
+        )
+      );
+      results = await settlePersistedReviewers(
+        config.reviewers,
+        initial,
+        ctx,
+        cache,
+        config.persistPasses.minConfidence,
+        concurrency
+      );
+    } else {
+      results = await mapWithConcurrency(
+        config.reviewers,
+        concurrency,
+        (reviewer, i) => runReviewer(reviewer, i, ctx)
+      );
+    }
+    if (cacheKey && cache && !Object.keys(cache).length)
+      delete ctx.state[cacheKey];
+    const verdicts = results.filter(
+      (r) => r.kind === "verdict"
+    );
+    const errors = results.filter(
+      (r) => r.kind === "engine-error"
+    );
+    const blockingErrors = errors.filter((error) => error.blocking);
+    const passedCount = verdicts.filter((r) => r.met).length;
+    const required = config.pass === void 0 || config.pass === "all" ? results.length : config.pass;
+    const rawFindings = [
+      ...verdicts.filter((r) => !r.met).flatMap(reviewFindings),
+      ...errors.flatMap((r) => r.findings ?? [])
+    ];
+    const findings = rawFindings.filter(
+      (f) => isActionableFinding(f, config.actionableScopes)
+    );
+    const escalatedFindings = rawFindings.filter((f) => !isActionableFinding(f, config.actionableScopes)).map(escalatedFinding);
+    const passed2 = blockingErrors.length === 0 && verdicts.length > 0 && passedCount >= required;
+    const summaryHead = `Review panel: ${passedCount}/${results.length} reviewer(s) cleared`;
+    const summaryParts = [`${summaryHead}.`];
+    if (findings.length) summaryParts.push(findings.map(findingLine).join("\n"));
+    if (escalatedFindings.length)
+      summaryParts.push(
+        `Escalated:
+${escalatedFindings.map(findingLine).join("\n")}`
+      );
+    if (errors.length)
+      summaryParts.push(
+        `Engine errors:
+${errors.map((e) => `- ${e.name}: ${oneLine(e.reason)}`).join("\n")}`
+      );
+    const summary = summaryParts.join("\n");
+    const scored = verdicts.map((r) => r.confidence).filter((c) => c != null);
+    const confidence = scored.length ? scored.reduce((sum, c) => sum + c, 0) / scored.length : void 0;
+    const data = {
+      findings,
+      escalatedFindings,
+      errors,
+      results,
+      passed: passedCount,
+      required,
+      severityCounts: findingSeverityCounts(findings)
+    };
+    const blockedByInfrastructure = blockingErrors.length > 0 || errors.length > 0 && (config.pass === void 0 || config.pass === "all" ? true : passedCount < required && passedCount + errors.length >= required);
+    let outcome;
+    if (passed2) {
+      outcome = { status: "pass", summary, confidence, data };
+    } else if (blockedByInfrastructure || !findings.length && errors.length) {
+      const first = errors[0];
+      outcome = {
+        status: "paused",
+        summary,
+        confidence,
+        data,
+        error: first.error ?? new LoopError({
+          code: "ENGINE",
+          phase: "review",
+          message: first.reason
+        })
+      };
+    } else if (!findings.length && escalatedFindings.length) {
+      outcome = { status: "pass", summary, confidence, data };
+    } else {
+      outcome = revisionRequest(
+        {
+          target: config.target,
+          // A clean one-line reason. The findings ride the `findings` array, so
+          // feedbackBlock renders them once (not embedded in the reason too) and
+          // the records/tail `reason` stays a single tidy line. The full
+          // multi-line `summary` is kept on the outcome below for host logs.
+          reason: `${summaryHead}.`,
+          findings,
+          rerun: config.rerun
+        },
+        { summary, confidence, data }
+      );
+    }
+    ctx.emit({ kind: "job:end", ts: Date.now(), path: [...ctx.path], label, outcome });
+    return outcome;
+  };
+  return setMeta(job, {
+    kind: "reviewPanel",
+    name: label,
+    concurrency,
+    actionableScopes: config.actionableScopes
+  });
+}
+async function gitOutput(cwd, args, signal) {
+  const out = await runRuntimeProcess({
+    executable: "git",
+    args,
+    cwd,
+    signal
+  });
+  return processText(out.stdout).trim();
+}
+async function resolveFiles(ctx, patterns) {
+  const fromGit = await gitOutput(
+    ctx.workspace.dir,
+    ["ls-files", "--", ...patterns],
+    ctx.signal
+  ).catch(() => "");
+  const files = fromGit ? fromGit.split("\n").filter(Boolean) : [];
+  if (files.length) return files;
+  return patterns.filter((p) => existsSync(join(ctx.workspace.dir, p)));
+}
+function reviewContext(config) {
+  return async (ctx, last) => {
+    const max = config.maxChars ?? 6e3;
+    const buildTests = async () => {
+      if (!config.tests) return [];
+      if (config.tests === true) {
+        const lines = [];
+        if (last?.status) lines.push(`Last outcome status: ${last.status}`);
+        if (last?.summary) lines.push(`Last outcome summary: ${last.summary}`);
+        if (last?.data !== void 0) {
+          let rendered;
+          try {
+            rendered = JSON.stringify(last.data, null, 2);
+          } catch {
+            rendered = String(last.data);
+          }
+          lines.push(`Last outcome data: ${rendered}`);
+        }
+        return lines.length ? [`## Test and outcome context
+
+${lines.join("\n")}`] : [];
+      }
+      const cwd = config.tests.cwd ?? ctx.workspace.dir;
+      const result = await runRuntimeProcess({
+        executable: config.tests.command,
+        args: config.tests.args ?? [],
+        cwd,
+        signal: ctx.signal
+      }).catch((e) => {
+        if (ctx.signal.aborted) throw e;
+        return void 0;
+      });
+      const exit = result?.exitCode ?? "(command did not run)";
+      const stdout = result === void 0 ? "" : processText(result.stdout);
+      const stderr = result === void 0 ? "" : processText(result.stderr);
+      return [
+        `## Test command
+
+${config.tests.command} ${(config.tests.args ?? []).join(" ")}
+
+exit: ${exit}
+
+stdout:
+${truncate(stdout, max)}
+
+stderr:
+${truncate(stderr, max)}`
+      ];
+    };
+    const buildDiff = async () => {
+      if (!config.diff) return [];
+      const diff2 = await gitOutput(
+        ctx.workspace.dir,
+        ["diff", "HEAD", "--"],
+        ctx.signal
+      ).catch(() => "");
+      return diff2 ? [`## Git diff
+
+${truncate(diff2, max)}`] : [];
+    };
+    const buildFiles = async () => {
+      if (!config.files?.length) return [];
+      const files2 = await resolveFiles(ctx, config.files);
+      const out = [];
+      for (const file of files2) {
+        const path = join(ctx.workspace.dir, file);
+        if (!existsSync(path)) continue;
+        out.push(`## File: ${file}
+
+${truncate(readFileSync(path, "utf8"), max)}`);
+      }
+      return out;
+    };
+    const [tests, diff, files] = await Promise.all([
+      buildTests(),
+      buildDiff(),
+      buildFiles()
+    ]);
+    const sections = [...tests, ...diff, ...files];
+    return truncate(
+      sections.join("\n\n---\n\n") || "(no review context)",
+      max
+    );
+  };
+}
+
+// src/core/job.ts
+var RECORDED_ENGINE_USAGE = "obversa:recorded-engine-usage";
+function recordEngineUsage(ctx, model, path, recordAs) {
+  const records = ctx.state[RECORDED_ENGINE_USAGE];
+  const entry = {
+    model,
+    path: [...path],
+    ...recordAs === void 0 ? {} : { role: recordAs.role, stage: recordAs.stage }
+  };
+  if (records === void 0) {
+    ctx.state[RECORDED_ENGINE_USAGE] = [entry];
+  } else {
+    records.push(entry);
+  }
+}
+var TERMINAL = (text) => ({
+  status: "pass",
+  summary: text.trim().slice(0, 280),
+  data: text
+});
+function advisorInstruction(maxCalls) {
+  return `## Advisor consults
+When you hit a hard design fork, you may request at most ${maxCalls} advisor consult${maxCalls === 1 ? "" : "s"}. Do not shell out to another model. Instead, make your whole reply exactly this block:
+
+<consult_advisor>
+<question>the precise question</question>
+<context>the minimum context the advisor needs</context>
+</consult_advisor>
+
+The runtime will record the consult and return the advisor reply to you.`;
+}
+function withOperationalContext(ctx, userPrompt, config) {
+  const parts = [userPrompt];
+  if (config.consumeFeedback && ctx.lastReview) {
+    parts.push(feedbackBlock(ctx.lastReview));
+  }
+  if (config.graphContext && ctx.graph) {
+    parts.push(graphPositionBlock(ctx.graph, ctx.reviewerGate));
+  }
+  if (config.advisor) parts.push(advisorInstruction(config.advisor.maxCalls ?? 1));
+  return parts.join("\n\n---\n\n");
+}
+function tagValue(text, tag) {
+  const match = new RegExp(`<${tag}>\\s*([\\s\\S]*?)\\s*</${tag}>`, "i").exec(text);
+  return match?.[1]?.trim() || void 0;
+}
+function parseAdvisorRequest(text) {
+  const block = /^\s*<consult_advisor>\s*([\s\S]*?)\s*<\/consult_advisor>\s*$/i.exec(text)?.[1];
+  if (!block) return void 0;
+  const question = tagValue(block, "question") ?? block.trim();
+  if (!question) return void 0;
+  return { question, context: tagValue(block, "context") };
+}
+function advisorFollowup(call, request, reply) {
+  return `Advisor consult #${call}
+
+Question:
+${request.question}
+
+${request.context ? `Context supplied:
+${request.context}
+
+` : ""}Advisor reply:
+${reply}
+
+Continue the original task. Do not ask the same question again.`;
+}
+async function runAdvisorConsult(ctx, label, config, call, request, inherited, redactionEnv) {
+  assertBudget(ctx);
+  const engine = ctx.resolveEngine(config.engine);
+  const result = await engine.run(
+    {
+      prompt: `Question:
+${request.question}` + (request.context ? `
+
+Context:
+${request.context}` : ""),
+      system: config.systemPrompt,
+      model: config.model,
+      maxTokens: config.maxTokens ?? inherited.maxTokens,
+      timeoutMs: config.timeoutMs ?? inherited.timeoutMs,
+      timeoutGraceMs: config.timeoutGraceMs ?? inherited.timeoutGraceMs,
+      cwd: ctx.workspace.dir,
+      leaf: true,
+      attempt: attemptRequestMeta(ctx, `${label}:advisor`)
+    },
+    (event) => {
+      const ts = Date.now();
+      if (event.type === "usage") {
+        ctx.emit({
+          kind: "engine:usage",
+          ts,
+          path: [...ctx.path],
+          model: event.model,
+          usage: event.usage
+        });
+        recordEngineUsage(ctx, event.model, ctx.path);
+      } else if (event.type === "tool") {
+        ctx.emit({
+          kind: "engine:tool",
+          ts,
+          path: [...ctx.path],
+          name: event.name,
+          phase: event.phase
+        });
+      }
+    },
+    ctx.signal
+  );
+  logEngineTransportFailure(ctx, result, redactionEnv);
+  const reply = scrubCapture(
+    requireFinalResultText(result),
+    redactionEnv
+  ).trim();
+  ctx.emit({
+    kind: "advisor:consult",
+    ts: Date.now(),
+    path: [...ctx.path],
+    label,
+    call,
+    question: request.question,
+    reply,
+    model: result.effective.model ?? void 0
+  });
+  return { reply, model: result.effective.model ?? void 0 };
+}
+function agentJob(config) {
+  const job = async (ctx) => {
+    const recordAs = "recordAs" in config ? config.recordAs : void 0;
+    const path = [...ctx.path];
+    const label = config.label ?? config.agent?.name ?? "agent";
+    const defaultTimeoutMs = config.timeoutMs ?? ctx.timeoutMs;
+    const defaultTimeoutGraceMs = config.timeoutGraceMs ?? ctx.timeoutGraceMs;
+    ctx.emit({
+      kind: "job:start",
+      ts: Date.now(),
+      path,
+      label,
+      timeoutMs: defaultTimeoutMs
+    });
+    const userPrompt = typeof config.prompt === "function" ? await config.prompt(ctx) : config.prompt;
+    const contextualPrompt = withOperationalContext(ctx, userPrompt, config);
+    const system = config.system !== void 0 ? typeof config.system === "function" ? config.system(ctx) : config.system : config.agent ? resolveSystem(config.agent) : void 0;
+    const env = resolveEnv(ctx, config.env);
+    const fallbacks = config.fallback ? Array.isArray(config.fallback) ? config.fallback : [config.fallback] : [];
+    const routes = [
+      {
+        engine: config.engine,
+        model: config.model ?? config.agent?.model,
+        timeoutMs: defaultTimeoutMs,
+        timeoutGraceMs: defaultTimeoutGraceMs
+      },
+      ...fallbacks
+    ];
+    const fallbackOn = new Set(
+      config.fallbackOn ?? ["RATE_LIMIT", "QUOTA"]
+    );
+    let result;
+    for (let i = 0; i < routes.length; i += 1) {
+      const route = routes[i];
+      const routeModel = route.model;
+      const timeoutMs = route.timeoutMs ?? defaultTimeoutMs;
+      const timeoutGraceMs = route.timeoutGraceMs ?? defaultTimeoutGraceMs;
+      try {
+        const basePrompt = contextualPrompt;
+        const engine = ctx.resolveEngine(route.engine ?? config.engine);
+        const maxAdvisorCalls = config.advisor?.maxCalls ?? 1;
+        const advisorReplies = [];
+        for (; ; ) {
+          const prompt = advisorReplies.length ? `${basePrompt}
+
+---
+
+${advisorReplies.join("\n\n---\n\n")}` : basePrompt;
+          assertBudget(ctx);
+          result = await engine.run(
+            {
+              prompt,
+              system,
+              model: routeModel,
+              maxTokens: config.maxTokens,
+              tools: config.tools ?? config.agent?.tools,
+              allowedTools: config.allowedTools,
+              workspaceMode: config.workspaceMode,
+              leaf: config.leaf ?? config.agent?.leaf,
+              cwd: config.cwd ?? ctx.workspace.dir,
+              timeoutMs,
+              timeoutGraceMs,
+              env,
+              attempt: attemptRequestMeta(ctx, label)
+            },
+            (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":
+                  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,
+                    ...recordAs
+                  });
+                  recordEngineUsage(ctx, e.model, path, recordAs);
+                  break;
+              }
+            },
+            ctx.signal
+          );
+          logEngineTransportFailure(ctx, result, env);
+          const advisor = config.advisor;
+          const capturedText = scrubCapture(
+            requireFinalResultText(result),
+            env
+          );
+          const consult = advisor ? parseAdvisorRequest(capturedText) : void 0;
+          if (!advisor || !consult) break;
+          if (advisorReplies.length >= maxAdvisorCalls) {
+            throw new LoopError({
+              code: "BUDGET",
+              phase: "body",
+              message: `${label} exceeded advisor consult cap (${maxAdvisorCalls})`
+            });
+          }
+          const call = advisorReplies.length + 1;
+          const { reply } = await runAdvisorConsult(
+            ctx,
+            label,
+            advisor,
+            call,
+            consult,
+            { maxTokens: config.maxTokens, timeoutMs, timeoutGraceMs },
+            env
+          );
+          advisorReplies.push(advisorFollowup(call, consult, reply));
+        }
+        break;
+      } catch (e) {
+        const error = LoopError.from(e, {
+          code: ctx.signal.aborted ? "ABORTED" : "ENGINE",
+          phase: "body",
+          path: ctx.path,
+          iteration: ctx.iteration
+        });
+        if (i < routes.length - 1 && !ctx.signal.aborted && fallbackOn.has(error.code)) {
+          ctx.log(
+            `${label} primary route hit ${error.code}; trying fallback route ${i + 2}`,
+            "warn"
+          );
+          continue;
+        }
+        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 (!result)
+      throw new LoopError({
+        code: "ENGINE",
+        phase: "body",
+        message: `${label} produced no engine result`
+      });
+    const text = scrubCapture(requireFinalResultText(result), env);
+    const outcome = config.outcome ? await config.outcome(text, ctx) : TERMINAL(text);
+    const finalOutcome = result.transportFailure?.kind === "timeout" && outcome.late !== true ? { ...outcome, late: true } : outcome;
+    ctx.emit({
+      kind: "job:end",
+      ts: Date.now(),
+      path,
+      label,
+      outcome: finalOutcome
+    });
+    return finalOutcome;
+  };
+  return setMeta(job, {
+    kind: "agent",
+    name: config.label ?? config.agent?.name ?? "agent",
+    contract: agentContract(config.agent)
+  });
+}
+var OUTCOME_STATUSES = /* @__PURE__ */ new Set(["pass", "fail", "aborted", "exhausted", "paused"]);
+function isOutcome(value) {
+  return typeof value === "object" && value !== null && OUTCOME_STATUSES.has(value.status);
+}
+function describeReturn(value) {
+  if (value === null) return "null";
+  if (typeof value === "object") {
+    return `an object with status ${JSON.stringify(value.status)}`;
+  }
+  return `a ${typeof value}`;
+}
+function fnJob(label, fn) {
+  const job = async (ctx) => {
+    const path = [...ctx.path];
+    ctx.emit({
+      kind: "job:start",
+      ts: Date.now(),
+      path,
+      label,
+      timeoutMs: ctx.timeoutMs
+    });
+    let outcome;
+    try {
+      const returned = await fn(ctx);
+      if (returned === void 0) {
+        outcome = { status: "pass", summary: label };
+      } else if (typeof returned === "string") {
+        outcome = { status: "pass", summary: returned };
+      } else if (isOutcome(returned)) {
+        outcome = returned;
+      } else {
+        throw new LoopError({
+          code: "VALIDATION",
+          message: `fnJob "${label}" returned ${describeReturn(returned)}, which is not an outcome, a string or nothing`
+        });
+      }
+    } 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 });
+}
+function validateProofArtifact(name, artifact) {
+  if (!artifact || typeof artifact !== "object") {
+    throw new LoopError({
+      code: "VALIDATION",
+      message: `prove "${name}" returned no artifact descriptor`
+    });
+  }
+  if (!["html", "image", "markdown", "table", "json"].includes(artifact.kind)) {
+    throw new LoopError({
+      code: "VALIDATION",
+      message: `prove "${name}" returned unsupported kind "${String(artifact.kind)}"`
+    });
+  }
+  const hasPath = typeof artifact.path === "string" && artifact.path.trim() !== "";
+  const hasData = artifact.data !== void 0;
+  if (hasPath === hasData) {
+    throw new LoopError({
+      code: "VALIDATION",
+      message: `prove "${name}" must return exactly one of path or data`
+    });
+  }
+  if (artifact.data !== void 0 && !isJsonValue(artifact.data)) {
+    throw new LoopError({
+      code: "VALIDATION",
+      message: `prove "${name}" data must be JSON-serializable`
+    });
+  }
+  if (artifact.meta !== void 0 && !isJsonValue(artifact.meta)) {
+    throw new LoopError({
+      code: "VALIDATION",
+      message: `prove "${name}" meta must be JSON-serializable`
+    });
+  }
+}
+function isJsonValue(value) {
+  try {
+    cloneFrozenJson(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function prove(name, producer) {
+  const job = async (ctx) => {
+    const path = [...ctx.path];
+    ctx.emit({
+      kind: "job:start",
+      ts: Date.now(),
+      path,
+      label: name,
+      timeoutMs: ctx.timeoutMs
+    });
+    let outcome;
+    try {
+      const artifact = await producer(ctx);
+      validateProofArtifact(name, artifact);
+      if (artifact.path) {
+        const artifactPath = isAbsolute(artifact.path) ? artifact.path : resolve(ctx.workspace.dir, artifact.path);
+        if (!existsSync(artifactPath)) {
+          throw new LoopError({
+            code: "VALIDATION",
+            message: `prove "${name}" path does not exist: ${artifact.path}`
+          });
+        }
+      }
+      ctx.emit({ kind: "proof", ts: Date.now(), path, name, artifact });
+      outcome = {
+        status: "pass",
+        summary: `proof registered: ${artifact.title ?? name}`,
+        data: { proof: artifact }
+      };
+    } catch (e) {
+      const error = LoopError.from(e, {
+        code: "VALIDATION",
+        phase: "body",
+        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: name, outcome });
+    return outcome;
+  };
+  return setMeta(job, { kind: "prove", name });
+}
+
+// src/workflow-agent-response.ts
+var INVALID_TEAM_DECISION = "The engine response was not a valid team decision JSON object.";
+function firstObject(text) {
+  const start = text.indexOf("{");
+  if (start === -1) return void 0;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = start; index < text.length; index += 1) {
+    const character = text[index];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === '"') inString = false;
+      continue;
+    }
+    if (character === '"') inString = true;
+    else if (character === "{") depth += 1;
+    else if (character === "}" && --depth === 0) return text.slice(start, index + 1);
+  }
+  return void 0;
+}
+function parseDecision(text) {
+  const trimmed = text.trim();
+  const object = firstObject(trimmed);
+  if (!object) return void 0;
+  try {
+    const value = JSON.parse(object);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+    const candidate = value;
+    if (candidate.status !== "pass" && candidate.status !== "revise") return void 0;
+    if (typeof candidate.summary !== "string" || !candidate.summary.trim()) return void 0;
+    if (candidate.findings !== void 0 && !Array.isArray(candidate.findings)) return void 0;
+    return {
+      status: candidate.status,
+      summary: candidate.summary,
+      findings: candidate.findings ? [...candidate.findings] : void 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+function outcomeFromAgentText(text, target) {
+  const decision = parseDecision(text);
+  if (!decision) {
+    return {
+      status: "fail",
+      summary: INVALID_TEAM_DECISION,
+      data: { response: text }
+    };
+  }
+  if (decision.status === "pass") {
+    return { status: "pass", summary: decision.summary };
+  }
+  return revisionRequest({
+    target,
+    reason: decision.summary,
+    findings: decision.findings ? [...decision.findings] : void 0
+  });
+}
+
+// src/workflow-support.ts
+function seatIdentity(seat) {
+  const identity = seat.identity;
+  if (!identity || typeof identity.adapter !== "string" || typeof identity.provider !== "string" || typeof identity.modelFamily !== "string" || typeof identity.model !== "string" || !Array.isArray(identity.tools) || !identity.adapter.trim() || !identity.provider.trim() || !identity.model.trim() || !identity.modelFamily.trim()) {
+    throw new TypeError("engine identity must contain adapter, provider, model family, and model");
+  }
+  return identity;
+}
+function assertDistinctSeats(seats) {
+  const identities = seats.map((seat, index) => {
+    try {
+      return seatIdentity(seat);
+    } catch (cause) {
+      const message = cause instanceof Error ? cause.message : "invalid engine identity";
+      throw new TypeError(`seat ${index + 1} has an invalid engine identity: ${message}`, { cause });
+    }
+  });
+  for (let leftIndex = 0; leftIndex < identities.length; leftIndex += 1) {
+    for (let rightIndex = leftIndex + 1; rightIndex < identities.length; rightIndex += 1) {
+      const left = identities[leftIndex];
+      const right = identities[rightIndex];
+      const sameFamily = left.modelFamily === right.modelFamily;
+      if (!sameFamily) continue;
+      throw new TypeError(
+        `seats ${leftIndex + 1} and ${rightIndex + 1} report the same model family ${left.modelFamily}; model family must be distinct per seat`
+      );
+    }
+  }
+}
+function requireNonEmptyFiles(label, job, workspace, files) {
+  return async (ctx) => {
+    const outcome = await job(ctx);
+    if (outcome.status !== "pass") return outcome;
+    for (const file of files) {
+      const path = join(workspace, file);
+      try {
+        const details = await stat(path);
+        if (!details.isFile() || details.size === 0) {
+          return {
+            status: "fail",
+            summary: `${label} did not produce a non-empty file: ${file}`
+          };
+        }
+      } catch {
+        return {
+          status: "fail",
+          summary: `${label} did not produce a non-empty file: ${file}`
+        };
+      }
+    }
+    return outcome;
+  };
+}
+function requireNoFiles(label, job, workspace, files, phase = "review") {
+  const wrapper = async (ctx) => {
+    const before = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      before.set(file, await snapshotFile(join(workspace, file)));
+    }
+    const outcome = await job(ctx);
+    const changed = [];
+    for (const file of files) {
+      const after = await snapshotFile(join(workspace, file));
+      const previous = before.get(file);
+      if (previous.exists !== after.exists || previous.hash !== after.hash) {
+        changed.push(file);
+      }
+    }
+    if (changed.length) {
+      const summary = `${label} wrote, changed or removed the implementation before its step completed: ${changed.join(", ")}`;
+      return {
+        status: "fail",
+        summary,
+        error: new LoopError({ code: "WRITE_BOUNDARY", phase, message: summary })
+      };
+    }
+    return outcome;
+  };
+  return copyJobMeta(wrapper, job);
+}
+async function snapshotFile(path) {
+  try {
+    const details = await stat(path);
+    if (!details.isFile()) return { exists: true, hash: null };
+    const contents = await readFile(path);
+    return { exists: true, hash: createHash("sha256").update(contents).digest("hex") };
+  } catch {
+    return { exists: false, hash: null };
+  }
+}
+function rolePrompt(role, brief) {
+  return [
+    `Obversa team role: ${role}`,
+    `Work brief: ${brief}`,
+    "Work in the supplied cwd."
+  ].join("\n");
+}
+function teamAgent(label, seat, input, instructions, target, decisionFile, workspaceMode = "write", recordAs) {
+  const identity = seatIdentity(seat);
+  if (workspaceMode === "read" && identity.tools.length === 0) {
+    throw new TypeError(`${label} cannot read the workspace: reviewer seat declares no tools`);
+  }
+  const agent = agentJob({
+    label,
+    engine: seat.engine,
+    model: identity.model,
+    tools: [...identity.tools],
+    allowedTools: [...identity.tools],
+    workspaceMode,
+    cwd: input.workspace,
+    consumeFeedback: target !== void 0,
+    ...recordAs === void 0 ? {} : { recordAs },
+    prompt: (ctx) => `${rolePrompt(label, input.brief)}
+${typeof instructions === "function" ? instructions(ctx) : instructions}
+Return one JSON object: {"status":"pass"|"revise","summary":"...","findings":[{"evidence":"..."}]}`,
+    outcome: (text) => outcomeFromAgentText(text, target)
+  });
+  if (!decisionFile) return agent;
+  return async (ctx) => {
+    const path = join(input.workspace, decisionFile);
+    const before = await snapshotFile(path);
+    const replyOutcome = await agent(ctx);
+    const after = await snapshotFile(path);
+    const changed = before.exists !== after.exists || before.hash !== after.hash;
+    if (!changed || !after.exists || after.hash === null) return replyOutcome;
+    try {
+      const fileOutcome = outcomeFromAgentText(await readFile(path, "utf8"), target);
+      return fileOutcome.status === "fail" && fileOutcome.summary === INVALID_TEAM_DECISION ? replyOutcome : fileOutcome;
+    } catch {
+      return replyOutcome;
+    }
+  };
+}
+function panelReviewers(reviewers, input, reviewTarget, recordAs) {
+  return reviewers.map((reviewer) => {
+    const instructions = [
+      `Review target: ${reviewTarget ?? "the supplied files and test evidence"}.`,
+      "Judge only that target against this stage gate; do not require files from another stage.",
+      reviewer.scope ? `Scope: ${reviewer.scope}` : void 0
+    ].filter(Boolean).join("\n");
+    const review = teamAgent(
+      reviewer.name,
+      reviewer.seat,
+      input,
+      instructions,
+      void 0,
+      void 0,
+      "read",
+      recordAs
+    );
+    const retry = teamAgent(
+      reviewer.name,
+      reviewer.seat,
+      input,
+      `${instructions}
+Your previous response was not a valid decision. Return only the required JSON object.`,
+      void 0,
+      void 0,
+      "read",
+      recordAs
+    );
+    const job = async (ctx) => {
+      const first = await review(ctx);
+      if (first.status !== "fail" || first.summary !== INVALID_TEAM_DECISION) return first;
+      const second = await retry(ctx);
+      if (second.status !== "fail" || second.summary !== INVALID_TEAM_DECISION) return second;
+      const summary = `reviewer ${reviewer.name} returned no decision`;
+      return {
+        status: "fail",
+        summary,
+        error: new LoopError({ code: "ENGINE", phase: "review", message: summary })
+      };
+    };
+    return { name: reviewer.name, scope: reviewer.scope, job };
+  });
+}
+
+export { Budget, DEFAULT_FANOUT_CONCURRENCY, INVALID_TEAM_DECISION, LoopError, RECORDED_ENGINE_USAGE, addWorktree, agentCheck, agentJob, all, always, any, approval, assertDistinctSeats, bodyPassed, branchCommits, captureGitWorkspaceSnapshot, childContext, commandJob, commandSucceeds, commit, compareGitWorkspaceSnapshots, copyJobMeta, currentBranch, defineAgent, defineSkill, delegateNodeJob, deleteBranch, describeConditions, failed, fnJob, fromFile, gateJob, gitRoot, hasStagedChanges, headSha, isInfrastructureError, isRepo, jobMeta, kickback, mergeAbort, mergeBranch, mergeNoCommit, minConfidence, needDecisionsOf, never, nodeJobContext, not, outcomeFromAgentText, panelReviewers, passed, predicate, prepareCondition, prove, quorum, removeWorktree, renderPlan, requireNoFiles, requireNonEmptyFiles, resolveEnv, reviewContext, reviewPanel, revisionFromOutcome, revisionRequest, seatIdentity, setLabel, setMeta, stageAll, teamAgent, toCondition, withConditionPreparation, withEnv, workspaceFingerprint };
+//# sourceMappingURL=chunk-DV5P4QLI.js.map
+//# sourceMappingURL=chunk-DV5P4QLI.js.map