@agentskit/harness 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,9 +1,9 @@
-import { resolve, dirname, join, relative, sep } from 'path';
-import { randomUUID, createPrivateKey, createPublicKey, sign, verify, createHash } from 'crypto';
-import { existsSync, mkdirSync, openSync, writeSync, appendFileSync, closeSync, unlinkSync, readFileSync, writeFileSync, mkdtempSync, renameSync, rmSync, lstatSync, readdirSync } from 'fs';
+import { resolve, dirname, join, relative, basename, extname, sep } from 'path';
+import { createHash, randomUUID, createPrivateKey, createPublicKey, sign, verify } from 'crypto';
+import { existsSync, mkdirSync, openSync, writeSync, appendFileSync, closeSync, unlinkSync, readFileSync, writeFileSync, mkdtempSync, renameSync, rmSync, readdirSync } from 'fs';
 import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
-import { tmpdir } from 'os';
+import { cpus, loadavg, freemem, totalmem, tmpdir } from 'os';
 
 // src/constants.ts
 var STATES = [
@@ -23,7 +23,7 @@ var LEGAL_TRANSITIONS = {
   CLARIFYING: ["PLANNED", "BLOCKED", "CANCELLED"],
   PLANNED: ["IMPLEMENTING", "CLARIFYING", "STALE", "CANCELLED"],
   IMPLEMENTING: ["VERIFYING", "CLARIFYING", "STALE", "CANCELLED"],
-  VERIFYING: ["AWAITING_HUMAN_APPROVAL", "BLOCKED", "STALE", "CANCELLED"],
+  VERIFYING: ["AWAITING_HUMAN_APPROVAL", "COMPLETE", "BLOCKED", "STALE", "CANCELLED"],
   AWAITING_HUMAN_APPROVAL: ["AWAITING_AUTHORIZATION", "COMPLETE", "BLOCKED", "IMPLEMENTING", "STALE", "CANCELLED"],
   AWAITING_AUTHORIZATION: ["COMPLETE", "BLOCKED", "IMPLEMENTING", "STALE", "CANCELLED"],
   COMPLETE: ["STALE", "SUPERSEDED"],
@@ -61,9 +61,11 @@ var id = (value, label) => {
 var parents = (value, label) => value === void 0 ? [] : Array.isArray(value) ? value.map((item, index2) => id(item, `${label}[${index2}]`)) : [id(value, label)];
 var merge = (base, overlay) => {
   const result = { ...base };
-  for (const key of ["surfaces", "budget", "cleanup"]) {
+  for (const key of ["surfaces", "budget", "cleanup", "runtime", "verification"]) {
     if (overlay[key] !== void 0) result[key] = { ...isRecord(result[key]) ? result[key] : {}, ...record(overlay[key], `profile.${key}`) };
   }
+  if (overlay["autonomy"] !== void 0) result["autonomy"] = overlay["autonomy"];
+  if (Array.isArray(overlay["checks"])) result["checks"] = overlay["checks"];
   if (overlay["checkOverrides"] !== void 0) {
     if (!Array.isArray(overlay["checkOverrides"])) fail("profile.checkOverrides must be an array.", "INVALID_CONFIG");
     const checks = Array.isArray(result["checks"]) ? [...result["checks"]] : [];
@@ -181,18 +183,20 @@ var surface = (value, name) => {
 var parseCheck = (value, index2) => {
   const record3 = asRecord(value, `checks[${index2}]`);
   const id2 = stringValue(record3["id"], `checks[${index2}].id`);
-  const category = stringValue(record3["category"], `checks[${index2}].category`);
-  if (!CHECK_CATEGORIES.includes(category)) fail(`checks[${index2}].category is invalid.`, "INVALID_CONFIG");
+  const category2 = stringValue(record3["category"], `checks[${index2}].category`);
+  if (!CHECK_CATEGORIES.includes(category2)) fail(`checks[${index2}].category is invalid.`, "INVALID_CONFIG");
   const command = stringValue(record3["command"], `checks[${index2}].command`);
-  if (REAL_CATEGORIES.has(category) && record3["execution"] !== "real") fail(`checks[${index2}] must declare execution: real.`, "INVALID_CONFIG");
+  if (REAL_CATEGORIES.has(category2) && record3["execution"] !== "real") fail(`checks[${index2}] must declare execution: real.`, "INVALID_CONFIG");
   if (record3["evidence"] !== "structured") fail(`checks[${index2}] must declare evidence: structured.`, "INVALID_CONFIG");
   if (record3["capabilities"] !== void 0 && (!Array.isArray(record3["capabilities"]) || !record3["capabilities"].every((item) => typeof item === "string"))) fail(`checks[${index2}].capabilities must be strings.`, "INVALID_CONFIG");
   const capabilities = Array.isArray(record3["capabilities"]) ? record3["capabilities"].filter((item) => typeof item === "string") : void 0;
-  if (category === "ui" && !capabilities?.includes("real-browser")) fail(`checks[${index2}] must declare real-browser.`, "INVALID_CONFIG");
-  if (category === "ui" && !capabilities?.includes("screenshot")) fail(`checks[${index2}] must declare screenshot.`, "INVALID_CONFIG");
+  if (category2 === "ui" && !capabilities?.includes("real-browser")) fail(`checks[${index2}] must declare real-browser.`, "INVALID_CONFIG");
+  if (category2 === "ui" && !capabilities?.includes("screenshot")) fail(`checks[${index2}] must declare screenshot.`, "INVALID_CONFIG");
   if (record3["required"] !== void 0 && typeof record3["required"] !== "boolean") fail(`checks[${index2}].required must be boolean.`, "INVALID_CONFIG");
+  if (record3["required"] === false && typeof record3["reason"] !== "string") fail(`checks[${index2}].reason is required when required is false.`, "INVALID_CONFIG");
   if (record3["timeoutMs"] !== void 0 && (!Number.isInteger(record3["timeoutMs"]) || typeof record3["timeoutMs"] !== "number" || record3["timeoutMs"] < 1)) fail(`checks[${index2}].timeoutMs must be positive.`, "INVALID_CONFIG");
-  return { id: id2, category, command, required: record3["required"] !== false, timeoutMs: typeof record3["timeoutMs"] === "number" ? record3["timeoutMs"] : 12e4, ...record3["execution"] === "real" ? { execution: "real" } : {}, ...capabilities ? { capabilities } : {}, evidence: "structured" };
+  const dependsOn = record3["dependsOn"] === void 0 ? void 0 : stringArray(record3["dependsOn"], `checks[${index2}].dependsOn`);
+  return { id: id2, category: category2, command, required: record3["required"] !== false, ...typeof record3["reason"] === "string" ? { reason: record3["reason"] } : {}, timeoutMs: typeof record3["timeoutMs"] === "number" ? record3["timeoutMs"] : 12e4, ...record3["execution"] === "real" ? { execution: "real" } : {}, ...capabilities ? { capabilities } : {}, ...dependsOn ? { dependsOn: [...new Set(dependsOn)] } : {}, evidence: "structured" };
 };
 var parseOutcome = (value, index2, checks) => {
   const record3 = asRecord(value, `contract.outcomes[${index2}]`);
@@ -206,10 +210,28 @@ var validateConfig = (rawValue) => {
   const raw = resolveProfile(asRecord(rawValue, "verification config"));
   if (raw["schemaVersion"] !== 1) fail("verification config schemaVersion must be 1.", "INVALID_CONFIG");
   const project = stringValue(raw["project"], "verification config project");
+  const runtimeRaw = asRecord(raw["runtime"] ?? { kind: "process" }, "runtime");
+  if (runtimeRaw["kind"] !== "process" && runtimeRaw["kind"] !== "docker") fail("runtime.kind must be process or docker.", "INVALID_CONFIG");
+  const runtime = { kind: runtimeRaw["kind"] };
+  if (raw["autonomy"] !== void 0 && raw["autonomy"] !== "controlled" && raw["autonomy"] !== "yolo") fail("autonomy must be controlled or yolo.", "INVALID_CONFIG");
+  const autonomy = raw["autonomy"] ?? "controlled";
   const contractRaw = asRecord(raw["contract"], "contract");
   const rawChecks = raw["checks"];
   const checks = Array.isArray(rawChecks) ? rawChecks.map(parseCheck) : fail("checks must be a non-empty array.", "INVALID_CONFIG");
   if (!checks.length || new Set(checks.map((check) => check.id)).size !== checks.length) fail("check ids must be unique.", "INVALID_CONFIG");
+  const checkIds = new Set(checks.map((check) => check.id));
+  for (const check of checks) for (const dependency of check.dependsOn ?? []) if (!checkIds.has(dependency) || dependency === check.id) fail(`check ${check.id} has an invalid dependency: ${dependency}.`, "INVALID_CONFIG");
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (id2) => {
+    if (visiting.has(id2)) fail(`check dependency cycle includes ${id2}.`, "INVALID_CONFIG");
+    if (visited.has(id2)) return;
+    visiting.add(id2);
+    for (const dependency of checks.find((check) => check.id === id2)?.dependsOn ?? []) visit(dependency);
+    visiting.delete(id2);
+    visited.add(id2);
+  };
+  for (const check of checks) visit(check.id);
   const scopeRaw = asRecord(contractRaw["scope"], "contract.scope");
   const scope = { inScope: stringArray(scopeRaw["inScope"], "contract.scope.inScope"), outOfScope: stringArray(scopeRaw["outOfScope"], "contract.scope.outOfScope") };
   const ambiguities = stringArray(contractRaw["ambiguities"], "contract.ambiguities");
@@ -226,13 +248,15 @@ var validateConfig = (rawValue) => {
   if (trackingRaw["required"] !== true && typeof trackingRaw["reason"] !== "string") fail("tracking.reason is required when tracking is disabled.", "INVALID_CONFIG");
   const budgetRaw = raw["budget"] === void 0 ? void 0 : asRecord(raw["budget"], "budget");
   if (budgetRaw && budgetRaw["maxDurationMs"] !== void 0 && (!Number.isInteger(budgetRaw["maxDurationMs"]) || typeof budgetRaw["maxDurationMs"] !== "number" || budgetRaw["maxDurationMs"] < 1)) fail("budget.maxDurationMs must be positive.", "INVALID_CONFIG");
+  const verificationRaw = raw["verification"] === void 0 ? void 0 : asRecord(raw["verification"], "verification");
+  if (verificationRaw && verificationRaw["maxConcurrency"] !== void 0 && (!Number.isInteger(verificationRaw["maxConcurrency"]) || typeof verificationRaw["maxConcurrency"] !== "number" || verificationRaw["maxConcurrency"] < 1)) fail("verification.maxConcurrency must be a positive integer.", "INVALID_CONFIG");
   const cleanupRaw = raw["cleanup"] === void 0 ? void 0 : asRecord(raw["cleanup"], "cleanup");
   const cleanup = cleanupRaw ? { roots: cleanupRaw["roots"] === void 0 ? void 0 : stringArray(cleanupRaw["roots"], "cleanup.roots") } : void 0;
   const benchmarkRaw = raw["benchmark"] === void 0 ? void 0 : asRecord(raw["benchmark"], "benchmark");
   const benchmark = benchmarkRaw ? { suiteId: stringValue(benchmarkRaw["suiteId"], "benchmark.suiteId"), taskId: stringValue(benchmarkRaw["taskId"], "benchmark.taskId"), mode: benchmarkRaw["mode"] === "harness" ? "harness" : fail("benchmark.mode must be harness.", "INVALID_CONFIG") } : void 0;
   const contract = { intent: stringValue(contractRaw["intent"], "contract.intent"), scope, ambiguities, outcomes };
   const tracking = { required: trackingRaw["required"] === true, ...typeof trackingRaw["target"] === "string" ? { target: trackingRaw["target"] } : {}, ...typeof trackingRaw["reason"] === "string" ? { reason: trackingRaw["reason"] } : {} };
-  return { schemaVersion: 1, project, ...typeof raw["root"] === "string" ? { root: raw["root"] } : {}, ...typeof raw["stateDir"] === "string" ? { stateDir: raw["stateDir"] } : {}, profile: typeof raw["profile"] === "string" ? raw["profile"] : "strict", contract, surfaces, checks, tracking, ...budgetRaw ? { budget: { maxDurationMs: budgetRaw["maxDurationMs"] } } : {}, ...cleanup ? { cleanup } : {}, ...benchmark ? { benchmark } : {} };
+  return { schemaVersion: 1, project, ...typeof raw["root"] === "string" ? { root: raw["root"] } : {}, ...typeof raw["stateDir"] === "string" ? { stateDir: raw["stateDir"] } : {}, profile: typeof raw["profile"] === "string" ? raw["profile"] : "strict", runtime, autonomy, contract, surfaces, checks, tracking, ...verificationRaw ? { verification: { maxConcurrency: verificationRaw["maxConcurrency"] } } : {}, ...budgetRaw ? { budget: { maxDurationMs: budgetRaw["maxDurationMs"] } } : {}, ...cleanup ? { cleanup } : {}, ...benchmark ? { benchmark } : {} };
 };
 var loadConfig = (configPath = ".codex/verification.json") => {
   const absolute = resolve(configPath);
@@ -240,7 +264,7 @@ var loadConfig = (configPath = ".codex/verification.json") => {
   const rawRecord = asRecord(raw, "verification config");
   const root = resolve(dirname(absolute), typeof rawRecord["root"] === "string" ? rawRecord["root"] : ".");
   const stateDir = resolve(root, typeof rawRecord["stateDir"] === "string" ? rawRecord["stateDir"] : ".codex/verification");
-  if (!pathInside(root, stateDir)) fail("stateDir must be inside the project root.", "INVALID_CONFIG");
+  if (stateDir === root) fail("stateDir must be separate from the project root.", "INVALID_CONFIG");
   const config = validateConfig(raw);
   return { absolute, root, stateDir, config, configHash: hashJson(config) };
 };
@@ -289,7 +313,9 @@ var eventDigest = (event) => sha256(JSON.stringify(eventBody(event)));
 var parseEvent = (value, expectedSequence) => {
   if (typeof value !== "object" || value === null || Array.isArray(value)) fail("Event log contains a non-object record.", "HARNESS_ERROR");
   const record3 = value;
-  if (record3["schemaVersion"] !== HARNESS_EVENT_SCHEMA_VERSION || typeof record3["runId"] !== "string" || typeof record3["sequence"] !== "number" || record3["sequence"] !== expectedSequence || typeof record3["at"] !== "string" || typeof record3["sourceRevision"] !== "string" || typeof record3["configHash"] !== "string" || !isEventType(record3["type"]) || typeof record3["payload"] !== "object" || record3["payload"] === null || record3["sessionId"] !== void 0 && (typeof record3["sessionId"] !== "string" || !record3["sessionId"].trim()) || SESSION_EVENT_TYPES.has(record3["type"]) && typeof record3["sessionId"] !== "string") fail("Event log is invalid or out of order.", "HARNESS_ERROR");
+  const context = record3["correlation"];
+  const validContext = context === void 0 || typeof context === "object" && context !== null && !Array.isArray(context) && Object.entries(context).every(([key, value2]) => ["operationId", "runId", "sessionId", "turnId", "actionId", "traceId"].includes(key) && typeof value2 === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value2)) && typeof context["operationId"] === "string";
+  if (record3["schemaVersion"] !== HARNESS_EVENT_SCHEMA_VERSION || typeof record3["runId"] !== "string" || typeof record3["sequence"] !== "number" || record3["sequence"] !== expectedSequence || typeof record3["at"] !== "string" || typeof record3["sourceRevision"] !== "string" || typeof record3["configHash"] !== "string" || !isEventType(record3["type"]) || typeof record3["payload"] !== "object" || record3["payload"] === null || record3["sessionId"] !== void 0 && (typeof record3["sessionId"] !== "string" || !record3["sessionId"].trim()) || SESSION_EVENT_TYPES.has(record3["type"]) && typeof record3["sessionId"] !== "string" || !validContext) fail("Event log is invalid or out of order.", "HARNESS_ERROR");
   const hasPreviousHash = record3["previousHash"] !== void 0;
   const hasEventHash = record3["eventHash"] !== void 0;
   if (hasPreviousHash !== hasEventHash || hasPreviousHash && (typeof record3["previousHash"] !== "string" || record3["previousHash"] !== EVENT_LOG_GENESIS && !digest(record3["previousHash"]) || typeof record3["eventHash"] !== "string" || !digest(record3["eventHash"]))) fail("Event log integrity metadata is invalid.", "HARNESS_ERROR");
@@ -318,6 +344,7 @@ var FileEventStore = class {
     if (!isEventType(event.type)) fail("Event type is invalid.", "INVALID_INPUT");
     if (SESSION_EVENT_TYPES.has(event.type) && (!event.sessionId || !event.sessionId.trim())) fail("Session events require a sessionId.", "INVALID_INPUT");
     if (event.sessionId !== void 0 && !event.sessionId.trim()) fail("Event sessionId cannot be empty.", "INVALID_INPUT");
+    if (event.correlation !== void 0 && (!event.correlation.operationId || !event.correlation.operationId.trim())) fail("Event correlation operationId is required.", "INVALID_INPUT");
     const path = eventPath(this.stateDir, event.runId);
     const lock = lockPath(this.stateDir, event.runId);
     mkdirSync(join(this.stateDir, "runs", event.runId), { recursive: true });
@@ -332,7 +359,7 @@ var FileEventStore = class {
     try {
       const events = this.readUnlocked(event.runId);
       const previous = events.at(-1);
-      const body2 = { schemaVersion: HARNESS_EVENT_SCHEMA_VERSION, sequence: events.length + 1, at: (/* @__PURE__ */ new Date()).toISOString(), runId: event.runId, sourceRevision: event.sourceRevision, configHash: event.configHash, ...event.sessionId ? { sessionId: event.sessionId } : {}, ...previous?.eventHash ? { previousHash: previous.eventHash } : events.length ? {} : { previousHash: EVENT_LOG_GENESIS }, type: event.type, payload: event.payload };
+      const body2 = { schemaVersion: HARNESS_EVENT_SCHEMA_VERSION, sequence: events.length + 1, at: (/* @__PURE__ */ new Date()).toISOString(), runId: event.runId, sourceRevision: event.sourceRevision, configHash: event.configHash, ...event.correlation ? { correlation: event.correlation } : {}, ...event.sessionId ? { sessionId: event.sessionId } : {}, ...previous?.eventHash ? { previousHash: previous.eventHash } : events.length ? {} : { previousHash: EVENT_LOG_GENESIS }, type: event.type, payload: event.payload };
       const record3 = events.length && !previous?.eventHash ? body2 : { ...body2, eventHash: eventDigest(body2) };
       appendFileSync(path, `${JSON.stringify(record3)}
 `, "utf8");
@@ -578,8 +605,7 @@ var saveRun2 = (stateDir, run) => {
     store.append({ runId: run.runId, sourceRevision: run.sourceRevision, configHash: run.configHash, type: "context.attached", payload: { providerId: snapshot.providerId, sourceHash: snapshot.sourceHash, snapshotHash: snapshot.snapshotHash, query: snapshot.query } });
   }
 };
-var createRun = async ({ loaded, baseline, supersedes, dirtyBaselineAuthorized, contextSnapshots = [], planner = "human" }) => {
-  const contractHash = hashJson(loaded.config.contract);
+var createRun = async ({ loaded, baseline, supersedes, dirtyBaselineAuthorized, contextSnapshots = [] }) => {
   const run = {
     type: "agentskit-harness-run",
     schemaVersion: 1,
@@ -587,17 +613,18 @@ var createRun = async ({ loaded, baseline, supersedes, dirtyBaselineAuthorized,
     project: loaded.config.project,
     state: "PLANNED",
     configHash: loaded.configHash,
-    contractHash,
+    contractHash: hashJson(loaded.config.contract),
     sourceRevision: baseline.revision,
     sourceStatusHash: baseline.statusHash,
     baseline,
-    ...planner === "human" ? { contractApproval: { actor: "human", at: now(), contractHash } } : { contractPreparation: { actor: "ci", at: now(), contractHash } },
-    checks: loaded.config.checks.map(({ id: id2, category }) => ({ id: id2, category, status: "pending" })),
+    autonomy: loaded.config.autonomy,
+    contractApproval: { actor: "human", at: now(), contractHash: hashJson(loaded.config.contract) },
+    checks: loaded.config.checks.map(({ id: id2, category: category2 }) => ({ id: id2, category: category2, status: "pending" })),
     contextSnapshots,
     ...contextSnapshots.length ? { contextHash: hashContextSnapshots(contextSnapshots) } : {},
     ...loaded.config.benchmark ? { benchmark: loaded.config.benchmark } : {},
     outcomes: loaded.config.contract.outcomes.map(({ id: id2, statement, checks }) => ({ id: id2, statement, checks, status: "pending" })),
-    transitions: [{ from: null, to: "PLANNED", at: now(), actor: planner }],
+    transitions: [{ from: null, to: "PLANNED", at: now(), actor: "human" }],
     evidenceReferences: [],
     ...supersedes ? { supersedes } : {},
     ...dirtyBaselineAuthorized ? { dirtyBaselineAuthorized: true } : {}
@@ -650,22 +677,97 @@ var git = async (root, args) => {
 };
 var sourceSnapshot = async (root, stateDir) => {
   const revision = await git(root, ["rev-parse", "HEAD"]);
+  if (!revision) fail("Current-source evidence requires a Git repository with a committed HEAD.", "GIT_REQUIRED");
   const stateRelative = relative(root, stateDir).replaceAll("\\", "/");
   const pathspec = ["--", "."];
   if (stateRelative && stateRelative !== ".." && !stateRelative.startsWith("../")) pathspec.push(`:(exclude)${stateRelative}`);
   const status = await git(root, ["status", "--porcelain=v1", "--untracked-files=all", ...pathspec]);
   const diff = await git(root, ["diff", "--no-ext-diff", "--binary", "HEAD", ...pathspec]);
   const untrackedPaths = (await git(root, ["ls-files", "--others", "--exclude-standard", "-z"])).split("\0").filter(Boolean).filter((path) => !stateRelative || path !== stateRelative && !path.startsWith(`${stateRelative}/`));
-  const untracked = untrackedPaths.flatMap((path) => {
-    const absolute = resolve(root, path);
-    try {
-      return lstatSync(absolute).isFile() ? [{ path, hash: sha256(readFileSync(absolute)) }] : [];
-    } catch {
-      return [];
-    }
-  });
+  const untracked = untrackedPaths.map((path) => ({ path, hash: sha256(readFileSync(resolve(root, path))) }));
   const fingerprint = { revision, status, diff, untracked };
-  return { revision: revision || `content:${hashJson(fingerprint)}`, status, statusHash: hashJson(fingerprint) };
+  return { revision, status, statusHash: hashJson(fingerprint) };
+};
+var thresholds = (value = {}) => {
+  const result = { warningPercent: value.warningPercent ?? 75, criticalPercent: value.criticalPercent ?? 90 };
+  if (![result.warningPercent, result.criticalPercent].every((item) => Number.isFinite(item) && item >= 0 && item <= 100) || result.warningPercent > result.criticalPercent) fail("Machine thresholds must be between 0 and 100 and warning must not exceed critical.", "INVALID_INPUT");
+  return result;
+};
+var linuxSwap = () => {
+  if (process.platform !== "linux" || !existsSync("/proc/meminfo")) return void 0;
+  const values = Object.fromEntries(readFileSync("/proc/meminfo", "utf8").split(/\r?\n/).flatMap((line) => {
+    const match = line.match(/^(SwapTotal|SwapFree):\s+(\d+)\s+kB$/);
+    return match ? [[match[1], Number(match[2])]] : [];
+  }));
+  if (!values["SwapTotal"]) return void 0;
+  return Number(((1 - (values["SwapFree"] ?? 0) / values["SwapTotal"]) * 100).toFixed(2));
+};
+var sampleMachine = () => {
+  const cpus$1 = Math.max(1, cpus().length);
+  const load1 = Math.max(0, loadavg()[0] ?? 0);
+  const memory = Math.max(0, Math.min(100, (1 - freemem() / Math.max(1, totalmem())) * 100));
+  const swapUsedPercent = linuxSwap();
+  return {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    cpus: cpus$1,
+    load1: Number(load1.toFixed(4)),
+    load1PerCpuPercent: Number(Math.min(100, load1 / cpus$1 * 100).toFixed(2)),
+    memoryUsedPercent: Number(memory.toFixed(2)),
+    rssBytes: process.memoryUsage().rss,
+    ...swapUsedPercent === void 0 ? {} : { swapUsedPercent }
+  };
+};
+var summarizeMachine = (samples, sampleIntervalMs = 5e3, limits = {}) => {
+  const limit = thresholds(limits);
+  const load = samples.map((sample) => sample.load1PerCpuPercent);
+  const memory = samples.map((sample) => sample.memoryUsedPercent);
+  const rss = samples.map((sample) => sample.rssBytes);
+  return {
+    sampleIntervalMs,
+    samples,
+    peakLoad1PerCpuPercent: Number(Math.max(...load, 0).toFixed(2)),
+    peakMemoryUsedPercent: Number(Math.max(...memory, 0).toFixed(2)),
+    peakRssBytes: Math.max(...rss, 0),
+    pressureEvents: samples.filter((sample) => sample.load1PerCpuPercent >= limit.criticalPercent || sample.memoryUsedPercent >= limit.criticalPercent || (sample.swapUsedPercent ?? 0) >= limit.criticalPercent || sample.memoryPressure === "critical").length,
+    throttleEvents: 0,
+    minimumEffectiveConcurrency: 0
+  };
+};
+var adaptiveConcurrency = (configured, sample, limits = {}) => {
+  if (!Number.isInteger(configured) || configured < 1) throw new Error("configured concurrency must be a positive integer.");
+  const limit = thresholds(limits);
+  const critical = sample.load1PerCpuPercent >= limit.criticalPercent || sample.memoryUsedPercent >= limit.criticalPercent || (sample.swapUsedPercent ?? 0) >= limit.criticalPercent || sample.memoryPressure === "critical";
+  const warning = sample.load1PerCpuPercent >= limit.warningPercent || sample.memoryUsedPercent >= limit.warningPercent || (sample.swapUsedPercent ?? 0) >= limit.warningPercent || sample.memoryPressure === "warning";
+  if (critical) return 1;
+  if (warning) return Math.min(configured, 2);
+  return configured;
+};
+var createMachineMonitor = (sampleIntervalMs = 5e3, options = {}) => {
+  const sampler = options.sample ?? sampleMachine;
+  const limits = thresholds(options.thresholds);
+  const samples = [sampler()];
+  let throttleEvents = 0;
+  const effectiveConcurrency = [];
+  const record3 = () => {
+    const sample = sampler();
+    samples.push(sample);
+    return sample;
+  };
+  const timer = setInterval(record3, sampleIntervalMs);
+  timer.unref();
+  return {
+    sample: record3,
+    observeConcurrency: (value) => effectiveConcurrency.push(value),
+    markThrottle: () => {
+      throttleEvents += 1;
+    },
+    stop: () => {
+      clearInterval(timer);
+      record3();
+      const summary = summarizeMachine(samples, sampleIntervalMs, limits);
+      return { ...summary, throttleEvents, minimumEffectiveConcurrency: effectiveConcurrency.length ? Math.min(...effectiveConcurrency) : 0 };
+    }
+  };
 };
 
 // src/verification.ts
@@ -694,6 +796,12 @@ var runCommand = (check, cwd) => new Promise((resolveResult) => {
     resolveResult({ exitCode: exitCode ?? 1, timedOut, stdout, stderr, durationMs: Date.now() - started });
   });
 });
+var executeCheck = async (check, cwd, checkDir, outcomes) => {
+  const result = await runCommand(check, cwd);
+  const evidence = parseStructuredEvidence(result.stdout);
+  const failures = result.exitCode === 0 && !result.timedOut && evidence ? validateEvidence(cwd, check, evidence, outcomes) : [result.timedOut ? "check timed out" : result.exitCode !== 0 ? `exit code ${result.exitCode}` : "missing final structured evidence"];
+  return { check: { id: check.id, category: check.category, status: failures.length ? "failed" : "passed", exitCode: result.exitCode, durationMs: result.durationMs, ...evidence ? { evidence } : {}, ...failures.length ? { failures } : {} }, stdout: result.stdout, stderr: result.stderr, durationMs: result.durationMs };
+};
 var currentBinding = async (loaded) => ({ source: await sourceSnapshot(loaded.root, loaded.stateDir), configHash: loaded.configHash });
 var staleRun = (loaded, run, reason) => {
   const stale = transition(run, "STALE", reason);
@@ -706,11 +814,8 @@ var isFresh = async (loaded, run) => {
   return current.configHash === run.configHash && current.source.revision === run.sourceRevision && current.source.statusHash === run.sourceStatusHash;
 };
 var planRun = async ({ configPath, decision, actor = "human", allowDirty = false, contextSnapshots = [] }) => {
-  const automatedPreparation = actor === "ci" && decision === "prepared";
-  if (!automatedPreparation) {
-    assertHuman(actor);
-    if (!approvedDecision(decision)) fail("Contract was not approved.", "CLARIFYING");
-  }
+  assertHuman(actor);
+  if (!approvedDecision(decision)) fail("Contract was not approved.", "CLARIFYING");
   const loaded = loadConfig(configPath);
   if (loaded.config.contract.ambiguities.length) fail(`Unresolved ambiguities remain: ${loaded.config.contract.ambiguities.join(" | ")}`, "CLARIFYING");
   const validatedContextSnapshots = validateContextSnapshots(contextSnapshots);
@@ -722,7 +827,7 @@ ${meaningful.join("\n")}
 Use --allow-dirty only with explicit human authorization.`, "WORKTREE_DIRTY");
   const previous = loadLatestRun(loaded.stateDir);
   if (previous && !["STALE", "SUPERSEDED"].includes(previous.state)) fail(`An active run already exists: ${previous.runId} (${previous.state}).`, "ACTIVE_RUN");
-  return createRun({ loaded, baseline, supersedes: previous?.runId, dirtyBaselineAuthorized: allowDirty, contextSnapshots: validatedContextSnapshots, planner: automatedPreparation ? "ci" : "human" });
+  return createRun({ loaded, baseline, supersedes: previous?.runId, dirtyBaselineAuthorized: allowDirty, contextSnapshots: validatedContextSnapshots });
 };
 var startRun = (loaded) => {
   const run = requireRun(loadLatestRun(loaded.stateDir));
@@ -742,42 +847,81 @@ var cancelRun = async ({ configPath, runId, reason = "Run cancelled by a human."
 };
 var verifyRun = async ({ configPath }) => {
   const loaded = loadConfig(configPath);
+  const machineMonitor = createMachineMonitor();
   const run = requireRun(loadLatestRun(loaded.stateDir));
   if (!["IMPLEMENTING", "VERIFYING"].includes(run.state)) {
     if (["AWAITING_HUMAN_APPROVAL", "AWAITING_AUTHORIZATION", "COMPLETE"].includes(run.state) && !await isFresh(loaded, run)) staleRun(loaded, run, "Run is stale because source or contract changed.");
     fail(`Cannot verify from ${run.state}.`, "INVALID_STATE");
   }
   if (run.configHash !== loaded.configHash) staleRun(loaded, run, "Run is stale because the verification contract changed.");
-  const binding = await currentBinding(loaded);
-  let current = { ...transition(run, "VERIFYING", "Verification started.", "agent"), sourceRevision: binding.source.revision, sourceStatusHash: binding.source.statusHash };
+  const binding2 = await currentBinding(loaded);
+  let current = { ...transition(run, "VERIFYING", "Verification started.", "agent"), sourceRevision: binding2.source.revision, sourceStatusHash: binding2.source.statusHash };
   saveRun2(loaded.stateDir, current);
   const checkDir = join(loaded.stateDir, "runs", current.runId, "checks");
   mkdirSync(checkDir, { recursive: true });
   const outcomesByCheck = new Map(loaded.config.checks.map((check) => [check.id, loaded.config.contract.outcomes.filter((outcome) => outcome.checks.includes(check.id)).map((outcome) => outcome.id)]));
   let totalDurationMs = 0;
-  for (const check of loaded.config.checks) {
-    const result = await runCommand(check, loaded.root);
-    totalDurationMs += result.durationMs;
-    const stdoutPath = join(checkDir, `${check.id}.stdout`);
-    const stderrPath = join(checkDir, `${check.id}.stderr`);
-    writeFileSync(stdoutPath, result.stdout, "utf8");
-    writeFileSync(stderrPath, result.stderr, "utf8");
-    const evidence = parseStructuredEvidence(result.stdout);
-    const failures = result.exitCode === 0 && !result.timedOut && evidence ? validateEvidence(loaded.root, check, evidence, outcomesByCheck.get(check.id) ?? []) : [result.timedOut ? "check timed out" : result.exitCode !== 0 ? `exit code ${result.exitCode}` : "missing final structured evidence"];
-    const nextCheck = { id: check.id, category: check.category, status: failures.length ? "failed" : "passed", exitCode: result.exitCode, durationMs: result.durationMs, ...evidence ? { evidence } : {}, ...failures.length ? { failures } : {} };
-    current = { ...current, evidenceReferences: [...current.evidenceReferences, { checkId: check.id, stdout: relative(loaded.stateDir, stdoutPath), stderr: relative(loaded.stateDir, stderrPath) }], checks: current.checks.map((item) => item.id === check.id ? nextCheck : item) };
-    saveRun2(loaded.stateDir, current);
+  let activeChecks = 0;
+  let observedPeakConcurrency = 0;
+  const verificationStarted = Date.now();
+  const maxConcurrency = loaded.config.verification?.maxConcurrency ?? 1;
+  const requiredChecks = loaded.config.checks.filter((check) => check.required);
+  for (const check of loaded.config.checks.filter((item) => !item.required)) {
+    const nextCheck = { id: check.id, category: check.category, status: "not-applicable", failures: [check.reason ?? "Not required by the selected profile."] };
+    current = { ...current, checks: current.checks.map((item) => item.id === check.id ? nextCheck : item) };
+  }
+  const remaining = new Set(requiredChecks.map((check) => check.id));
+  const completed = new Set(loaded.config.checks.filter((check) => !check.required).map((check) => check.id));
+  while (remaining.size) {
+    const ready = requiredChecks.filter((check) => remaining.has(check.id) && (check.dependsOn ?? []).every((dependency) => completed.has(dependency)));
+    if (!ready.length) fail("Check dependency graph contains an unknown dependency or cycle.", "INVALID_CONFIG");
+    const buildChecks = ready.filter((check) => check.category === "build");
+    const queue = buildChecks.length ? buildChecks : ready;
+    let offset = 0;
+    while (offset < queue.length) {
+      const effectiveConcurrency = buildChecks.length ? 1 : adaptiveConcurrency(maxConcurrency, machineMonitor.sample());
+      machineMonitor.observeConcurrency(effectiveConcurrency);
+      if (effectiveConcurrency < maxConcurrency) machineMonitor.markThrottle();
+      const batch = queue.slice(offset, offset + effectiveConcurrency);
+      const executed = await Promise.all(batch.map(async (check) => {
+        activeChecks += 1;
+        observedPeakConcurrency = Math.max(observedPeakConcurrency, activeChecks);
+        try {
+          return await executeCheck(check, loaded.root, checkDir, outcomesByCheck.get(check.id) ?? []);
+        } finally {
+          activeChecks -= 1;
+        }
+      }));
+      for (const item of executed) {
+        totalDurationMs += item.durationMs;
+        const stdoutPath = join(checkDir, `${item.check.id}.stdout`);
+        const stderrPath = join(checkDir, `${item.check.id}.stderr`);
+        writeFileSync(stdoutPath, item.stdout, "utf8");
+        writeFileSync(stderrPath, item.stderr, "utf8");
+        current = { ...current, evidenceReferences: [...current.evidenceReferences, { checkId: item.check.id, stdout: relative(loaded.stateDir, stdoutPath), stderr: relative(loaded.stateDir, stderrPath) }], checks: current.checks.map((check) => check.id === item.check.id ? item.check : check) };
+      }
+      saveRun2(loaded.stateDir, current);
+      for (const check of batch) {
+        remaining.delete(check.id);
+        completed.add(check.id);
+      }
+      offset += batch.length;
+    }
   }
   const statuses = new Map(current.checks.map((check) => [check.id, check.status]));
   const budgetExceeded = loaded.config.budget?.maxDurationMs !== void 0 && totalDurationMs > loaded.config.budget.maxDurationMs;
-  const allPassed = loaded.config.checks.every((check) => statuses.get(check.id) === "passed") && !budgetExceeded;
-  current = { ...current, outcomes: current.outcomes.map((outcome) => ({ ...outcome, status: outcome.checks.every((id2) => statuses.get(id2) === "passed") ? "passed" : "failed" })), metrics: { totalDurationMs, budgetExceeded } };
-  const digest2 = verificationDigest(current);
-  current = { ...current, verificationDigest: digest2 };
+  const allPassed = loaded.config.checks.every((check) => !check.required || statuses.get(check.id) === "passed") && !budgetExceeded;
+  current = { ...current, outcomes: current.outcomes.map((outcome) => {
+    const required15 = outcome.checks.filter((id2) => loaded.config.checks.find((check) => check.id === id2)?.required);
+    return { ...outcome, status: required15.length === 0 ? "not-applicable" : required15.every((id2) => statuses.get(id2) === "passed") ? "passed" : "failed" };
+  }), metrics: { totalDurationMs, wallDurationMs: Date.now() - verificationStarted, peakConcurrency: observedPeakConcurrency, budgetExceeded, machine: machineMonitor.stop() } };
+  const digest3 = verificationDigest(current);
+  current = { ...current, verificationDigest: digest3 };
   saveRun2(loaded.stateDir, current);
-  new FileEventStore(loaded.stateDir).append({ runId: current.runId, sourceRevision: current.sourceRevision, configHash: current.configHash, type: "verification.completed", payload: { verificationDigest: digest2, checkCount: current.checks.length, outcomeCount: current.outcomes.length, totalDurationMs, budgetExceeded } });
-  const nextState = allPassed ? "AWAITING_HUMAN_APPROVAL" : "BLOCKED";
-  current = { ...transition(current, nextState, allPassed ? "All configured checks passed; human approval is required." : budgetExceeded ? "Verification budget was exceeded." : "A configured check failed or lacked structured evidence.", "harness") };
+  new FileEventStore(loaded.stateDir).append({ runId: current.runId, sourceRevision: current.sourceRevision, configHash: current.configHash, type: "verification.completed", payload: { verificationDigest: digest3, checkCount: current.checks.length, outcomeCount: current.outcomes.length, totalDurationMs, budgetExceeded } });
+  const automatic = allPassed && current.autonomy === "yolo" && !loaded.config.tracking.required && loaded.config.contract.ambiguities.length === 0;
+  const nextState = allPassed ? automatic ? "COMPLETE" : "AWAITING_HUMAN_APPROVAL" : "BLOCKED";
+  current = { ...transition(current, nextState, automatic ? "All applicable checks passed; YOLO policy permits automatic completion." : allPassed ? "All configured checks passed; human approval is required." : budgetExceeded ? "Verification budget was exceeded." : "A configured check failed or lacked structured evidence.", "harness") };
   saveRun2(loaded.stateDir, current);
   setLatest(loaded.stateDir, current);
   return current;
@@ -791,11 +935,6 @@ var assertVerificationAttestation = (loaded, run) => {
   const event = new FileEventStore(loaded.stateDir).read(run.runId).filter((item) => item.type === "verification.completed").at(-1);
   if (!event || event.payload.verificationDigest !== expected || event.sourceRevision !== run.sourceRevision || event.configHash !== run.configHash) fail("Verification projection attestation is missing from the event log.", "HARNESS_ERROR");
 };
-var plannerForRetry = (loaded, run) => {
-  if (run.contractPreparation) return "ci";
-  if (!run.supersedes) return "human";
-  return plannerForRetry(loaded, readRun(loaded.stateDir, run.supersedes));
-};
 var recordDecision = (loaded, run, type, payload) => {
   new FileEventStore(loaded.stateDir).append({ runId: run.runId, sourceRevision: run.sourceRevision, configHash: run.configHash, type, payload: type === "authorization.recorded" ? { ...payload, target: payload.target ?? fail("tracking.target is required when authorizing.", "INVALID_CONFIG") } : payload });
 };
@@ -815,7 +954,7 @@ var reconcileRun = async ({ configPath, runId }) => {
     if (eventLog.status !== "verified") fail("Terminal run requires a verified event log.", "HARNESS_ERROR");
     assertVerificationAttestation(loaded, run);
   }
-  if (run.state === "AWAITING_AUTHORIZATION" || run.state === "COMPLETE") {
+  if ((run.state === "AWAITING_AUTHORIZATION" || run.state === "COMPLETE") && run.autonomy !== "yolo") {
     const approval = events.filter((event) => event.type === "approval.recorded").at(-1) ?? fail("Terminal run is missing its human approval event.", "HARNESS_ERROR");
     assertDecisionProjection(run, approval.payload, run.state === "COMPLETE" && !loaded.config.tracking.required ? "COMPLETE" : "AWAITING_AUTHORIZATION");
     if (!run.humanApproval || run.humanApproval.actor !== "human" || run.humanApproval.verificationDigest !== run.verificationDigest || run.humanApproval.sourceRevision !== run.sourceRevision || run.humanApproval.contractHash !== run.contractHash) fail("Human approval projection is inconsistent with its audit event.", "HARNESS_ERROR");
@@ -877,7 +1016,7 @@ var retryRun = async ({ configPath }) => {
   const baseline = await sourceSnapshot(loaded.root, loaded.stateDir);
   const superseded = transition(previousRun, "SUPERSEDED", "Retry superseded the previous run.", "harness");
   saveRun2(loaded.stateDir, superseded);
-  const run = await createRun({ loaded, baseline, supersedes: previousRun.runId, dirtyBaselineAuthorized: previousRun.dirtyBaselineAuthorized, planner: plannerForRetry(loaded, previousRun) });
+  const run = await createRun({ loaded, baseline, supersedes: previousRun.runId, dirtyBaselineAuthorized: previousRun.dirtyBaselineAuthorized });
   const next = transition(run, "IMPLEMENTING", "Retry started after a previous attempt.", "agent");
   saveRun2(loaded.stateDir, next);
   setLatest(loaded.stateDir, next);
@@ -904,13 +1043,543 @@ var createDocBridgeContextProvider = ({ root, indexPath = ".doc-bridge/index.jso
     return { providerId: "doc-bridge", query, references, sourceHash: contentHash, snapshotHash: hashContextSnapshot({ providerId: "doc-bridge", query, references, sourceHash: contentHash }), resolvedAt: (/* @__PURE__ */ new Date()).toISOString() };
   }
 });
+
+// src/discovery.ts
+var required = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var unique = (values, label) => {
+  if (new Set(values).size !== values.length) fail(`${label} must be unique.`, "INVALID_INPUT");
+};
+var validate = (input) => {
+  required(input.issueId, "issueId");
+  required(input.sourceRevision, "sourceRevision");
+  required(input.contractHash, "contractHash");
+  if (!Array.isArray(input.ambiguities)) fail("ambiguities must be an array.", "INVALID_INPUT");
+  unique(input.ambiguities.map((item) => required(item.id, "ambiguity.id")), "ambiguity ids");
+  const assumptions = /* @__PURE__ */ new Map();
+  for (const assumption of input.approvedAssumptions ?? []) {
+    const id2 = required(assumption.id, "assumption.id");
+    if (assumptions.has(id2)) fail("assumption ids must be unique.", "INVALID_INPUT");
+    assumptions.set(id2, { id: id2, policyId: required(assumption.policyId, "assumption.policyId"), resolution: required(assumption.resolution, "assumption.resolution") });
+  }
+  for (const ambiguity of input.ambiguities) {
+    required(ambiguity.question, "ambiguity.question");
+    if (typeof ambiguity.material !== "boolean") fail("ambiguity.material must be boolean.", "INVALID_INPUT");
+    if (!Array.isArray(ambiguity.options) || ambiguity.options.length < 2 || ambiguity.options.length > 4) fail("ambiguity.options must contain 2 to 4 options.", "INVALID_INPUT");
+    unique(ambiguity.options.map((option) => required(option.id, "option.id")), "option ids");
+    for (const option of ambiguity.options) {
+      required(option.summary, "option.summary");
+      required(option.impact, "option.impact");
+    }
+    if (!ambiguity.options.some((option) => option.id === ambiguity.recommendedOptionId)) fail("recommendedOptionId must identify an option.", "INVALID_INPUT");
+    if (!ambiguity.material && (!ambiguity.assumptionId || !assumptions.has(ambiguity.assumptionId))) fail("non-material ambiguity requires an approved assumption.", "INVALID_INPUT");
+  }
+  return { assumptions };
+};
+var digest2 = (result) => hashJson(result);
+var assessDiscovery = (input) => {
+  const { assumptions } = validate(input);
+  const human = input.ambiguities.filter((ambiguity) => ambiguity.material);
+  const decisionLog = input.ambiguities.map((ambiguity) => {
+    if (ambiguity.material) return { ambiguityId: ambiguity.id, kind: "human-decision-required", detail: `Recommendation: ${ambiguity.recommendedOptionId}.` };
+    const assumption = assumptions.get(ambiguity.assumptionId);
+    return { ambiguityId: ambiguity.id, kind: "approved-assumption", detail: assumption.resolution, policyId: assumption.policyId };
+  });
+  const base = {
+    version: 1,
+    issueId: input.issueId,
+    sourceRevision: input.sourceRevision,
+    contractHash: input.contractHash,
+    ...input.contextHash ? { contextHash: input.contextHash } : {},
+    status: human.length ? "awaiting-decision" : "ready",
+    ...human.length ? { packet: {
+      issueId: input.issueId,
+      contractHash: input.contractHash,
+      sourceRevision: input.sourceRevision,
+      ...input.contextHash ? { contextHash: input.contextHash } : {},
+      decisions: human.map((ambiguity) => ({ id: ambiguity.id, question: ambiguity.question, options: ambiguity.options, recommendedOptionId: ambiguity.recommendedOptionId }))
+    } } : {},
+    decisionLog
+  };
+  return { ...base, digest: digest2(base) };
+};
+var isDiscoveryCurrent = (result, current) => {
+  const reasons = [];
+  if (result.sourceRevision !== current.sourceRevision) reasons.push("source");
+  if (result.contractHash !== current.contractHash) reasons.push("contract");
+  if ((result.contextHash ?? "") !== (current.contextHash ?? "")) reasons.push("context");
+  return { current: reasons.length === 0, reasons };
+};
+
+// src/wip.ts
+var WIP_STATES = ["ready", "implementing", "blocked", "awaiting-decision", "awaiting-acceptance", "done", "cancelled"];
+var terminal = /* @__PURE__ */ new Set(["done", "cancelled"]);
+var required2 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var assessWip = ({ entries, candidate, maxInFlight = 3 }) => {
+  if (!Array.isArray(entries)) fail("entries must be an array.", "INVALID_INPUT");
+  if (!Number.isInteger(maxInFlight) || maxInFlight < 1) fail("maxInFlight must be a positive integer.", "INVALID_INPUT");
+  const candidateId = required2(candidate.issueId, "candidate.issueId");
+  if (candidate.kind !== "new" && candidate.kind !== "resume") fail("candidate.kind must be new or resume.", "INVALID_INPUT");
+  const ids = /* @__PURE__ */ new Set();
+  const counts = Object.fromEntries(WIP_STATES.map((state) => [state, 0]));
+  for (const entry of entries) {
+    const id2 = required2(entry.issueId, "entry.issueId");
+    if (ids.has(id2)) fail("entry issueIds must be unique.", "INVALID_INPUT");
+    ids.add(id2);
+    if (!WIP_STATES.includes(entry.state)) fail(`Unknown WIP state: ${entry.state}.`, "INVALID_INPUT");
+    counts[entry.state] += 1;
+  }
+  const inFlight = entries.filter((entry) => !terminal.has(entry.state));
+  const existing = entries.find((entry) => entry.issueId === candidateId);
+  if (candidate.kind === "resume") {
+    if (!existing || terminal.has(existing.state)) return { decision: "hold", inFlight, counts, reason: "A resume requires an existing non-terminal issue." };
+    return { decision: "admit", inFlight, counts, reason: "A resume keeps its existing WIP reservation and takes priority over new work." };
+  }
+  if (existing) return { decision: "hold", inFlight, counts, reason: "A new admission cannot reuse an existing issue id." };
+  if (inFlight.length >= maxInFlight) return { decision: "hold", inFlight, counts, reason: `WIP limit ${maxInFlight} reached; blocked and awaiting-human work still count.` };
+  return { decision: "admit", inFlight, counts, reason: `WIP slot available (${inFlight.length}/${maxInFlight}).` };
+};
+
+// src/experiment.ts
+var required3 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var comparable = (candidate, baseline) => {
+  for (const key of ["sourceRevision", "contractHash", "provider", "model", "configurationHash"]) {
+    if (candidate[key] !== baseline[key]) fail(`Candidates must share ${key}.`, "INVALID_INPUT");
+  }
+};
+var selectRuntime = (candidates) => {
+  if (!Array.isArray(candidates) || candidates.length < 2) fail("At least two runtime candidates are required.", "INVALID_INPUT");
+  const names = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const runtime = required3(candidate.runtime, "candidate.runtime");
+    if (names.has(runtime)) fail("candidate.runtime values must be unique.", "INVALID_INPUT");
+    names.add(runtime);
+    for (const key of ["sourceRevision", "contractHash", "provider", "model", "configurationHash"]) required3(candidate[key], `candidate.${key}`);
+    for (const key of ["humanMinutes", "durationMs", "cost"]) if (!Number.isFinite(candidate[key]) || candidate[key] < 0) fail(`candidate.${key} must be a non-negative number.`, "INVALID_INPUT");
+    comparable(candidate, candidates[0]);
+  }
+  const eligible = candidates.filter((candidate) => candidate.hardGatesPassed);
+  if (!eligible.length) return { decision: "blocked", eligible, reason: "No runtime passed every hard gate." };
+  const selected = [...eligible].sort((left, right) => left.humanMinutes - right.humanMinutes || left.durationMs - right.durationMs || left.cost - right.cost || (left.runtime === "orca" ? -1 : right.runtime === "orca" ? 1 : left.runtime.localeCompare(right.runtime)))[0];
+  return { decision: "selected", selected, eligible, reason: "Selected by human minutes, duration, cost, then Orca tie-break." };
+};
+
+// src/delivery.ts
+var required4 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var criteriaFor = (criteria, gate) => {
+  if (!Array.isArray(criteria)) fail("criteria must be an array.", "INVALID_INPUT");
+  const ids = /* @__PURE__ */ new Set();
+  for (const criterion of criteria) {
+    const id2 = required4(criterion.id, "criterion.id");
+    if (ids.has(id2)) fail("criterion ids must be unique.", "INVALID_INPUT");
+    ids.add(id2);
+    if (!["G2", "G3", "G4", "G5"].includes(criterion.gate)) fail("criterion.gate is invalid.", "INVALID_INPUT");
+    if (!["passed", "failed", "pending", "not-applicable"].includes(criterion.status)) fail("criterion.status is invalid.", "INVALID_INPUT");
+    if (criterion.status === "not-applicable" && !criterion.reason?.trim()) fail("not-applicable criteria require a reason.", "INVALID_INPUT");
+  }
+  return criteria.filter((criterion) => criterion.gate === gate);
+};
+var binding = (value) => ({ candidateRevision: required4(value.candidateRevision, "binding.candidateRevision"), contractHash: required4(value.contractHash, "binding.contractHash"), configHash: required4(value.configHash, "binding.configHash") });
+var assessed = (gate, decision, reasons, current) => {
+  const base = { gate, decision, reasons, binding: binding(current) };
+  return { ...base, digest: hashJson(base) };
+};
+var assessPreflight = ({ criteria, repairAttempts = 0, implementerId, reviewerId, reviewKind, reviewApproved, binding: current }) => {
+  required4(implementerId, "implementerId");
+  if (!Number.isInteger(repairAttempts) || repairAttempts < 0) fail("repairAttempts must be a non-negative integer.", "INVALID_INPUT");
+  const g2 = criteriaFor(criteria, "G2");
+  const reasons = [
+    ...g2.length ? [] : ["No G2 criteria are defined."],
+    ...g2.filter((criterion) => criterion.status === "failed" || criterion.status === "pending").map((criterion) => `${criterion.id} is ${criterion.status}.`),
+    ...reviewApproved && reviewerId && reviewerId !== implementerId && reviewKind === "adversarial" ? [] : ["An approved adversarial review by a reviewer different from the implementer is required."],
+    ...repairAttempts <= 2 ? [] : ["The two-repair limit was exceeded; preserve diagnostics and return blocked."]
+  ];
+  return assessed("G2", reasons.length ? "blocked" : "approved", reasons, current);
+};
+var composePullRequest = ({ draft, g2, remote }) => {
+  for (const [label, value] of Object.entries({ issueId: draft.issueId, candidateRevision: draft.candidateRevision, contractHash: draft.contractHash, configHash: draft.configHash, g2Digest: draft.g2Digest, risk: draft.risk, rollback: draft.rollback })) required4(value, `draft.${label}`);
+  if (g2.gate !== "G2" || g2.decision !== "approved" || g2.digest !== draft.g2Digest || g2.binding.candidateRevision !== draft.candidateRevision || g2.binding.contractHash !== draft.contractHash || g2.binding.configHash !== draft.configHash) return { decision: "blocked", reason: "A current approved G2 assessment is required before a PR can be created.", idempotencyKey: hashJson(draft) };
+  const idempotencyKey = hashJson({ issueId: draft.issueId, contractHash: draft.contractHash, action: "pull-request", revision: draft.candidateRevision });
+  if (remote?.state === "uncertain") return { decision: "blocked", reason: "Remote PR state is uncertain; reconcile before retrying.", idempotencyKey };
+  if (remote?.state === "confirmed") {
+    if (remote.candidateRevision !== draft.candidateRevision || !remote.url) return { decision: "blocked", reason: "Confirmed remote PR does not match the candidate revision.", idempotencyKey };
+    return { decision: "reuse", reason: "The idempotent remote PR already exists for this candidate revision.", idempotencyKey };
+  }
+  const body2 = [`## Contract`, `- Issue: ${draft.issueId}`, `- Candidate: ${draft.candidateRevision}`, `- Contract: ${draft.contractHash}`, `- Configuration: ${draft.configHash}`, "", "## G2 evidence", ...draft.evidence.map((item) => `- ${item}`), "", "## Documentation", ...draft.documentation.map((item) => `- ${item}`), "", "## Risk and rollback", `- Risk: ${draft.risk}`, `- Rollback: ${draft.rollback}`, "", "## Later gates", ...draft.pendingCriteria.length ? draft.pendingCriteria.map((item) => `- Pending: ${item}`) : ["- None."]].join("\n");
+  return { decision: "create", body: body2, reason: "G2 is current and the remote PR is absent.", idempotencyKey };
+};
+var assessIntegration = ({ g2, candidateRevision, evidenceRevision, contractHash, configHash, ci }) => {
+  required4(candidateRevision, "candidateRevision");
+  required4(evidenceRevision, "evidenceRevision");
+  if (!["passed", "failed", "pending", "not-applicable"].includes(ci)) fail("ci is invalid.", "INVALID_INPUT");
+  const reasons = [
+    ...g2.gate === "G2" && g2.decision === "approved" ? [] : ["G2 is not approved."],
+    ...g2.binding.candidateRevision === candidateRevision && g2.binding.contractHash === contractHash && g2.binding.configHash === configHash ? [] : ["G2 is not bound to the current candidate, contract, and configuration."],
+    ...candidateRevision === evidenceRevision ? [] : ["Candidate revision changed; G3 evidence must be revalidated."],
+    ...ci === "passed" ? [] : [`Integration CI is ${ci}.`]
+  ];
+  return assessed("G3", reasons.length ? "blocked" : "approved", reasons, { candidateRevision, contractHash, configHash });
+};
+var assessWorktreeCleanup = ({ branch, candidateRevision, contractHash, configHash, remoteBranchRevision, remotePr, integration }) => {
+  required4(branch, "branch");
+  required4(candidateRevision, "candidateRevision");
+  if (remotePr === "uncertain") return { decision: "preserve", reason: "Remote PR state is uncertain; preserve the worktree for reconciliation." };
+  if (remotePr !== "confirmed") return { decision: "preserve", reason: "No confirmed remote PR exists; preserve the worktree." };
+  if (remoteBranchRevision !== candidateRevision) return { decision: "preserve", reason: "Remote branch SHA does not match the candidate revision." };
+  if (integration.gate !== "G3" || integration.decision !== "approved") return { decision: "preserve", reason: "G3 is not approved." };
+  if (integration.binding.candidateRevision !== candidateRevision || integration.binding.contractHash !== contractHash || integration.binding.configHash !== configHash) return { decision: "preserve", reason: "G3 is not bound to the current candidate, contract, and configuration." };
+  return { decision: "clean", reason: "Remote branch, PR, and G3 evidence are confirmed for the candidate revision." };
+};
+var profileReasons = (profile) => Object.entries(profile).flatMap(([key, value]) => Array.isArray(value) ? value.length ? [] : [`RepositoryProfile.${key} is required.`] : typeof value === "string" && value.trim() ? [] : [`RepositoryProfile.${key} is required.`]);
+var assessProduction = ({ profile, integration, artifact, isolated, acceptanceArtifact, lowRisk = true, observationMinutes, technicalPassed, evidence, containmentPreauthorized, containmentAction, linkedDefect }) => {
+  required4(artifact, "artifact");
+  if (!Number.isFinite(observationMinutes) || observationMinutes < 0) fail("observationMinutes must be non-negative.", "INVALID_INPUT");
+  const evidenceReasons = [required4(evidence.tenant, "evidence.tenant"), required4(evidence.realFlow, "evidence.realFlow"), ...Array.isArray(evidence.logs) && evidence.logs.length ? [] : ["Production evidence requires logs."], ...Array.isArray(evidence.metrics) && evidence.metrics.length ? [] : ["Production evidence requires metrics."]].filter((item) => item.startsWith("Production evidence"));
+  const reasons = [
+    ...profileReasons(profile),
+    ...integration.gate === "G3" && integration.decision === "approved" ? [] : ["G3 is not approved."],
+    ...evidenceReasons,
+    ...isolated || acceptanceArtifact === artifact ? [] : ["Exposure requires isolation or acceptance linked to this artifact version."],
+    ...technicalPassed ? [] : [containmentPreauthorized && containmentAction?.trim() && linkedDefect?.trim() ? "Technical validation failed; pre-authorized containment and linked defect are recorded." : containmentPreauthorized ? "Technical validation failed; containment action and linked defect are required." : "Technical validation failed."],
+    ...lowRisk && observationMinutes < 15 ? ["Low-risk production validation requires a 15-minute observation window."] : []
+  ];
+  return assessed("G4", reasons.length ? "blocked" : "approved", reasons, integration.binding);
+};
+var assessAcceptance = ({ production, acceptanceRequired, accepted, notApplicableReason, materialChange }) => {
+  const reasons = [
+    ...production.gate === "G4" && production.decision === "approved" ? [] : ["G4 is not approved."],
+    ...materialChange ? ["A material change invalidated acceptance; return to the affected gate."] : []
+  ];
+  if (reasons.length) return assessed("G5", "blocked", reasons, production.binding);
+  if (acceptanceRequired && !accepted) return assessed("G5", "awaiting-acceptance", ["Business or UX acceptance is still required."], production.binding);
+  if (!acceptanceRequired && !notApplicableReason?.trim()) return assessed("G5", "blocked", ["Acceptance marked not applicable requires a contractual reason."], production.binding);
+  return assessed("G5", "approved", acceptanceRequired ? [] : [`Acceptance is not applicable: ${notApplicableReason}.`], production.binding);
+};
+
+// src/pilot.ts
+var required5 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var assessPilot = (manifest) => {
+  required5(manifest.policyHash, "policyHash");
+  required5(manifest.baselineReference, "baselineReference");
+  if (!Array.isArray(manifest.entries)) fail("entries must be an array.", "INVALID_INPUT");
+  const ids = /* @__PURE__ */ new Set();
+  const reasons = [];
+  const included = [];
+  for (const entry of manifest.entries) {
+    const issueId = required5(entry.issueId, "entry.issueId");
+    if (ids.has(issueId)) fail("entry issueIds must be unique; an issue cannot be substituted in the same pilot.", "INVALID_INPUT");
+    ids.add(issueId);
+    if (!["normal", "incident", "sensitive"].includes(entry.classification)) fail("entry.classification is invalid.", "INVALID_INPUT");
+    if (!["included", "excluded", "aborted"].includes(entry.status)) fail("entry.status is invalid.", "INVALID_INPUT");
+    if (entry.status !== "included" && !entry.reason?.trim()) reasons.push(`${issueId} is ${entry.status} without an auditable reason.`);
+    if (entry.status === "included") {
+      included.push(issueId);
+      if (entry.classification !== "normal") reasons.push(`${issueId} is ${entry.classification}; only normal issues can enter the pilot.`);
+    }
+  }
+  if (included.length !== 10) reasons.push(`Pilot requires exactly 10 included issues; found ${included.length}.`);
+  const base = { decision: reasons.length ? "blocked" : "ready", included, reasons };
+  return { ...base, digest: hashJson({ ...manifest, ...base }) };
+};
+var IMPROVEMENT_CYCLE_STEPS = ["adversarial-review", "g2-preflight", "baseline-record", "pilot-execution", "comparison"];
+var nonEmpty = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) return fail(`${label} must be a non-empty string.`, "INVALID_INPUT");
+  return value.trim();
+};
+var validateMetrics = (metrics, index2) => {
+  if (metrics === void 0) return void 0;
+  for (const [key, value] of Object.entries(metrics)) {
+    if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value) || value < 0)) return fail(`iterations[${index2}].metrics.${key} must be a non-negative number.`, "INVALID_INPUT");
+  }
+  return metrics;
+};
+var validateIteration = (iteration, index2) => {
+  if (typeof iteration !== "object" || iteration === null || Array.isArray(iteration)) return fail(`iterations[${index2}] must be an object.`, "INVALID_INPUT");
+  if (!Number.isInteger(iteration.iteration) || iteration.iteration < 1) return fail(`iterations[${index2}].iteration must be a positive integer.`, "INVALID_INPUT");
+  if (!Array.isArray(iteration.steps) || iteration.steps.length !== IMPROVEMENT_CYCLE_STEPS.length) return fail(`iterations[${index2}].steps must contain the five cycle steps exactly once, in order.`, "INVALID_INPUT");
+  iteration.steps.forEach((result, stepIndex) => {
+    if (typeof result !== "object" || result === null || Array.isArray(result)) return fail(`iterations[${index2}].steps[${stepIndex}] must be an object.`, "INVALID_INPUT");
+    if (result.step !== IMPROVEMENT_CYCLE_STEPS[stepIndex]) return fail(`iterations[${index2}].steps[${stepIndex}] must be ${IMPROVEMENT_CYCLE_STEPS[stepIndex]}.`, "INVALID_INPUT");
+    if (!["passed", "failed", "blocked", "pending"].includes(result.status)) return fail(`iterations[${index2}].steps[${stepIndex}].status is invalid.`, "INVALID_INPUT");
+    if (result.status !== "passed" && !nonEmpty(result.reason, `iterations[${index2}].steps[${stepIndex}].reason`)) return fail(`iterations[${index2}].steps[${stepIndex}].reason is required when the step does not pass.`, "INVALID_INPUT");
+  });
+  if (iteration.adjustment !== void 0) nonEmpty(iteration.adjustment, `iterations[${index2}].adjustment`);
+  return { ...iteration, metrics: validateMetrics(iteration.metrics, index2) };
+};
+var assessImprovementCycle = (input) => {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return fail("cycle input must be an object.", "INVALID_INPUT");
+  const cycleId = nonEmpty(input.cycleId, "cycleId");
+  if (!Number.isInteger(input.maxIterations) || input.maxIterations < 1) return fail("maxIterations must be a positive integer.", "INVALID_INPUT");
+  if (!Array.isArray(input.iterations) || input.iterations.length < 1) return fail("iterations must be non-empty.", "INVALID_INPUT");
+  if (input.iterations.length > input.maxIterations) return fail("iterations cannot exceed maxIterations.", "INVALID_INPUT");
+  const iterations = input.iterations.map(validateIteration);
+  iterations.forEach((iteration, index2) => {
+    if (iteration.iteration !== index2 + 1) return fail("iterations must be sequential and start at 1.", "INVALID_INPUT");
+    if (index2 > 0 && iterations[index2 - 1]?.steps.every((step) => step.status === "passed")) return fail("a completed cycle cannot have later iterations.", "INVALID_INPUT");
+    if (index2 < iterations.length - 1 && !iteration.adjustment) return fail(`iterations[${index2}].adjustment is required before repeating.`, "INVALID_INPUT");
+  });
+  const matrix = iterations.map((iteration) => {
+    const statuses = Object.fromEntries(iteration.steps.map((step) => [step.step, step.status]));
+    const passedSteps = iteration.steps.filter((step) => step.status === "passed").length;
+    return { iteration: iteration.iteration, passedSteps, totalSteps: IMPROVEMENT_CYCLE_STEPS.length, passRate: Number((passedSteps / IMPROVEMENT_CYCLE_STEPS.length).toFixed(4)), statuses, ...iteration.adjustment ? { adjustment: iteration.adjustment } : {}, ...iteration.metrics ? { metrics: iteration.metrics } : {} };
+  });
+  const latest = iterations[iterations.length - 1];
+  const complete = latest.steps.every((step) => step.status === "passed");
+  const reasons = complete ? ["All five cycle steps passed."] : iterations.length >= input.maxIterations ? ["Maximum cycle iterations reached; human adjustment is required."] : latest.adjustment ? ["A failed or blocked step remains; repeat with the recorded adjustment."] : ["A failed or blocked step remains; an explicit adjustment is required before repeating."];
+  const decision = complete ? "complete" : iterations.length >= input.maxIterations || !latest.adjustment ? "blocked" : "repeat";
+  const result = { type: "agentskit-harness-improvement-cycle", cycleId, decision, ...decision === "repeat" ? { nextIteration: latest.iteration + 1 } : {}, reasons, matrix };
+  const digest3 = createHash("sha256").update(JSON.stringify(result)).digest("hex");
+  return { ...result, digest: digest3 };
+};
+
+// src/eval.ts
+var pass = (expected, output) => typeof expected === "string" ? output === expected : expected(output);
+var runAgentEval = async ({ suite, agent, concurrency = 1 }) => {
+  if (!suite.name.trim() || !suite.cases.length) fail("Eval suite must have a name and at least one case.", "INVALID_INPUT");
+  if (!Number.isInteger(concurrency) || concurrency < 1) fail("Eval concurrency must be a positive integer.", "INVALID_INPUT");
+  const failures = [];
+  let passed = 0;
+  for (let offset = 0; offset < suite.cases.length; offset += concurrency) {
+    const batch = suite.cases.slice(offset, offset + concurrency);
+    const outputs = await Promise.all(batch.map((testCase) => agent(testCase.input)));
+    batch.forEach((testCase, index2) => {
+      if (pass(testCase.expected, outputs[index2])) passed += 1;
+      else failures.push(testCase.id);
+    });
+  }
+  return { suite: suite.name, total: suite.cases.length, passed, failed: suite.cases.length - passed, accuracy: passed / suite.cases.length, failures };
+};
+var assessAgentEval = (report, minimumAccuracy) => {
+  if (!Number.isFinite(minimumAccuracy) || minimumAccuracy < 0 || minimumAccuracy > 1) fail("minimumAccuracy must be between 0 and 1.", "INVALID_INPUT");
+  if (report.total < 1 || report.passed + report.failed !== report.total || report.accuracy !== report.passed / report.total) fail("Eval report is inconsistent.", "INVALID_INPUT");
+  return report.accuracy >= minimumAccuracy ? { status: "passed", reason: `Accuracy ${report.accuracy.toFixed(4)} meets ${minimumAccuracy.toFixed(4)}.`, report } : { status: "blocked", reason: `Accuracy ${report.accuracy.toFixed(4)} is below ${minimumAccuracy.toFixed(4)}.`, report };
+};
+
+// src/cache.ts
+var validateCacheableOperation = (operation) => {
+  if (operation !== "context" && operation !== "read-only") fail("Only context and read-only operations may use the LLM cache.", "POLICY_BLOCKED");
+  return operation;
+};
+var createLlmCacheKey = (input) => {
+  validateCacheableOperation(input.operation);
+  return hashJson(input);
+};
+var createLlmCache = () => {
+  const values = /* @__PURE__ */ new Map();
+  let hits = 0;
+  let misses = 0;
+  let invalidations = 0;
+  return {
+    async getOrCompute(key, compute) {
+      const cached = values.get(key);
+      if (cached !== void 0) {
+        hits += 1;
+        return cached;
+      }
+      misses += 1;
+      const value = await compute();
+      values.set(key, value);
+      return value;
+    },
+    invalidate(key) {
+      if (key === void 0) {
+        invalidations += values.size;
+        values.clear();
+        return;
+      }
+      if (values.delete(key)) invalidations += 1;
+    },
+    stats: () => ({ hits, misses, invalidations })
+  };
+};
+
+// src/optimization.ts
+var nonNegative = (value, label) => {
+  if (!Number.isFinite(value) || value < 0) fail(`${label} must be a non-negative number.`, "INVALID_INPUT");
+  return value;
+};
+var nonNegativeInteger = (value, label) => {
+  nonNegative(value, label);
+  if (!Number.isInteger(value)) fail(`${label} must be an integer.`, "INVALID_INPUT");
+  return value;
+};
+var required6 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var validateOptimizationObservation = (observation) => {
+  required6(observation.sourceRevision, "sourceRevision");
+  required6(observation.contractHash, "contractHash");
+  required6(observation.configHash, "configHash");
+  required6(observation.provider, "provider");
+  required6(observation.model, "model");
+  nonNegative(observation.durationMs, "durationMs");
+  if (observation.accuracy !== void 0 && (!Number.isFinite(observation.accuracy) || observation.accuracy < 0 || observation.accuracy > 1)) fail("accuracy must be between 0 and 1.", "INVALID_INPUT");
+  if (observation.tokens) {
+    const tokens = observation.tokens;
+    for (const key of ["inputTokens", "outputTokens", "totalTokens"]) nonNegativeInteger(tokens[key], `tokens.${key}`);
+    if (tokens.totalTokens !== tokens.inputTokens + tokens.outputTokens) fail("tokens.totalTokens must equal inputTokens + outputTokens.", "INVALID_INPUT");
+    for (const key of ["cacheReadTokens", "cacheWriteTokens"]) if (tokens[key] !== void 0) nonNegativeInteger(tokens[key], `tokens.${key}`);
+  }
+  if (observation.memory) for (const key of ["reads", "writes", "relevantHits", "staleHits"]) nonNegativeInteger(observation.memory[key], `memory.${key}`);
+  if (observation.cache) {
+    for (const key of ["hits", "misses", "invalidations"]) nonNegativeInteger(observation.cache[key], `cache.${key}`);
+    if (observation.cache.tokensSaved !== void 0) nonNegativeInteger(observation.cache.tokensSaved, "cache.tokensSaved");
+  }
+  if (observation.parallelism) {
+    for (const key of ["tasks", "peakConcurrency"]) nonNegativeInteger(observation.parallelism[key], `parallelism.${key}`);
+    nonNegative(observation.parallelism.criticalPathMs, "parallelism.criticalPathMs");
+    if (observation.parallelism.queueWaitMs !== void 0) nonNegative(observation.parallelism.queueWaitMs, "parallelism.queueWaitMs");
+    if (observation.parallelism.tasks > 0 && observation.parallelism.peakConcurrency < 1) fail("parallelism.peakConcurrency must be positive when tasks exist.", "INVALID_INPUT");
+  }
+  return observation;
+};
+var rate = (hits, total) => total ? Number((hits / total).toFixed(4)) : void 0;
+var compareOptimization = (baseline, candidate) => {
+  validateOptimizationObservation(baseline);
+  validateOptimizationObservation(candidate);
+  for (const key of ["sourceRevision", "contractHash", "configHash", "provider", "model"]) if (baseline[key] !== candidate[key]) return { comparable: false, reason: `Bindings differ: ${key}.`, digest: hashJson({ baseline, candidate }) };
+  const result = {
+    comparable: true,
+    reason: "Observations share source, contract, configuration, provider, and model bindings.",
+    digest: hashJson({ baseline, candidate }),
+    durationDeltaMs: candidate.durationMs - baseline.durationMs,
+    ...baseline.accuracy !== void 0 && candidate.accuracy !== void 0 ? { accuracyDelta: Number((candidate.accuracy - baseline.accuracy).toFixed(4)) } : {},
+    ...baseline.tokens && candidate.tokens ? { tokenDelta: candidate.tokens.totalTokens - baseline.tokens.totalTokens } : {},
+    ...baseline.cache && candidate.cache ? { cacheHitRateDelta: (rate(candidate.cache.hits, candidate.cache.hits + candidate.cache.misses) ?? 0) - (rate(baseline.cache.hits, baseline.cache.hits + baseline.cache.misses) ?? 0) } : {},
+    ...baseline.memory && candidate.memory ? { memoryRelevantHitRateDelta: (rate(candidate.memory.relevantHits, candidate.memory.reads) ?? 0) - (rate(baseline.memory.relevantHits, baseline.memory.reads) ?? 0) } : {},
+    ...baseline.parallelism && candidate.parallelism ? { peakConcurrencyDelta: candidate.parallelism.peakConcurrency - baseline.parallelism.peakConcurrency } : {}
+  };
+  return result;
+};
+
+// src/memory.ts
+var MEMORY_SCOPES = ["issue", "project", "global"];
+var text2 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(label + " must be a non-empty string.", "INVALID_INPUT");
+  return value.trim();
+};
+var validateMemoryRecord = (record3) => {
+  text2(record3.id, "memory.id");
+  if (!MEMORY_SCOPES.includes(record3.scope)) fail("memory.scope is invalid.", "INVALID_INPUT");
+  text2(record3.summary, "memory.summary");
+  text2(record3.source, "memory.source");
+  text2(record3.sourceRevision, "memory.sourceRevision");
+  text2(record3.contentHash, "memory.contentHash");
+  if (record3.approved !== true) fail("Only approved memory may enter the shared store.", "POLICY_BLOCKED");
+  return record3;
+};
+var createInMemoryMemoryAdapter = (options = {}) => {
+  const records = /* @__PURE__ */ new Map();
+  return {
+    id: options.id ?? "in-memory",
+    version: options.version ?? "1",
+    async remember(record3) {
+      records.set(validateMemoryRecord(record3).id, record3);
+    },
+    async recall({ query, issueId, project, sourceRevision }) {
+      const needle = query.trim().toLowerCase();
+      return [...records.values()].filter((record3) => {
+        const scopeMatch = record3.scope === "global" || (record3.scope === "issue" ? Boolean(issueId && record3.source.includes(issueId)) : Boolean(project && record3.source.includes(project)));
+        return scopeMatch && (!needle || `${record3.summary} ${record3.source}`.toLowerCase().includes(needle));
+      }).map((record3) => ({ record: record3, relevant: true, stale: sourceRevision !== void 0 && record3.sourceRevision !== sourceRevision }));
+    }
+  };
+};
+var createKvMemoryAdapter = (store, options = {}) => {
+  const indexKey = "agentskit-harness:memory:index";
+  const matches2 = (record3, query, issueId, project) => {
+    const scopeMatch = record3.scope === "global" || (record3.scope === "issue" ? Boolean(issueId && record3.source.includes(issueId)) : Boolean(project && record3.source.includes(project)));
+    return scopeMatch && (!query || `${record3.summary} ${record3.source}`.toLowerCase().includes(query));
+  };
+  return {
+    id: options.id ?? "agentskit-kv",
+    version: options.version ?? "1",
+    async remember(record3) {
+      const valid = validateMemoryRecord(record3);
+      const ids = await store.get(indexKey);
+      const index2 = Array.isArray(ids) ? ids.filter((id2) => typeof id2 === "string") : [];
+      if (!index2.includes(valid.id)) await store.set(indexKey, [...index2, valid.id].sort());
+      await store.set(`agentskit-harness:memory:${valid.id}`, valid);
+    },
+    async recall({ query, issueId, project, sourceRevision }) {
+      const ids = await store.get(indexKey);
+      const records = Array.isArray(ids) ? await Promise.all(ids.filter((id2) => typeof id2 === "string").map((id2) => store.get(`agentskit-harness:memory:${id2}`))) : [];
+      return records.filter((record3) => Boolean(record3 && typeof record3 === "object" && record3.approved === true)).filter((record3) => matches2(record3, query.trim().toLowerCase(), issueId, project)).map((record3) => ({ record: record3, relevant: true, stale: sourceRevision !== void 0 && record3.sourceRevision !== sourceRevision }));
+    }
+  };
+};
+
+// src/workflow.ts
+var validId2 = (id2) => {
+  if (typeof id2 !== "string" || !id2.trim()) fail("Workflow node id must be non-empty.", "INVALID_INPUT");
+  return id2.trim();
+};
+var levels = (nodes) => {
+  const byId = new Map(nodes.map((node) => [validId2(node.id), node]));
+  if (byId.size !== nodes.length) fail("Workflow node ids must be unique.", "INVALID_INPUT");
+  const remaining = new Set(byId.keys());
+  const completed = /* @__PURE__ */ new Set();
+  const result = [];
+  while (remaining.size) {
+    const ready = [...remaining].sort().map((id2) => byId.get(id2)).filter((node) => (node.dependsOn ?? []).every((dependency) => completed.has(dependency)));
+    if (!ready.length) fail("Workflow contains an unknown dependency or cycle.", "INVALID_INPUT");
+    result.push(ready);
+    for (const node of ready) {
+      remaining.delete(node.id);
+      completed.add(node.id);
+    }
+  }
+  return result;
+};
+var runWorkflow = async (nodes, options) => {
+  if (!Number.isInteger(options.maxConcurrency) || options.maxConcurrency < 1) fail("maxConcurrency must be a positive integer.", "INVALID_INPUT");
+  const started = Date.now();
+  const results = {};
+  const order = [];
+  let peakConcurrency = 0;
+  for (const level of levels(nodes)) {
+    const remaining = [...level];
+    while (remaining.length) {
+      const batch = [];
+      const keys = /* @__PURE__ */ new Set();
+      const limit = options.currentConcurrency ? options.currentConcurrency() : options.maxConcurrency;
+      if (!Number.isInteger(limit) || limit < 1) fail("currentConcurrency must return a positive integer.", "INVALID_INPUT");
+      for (const node of remaining) {
+        const key = node.mutationKey?.trim();
+        if (batch.length >= limit || key && keys.has(key)) continue;
+        batch.push(node);
+        if (key) keys.add(key);
+      }
+      if (!batch.length) fail("Workflow could not schedule a mutation batch.", "INVALID_INPUT");
+      peakConcurrency = Math.max(peakConcurrency, batch.length);
+      const values = await Promise.all(batch.map((node) => node.run()));
+      batch.forEach((node, index2) => {
+        results[node.id] = values[index2];
+        order.push(node.id);
+      });
+      for (const node of batch) remaining.splice(remaining.indexOf(node), 1);
+    }
+  }
+  return { results, order, peakConcurrency, criticalPathMs: Date.now() - started };
+};
 var BENCHMARK_SCHEMA_VERSION = 1;
 var percentage = (part, total) => total ? Number((part / total).toFixed(4)) : null;
-var DEFAULT_POLICY = { minComparableTasks: 3, maxDurationRegressionRate: 0.2, minCompletedRunsPerTask: 3, minBaselineSamplesPerTask: 3, requireZeroEscapedIncomplete: true };
 var improvementRate = (baseline, current) => baseline === void 0 || current === void 0 || baseline === 0 ? null : Number(((baseline - current) / baseline).toFixed(4));
-var increaseRate = (baseline, current) => baseline === void 0 || current === void 0 || baseline === 0 ? null : Number(((current - baseline) / baseline).toFixed(4));
-var increaseDelta = (baseline, current) => baseline === void 0 || current === null ? null : Number((current - baseline).toFixed(4));
-var increaseDirection = (rate2, delta) => delta === null ? improvementDirection(rate2) : delta > 0 ? "improved" : delta < 0 ? "regressed" : "unchanged";
 var improvementDirection = (rate2) => rate2 === null ? "unavailable" : rate2 > 0 ? "improved" : rate2 < 0 ? "regressed" : "unchanged";
 var count = (items, predicate) => items.filter(predicate).length;
 var median = (values) => {
@@ -926,25 +1595,13 @@ var reviewMinutes = (run) => {
   const elapsed = Date.parse(run.humanApproval.at) - Date.parse(reviewStart);
   return Number.isFinite(elapsed) && elapsed >= 0 ? Number((elapsed / 6e4).toFixed(2)) : void 0;
 };
-var confidence = (comparable, completedRuns, policy) => !comparable ? "insufficient" : completedRuns >= policy.minCompletedRunsPerTask ? "reliable" : "directional";
-var artifactAcceptanceRate = (run) => {
-  const rates = run.checks.flatMap((check) => {
-    const evidence = check.evidence;
-    if (!evidence) return [];
-    const direct = typeof evidence["artifactAcceptanceRate"] === "number" ? [evidence["artifactAcceptanceRate"]] : [];
-    const reports = Array.isArray(evidence["reports"]) ? evidence["reports"].flatMap((report) => typeof report === "object" && report !== null && typeof report["artifactAcceptanceRate"] === "number" ? [report["artifactAcceptanceRate"]] : []) : [];
-    return [...direct, ...reports].filter((rate2) => Number.isFinite(rate2) && rate2 >= 0 && rate2 <= 1);
-  });
-  return rates.length ? Number((rates.reduce((total, rate2) => total + rate2, 0) / rates.length).toFixed(4)) : void 0;
-};
 var projectRun = (run) => {
   const checks = { total: run.checks.length, passed: count(run.checks, (check) => check.status === "passed"), failed: count(run.checks, (check) => check.status === "failed") };
   const outcomes = { total: run.outcomes.length, passed: count(run.outcomes, (outcome) => outcome.status === "passed"), failed: count(run.outcomes, (outcome) => outcome.status === "failed") };
   const evidence = { total: run.checks.length, attached: count(run.checks, (check) => check.evidence !== void 0) };
-  const acceptanceRate = artifactAcceptanceRate(run);
   const humanReviewMinutes = reviewMinutes(run);
   const escapedIncomplete = run.state === "COMPLETE" && checks.failed === 0 && outcomes.failed === 0 && evidence.attached === evidence.total ? 0 : void 0;
-  return { runId: run.runId, state: run.state, sourceRevision: run.sourceRevision, configHash: run.configHash, contractHash: run.contractHash, ...run.supersedes ? { supersedes: run.supersedes } : {}, ...run.metrics ? { durationMs: run.metrics.totalDurationMs } : {}, checks, outcomes, evidence, ...acceptanceRate === void 0 ? {} : { artifactAcceptanceRate: acceptanceRate }, ...escapedIncomplete === void 0 ? {} : { escapedIncomplete }, humanApproved: run.humanApproval !== void 0, ...humanReviewMinutes === void 0 ? {} : { humanReviewMinutes }, authorized: run.authorization !== void 0, ...run.benchmark ? { benchmark: run.benchmark } : {} };
+  return { runId: run.runId, state: run.state, sourceRevision: run.sourceRevision, configHash: run.configHash, contractHash: run.contractHash, ...run.supersedes ? { supersedes: run.supersedes } : {}, ...run.metrics ? { durationMs: run.metrics.totalDurationMs } : {}, checks, outcomes, evidence, ...escapedIncomplete === void 0 ? {} : { escapedIncomplete }, humanApproved: run.humanApproval !== void 0, ...humanReviewMinutes === void 0 ? {} : { humanReviewMinutes }, authorized: run.authorization !== void 0, ...run.metrics?.machine ? { machine: run.metrics.machine } : {}, ...run.benchmark ? { benchmark: run.benchmark } : {} };
 };
 var summarize = (runs) => {
   const stateCounts = Object.fromEntries(RUN_STATES.map((state) => [state, count(runs, (run) => run.state === state)]));
@@ -955,14 +1612,6 @@ var summarize = (runs) => {
   const evidenceTotal = runs.reduce((total, run) => total + run.evidence.total, 0);
   const evidenceAttached = runs.reduce((total, run) => total + run.evidence.attached, 0);
   const firstAttempts = runs.filter((run) => !run.supersedes);
-  const superseded = new Set(runs.flatMap((run) => run.supersedes ? [run.supersedes] : []));
-  const effectiveRuns = runs.filter((run) => !superseded.has(run.runId));
-  const effectiveChecksTotal = effectiveRuns.reduce((total, run) => total + run.checks.total, 0);
-  const effectiveChecksPassed = effectiveRuns.reduce((total, run) => total + run.checks.passed, 0);
-  const effectiveOutcomesTotal = effectiveRuns.reduce((total, run) => total + run.outcomes.total, 0);
-  const effectiveOutcomesPassed = effectiveRuns.reduce((total, run) => total + run.outcomes.passed, 0);
-  const effectiveEvidenceTotal = effectiveRuns.reduce((total, run) => total + run.evidence.total, 0);
-  const effectiveEvidenceAttached = effectiveRuns.reduce((total, run) => total + run.evidence.attached, 0);
   const durations = runs.flatMap((run) => run.durationMs === void 0 ? [] : [run.durationMs]);
   return {
     totalRuns: runs.length,
@@ -973,12 +1622,6 @@ var summarize = (runs) => {
     firstAttemptRuns: firstAttempts.length,
     humanApprovedRuns: count(runs, (run) => run.humanApproved),
     authorizedRuns: count(runs, (run) => run.authorized),
-    effectiveRunCount: effectiveRuns.length,
-    effectiveCompleteRuns: count(effectiveRuns, (run) => run.state === "COMPLETE"),
-    effectiveCompletionRate: percentage(count(effectiveRuns, (run) => run.state === "COMPLETE"), effectiveRuns.length),
-    effectiveCheckPassRate: percentage(effectiveChecksPassed, effectiveChecksTotal),
-    effectiveOutcomePassRate: percentage(effectiveOutcomesPassed, effectiveOutcomesTotal),
-    effectiveEvidenceCoverageRate: percentage(effectiveEvidenceAttached, effectiveEvidenceTotal),
     checkPassRate: percentage(checksPassed, checksTotal),
     outcomePassRate: percentage(outcomesPassed, outcomesTotal),
     evidenceCoverageRate: percentage(evidenceAttached, evidenceTotal),
@@ -1026,73 +1669,16 @@ var nonNegativeNumber = (value, label) => {
   const result = value;
   return result;
 };
-var nonNegativeInteger = (value, label) => {
+var nonNegativeInteger2 = (value, label) => {
   const result = nonNegativeNumber(value, label);
   if (result !== void 0 && !Number.isInteger(result)) return fail(`${label} must be an integer.`, "INVALID_CONFIG");
   return result;
 };
-var rate = (value, label) => {
-  const result = nonNegativeNumber(value, label);
-  if (result !== void 0 && result > 1) return fail(`${label} must be between 0 and 1.`, "INVALID_CONFIG");
-  return result;
-};
 var timestamp = (value, label) => {
   const result = nonEmptyString(value, label);
   if (!Number.isFinite(Date.parse(result))) return fail(`${label} must be a valid timestamp.`, "INVALID_CONFIG");
   return result;
 };
-var relativePath = (value, label) => {
-  const result = nonEmptyString(value, label);
-  if (result.startsWith("/") || result.split("/").includes("..")) return fail(`${label} must be a repository-relative path.`, "INVALID_CONFIG");
-  return result;
-};
-var taskFile = (value, label) => {
-  if (value === void 0) return void 0;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return fail(`${label} must be an object.`, "INVALID_CONFIG");
-  const raw = value;
-  return { path: relativePath(raw["path"], `${label}.path`), sha256: sha2562(raw["sha256"], `${label}.sha256`) ?? fail(`${label}.sha256 is required.`, "INVALID_CONFIG") };
-};
-var taskSource = (value, label) => {
-  if (value === void 0) return void 0;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return fail(`${label} must be an object.`, "INVALID_CONFIG");
-  const raw = value;
-  return { repository: nonEmptyString(raw["repository"], `${label}.repository`), path: relativePath(raw["path"], `${label}.path`), revision: nonEmptyString(raw["revision"], `${label}.revision`) };
-};
-var suiteSource = (value, label) => {
-  if (value === void 0) return void 0;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return fail(`${label} must be an object.`, "INVALID_CONFIG");
-  const raw = value;
-  return { repository: nonEmptyString(raw["repository"], `${label}.repository`), revision: nonEmptyString(raw["revision"], `${label}.revision`), taskDefinition: relativePath(raw["taskDefinition"], `${label}.taskDefinition`) };
-};
-var taskScope = (value, label) => {
-  if (value === void 0) return void 0;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return fail(`${label} must be an object.`, "INVALID_CONFIG");
-  const raw = value;
-  return { read: stringList(raw["read"], `${label}.read`), write: stringList(raw["write"], `${label}.write`) };
-};
-var taskSurfaces = (value, label) => {
-  if (value === void 0) return void 0;
-  if (!Array.isArray(value) || !value.length) return fail(`${label} must be a non-empty array.`, "INVALID_CONFIG");
-  const surfaces = value.map((item, index2) => nonEmptyString(item, `${label}[${index2}]`));
-  if (surfaces.some((surface2) => !SURFACE_NAMES.includes(surface2))) fail(`${label} contains an unknown surface.`, "INVALID_CONFIG");
-  if (new Set(surfaces).size !== surfaces.length) fail(`${label} must contain unique surfaces.`, "INVALID_CONFIG");
-  return surfaces;
-};
-var benchmarkPolicy = (value) => {
-  if (value === void 0) return void 0;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return fail("benchmark.policy must be an object.", "INVALID_CONFIG");
-  const raw = value;
-  const minComparableTasks = nonNegativeInteger(raw["minComparableTasks"], "benchmark.policy.minComparableTasks");
-  const maxDurationRegressionRate = nonNegativeNumber(raw["maxDurationRegressionRate"], "benchmark.policy.maxDurationRegressionRate");
-  const minCompletedRunsPerTask = nonNegativeInteger(raw["minCompletedRunsPerTask"], "benchmark.policy.minCompletedRunsPerTask");
-  const minBaselineSamplesPerTask = nonNegativeInteger(raw["minBaselineSamplesPerTask"] ?? 1, "benchmark.policy.minBaselineSamplesPerTask");
-  if (minComparableTasks === void 0 || minComparableTasks < 1) return fail("benchmark.policy.minComparableTasks must be at least 1.", "INVALID_CONFIG");
-  if (maxDurationRegressionRate === void 0 || maxDurationRegressionRate > 1) return fail("benchmark.policy.maxDurationRegressionRate must be between 0 and 1.", "INVALID_CONFIG");
-  if (minCompletedRunsPerTask === void 0 || minCompletedRunsPerTask < 1) return fail("benchmark.policy.minCompletedRunsPerTask must be at least 1.", "INVALID_CONFIG");
-  if (minBaselineSamplesPerTask === void 0 || minBaselineSamplesPerTask < 1) return fail("benchmark.policy.minBaselineSamplesPerTask must be at least 1.", "INVALID_CONFIG");
-  if (typeof raw["requireZeroEscapedIncomplete"] !== "boolean") return fail("benchmark.policy.requireZeroEscapedIncomplete must be boolean.", "INVALID_CONFIG");
-  return { minComparableTasks, maxDurationRegressionRate, minCompletedRunsPerTask, minBaselineSamplesPerTask, requireZeroEscapedIncomplete: raw["requireZeroEscapedIncomplete"] };
-};
 var validateBenchmarkManifest = (value) => {
   if (typeof value !== "object" || value === null || Array.isArray(value)) fail("benchmark manifest must be an object.", "INVALID_CONFIG");
   const raw = value;
@@ -1101,12 +1687,7 @@ var validateBenchmarkManifest = (value) => {
   const tasks = rawTasks.map((item, index2) => {
     if (typeof item !== "object" || item === null || Array.isArray(item)) fail(`benchmark.tasks[${index2}] must be an object.`, "INVALID_CONFIG");
     const task = item;
-    const kind = task["kind"] === void 0 ? void 0 : nonEmptyString(task["kind"], `benchmark.tasks[${index2}].kind`);
-    const prompt = taskFile(task["prompt"], `benchmark.tasks[${index2}].prompt`);
-    const source = taskSource(task["source"], `benchmark.tasks[${index2}].source`);
-    const scope = taskScope(task["scope"], `benchmark.tasks[${index2}].scope`);
-    const surfaces = taskSurfaces(task["surfaces"], `benchmark.tasks[${index2}].surfaces`);
-    return { id: nonEmptyString(task["id"], `benchmark.tasks[${index2}].id`), title: nonEmptyString(task["title"], `benchmark.tasks[${index2}].title`), acceptanceCriteria: stringList(task["acceptanceCriteria"], `benchmark.tasks[${index2}].acceptanceCriteria`), ...surfaces === void 0 ? {} : { surfaces }, ...kind === void 0 ? {} : { kind }, ...prompt === void 0 ? {} : { prompt }, ...source === void 0 ? {} : { source }, ...scope === void 0 ? {} : { scope } };
+    return { id: nonEmptyString(task["id"], `benchmark.tasks[${index2}].id`), title: nonEmptyString(task["title"], `benchmark.tasks[${index2}].title`), acceptanceCriteria: stringList(task["acceptanceCriteria"], `benchmark.tasks[${index2}].acceptanceCriteria`) };
   });
   if (new Set(tasks.map((task) => task.id)).size !== tasks.length) fail("benchmark task ids must be unique.", "INVALID_CONFIG");
   const taskIds = new Set(tasks.map((task) => task.id));
@@ -1119,14 +1700,10 @@ var validateBenchmarkManifest = (value) => {
     const taskId = nonEmptyString(observation["taskId"], `benchmark.observations[${index2}].taskId`);
     if (!taskIds.has(taskId)) fail(`benchmark observation references unknown task: ${taskId}.`, "INVALID_CONFIG");
     const task = tasks.find((candidate) => candidate.id === taskId) ?? fail(`benchmark observation references unknown task: ${taskId}.`, "INVALID_CONFIG");
-    const attempts = nonNegativeInteger(observation["attempts"], `benchmark.observations[${index2}].attempts`);
+    const attempts = nonNegativeInteger2(observation["attempts"], `benchmark.observations[${index2}].attempts`);
     const durationMs = nonNegativeNumber(observation["durationMs"], `benchmark.observations[${index2}].durationMs`);
-    const durationSamplesMs = observation["durationSamplesMs"] === void 0 ? void 0 : Array.isArray(observation["durationSamplesMs"]) ? observation["durationSamplesMs"].map((sample, sampleIndex) => nonNegativeNumber(sample, `benchmark.observations[${index2}].durationSamplesMs[${sampleIndex}]`) ?? fail(`benchmark.observations[${index2}].durationSamplesMs must contain numbers.`, "INVALID_CONFIG")) : fail(`benchmark.observations[${index2}].durationSamplesMs must be an array.`, "INVALID_CONFIG");
-    if (durationSamplesMs && !durationSamplesMs.length) fail(`benchmark.observations[${index2}].durationSamplesMs must not be empty.`, "INVALID_CONFIG");
-    const artifactAcceptanceRate2 = rate(observation["artifactAcceptanceRate"], `benchmark.observations[${index2}].artifactAcceptanceRate`);
-    const protocolCompletionRate = rate(observation["protocolCompletionRate"], `benchmark.observations[${index2}].protocolCompletionRate`);
     const reviewMinutes2 = nonNegativeNumber(observation["reviewMinutes"], `benchmark.observations[${index2}].reviewMinutes`);
-    const escapedIncomplete = nonNegativeInteger(observation["escapedIncomplete"], `benchmark.observations[${index2}].escapedIncomplete`);
+    const escapedIncomplete = nonNegativeInteger2(observation["escapedIncomplete"], `benchmark.observations[${index2}].escapedIncomplete`);
     const evidenceDigest = sha2562(observation["evidenceDigest"], `benchmark.observations[${index2}].evidenceDigest`);
     const rawEvidence = observation["evidence"] === void 0 ? void 0 : Array.isArray(observation["evidence"]) ? observation["evidence"] : fail(`benchmark.observations[${index2}].evidence must be an array.`, "INVALID_CONFIG");
     const evidence = rawEvidence?.map((item2, evidenceIndex) => {
@@ -1139,12 +1716,10 @@ var validateBenchmarkManifest = (value) => {
       return { criterion, status: evidenceStatus, source: nonEmptyString(entry["source"], `benchmark.observations[${index2}].evidence[${evidenceIndex}].source`) };
     });
     if (evidence && new Set(evidence.map((entry) => entry.criterion)).size !== evidence.length) fail(`benchmark.observations[${index2}].evidence criteria must be unique.`, "INVALID_CONFIG");
-    return { taskId, mode: "baseline", status, source: nonEmptyString(observation["source"], `benchmark.observations[${index2}].source`), recordedAt: timestamp(observation["recordedAt"], `benchmark.observations[${index2}].recordedAt`), ...attempts === void 0 ? {} : { attempts }, ...durationMs === void 0 ? {} : { durationMs }, ...durationSamplesMs === void 0 ? {} : { durationSamplesMs }, ...artifactAcceptanceRate2 === void 0 ? {} : { artifactAcceptanceRate: artifactAcceptanceRate2 }, ...protocolCompletionRate === void 0 ? {} : { protocolCompletionRate }, ...reviewMinutes2 === void 0 ? {} : { reviewMinutes: reviewMinutes2 }, ...escapedIncomplete === void 0 ? {} : { escapedIncomplete }, ...evidence === void 0 ? {} : { evidence }, ...evidenceDigest === void 0 ? {} : { evidenceDigest } };
+    return { taskId, mode: "baseline", status, source: nonEmptyString(observation["source"], `benchmark.observations[${index2}].source`), recordedAt: timestamp(observation["recordedAt"], `benchmark.observations[${index2}].recordedAt`), ...attempts === void 0 ? {} : { attempts }, ...durationMs === void 0 ? {} : { durationMs }, ...reviewMinutes2 === void 0 ? {} : { reviewMinutes: reviewMinutes2 }, ...escapedIncomplete === void 0 ? {} : { escapedIncomplete }, ...evidence === void 0 ? {} : { evidence }, ...evidenceDigest === void 0 ? {} : { evidenceDigest } };
   });
   if (new Set(observations.map((observation) => observation.taskId)).size !== observations.length) fail("benchmark allows at most one baseline observation per task.", "INVALID_CONFIG");
-  const provenance = suiteSource(raw["provenance"], "benchmark.provenance");
-  const policy = benchmarkPolicy(raw["policy"]);
-  return { type: "agentskit-harness-benchmark-manifest", schemaVersion: BENCHMARK_SCHEMA_VERSION, suiteId: nonEmptyString(raw["suiteId"], "benchmark.suiteId"), name: nonEmptyString(raw["name"], "benchmark.name"), ...provenance === void 0 ? {} : { provenance }, tasks, observations, ...policy === void 0 ? {} : { policy } };
+  return { type: "agentskit-harness-benchmark-manifest", schemaVersion: BENCHMARK_SCHEMA_VERSION, suiteId: nonEmptyString(raw["suiteId"], "benchmark.suiteId"), name: nonEmptyString(raw["name"], "benchmark.name"), tasks, observations };
 };
 var loadBenchmarkManifest = (path) => {
   try {
@@ -1170,9 +1745,6 @@ var recordBenchmarkObservation = (path, input) => {
       recordedAt: input.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
       ...input.attempts === void 0 ? {} : { attempts: input.attempts },
       ...input.durationMs === void 0 ? {} : { durationMs: input.durationMs },
-      ...input.durationSamplesMs === void 0 ? {} : { durationSamplesMs: input.durationSamplesMs },
-      ...input.artifactAcceptanceRate === void 0 ? {} : { artifactAcceptanceRate: input.artifactAcceptanceRate },
-      ...input.protocolCompletionRate === void 0 ? {} : { protocolCompletionRate: input.protocolCompletionRate },
       ...input.reviewMinutes === void 0 ? {} : { reviewMinutes: input.reviewMinutes },
       ...input.escapedIncomplete === void 0 ? {} : { escapedIncomplete: input.escapedIncomplete },
       ...input.evidence === void 0 ? {} : { evidence: input.evidence },
@@ -1191,99 +1763,27 @@ var recordBenchmarkObservation = (path, input) => {
   }
   return observation;
 };
-var comparisons = (runs, manifest, policy) => manifest.tasks.map((task) => {
+var comparisons = (runs, manifest) => manifest.tasks.map((task) => {
   const taskRuns = runs.filter((run) => run.benchmark?.suiteId === manifest.suiteId && run.benchmark.taskId === task.id);
   const latest = taskRuns.at(-1);
   const baseline = manifest.observations.find((observation) => observation.taskId === task.id);
   const coveredCriteria = new Set((baseline?.evidence ?? []).map((entry) => entry.criterion));
   const baselineEvidenceCoverageRate = baseline ? percentage(coveredCriteria.size, task.acceptanceCriteria.length) : null;
   const baselineEvidenceComplete = baselineEvidenceCoverageRate === 1;
-  const baselineEvidencePassed = baselineEvidenceComplete && (baseline?.evidence?.every((entry) => entry.status === "passed") ?? false);
-  const baselineDeliveryComplete = baseline?.status === "passed" && baselineEvidencePassed;
-  const baselineDurationSamples = baseline?.durationSamplesMs ?? (baseline?.durationMs === void 0 ? [] : [baseline.durationMs]);
-  const baselineMedianDurationMs = median(baselineDurationSamples);
-  const baselineSamplesSufficient = baselineDurationSamples.length >= policy.minBaselineSamplesPerTask;
-  const comparable = baseline !== void 0 && baseline.status !== "not-run" && baselineEvidenceComplete && baselineDeliveryComplete && baselineSamplesSufficient && latest?.state === "COMPLETE";
-  const comparability = comparable ? "comparable" : baseline === void 0 ? "missing-baseline" : baseline.status === "not-run" ? "baseline-not-run" : !baselineEvidenceComplete ? "baseline-evidence-missing" : latest === void 0 ? "harness-not-run" : latest.state !== "COMPLETE" ? "harness-not-complete" : !baselineDeliveryComplete ? "baseline-incomplete" : "baseline-samples-insufficient";
-  const completedTaskRuns = taskRuns.filter((run) => run.state === "COMPLETE");
-  const durationSamplesMs = completedTaskRuns.flatMap((run) => run.durationMs === void 0 ? [] : [run.durationMs]);
-  const medianDurationMs = median(durationSamplesMs);
-  const retryCount = count(taskRuns, (run) => run.supersedes !== void 0);
-  const attempts = retryCount + (taskRuns.length ? 1 : 0);
-  const durationRate = comparable ? improvementRate(baselineMedianDurationMs ?? void 0, medianDurationMs ?? void 0) : null;
-  const attemptsRate = comparable ? improvementRate(baseline?.attempts, attempts) : null;
-  const reviewRate = comparable ? improvementRate(baseline?.reviewMinutes, latest?.humanReviewMinutes) : null;
-  const acceptanceSamples = taskRuns.flatMap((run) => run.artifactAcceptanceRate === void 0 ? [] : [run.artifactAcceptanceRate]);
-  const harnessArtifactAcceptanceRate = acceptanceSamples.length ? Number((acceptanceSamples.reduce((total, rate2) => total + rate2, 0) / acceptanceSamples.length).toFixed(4)) : null;
-  const artifactAcceptanceImprovementRate = increaseRate(baseline?.artifactAcceptanceRate, harnessArtifactAcceptanceRate ?? void 0);
-  const artifactAcceptanceDelta = increaseDelta(baseline?.artifactAcceptanceRate, harnessArtifactAcceptanceRate);
-  const completedRuns = completedTaskRuns.length;
-  const harnessProtocolCompletionRate = taskRuns.length ? percentage(completedRuns, taskRuns.length) : null;
-  const protocolCompletionImprovementRate = increaseRate(baseline?.protocolCompletionRate, harnessProtocolCompletionRate ?? void 0);
-  const protocolCompletionDelta = increaseDelta(baseline?.protocolCompletionRate, harnessProtocolCompletionRate);
-  const escapedIncompleteRate = improvementRate(baseline?.escapedIncomplete, latest?.escapedIncomplete);
-  return { taskId: task.id, title: task.title, comparability, comparable, baselineDeliveryComplete, baselineEvidenceCoverageRate, baselineSampleCount: baselineDurationSamples.length, baselineArtifactAcceptanceRate: baseline?.artifactAcceptanceRate ?? null, baselineProtocolCompletionRate: baseline?.protocolCompletionRate ?? null, ...baselineMedianDurationMs === null ? {} : { baselineMedianDurationMs }, improvement: { durationRate, duration: improvementDirection(durationRate), attemptsRate, attempts: improvementDirection(attemptsRate), reviewRate, review: improvementDirection(reviewRate), artifactAcceptanceRate: artifactAcceptanceImprovementRate, artifactAcceptance: increaseDirection(artifactAcceptanceImprovementRate, artifactAcceptanceDelta), artifactAcceptanceDelta, protocolCompletionRate: protocolCompletionImprovementRate, protocolCompletion: increaseDirection(protocolCompletionImprovementRate, protocolCompletionDelta), protocolCompletionDelta, escapedIncompleteRate, escapedIncomplete: improvementDirection(escapedIncompleteRate) }, ...baseline ? { baseline } : {}, harness: { attempts, retryCount, completedRuns, durationSamplesMs, ...medianDurationMs === null ? {} : { medianDurationMs }, ...harnessArtifactAcceptanceRate === null ? {} : { artifactAcceptanceRate: harnessArtifactAcceptanceRate }, artifactAcceptanceSampleCount: acceptanceSamples.length, protocolCompletionRate: harnessProtocolCompletionRate, protocolCompletionSampleCount: taskRuns.length, latestState: latest?.state ?? "NOT_RUN", ...latest ? { latestRunId: latest.runId } : {}, ...latest?.durationMs === void 0 ? {} : { latestDurationMs: latest.durationMs }, checkPassRate: latest ? percentage(latest.checks.passed, latest.checks.total) : null, outcomePassRate: latest ? percentage(latest.outcomes.passed, latest.outcomes.total) : null, evidenceCoverageRate: latest ? percentage(latest.evidence.attached, latest.evidence.total) : null, ...latest?.escapedIncomplete === void 0 ? {} : { escapedIncomplete: latest.escapedIncomplete }, ...latest?.humanReviewMinutes === void 0 ? {} : { humanReviewMinutes: latest.humanReviewMinutes }, humanApproved: latest?.humanApproved ?? false }, confidence: confidence(comparable, completedRuns, policy), ...comparable && baselineMedianDurationMs !== null && medianDurationMs !== null ? { durationDeltaMs: medianDurationMs - baselineMedianDurationMs } : {}, ...comparable && baseline?.attempts !== void 0 ? { attemptDelta: attempts - baseline.attempts } : {}, ...comparable && baseline?.reviewMinutes !== void 0 && latest?.humanReviewMinutes !== void 0 ? { reviewDeltaMinutes: latest.humanReviewMinutes - baseline.reviewMinutes } : {}, ...baseline?.escapedIncomplete !== void 0 && latest?.escapedIncomplete !== void 0 ? { escapedIncompleteDelta: latest.escapedIncomplete - baseline.escapedIncomplete } : {} };
+  const comparable2 = baseline !== void 0 && baseline.status !== "not-run" && baselineEvidenceComplete && latest?.state === "COMPLETE";
+  const comparability = comparable2 ? "comparable" : baseline === void 0 ? "missing-baseline" : baseline.status === "not-run" ? "baseline-not-run" : !baselineEvidenceComplete ? "baseline-evidence-missing" : latest === void 0 ? "harness-not-run" : "harness-not-complete";
+  const durationRate = comparable2 ? improvementRate(baseline?.durationMs, latest?.durationMs) : null;
+  const attemptsRate = comparable2 ? improvementRate(baseline?.attempts, taskRuns.length) : null;
+  const reviewRate = comparable2 ? improvementRate(baseline?.reviewMinutes, latest?.humanReviewMinutes) : null;
+  const escapedIncompleteRate = comparable2 ? improvementRate(baseline?.escapedIncomplete, latest?.escapedIncomplete) : null;
+  return { taskId: task.id, title: task.title, comparability, comparable: comparable2, baselineEvidenceCoverageRate, improvement: { durationRate, duration: improvementDirection(durationRate), attemptsRate, attempts: improvementDirection(attemptsRate), reviewRate, review: improvementDirection(reviewRate), escapedIncompleteRate, escapedIncomplete: improvementDirection(escapedIncompleteRate) }, ...baseline ? { baseline } : {}, harness: { attempts: taskRuns.length, latestState: latest?.state ?? "NOT_RUN", ...latest ? { latestRunId: latest.runId } : {}, ...latest?.durationMs === void 0 ? {} : { latestDurationMs: latest.durationMs }, checkPassRate: latest ? percentage(latest.checks.passed, latest.checks.total) : null, outcomePassRate: latest ? percentage(latest.outcomes.passed, latest.outcomes.total) : null, evidenceCoverageRate: latest ? percentage(latest.evidence.attached, latest.evidence.total) : null, ...latest?.escapedIncomplete === void 0 ? {} : { escapedIncomplete: latest.escapedIncomplete }, ...latest?.humanReviewMinutes === void 0 ? {} : { humanReviewMinutes: latest.humanReviewMinutes }, humanApproved: latest?.humanApproved ?? false }, ...comparable2 && baseline?.durationMs !== void 0 && latest?.durationMs !== void 0 ? { durationDeltaMs: latest.durationMs - baseline.durationMs } : {}, ...comparable2 && baseline?.attempts !== void 0 ? { attemptDelta: taskRuns.length - baseline.attempts } : {}, ...comparable2 && baseline?.reviewMinutes !== void 0 && latest?.humanReviewMinutes !== void 0 ? { reviewDeltaMinutes: latest.humanReviewMinutes - baseline.reviewMinutes } : {}, ...comparable2 && baseline?.escapedIncomplete !== void 0 && latest?.escapedIncomplete !== void 0 ? { escapedIncompleteDelta: latest.escapedIncomplete - baseline.escapedIncomplete } : {} };
 });
 var benchmarkRuns = (stateDir, manifest) => {
   const runs = readRuns(stateDir).map(projectRun).sort((left, right) => left.runId.localeCompare(right.runId));
-  const policy = manifest?.policy ?? DEFAULT_POLICY;
-  const reportComparisons = manifest ? comparisons(runs, manifest, policy) : [];
-  const comparable = reportComparisons.filter((comparison) => comparison.comparable);
-  const durationRegressionTaskIds = comparable.filter((comparison) => (comparison.improvement.durationRate ?? 0) < -policy.maxDurationRegressionRate).map((comparison) => comparison.taskId);
-  const escapedIncompleteTaskIds = comparable.filter((comparison) => comparison.harness.escapedIncomplete !== 0).map((comparison) => comparison.taskId);
-  const reasons = [];
-  if (comparable.length < policy.minComparableTasks) reasons.push(`requires at least ${policy.minComparableTasks} comparable tasks`);
-  const incompleteBaselineTaskIds = reportComparisons.filter((comparison) => comparison.comparability === "baseline-incomplete").map((comparison) => comparison.taskId);
-  if (incompleteBaselineTaskIds.length) reasons.push(`baseline delivery incomplete: ${incompleteBaselineTaskIds.join(", ")}`);
-  const baselineSampleGaps = reportComparisons.filter((comparison) => comparison.baselineSampleCount < policy.minBaselineSamplesPerTask).map((comparison) => `${comparison.taskId} (${comparison.baselineSampleCount}/${policy.minBaselineSamplesPerTask})`);
-  if (baselineSampleGaps.length) reasons.push(`requires ${policy.minBaselineSamplesPerTask} baseline samples per task: ${baselineSampleGaps.join(", ")}`);
-  if (durationRegressionTaskIds.length) reasons.push(`duration regression exceeds ${policy.maxDurationRegressionRate * 100}%: ${durationRegressionTaskIds.join(", ")}`);
-  if (policy.requireZeroEscapedIncomplete && escapedIncompleteTaskIds.length) reasons.push(`escaped incomplete delivery: ${escapedIncompleteTaskIds.join(", ")}`);
-  const confidenceLevel = comparable.length < policy.minComparableTasks ? "insufficient" : comparable.every((comparison) => comparison.confidence === "reliable") ? "reliable" : "directional";
-  const qualityGate = { status: comparable.length < policy.minComparableTasks ? "insufficient-data" : reasons.length ? "failed" : "passed", confidence: confidenceLevel, comparableTaskCount: comparable.length, policy, durationRegressionTaskIds, escapedIncompleteTaskIds, reasons };
-  return { type: "agentskit-harness-benchmark", schemaVersion: BENCHMARK_SCHEMA_VERSION, stateDir, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), runs, summary: summarize(runs), comparisons: reportComparisons, qualityGate, ...manifest ? { manifest: { suiteId: manifest.suiteId, taskCount: manifest.tasks.length, baselineCount: manifest.observations.length, comparableTaskCount: comparable.length } } : {} };
-};
-
-// src/coding-benchmark.ts
-var text2 = (value, label) => {
-  if (typeof value !== "string" || !value.trim()) fail(`${label} must be a non-empty string.`, "INVALID_INPUT");
-  return value.trim();
-};
-var numberValue = (value, label, integer = false) => {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || integer && !Number.isInteger(value)) fail(`${label} must be a non-negative ${integer ? "integer" : "number"}.`, "INVALID_INPUT");
-  return value;
-};
-var validateExternalCodingBenchmarkReport = (value) => {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) fail("coding benchmark report must be an object.", "INVALID_INPUT");
-  const raw = value;
-  if (!["edit", "fix-bug", "add-feature", "refactor", "add-test", "review-pr", "free-form"].includes(text2(raw["kind"], "report.kind"))) fail("report.kind is not a supported coding task kind.", "INVALID_INPUT");
-  if (typeof raw["dryRun"] !== "boolean" || typeof raw["isolateWorktrees"] !== "boolean") fail("report.dryRun and report.isolateWorktrees must be booleans.", "INVALID_INPUT");
-  if (!Array.isArray(raw["rows"]) || raw["rows"].length === 0) fail("report.rows must contain at least one provider result.", "INVALID_INPUT");
-  const rows = raw["rows"].map((item, index2) => {
-    if (typeof item !== "object" || item === null || Array.isArray(item)) fail(`report.rows[${index2}] must be an object.`, "INVALID_INPUT");
-    const row = item;
-    const status = text2(row["status"], `report.rows[${index2}].status`);
-    if (!["ok", "partial", "fail", "timeout"].includes(status)) fail(`report.rows[${index2}].status is invalid.`, "INVALID_INPUT");
-    const completenessScore = numberValue(row["completenessScore"], `report.rows[${index2}].completenessScore`);
-    if (completenessScore > 100) fail(`report.rows[${index2}].completenessScore must be between 0 and 100.`, "INVALID_INPUT");
-    const optional = (key) => row[key] === void 0 ? void 0 : numberValue(row[key], `report.rows[${index2}].${key}`);
-    return {
-      providerId: text2(row["providerId"], `report.rows[${index2}].providerId`),
-      status,
-      completenessScore,
-      fileEditCount: numberValue(row["fileEditCount"], `report.rows[${index2}].fileEditCount`, true),
-      summary: text2(row["summary"], `report.rows[${index2}].summary`),
-      ...optional("durationMs") === void 0 ? {} : { durationMs: optional("durationMs") },
-      ...optional("inputTokens") === void 0 ? {} : { inputTokens: optional("inputTokens") },
-      ...optional("outputTokens") === void 0 ? {} : { outputTokens: optional("outputTokens") },
-      ...optional("costUsd") === void 0 ? {} : { costUsd: optional("costUsd") },
-      ...row["successPassed"] === void 0 ? {} : typeof row["successPassed"] !== "boolean" ? fail(`report.rows[${index2}].successPassed must be a boolean.`, "INVALID_INPUT") : { successPassed: row["successPassed"] }
-    };
-  });
-  if (new Set(rows.map((row) => row.providerId)).size !== rows.length) fail("coding benchmark provider ids must be unique.", "INVALID_INPUT");
-  return { kind: text2(raw["kind"], "report.kind"), prompt: text2(raw["prompt"], "report.prompt"), dryRun: raw["dryRun"], isolateWorktrees: raw["isolateWorktrees"], repoRoot: text2(raw["repoRoot"], "report.repoRoot"), rows };
+  const reportComparisons = manifest ? comparisons(runs, manifest) : [];
+  return { type: "agentskit-harness-benchmark", schemaVersion: BENCHMARK_SCHEMA_VERSION, stateDir, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), runs, summary: summarize(runs), comparisons: reportComparisons, ...manifest ? { manifest: { suiteId: manifest.suiteId, taskCount: manifest.tasks.length, baselineCount: manifest.observations.length, comparableTaskCount: reportComparisons.filter((comparison) => comparison.comparable).length } } : {} };
 };
-var required = (value, label) => {
+var required7 = (value, label) => {
   if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
   return value.trim();
 };
@@ -1293,9 +1793,9 @@ var duration = (value) => {
 };
 var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionId = randomUUID(), resume = false }) => {
   if (run.state !== "IMPLEMENTING") fail(`Agent sessions can only start during IMPLEMENTING, not ${run.state}.`, "INVALID_STATE");
-  const id2 = required(sessionId, "sessionId");
-  const adapterId = required(adapter.id, "adapter.id");
-  const adapterVersion = required(adapter.version, "adapter.version");
+  const id2 = required7(sessionId, "sessionId");
+  const adapterId = required7(adapter.id, "adapter.id");
+  const adapterVersion = required7(adapter.version, "adapter.version");
   if (!policy || typeof policy.evaluate !== "function") fail("policy.evaluate is required.", "INVALID_INPUT");
   if (!runtime || typeof runtime.execute !== "function") fail("runtime.execute is required.", "INVALID_INPUT");
   if (!Array.isArray(adapter.capabilities) || adapter.capabilities.some((capability) => typeof capability !== "string" || !capability.trim())) fail("adapter.capabilities must contain non-empty strings.", "INVALID_INPUT");
@@ -1346,18 +1846,18 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
   };
   const complete = (input) => {
     open();
-    const actionId = required(input.actionId, "actionId");
+    const actionId = required7(input.actionId, "actionId");
     if (!pending.has(actionId)) fail(`Tool action is not pending: ${actionId}.`, "INVALID_STATE");
-    const event = append("tool.completed", { actionId, resultHash: required(input.resultHash, "resultHash"), durationMs: duration(input.durationMs), ...input.runtimeEvidence ? { runtimeEvidence: input.runtimeEvidence } : {} });
+    const event = append("tool.completed", { actionId, resultHash: required7(input.resultHash, "resultHash"), durationMs: duration(input.durationMs), ...input.runtimeEvidence ? { runtimeEvidence: input.runtimeEvidence } : {} });
     pending.delete(actionId);
     return event;
   };
   const failAction = (input) => {
     open();
-    const actionId = required(input.actionId, "actionId");
+    const actionId = required7(input.actionId, "actionId");
     if (!pending.has(actionId)) fail(`Tool action is not pending: ${actionId}.`, "INVALID_STATE");
     if (typeof input.retryable !== "boolean") fail("retryable must be boolean.", "INVALID_INPUT");
-    const event = append("tool.failed", { actionId, errorCode: required(input.errorCode, "errorCode"), retryable: input.retryable, durationMs: duration(input.durationMs), ...input.runtimeEvidence ? { runtimeEvidence: input.runtimeEvidence } : {} });
+    const event = append("tool.failed", { actionId, errorCode: required7(input.errorCode, "errorCode"), retryable: input.retryable, durationMs: duration(input.durationMs), ...input.runtimeEvidence ? { runtimeEvidence: input.runtimeEvidence } : {} });
     pending.delete(actionId);
     return event;
   };
@@ -1365,24 +1865,24 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
     sessionId: id2,
     startTurn: (inputHash, turnId = randomUUID()) => {
       open();
-      const turn = required(turnId, "turnId");
+      const turn = required7(turnId, "turnId");
       if (turns.has(turn)) fail(`Turn already exists: ${turn}.`, "INVALID_STATE");
-      const event = append("agent.turn.started", { turnId: turn, inputHash: required(inputHash, "inputHash") });
+      const event = append("agent.turn.started", { turnId: turn, inputHash: required7(inputHash, "inputHash") });
       turns.add(turn);
       return event;
     },
     requestTool: (input) => {
       open();
-      const turnId = required(input.turnId, "turnId");
+      const turnId = required7(input.turnId, "turnId");
       if (!turns.has(turnId)) fail(`Turn does not exist: ${turnId}.`, "INVALID_STATE");
-      const actionId = required(input.actionId ?? randomUUID(), "actionId");
+      const actionId = required7(input.actionId ?? randomUUID(), "actionId");
       if (actions.has(actionId)) fail(`Tool action already exists: ${actionId}.`, "INVALID_STATE");
-      const toolId = required(input.toolId, "toolId");
-      const argumentsHash = required(input.argumentsHash, "argumentsHash");
+      const toolId = required7(input.toolId, "toolId");
+      const argumentsHash = required7(input.argumentsHash, "argumentsHash");
       const decision = policy.evaluate({ actionId, turnId, toolId, argumentsHash });
       if (!decision || decision.decision !== "allow" && decision.decision !== "block" && decision.decision !== "approve") fail("Policy decision is invalid.", "HARNESS_ERROR");
-      const policyId = required(decision.policyId, "policyId");
-      const reason = required(decision.reason, "policy reason");
+      const policyId = required7(decision.policyId, "policyId");
+      const reason = required7(decision.reason, "policy reason");
       append("policy.evaluated", { actionId, turnId, toolId, decision: decision.decision, policyId, reason });
       actions.add(actionId);
       if (decision.decision === "block") {
@@ -1400,7 +1900,7 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
     },
     approveTool: (input) => {
       open();
-      const actionId = required(input.actionId, "actionId");
+      const actionId = required7(input.actionId, "actionId");
       const approval = approvals.get(actionId) ?? fail(`Tool action is not awaiting human approval: ${actionId}.`, "INVALID_STATE");
       if (input.actor !== void 0 && input.actor !== "human") fail("Tool approval requires a human actor.", "HUMAN_APPROVAL_REQUIRED");
       const decision = input.decision;
@@ -1414,7 +1914,7 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
     },
     recoverTool: (input) => {
       open();
-      const actionId = required(input.actionId, "actionId");
+      const actionId = required7(input.actionId, "actionId");
       const action = pending.get(actionId) ?? fail(`Tool action is not pending: ${actionId}.`, "INVALID_STATE");
       if (!action.executionStarted) fail(`Tool action does not require recovery: ${actionId}.`, "INVALID_STATE");
       if (input.actor !== void 0 && input.actor !== "human") fail("Tool recovery requires a human actor.", "HUMAN_APPROVAL_REQUIRED");
@@ -1432,7 +1932,7 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
     failTool: failAction,
     executeTool: async (input) => {
       open();
-      const actionId = required(input.actionId, "actionId");
+      const actionId = required7(input.actionId, "actionId");
       const action = pending.get(actionId) ?? fail(`Tool action is not pending: ${actionId}.`, "INVALID_STATE");
       if (action.executionStarted) fail(`Tool action requires human recovery decision: ${actionId}.`, "HUMAN_APPROVAL_REQUIRED");
       if (executing.has(actionId)) fail(`Tool action is already executing: ${actionId}.`, "INVALID_STATE");
@@ -1476,7 +1976,7 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
 };
 
 // src/policy.ts
-var required2 = (value, label) => {
+var required8 = (value, label) => {
   if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
   return value.trim();
 };
@@ -1484,25 +1984,26 @@ var createPolicyGate = ({ rules }) => {
   if (!Array.isArray(rules)) fail("Policy rules must be an array.", "INVALID_INPUT");
   const normalized = rules.map((rule, index2) => {
     if (typeof rule !== "object" || rule === null || Array.isArray(rule)) fail(`rules[${index2}] must be an object.`, "INVALID_INPUT");
-    const id2 = required2(rule.id, `rules[${index2}].id`);
+    const id2 = required8(rule.id, `rules[${index2}].id`);
     if (rule.effect !== "allow" && rule.effect !== "block" && rule.effect !== "approve") fail(`rules[${index2}].effect is invalid.`, "INVALID_INPUT");
     if (!Array.isArray(rule.toolIds) || !rule.toolIds.length || rule.toolIds.some((toolId) => typeof toolId !== "string" || !toolId.trim())) fail(`rules[${index2}].toolIds must contain non-empty strings.`, "INVALID_INPUT");
-    return { id: id2, effect: rule.effect, toolIds: rule.toolIds.map((toolId) => required2(toolId, `rules[${index2}].toolIds`)), reason: required2(rule.reason, `rules[${index2}].reason`) };
+    return { id: id2, effect: rule.effect, toolIds: rule.toolIds.map((toolId) => required8(toolId, `rules[${index2}].toolIds`)), reason: required8(rule.reason, `rules[${index2}].reason`) };
   });
   if (new Set(normalized.map((rule) => rule.id)).size !== normalized.length) fail("Policy rules must have unique ids.", "INVALID_INPUT");
   return {
     evaluate: (request) => {
       if (typeof request !== "object" || request === null || Array.isArray(request)) fail("Policy request must be an object.", "INVALID_INPUT");
-      required2(request.actionId, "request.actionId");
-      required2(request.turnId, "request.turnId");
-      const toolId = required2(request.toolId, "request.toolId");
-      required2(request.argumentsHash, "request.argumentsHash");
+      required8(request.actionId, "request.actionId");
+      required8(request.turnId, "request.turnId");
+      const toolId = required8(request.toolId, "request.toolId");
+      required8(request.argumentsHash, "request.argumentsHash");
       const rule = normalized.find((candidate) => candidate.toolIds.includes(toolId));
       return rule ? { decision: rule.effect, policyId: rule.id, reason: rule.reason } : { decision: "block", policyId: "default-deny", reason: `No policy rule allows tool: ${toolId}.` };
     }
   };
 };
-var required3 = (value, label) => {
+var createConfiguredToolRuntime = ({ runtime, process: process2, docker }) => runtime.kind === "docker" ? createDockerToolRuntime(docker) : createProcessToolRuntime(process2);
+var required9 = (value, label) => {
   if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
   return value.trim();
 };
@@ -1516,7 +2017,7 @@ var positiveNumber = (value, label) => {
   return normalized;
 };
 var absolutePath = (value, label) => {
-  const normalized = required3(value, label);
+  const normalized = required9(value, label);
   if (!normalized.startsWith("/") || normalized.includes(",")) fail(`${label} must be an absolute path without commas.`, "INVALID_INPUT");
   return normalized;
 };
@@ -1534,7 +2035,7 @@ var createToolRuntime = ({ tools, timeoutMs = 3e4 }) => {
   if (!Number.isInteger(timeoutMs) || timeoutMs < 1) fail("Runtime timeoutMs must be a positive integer.", "INVALID_INPUT");
   const normalized = tools.map((tool, index2) => {
     if (typeof tool !== "object" || tool === null || Array.isArray(tool)) fail(`tools[${index2}] must be an object.`, "INVALID_INPUT");
-    const toolId = required3(tool.toolId, `tools[${index2}].toolId`);
+    const toolId = required9(tool.toolId, `tools[${index2}].toolId`);
     if (typeof tool.execute !== "function") fail(`tools[${index2}].execute is required.`, "INVALID_INPUT");
     return { toolId, execute: tool.execute };
   });
@@ -1542,10 +2043,10 @@ var createToolRuntime = ({ tools, timeoutMs = 3e4 }) => {
   return {
     execute: async (request) => {
       const started = Date.now();
-      const actionId = required3(request.actionId, "request.actionId");
-      const turnId = required3(request.turnId, "request.turnId");
-      const toolId = required3(request.toolId, "request.toolId");
-      const argumentsHash = required3(request.argumentsHash, "request.argumentsHash");
+      const actionId = required9(request.actionId, "request.actionId");
+      const turnId = required9(request.turnId, "request.turnId");
+      const toolId = required9(request.toolId, "request.toolId");
+      const argumentsHash = required9(request.argumentsHash, "request.argumentsHash");
       const tool = normalized.find((candidate) => candidate.toolId === toolId);
       if (!tool) return { status: "failed", errorCode: "TOOL_NOT_FOUND", retryable: false, durationMs: duration2(Date.now() - started) };
       const controller = new AbortController();
@@ -1575,8 +2076,8 @@ var createProcessToolRuntime = ({ tools, timeoutMs = 3e4, maxOutputBytes = 10485
   if (!Number.isInteger(maxOutputBytes) || maxOutputBytes < 1) fail("Process runtime maxOutputBytes must be a positive integer.", "INVALID_INPUT");
   const normalized = tools.map((tool, index2) => {
     if (typeof tool !== "object" || tool === null || Array.isArray(tool)) fail(`tools[${index2}] must be an object.`, "INVALID_INPUT");
-    const toolId = required3(tool.toolId, `tools[${index2}].toolId`);
-    const command = required3(tool.command, `tools[${index2}].command`);
+    const toolId = required9(tool.toolId, `tools[${index2}].toolId`);
+    const command = required9(tool.command, `tools[${index2}].command`);
     if (tool.args !== void 0 && (!Array.isArray(tool.args) || tool.args.some((arg) => typeof arg !== "string"))) fail(`tools[${index2}].args must contain strings.`, "INVALID_INPUT");
     if (tool.env !== void 0 && (typeof tool.env !== "object" || tool.env === null || Array.isArray(tool.env) || Object.values(tool.env).some((value) => typeof value !== "string"))) fail(`tools[${index2}].env must contain string values.`, "INVALID_INPUT");
     return { toolId, command, args: tool.args ? [...tool.args] : [], ...tool.cwd ? { cwd: tool.cwd } : {}, env: tool.env ? { ...tool.env } : { PATH: process.env["PATH"] ?? "" } };
@@ -1585,10 +2086,10 @@ var createProcessToolRuntime = ({ tools, timeoutMs = 3e4, maxOutputBytes = 10485
   return {
     execute: async (request) => {
       const started = Date.now();
-      const actionId = required3(request.actionId, "request.actionId");
-      const turnId = required3(request.turnId, "request.turnId");
-      const toolId = required3(request.toolId, "request.toolId");
-      const argumentsHash = required3(request.argumentsHash, "request.argumentsHash");
+      const actionId = required9(request.actionId, "request.actionId");
+      const turnId = required9(request.turnId, "request.turnId");
+      const toolId = required9(request.toolId, "request.toolId");
+      const argumentsHash = required9(request.argumentsHash, "request.argumentsHash");
       const tool = normalized.find((candidate) => candidate.toolId === toolId);
       if (!tool) return { status: "failed", errorCode: "TOOL_NOT_FOUND", retryable: false, durationMs: Date.now() - started };
       let input;
@@ -1598,7 +2099,7 @@ var createProcessToolRuntime = ({ tools, timeoutMs = 3e4, maxOutputBytes = 10485
         return { status: "failed", errorCode: "SERIALIZATION_ERROR", retryable: false, durationMs: Date.now() - started };
       }
       return new Promise((resolve6) => {
-        const child = spawn(tool.command, tool.args, { cwd: tool.cwd, env: tool.env, shell: false, stdio: ["pipe", "pipe", "pipe"] });
+        const child = spawn(tool.command, [...tool.args], { cwd: tool.cwd, env: tool.env, shell: false, stdio: ["pipe", "pipe", "pipe"] });
         let stdout = "";
         let timedOut = false;
         let outputLimit = false;
@@ -1658,17 +2159,17 @@ var createDockerToolRuntime = ({
   pull = "never"
 }) => {
   if (!Array.isArray(tools)) fail("Docker runtime tools must be an array.", "INVALID_INPUT");
-  const command = required3(dockerCommand, "dockerCommand");
-  const memory = required3(memoryLimit, "memoryLimit");
+  const command = required9(dockerCommand, "dockerCommand");
+  const memory = required9(memoryLimit, "memoryLimit");
   const cpu = positiveNumber(cpus, "cpus");
   if (!Number.isInteger(pidsLimit) || pidsLimit < 1) fail("pidsLimit must be a positive integer.", "INVALID_INPUT");
-  const normalizedUser = required3(user, "user");
+  const normalizedUser = required9(user, "user");
   if (normalizedUser.includes(" ")) fail("user must not contain spaces.", "INVALID_INPUT");
   if (pull !== "never" && pull !== "missing" && pull !== "always") fail("pull must be never, missing, or always.", "INVALID_INPUT");
   const normalized = tools.map((tool, index2) => {
     if (typeof tool !== "object" || tool === null || Array.isArray(tool)) fail(`tools[${index2}] must be an object.`, "INVALID_INPUT");
-    const toolId = required3(tool.toolId, `tools[${index2}].toolId`);
-    const image = required3(tool.image, `tools[${index2}].image`);
+    const toolId = required9(tool.toolId, `tools[${index2}].toolId`);
+    const image = required9(tool.image, `tools[${index2}].image`);
     if (!Array.isArray(tool.command) || tool.command.length === 0 || tool.command.some((part) => typeof part !== "string" || !part.trim())) fail(`tools[${index2}].command must be a non-empty string array.`, "INVALID_INPUT");
     if (tool.args !== void 0 && (!Array.isArray(tool.args) || tool.args.some((arg) => typeof arg !== "string"))) fail(`tools[${index2}].args must contain strings.`, "INVALID_INPUT");
     const env = dockerEnvironment(tool.env, `tools[${index2}].env`);
@@ -1738,6 +2239,381 @@ var createDockerToolRuntime = ({
     }
   };
 };
+var required10 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var safeKey = (identity) => hashJson(identity);
+var now3 = () => (/* @__PURE__ */ new Date()).toISOString();
+var parse = (value, label) => {
+  try {
+    const raw = JSON.parse(value);
+    const identity = {
+      tracker: required10(raw["tracker"], `${label}.tracker`),
+      repository: required10(raw["repository"], `${label}.repository`),
+      issue: required10(raw["issue"], `${label}.issue`),
+      worktree: required10(raw["worktree"], `${label}.worktree`),
+      branch: required10(raw["branch"], `${label}.branch`)
+    };
+    return { ...identity, key: required10(raw["key"], `${label}.key`), leaseId: required10(raw["leaseId"], `${label}.leaseId`), owner: required10(raw["owner"], `${label}.owner`), claimedAt: required10(raw["claimedAt"], `${label}.claimedAt`) };
+  } catch (error) {
+    if (error instanceof SyntaxError) fail(`${label} contains invalid JSON.`, "HARNESS_ERROR");
+    throw error;
+  }
+};
+var createDispatchLedger = (stateDir) => {
+  const root = required10(stateDir, "stateDir");
+  const claimsDir = join(root, "coordination", "claims");
+  const ledgerPath = join(root, "coordination", "dispatch-ledger.ndjson");
+  mkdirSync(claimsDir, { recursive: true });
+  const claimPath = (key) => join(claimsDir, `${key}.json`);
+  const append = (record3) => appendFileSync(ledgerPath, `${JSON.stringify(record3)}
+`, "utf8");
+  const records = () => {
+    if (!existsSync(ledgerPath)) return [];
+    return readFileSync(ledgerPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line, index2) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return fail(`Dispatch ledger record ${index2 + 1} is invalid JSON.`, "HARNESS_ERROR");
+      }
+    });
+  };
+  const active = () => {
+    const byKey = /* @__PURE__ */ new Map();
+    for (const record3 of records()) {
+      if (record3.action === "release" || record3.action === "recover") byKey.delete(record3.key);
+      else if (record3.action === "dispatch") byKey.set(record3.key, record3);
+    }
+    return [...byKey.values()];
+  };
+  return {
+    claim: (input) => {
+      const identity = {
+        tracker: required10(input.tracker, "tracker"),
+        repository: required10(input.repository, "repository"),
+        issue: required10(input.issue, "issue"),
+        worktree: required10(input.worktree, "worktree"),
+        branch: required10(input.branch, "branch")
+      };
+      const owner = required10(input.owner, "owner");
+      const key = safeKey(identity);
+      const path = claimPath(key);
+      if (existsSync(path)) return { decision: "already-claimed", lease: parse(readFileSync(path, "utf8"), "claim") };
+      const lease = { ...identity, key, leaseId: randomUUID(), owner, claimedAt: now3() };
+      let fd;
+      try {
+        fd = openSync(path, "wx");
+      } catch (error) {
+        if (error.code === "EEXIST") return { decision: "already-claimed", lease: parse(readFileSync(path, "utf8"), "claim") };
+        throw error;
+      }
+      try {
+        writeFileSync(fd, JSON.stringify(lease), "utf8");
+      } finally {
+        closeSync(fd);
+      }
+      append({ ...lease, action: "dispatch", at: lease.claimedAt });
+      return { decision: "claimed", lease };
+    },
+    recordDispatch: ({ lease, idempotencyKey, commandDigest }) => {
+      const id2 = required10(idempotencyKey, "idempotencyKey");
+      const digest3 = required10(commandDigest, "commandDigest");
+      const existing = records().find((record4) => record4.action === "dispatch" && record4.idempotencyKey === id2);
+      if (existing) return { decision: "duplicate", record: existing };
+      const record3 = { ...lease, action: "dispatch", at: now3(), idempotencyKey: id2, commandDigest: digest3 };
+      append(record3);
+      return { decision: "recorded", record: record3 };
+    },
+    release: (lease, reason = "lease released") => {
+      const path = claimPath(required10(lease.key, "lease.key"));
+      if (!existsSync(path)) fail("Dispatch lease is not active.", "INVALID_STATE");
+      const current = parse(readFileSync(path, "utf8"), "claim");
+      if (current.leaseId !== lease.leaseId) fail("Dispatch lease owner does not match.", "INVALID_STATE");
+      unlinkSync(path);
+      const record3 = { ...current, action: "release", at: now3(), reason: required10(reason, "reason") };
+      append(record3);
+      return record3;
+    },
+    recover: (key, input) => {
+      if (input.actor !== "human") fail("Dispatch lease recovery requires a human actor.", "HUMAN_APPROVAL_REQUIRED");
+      const normalizedKey = required10(key, "key");
+      const maxAgeMs = input.maxAgeMs ?? 3e5;
+      if (!Number.isInteger(maxAgeMs) || maxAgeMs < 0) fail("maxAgeMs must be a non-negative integer.", "INVALID_INPUT");
+      const path = claimPath(normalizedKey);
+      if (!existsSync(path)) fail("Dispatch lease is not active.", "INVALID_STATE");
+      const current = parse(readFileSync(path, "utf8"), "claim");
+      if (Date.now() - Date.parse(current.claimedAt) < maxAgeMs) fail("Dispatch lease is not old enough to recover.", "HARNESS_ERROR");
+      unlinkSync(path);
+      const record3 = { ...current, action: "recover", at: now3(), reason: required10(input.reason, "reason") };
+      append(record3);
+      return record3;
+    },
+    active,
+    records
+  };
+};
+
+// src/resilience.ts
+var positiveInteger = (value, label) => {
+  if (!Number.isInteger(value) || value < 1) fail(`${label} must be a positive integer.`, "INVALID_INPUT");
+  return value;
+};
+var nonNegativeInteger3 = (value, label) => {
+  if (!Number.isInteger(value) || value < 0) fail(`${label} must be a non-negative integer.`, "INVALID_INPUT");
+  return value;
+};
+var classifyFailure = (error) => {
+  const value = error;
+  const code = typeof value?.code === "string" ? value.code.toUpperCase() : "";
+  const message = typeof value?.message === "string" ? value.message : String(error);
+  const text5 = `${code} ${message}`.toLowerCase();
+  if (/quota|rate.?limit|too many requests|429/.test(text5)) return { class: "quota", retryable: true, reason: message };
+  if (/timeout|timed out|deadline/.test(text5)) return { class: "timeout", retryable: true, reason: message };
+  if (/policy|forbidden|permission|approval/.test(text5)) return { class: "policy", retryable: false, reason: message };
+  if (/invalid|schema|argument|config|validation/.test(text5)) return { class: "validation", retryable: false, reason: message };
+  if (/network|connection|econn|503|502|external/.test(text5)) return { class: "external", retryable: true, reason: message };
+  return { class: "unknown", retryable: false, reason: message };
+};
+var recoveryDelayMs = (attempt, policy) => {
+  positiveInteger(attempt, "attempt");
+  nonNegativeInteger3(policy.baseDelayMs, "baseDelayMs");
+  nonNegativeInteger3(policy.maxDelayMs, "maxDelayMs");
+  if (policy.maxDelayMs < policy.baseDelayMs) fail("maxDelayMs must be greater than or equal to baseDelayMs.", "INVALID_INPUT");
+  return Math.min(policy.maxDelayMs, policy.baseDelayMs * 2 ** Math.max(0, attempt - 1));
+};
+var wait = (delayMs, sleep) => delayMs > 0 ? sleep(delayMs) : Promise.resolve();
+var runWithRecovery = async (operation, options) => {
+  const maxAttempts = positiveInteger(options.maxAttempts, "maxAttempts");
+  const baseDelayMs = nonNegativeInteger3(options.baseDelayMs, "baseDelayMs");
+  const maxDelayMs = nonNegativeInteger3(options.maxDelayMs, "maxDelayMs");
+  if (maxDelayMs < baseDelayMs) fail("maxDelayMs must be greater than or equal to baseDelayMs.", "INVALID_INPUT");
+  if (options.timeoutMs !== void 0) positiveInteger(options.timeoutMs, "timeoutMs");
+  const sleep = options.sleep ?? ((delayMs) => new Promise((resolve6) => setTimeout(resolve6, delayMs)));
+  const observations = [];
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const controller = new AbortController();
+    let timer;
+    try {
+      const operationPromise = operation(controller.signal, attempt);
+      const value = options.timeoutMs === void 0 ? await operationPromise : await Promise.race([
+        operationPromise,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            controller.abort();
+            reject(new Error("operation timed out"));
+          }, options.timeoutMs);
+        })
+      ]);
+      return { status: "completed", attempts: attempt, observations, value };
+    } catch (error) {
+      const failure = classifyFailure(error);
+      const delayMs = failure.retryable && attempt < maxAttempts ? recoveryDelayMs(attempt, { baseDelayMs, maxDelayMs }) : 0;
+      const observation = { attempt, failure, delayMs };
+      observations.push(observation);
+      options.onObservation?.(observation);
+      if (!failure.retryable || attempt >= maxAttempts) return { status: "failed", attempts: attempt, observations, failure };
+      await wait(delayMs, sleep);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  return fail("Recovery loop exhausted unexpectedly.", "HARNESS_ERROR");
+};
+var DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".txt", ".adoc", ".rst"]);
+var TEST_SUFFIXES = [".test.", ".spec.", "__tests__"];
+var SHELL_META = /[;&|`$()<>\n\r]/;
+var normalizedPath = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} must be a non-empty path.`, "INVALID_INPUT");
+  const path = value.trim().replaceAll("\\", "/");
+  if (path.startsWith("/") || path.split("/").includes("..")) fail(`${label} must be repository-relative.`, "INVALID_INPUT");
+  return path;
+};
+var validateSafeCommand = (command) => {
+  if (typeof command !== "string" || !command.trim()) fail("command must be a non-empty string.", "INVALID_INPUT");
+  const value = command.trim();
+  if (SHELL_META.test(value)) fail("command contains shell metacharacters; use argv-based execution.", "POLICY_BLOCKED");
+  return { valid: true, command: value };
+};
+var isTest = (path) => TEST_SUFFIXES.some((suffix) => path.includes(suffix)) || /(^|\/)(test|tests|__tests__)\//.test(path);
+var isDoc = (path) => DOC_EXTENSIONS.has(extname(path).toLowerCase());
+var planFilePreflight = (files, options = {}) => {
+  if (!Array.isArray(files)) fail("files must be an array.", "INVALID_INPUT");
+  const unique2 = [...new Set(files.map((file, index2) => normalizedPath(file.path, `files[${index2}].path`)))].sort();
+  const codeFiles = unique2.filter((path) => !isDoc(path) && !isTest(path));
+  const existingTests = unique2.filter(isTest);
+  const roots = (options.testRoots ?? ["test", "tests", "__tests__"]).map((root, index2) => normalizedPath(root, `testRoots[${index2}]`));
+  const colocated = options.includeTests === false ? [] : codeFiles.flatMap((path) => {
+    const file = basename(path);
+    const directory = dirname(path);
+    const stem = file.includes(".") ? file.slice(0, file.lastIndexOf(".")) : file;
+    return [join(directory, `${stem}.test.ts`), join(directory, `${stem}.spec.ts`)].filter((candidate) => unique2.includes(candidate));
+  });
+  const testFiles = [...new Set([...existingTests, ...colocated, ...unique2.filter((path) => roots.some((root) => path === root || path.startsWith(`${root}/`)))].sort())];
+  const docsOnly = unique2.length > 0 && codeFiles.length === 0 && existingTests.length === 0;
+  return { files: unique2, codeFiles, testFiles, docsOnly, checks: docsOnly ? [] : ["lint", "typecheck", ...testFiles.length ? ["test"] : []] };
+};
+
+// src/block.ts
+var BLOCK_STATUSES = ["todo", "picked", "development", "validation", "pr-open", "merged", "post-merge", "done", "blocked", "scope-cut"];
+var text3 = (value, label) => {
+  return typeof value === "string" && value.trim() ? value.trim() : fail(`${label} must be a non-empty string.`, "INVALID_INPUT");
+};
+var list = (value, label) => {
+  if (!Array.isArray(value)) return fail(`${label} must be an array of non-empty strings.`, "INVALID_INPUT");
+  if (!value.every((item) => typeof item === "string" && Boolean(item.trim()))) return fail(`${label} must be an array of non-empty strings.`, "INVALID_INPUT");
+  return [...new Set(value.map((item) => item.trim()))];
+};
+var validateBlockManifest = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail("block manifest must be an object.", "INVALID_INPUT");
+  const raw = value;
+  if (raw["schemaVersion"] !== 1) fail("block manifest schemaVersion must be 1.", "INVALID_INPUT");
+  const criteria = list(raw["acceptanceCriteria"], "acceptanceCriteria");
+  if (!criteria.length) fail("acceptanceCriteria must not be empty.", "INVALID_INPUT");
+  const dependencies = list(raw["dependencies"] ?? [], "dependencies");
+  const wave = raw["wave"];
+  if (!Number.isInteger(wave) || wave < 1) fail("wave must be a positive integer.", "INVALID_INPUT");
+  const status = raw["status"];
+  if (!BLOCK_STATUSES.includes(status)) fail("status is invalid.", "INVALID_INPUT");
+  const budgetRaw = raw["budget"];
+  let budget;
+  if (budgetRaw !== void 0) {
+    if (typeof budgetRaw !== "object" || budgetRaw === null || Array.isArray(budgetRaw)) fail("budget must be an object.", "INVALID_INPUT");
+    const candidate = budgetRaw;
+    for (const key of ["maxMinutes", "maxAttempts"]) if (candidate[key] !== void 0 && (!Number.isInteger(candidate[key]) || candidate[key] < 1)) fail(`budget.${key} must be a positive integer.`, "INVALID_INPUT");
+    budget = { ...candidate["maxMinutes"] === void 0 ? {} : { maxMinutes: candidate["maxMinutes"] }, ...candidate["maxAttempts"] === void 0 ? {} : { maxAttempts: candidate["maxAttempts"] } };
+  }
+  return { schemaVersion: 1, id: text3(raw["id"], "id"), title: text3(raw["title"], "title"), tracker: text3(raw["tracker"], "tracker"), repository: text3(raw["repository"], "repository"), acceptanceCriteria: criteria, dependencies, wave, status, ...budget ? { budget } : {}, ...raw["humanGates"] === void 0 ? {} : { humanGates: list(raw["humanGates"], "humanGates") }, ...raw["sourceHash"] === void 0 ? {} : { sourceHash: text3(raw["sourceHash"], "sourceHash") } };
+};
+var assessBlock = (manifest, completedDependencies = []) => {
+  const value = validateBlockManifest(manifest);
+  const completed = new Set(completedDependencies.map((item) => text3(item, "completedDependencies[]")));
+  const blockers = value.dependencies.filter((dependency) => !completed.has(dependency));
+  const next = blockers.length ? [`Complete dependencies: ${blockers.join(", ")}`] : value.status === "blocked" ? ["Resolve the recorded blocker before dispatch."] : ["Dispatch the block with the frozen acceptance criteria."];
+  return { status: blockers.length || value.status === "blocked" ? "blocked" : "ready", manifestHash: hashJson(value), blockers, next };
+};
+var LEARNING_STATUSES = ["proposed", "promoted", "rejected"];
+var text4 = (value, label) => {
+  return typeof value === "string" && value.trim() ? value.trim() : fail(`${label} must be a non-empty string.`, "INVALID_INPUT");
+};
+var category = (heading) => {
+  const value = heading.toLowerCase();
+  if (/went well|success|worked/.test(value)) return "worked";
+  if (/problem|failed|blocker|pain/.test(value)) return "problem";
+  if (/adjust|action|next|improv/.test(value)) return "adjustment";
+  return "other";
+};
+var parseRetro = (markdown, source, recordedAt = (/* @__PURE__ */ new Date()).toISOString()) => {
+  const input = text4(markdown, "markdown");
+  const origin = text4(source, "source");
+  if (!Number.isFinite(Date.parse(recordedAt))) fail("recordedAt must be a valid timestamp.", "INVALID_INPUT");
+  const records = [];
+  let current = "other";
+  for (const line of input.split(/\r?\n/)) {
+    const heading = line.match(/^#{1,6}\s+(.+)$/);
+    if (heading) {
+      current = category(heading[1] ?? "");
+      continue;
+    }
+    const item = line.match(/^\s*[-*]\s+(?:\[[ xX]\]\s+)?(.+?)\s*$/);
+    if (!item?.[1]?.trim()) continue;
+    const value = item[1].trim();
+    const id2 = `L-${createHash("sha256").update(`${origin}|${current}|${value}`).digest("hex").slice(0, 12)}`;
+    if (!records.some((record3) => record3.id === id2)) records.push({ id: id2, source: origin, category: current, text: value, status: "proposed", recordedAt });
+  }
+  return records;
+};
+var promoteLearnings = (records, input) => {
+  if (input.actor !== "human") fail("Learning promotion requires a human actor.", "HUMAN_APPROVAL_REQUIRED");
+  const ids = new Set(input.ids.map((id2) => text4(id2, "ids[]")));
+  const status = input.status ?? "promoted";
+  const result = records.map((record3) => ids.has(record3.id) ? { ...record3, status } : record3);
+  const unknown = [...ids].filter((id2) => !records.some((record3) => record3.id === id2));
+  if (unknown.length) fail(`Unknown learning IDs: ${unknown.join(", ")}`, "INVALID_INPUT");
+  return result;
+};
+
+// src/status.ts
+var required11 = (value, label) => {
+  return typeof value === "string" && value.trim() ? value.trim() : fail(`${label} must be a non-empty string.`, "INVALID_INPUT");
+};
+var createStatusSnapshot = (input) => {
+  const sourceRevision = required11(input.sourceRevision, "sourceRevision");
+  if (!Number.isFinite(Date.parse(input.generatedAt))) fail("generatedAt must be a valid timestamp.", "INVALID_INPUT");
+  if (!Array.isArray(input.blocks)) fail("blocks must be an array.", "INVALID_INPUT");
+  const blocks = input.blocks.map((block, index2) => {
+    if (typeof block !== "object" || block === null || Array.isArray(block)) fail(`blocks[${index2}] must be an object.`, "INVALID_INPUT");
+    const value = block;
+    if (!(typeof value.id === "string" && value.id.trim())) fail(`blocks[${index2}].id is required.`, "INVALID_INPUT");
+    if (!["todo", "picked", "development", "validation", "pr-open", "merged", "post-merge", "done", "blocked", "scope-cut"].includes(value.status)) fail(`blocks[${index2}].status is invalid.`, "INVALID_INPUT");
+    return { ...value, id: value.id.trim() };
+  }).sort((left, right) => left.id.localeCompare(right.id));
+  if (input.metrics !== void 0 && Object.entries(input.metrics).some(([key, value]) => !key.trim() || typeof value !== "number" || !Number.isFinite(value) || value < 0)) fail("metrics must contain finite non-negative numbers.", "INVALID_INPUT");
+  const body2 = { schemaVersion: 1, generatedAt: input.generatedAt, sourceRevision, blocks, ...input.machine ? { machine: input.machine } : {}, ...input.metrics ? { metrics: input.metrics } : {}, ...input.next ? { next: required11(input.next, "next") } : {} };
+  return { ...body2, digest: hashJson(body2) };
+};
+var validateStatusSnapshot = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail("status snapshot must be an object.", "INVALID_INPUT");
+  const raw = value;
+  const snapshot = createStatusSnapshot({ generatedAt: required11(raw.generatedAt, "generatedAt"), sourceRevision: required11(raw.sourceRevision, "sourceRevision"), blocks: raw.blocks, ...raw.machine ? { machine: raw.machine } : {}, ...raw.metrics ? { metrics: raw.metrics } : {}, ...raw.next ? { next: raw.next } : {} });
+  if (raw.schemaVersion !== 1 || raw.digest !== snapshot.digest) fail("status snapshot digest or schemaVersion is invalid.", "HARNESS_ERROR");
+  return snapshot;
+};
+
+// src/model-policy.ts
+var MODEL_ROLES = ["orchestrator", "reviewer", "builder", "watcher"];
+var required12 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var createModelPolicy = (bindings) => {
+  if (!Array.isArray(bindings) || !bindings.length) fail("bindings must be a non-empty array.", "INVALID_INPUT");
+  const normalized = bindings.map((binding2, index2) => {
+    if (typeof binding2 !== "object" || binding2 === null || Array.isArray(binding2)) fail(`bindings[${index2}] must be an object.`, "INVALID_INPUT");
+    if (!MODEL_ROLES.includes(binding2.role)) fail(`bindings[${index2}].role is invalid.`, "INVALID_INPUT");
+    if (binding2.maxTokens !== void 0 && (!Number.isInteger(binding2.maxTokens) || binding2.maxTokens < 1)) fail(`bindings[${index2}].maxTokens must be a positive integer.`, "INVALID_INPUT");
+    return { role: binding2.role, provider: required12(binding2.provider, `bindings[${index2}].provider`), model: required12(binding2.model, `bindings[${index2}].model`), ...binding2.maxTokens === void 0 ? {} : { maxTokens: binding2.maxTokens } };
+  });
+  if (new Set(normalized.map((binding2) => binding2.role)).size !== normalized.length) fail("Each model role may be bound only once.", "INVALID_INPUT");
+  return { bindings: normalized, digest: hashJson(normalized) };
+};
+var modelFor = (policy, role) => policy.bindings.find((binding2) => binding2.role === role) ?? fail(`No model binding exists for role: ${role}.`, "INVALID_STATE");
+
+// src/adapters/orca.ts
+var required13 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var createOrcaDispatchPlan = (input) => {
+  const repository = required13(input.repository, "repository");
+  const worktree = required13(input.worktree, "worktree");
+  const branch = required13(input.branch, "branch");
+  const baseBranch = required13(input.baseBranch, "baseBranch");
+  const goalFile = required13(input.goalFile, "goalFile");
+  const agent = required13(input.agent ?? "default", "agent");
+  const argv = ["orca", "worktree", "create", "--repo", repository, "--name", worktree, "--base-branch", baseBranch, "--agent", agent, "--prompt-file", goalFile];
+  validateSafeCommand(argv.join(" "));
+  const identity = { repository, worktree, branch, baseBranch, goalFile, agent };
+  return { argv, commandDigest: hashJson(argv), idempotencyKey: hashJson(identity) };
+};
+
+// src/adapters/tracking.ts
+var required14 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var createTrackingTransition = (input) => {
+  const transition2 = { tracker: required14(input.tracker, "tracker"), issue: required14(input.issue, "issue"), ...input.from ? { from: required14(input.from, "from") } : {}, to: required14(input.to, "to"), reason: required14(input.reason, "reason") };
+  return { ...transition2, idempotencyKey: hashJson(transition2) };
+};
+var createTrackingAdapter = (id2, handler) => {
+  const adapterId = required14(id2, "id");
+  return { id: adapterId, transition: async (input) => {
+    const transition2 = createTrackingTransition(input);
+    await handler(transition2);
+    return transition2;
+  } };
+};
 var EVIDENCE_BUNDLE_SCHEMA_VERSION = 1;
 var body = (bundle) => {
   const { payloadHash: _payloadHash, signature: _signature, ...unsigned } = bundle;
@@ -1764,7 +2640,7 @@ var exportEvidenceBundle = async ({ configPath, runId, outputPath, privateKeyPat
   const loaded = loadConfig(configPath);
   const run = requireRun2(runId ? readJson(join(loaded.stateDir, "runs", runId, "run.json")) : loadLatestRun(loaded.stateDir));
   const reconciliation = await reconcileRun({ configPath, runId: run.runId });
-  const digest2 = run.verificationDigest ?? fail("Only a reconciled COMPLETE run can be exported.", "INVALID_STATE");
+  const digest3 = run.verificationDigest ?? fail("Only a reconciled COMPLETE run can be exported.", "INVALID_STATE");
   if (reconciliation.state !== "COMPLETE") fail("Only a reconciled COMPLETE run can be exported.", "INVALID_STATE");
   const eventLog = new FileEventStore(loaded.stateDir);
   eventLog.read(run.runId);
@@ -1779,7 +2655,7 @@ var exportEvidenceBundle = async ({ configPath, runId, outputPath, privateKeyPat
     return bundleFile(loaded.stateDir, path);
   });
   const privateKey = createPrivateKey(readFileSync(privateKeyPath));
-  const unsigned = { type: "agentskit-harness-evidence-bundle", schemaVersion: EVIDENCE_BUNDLE_SCHEMA_VERSION, runId: run.runId, signerKeyId: keyId, sourceRevision: run.sourceRevision, configHash: run.configHash, contractHash: run.contractHash, verificationDigest: digest2, eventLog: eventVerification, files };
+  const unsigned = { type: "agentskit-harness-evidence-bundle", schemaVersion: EVIDENCE_BUNDLE_SCHEMA_VERSION, runId: run.runId, signerKeyId: keyId, sourceRevision: run.sourceRevision, configHash: run.configHash, contractHash: run.contractHash, verificationDigest: digest3, eventLog: eventVerification, files };
   const payloadHash = sha256(JSON.stringify(unsigned));
   const publicKeyPem = createPublicKey(privateKey).export({ type: "spki", format: "pem" }).toString();
   const bundle = { ...unsigned, payloadHash, signature: { algorithm: "ed25519", keyId, publicKeyPem, signatureBase64: sign(null, Buffer.from(payloadHash), privateKey).toString("base64") } };
@@ -1823,6 +2699,6 @@ var readEvidenceTrustStore = (path) => {
   });
 };
 
-export { BENCHMARK_SCHEMA_VERSION, CONTEXT_PROVIDER_SLOT, EVENT_LOG_GENESIS, EVIDENCE_BUNDLE_SCHEMA_VERSION, FileEventStore, HARNESS_EVENT_SCHEMA_VERSION, HARNESS_EVENT_TYPES, HARNESS_PLUGIN_API_VERSION, HarnessError, LEGAL_TRANSITIONS, STATES, approveRun, approvedDecision, assertHuman, authorizeRun, benchmarkRuns, cancelRun, cleanTaskArtifacts, createDocBridgeContextProvider, createDockerToolRuntime, createPluginRegistry, createPluginSlot, createPolicyGate, createProcessToolRuntime, createSessionRecorder, createToolRuntime, exportEvidenceBundle, hashContextSnapshot, hashContextSnapshots, inspectEventLogLock, loadBenchmarkManifest, loadConfig, loadLatestRun, planRun, readContextSnapshots, readEvidenceTrustStore, reconcileRun, recordBenchmarkObservation, recoverEventLogLock, retryRun, startRun, transition, validateBenchmarkManifest, validateConfig, validateContextSnapshot, validateContextSnapshots, validateExternalCodingBenchmarkReport, verifyEvidenceBundle, verifyRun };
+export { BENCHMARK_SCHEMA_VERSION, BLOCK_STATUSES, CONTEXT_PROVIDER_SLOT, EVENT_LOG_GENESIS, EVIDENCE_BUNDLE_SCHEMA_VERSION, FileEventStore, HARNESS_EVENT_SCHEMA_VERSION, HARNESS_EVENT_TYPES, HARNESS_PLUGIN_API_VERSION, HarnessError, IMPROVEMENT_CYCLE_STEPS, LEARNING_STATUSES, LEGAL_TRANSITIONS, MEMORY_SCOPES, MODEL_ROLES, STATES, WIP_STATES, adaptiveConcurrency, approveRun, approvedDecision, assertHuman, assessAcceptance, assessAgentEval, assessBlock, assessDiscovery, assessImprovementCycle, assessIntegration, assessPilot, assessPreflight, assessProduction, assessWip, assessWorktreeCleanup, authorizeRun, benchmarkRuns, cancelRun, classifyFailure, cleanTaskArtifacts, compareOptimization, composePullRequest, createConfiguredToolRuntime, createDispatchLedger, createDocBridgeContextProvider, createDockerToolRuntime, createInMemoryMemoryAdapter, createKvMemoryAdapter, createLlmCache, createLlmCacheKey, createMachineMonitor, createModelPolicy, createOrcaDispatchPlan, createPluginRegistry, createPluginSlot, createPolicyGate, createProcessToolRuntime, createSessionRecorder, createStatusSnapshot, createToolRuntime, createTrackingAdapter, createTrackingTransition, exportEvidenceBundle, hashContextSnapshot, hashContextSnapshots, inspectEventLogLock, isDiscoveryCurrent, loadBenchmarkManifest, loadConfig, loadLatestRun, modelFor, parseRetro, planFilePreflight, planRun, promoteLearnings, readContextSnapshots, readEvidenceTrustStore, reconcileRun, recordBenchmarkObservation, recoverEventLogLock, recoveryDelayMs, retryRun, runAgentEval, runWithRecovery, runWorkflow, sampleMachine, selectRuntime, startRun, summarizeMachine, transition, validateBenchmarkManifest, validateBlockManifest, validateCacheableOperation, validateConfig, validateContextSnapshot, validateContextSnapshots, validateMemoryRecord, validateOptimizationObservation, validateSafeCommand, validateStatusSnapshot, verifyEvidenceBundle, verifyRun };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map