@agentskit/harness 0.1.0 → 0.3.0

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { createPrivateKey, createPublicKey, sign, verify, createHash } from 'crypto';
-import { readFileSync, mkdirSync, writeFileSync, existsSync, openSync, writeSync, appendFileSync, closeSync, unlinkSync, mkdtempSync, renameSync, rmSync, lstatSync, readdirSync } from 'fs';
+import { createHash, randomUUID, createPrivateKey, createPublicKey, sign, verify } from 'crypto';
+import { readFileSync, mkdirSync, existsSync, unlinkSync, openSync, writeFileSync, closeSync, writeSync, appendFileSync, mkdtempSync, renameSync, rmSync, readdirSync } from 'fs';
 import { Command } from 'commander';
-import { resolve, dirname, relative, join, sep } from 'path';
+import { resolve, dirname, relative, basename, join, extname, sep } from 'path';
 import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
-import { tmpdir } from 'os';
+import { tmpdir, cpus, loadavg, freemem, totalmem } from 'os';
 
 // src/constants.ts
 var STATES = [
@@ -25,7 +25,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"],
@@ -63,9 +63,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"]] : [];
@@ -183,18 +185,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}]`);
@@ -208,10 +212,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");
@@ -228,13 +250,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 benchmark2 = 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 } : {}, ...benchmark2 ? { benchmark: benchmark2 } : {} };
+  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 } : {}, ...benchmark2 ? { benchmark: benchmark2 } : {} };
 };
 var loadConfig = (configPath = ".codex/verification.json") => {
   const absolute = resolve(configPath);
@@ -242,7 +266,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) };
 };
@@ -291,7 +315,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 context2 = record3["correlation"];
+  const validContext = context2 === void 0 || typeof context2 === "object" && context2 !== null && !Array.isArray(context2) && Object.entries(context2).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 context2["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");
@@ -320,6 +346,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 });
@@ -334,7 +361,7 @@ var FileEventStore = class {
     try {
       const events2 = this.readUnlocked(event.runId);
       const previous = events2.at(-1);
-      const body2 = { schemaVersion: HARNESS_EVENT_SCHEMA_VERSION, sequence: events2.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 } : events2.length ? {} : { previousHash: EVENT_LOG_GENESIS }, type: event.type, payload: event.payload };
+      const body2 = { schemaVersion: HARNESS_EVENT_SCHEMA_VERSION, sequence: events2.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 } : events2.length ? {} : { previousHash: EVENT_LOG_GENESIS }, type: event.type, payload: event.payload };
       const record3 = events2.length && !previous?.eventHash ? body2 : { ...body2, eventHash: eventDigest(body2) };
       appendFileSync(path, `${JSON.stringify(record3)}
 `, "utf8");
@@ -459,8 +486,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,
@@ -468,17 +494,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 } : {}
@@ -531,22 +558,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 status2 = 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: status2, diff, untracked };
+  return { revision, status: status2, 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, options2 = {}) => {
+  const sampler = options2.sample ?? sampleMachine;
+  const limits = thresholds(options2.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 };
     }
-  });
-  const fingerprint = { revision, status, diff, untracked };
-  return { revision: revision || `content:${hashJson(fingerprint)}`, status, statusHash: hashJson(fingerprint) };
+  };
 };
 
 // src/verification.ts
@@ -575,6 +677,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);
@@ -587,11 +695,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);
@@ -603,7 +708,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));
@@ -623,42 +728,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 required8 = outcome.checks.filter((id2) => loaded.config.checks.find((check) => check.id === id2)?.required);
+    return { ...outcome, status: required8.length === 0 ? "not-applicable" : required8.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;
@@ -672,11 +816,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 });
 };
@@ -696,7 +835,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 = events2.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");
@@ -758,7 +897,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);
@@ -785,14 +924,305 @@ 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) };
+};
+
+// 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 };
+};
 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 improvementDirection = (rate) => rate === null ? "unavailable" : rate > 0 ? "improved" : rate < 0 ? "regressed" : "unchanged";
 var count = (items, predicate) => items.filter(predicate).length;
 var median = (values) => {
   if (!values.length) return null;
@@ -807,25 +1237,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)]));
@@ -836,14 +1254,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,
@@ -854,12 +1264,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),
@@ -912,68 +1316,11 @@ var nonNegativeInteger = (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;
@@ -982,12 +1329,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));
@@ -995,17 +1337,13 @@ var validateBenchmarkManifest = (value) => {
   const observations = rawObservations.map((item, index2) => {
     if (typeof item !== "object" || item === null || Array.isArray(item)) fail(`benchmark.observations[${index2}] must be an object.`, "INVALID_CONFIG");
     const observation = item;
-    const status = observation["status"];
-    if (!["passed", "failed", "blocked", "not-run"].includes(String(status))) fail(`benchmark.observations[${index2}].status is invalid.`, "INVALID_CONFIG");
+    const status2 = observation["status"];
+    if (!["passed", "failed", "blocked", "not-run"].includes(String(status2))) fail(`benchmark.observations[${index2}].status is invalid.`, "INVALID_CONFIG");
     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 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 evidenceDigest = sha2562(observation["evidenceDigest"], `benchmark.observations[${index2}].evidenceDigest`);
@@ -1020,12 +1358,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: status2, 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 {
@@ -1051,9 +1387,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 },
@@ -1072,57 +1405,261 @@ 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 } } : {} };
+  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 required6 = (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: required6(raw["tracker"], `${label}.tracker`),
+      repository: required6(raw["repository"], `${label}.repository`),
+      issue: required6(raw["issue"], `${label}.issue`),
+      worktree: required6(raw["worktree"], `${label}.worktree`),
+      branch: required6(raw["branch"], `${label}.branch`)
+    };
+    return { ...identity, key: required6(raw["key"], `${label}.key`), leaseId: required6(raw["leaseId"], `${label}.leaseId`), owner: required6(raw["owner"], `${label}.owner`), claimedAt: required6(raw["claimedAt"], `${label}.claimedAt`) };
+  } catch (error) {
+    if (error instanceof SyntaxError) fail(`${label} contains invalid JSON.`, "HARNESS_ERROR");
+    throw error;
+  }
+};
+var createDispatchLedger = (stateDir) => {
+  const root = required6(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: required6(input.tracker, "tracker"),
+        repository: required6(input.repository, "repository"),
+        issue: required6(input.issue, "issue"),
+        worktree: required6(input.worktree, "worktree"),
+        branch: required6(input.branch, "branch")
+      };
+      const owner = required6(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 = required6(idempotencyKey, "idempotencyKey");
+      const digest3 = required6(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(required6(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: required6(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 = required6(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: required6(input.reason, "reason") };
+      append(record3);
+      return record3;
+    },
+    active,
+    records
+  };
+};
+var DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".txt", ".adoc", ".rst"]);
+var TEST_SUFFIXES = [".test.", ".spec.", "__tests__"];
+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 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, options2 = {}) => {
+  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 = (options2.testRoots ?? ["test", "tests", "__tests__"]).map((root, index2) => normalizedPath(root, `testRoots[${index2}]`));
+  const colocated = options2.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 text2 = (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 status2 = raw["status"];
+  if (!BLOCK_STATUSES.includes(status2)) 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: text2(raw["id"], "id"), title: text2(raw["title"], "title"), tracker: text2(raw["tracker"], "tracker"), repository: text2(raw["repository"], "repository"), acceptanceCriteria: criteria, dependencies, wave, status: status2, ...budget ? { budget } : {}, ...raw["humanGates"] === void 0 ? {} : { humanGates: list(raw["humanGates"], "humanGates") }, ...raw["sourceHash"] === void 0 ? {} : { sourceHash: text2(raw["sourceHash"], "sourceHash") } };
+};
+var assessBlock = (manifest, completedDependencies = []) => {
+  const value = validateBlockManifest(manifest);
+  const completed = new Set(completedDependencies.map((item) => text2(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 text3 = (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 = text3(markdown, "markdown");
+  const origin = text3(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;
+};
+
+// src/status.ts
+var required7 = (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 = required7(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((block2, index2) => {
+    if (typeof block2 !== "object" || block2 === null || Array.isArray(block2)) fail(`blocks[${index2}] must be an object.`, "INVALID_INPUT");
+    const value = block2;
+    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: required7(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: required7(raw.generatedAt, "generatedAt"), sourceRevision: required7(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;
 };
 var EVIDENCE_BUNDLE_SCHEMA_VERSION = 1;
 var body = (bundle) => {
@@ -1150,7 +1687,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);
@@ -1165,7 +1702,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") } };
@@ -1233,14 +1770,52 @@ var decisionArgs = (first, second) => {
   const decisions = /* @__PURE__ */ new Set(["approved", "approve", "yes", "ok", "rejected", "reject", "no"]);
   return decisions.has(first) ? { decision: first, ...second ? { runId: second } : {} } : { decision: second ?? "", runId: first };
 };
+var readJsonInput = (path, label) => {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    return fail(`Invalid ${label} JSON: ${error instanceof Error ? error.message : String(error)}`, "INVALID_INPUT");
+  }
+};
 program.command("doctor").description("Validate the contract without starting a run.").action(() => print({ status: "passed", criteria: ["package"], config: loadConfig(options().config).config }));
-program.command("plan <decision>").description("Prepare or approve the frozen task contract and create a planned run.").option("--by <actor>", "planner: human approval or ci preparation", "human").option("--allow-dirty", "allow a human-authorized dirty worktree").option("--context-file <path>", "attach a context snapshot JSON file").action(async (decision, command) => print(await planRun({ configPath: options().config, decision, actor: command.by, allowDirty: command.allowDirty ?? false, contextSnapshots: command.contextFile ? readContextSnapshots(command.contextFile) : [] })));
+program.command("plan <decision>").description("Approve the frozen task contract and create a planned run.").option("--by <actor>", "approval actor", "human").option("--allow-dirty", "allow a human-authorized dirty worktree").option("--context-file <path>", "attach a context snapshot JSON file").action(async (decision, command) => print(await planRun({ configPath: options().config, decision, actor: command.by, allowDirty: command.allowDirty ?? false, contextSnapshots: command.contextFile ? readContextSnapshots(command.contextFile) : [] })));
 var context = program.command("context").description("Resolve portable, provenance-bearing context snapshots.");
 context.command("resolve <query>").description("Resolve a Doc Bridge snapshot from the local index.").option("--provider <provider>", "context provider", "doc-bridge").option("--scope <scope...>", "optional search scopes").option("--index <path>", "Doc Bridge index path", ".doc-bridge/index.json").action(async (query, command) => {
   if (command.provider !== "doc-bridge") fail(`Unsupported context provider: ${command.provider}`, "INVALID_INPUT");
   const loaded = loadConfig(options().config);
   print(await createDocBridgeContextProvider({ root: loaded.root, indexPath: command.index }).resolve({ query, ...command.scope?.length ? { scope: command.scope } : {} }));
 });
+var discovery = program.command("discovery").description("Assess a structured discovery result before implementation.");
+discovery.command("assess <input>").description("Emit Ready or a human decision packet from a discovery JSON file.").action((input) => print(assessDiscovery(readJsonInput(input, "discovery input"))));
+var wip = program.command("wip").description("Assess deterministic WIP admission before starting work.");
+wip.command("assess <input>").description("Emit an admission decision from WIP ledger JSON.").action((input) => print(assessWip(readJsonInput(input, "WIP input"))));
+var experiment = program.command("experiment").description("Select a runtime only from a controlled, comparable experiment.");
+experiment.command("select <input>").description("Select the eligible runtime from experiment JSON.").action((input) => print(selectRuntime(readJsonInput(input, "experiment input"))));
+var delivery = program.command("delivery").description("Assess deterministic G2\u2013G5 gates and prepare idempotent PR handoff.");
+delivery.command("preflight <input>").action((input) => print(assessPreflight(readJsonInput(input, "preflight input"))));
+delivery.command("pr <input>").action((input) => print(composePullRequest(readJsonInput(input, "PR input"))));
+delivery.command("integration <input>").action((input) => print(assessIntegration(readJsonInput(input, "integration input"))));
+delivery.command("production <input>").action((input) => print(assessProduction(readJsonInput(input, "production input"))));
+delivery.command("acceptance <input>").action((input) => print(assessAcceptance(readJsonInput(input, "acceptance input"))));
+delivery.command("cleanup <input>").action((input) => print(assessWorktreeCleanup(readJsonInput(input, "cleanup input"))));
+program.command("pilot <input>").description("Freeze and assess a ten-issue pilot cohort.").action((input) => print(assessPilot(readJsonInput(input, "pilot input"))));
+var cycle = program.command("cycle").description("Run the five-step improvement cycle with explicit adjustment and bounded repetition.");
+cycle.command("assess <input>").description("Assess run \u2192 verify \u2192 adjust \u2192 repeat from a cycle JSON file.").action((input) => print(assessImprovementCycle(readJsonInput(input, "cycle input"))));
+var block = program.command("block").description("Validate and assess a portable execution block manifest.");
+block.command("validate <input>").action((input) => print(validateBlockManifest(readJsonInput(input, "block manifest"))));
+block.command("assess <input>").option("--completed <ids...>", "completed dependency IDs").action((input, command) => print(assessBlock(readJsonInput(input, "block manifest"), command.completed ?? [])));
+var preflight = program.command("preflight").description("Plan safe, file-scoped validation before commit.");
+preflight.command("files <input>").action((input) => print(planFilePreflight(readJsonInput(input, "changed files"))));
+var status = program.command("snapshot <input>").description("Create or validate a deterministic status snapshot.");
+status.action((input) => print(createStatusSnapshot(readJsonInput(input, "status input"))));
+status.command("validate <input>").action((input) => print(validateStatusSnapshot(readJsonInput(input, "status snapshot"))));
+var learning = program.command("learning").description("Parse retrospectives into proposed learnings.");
+learning.command("parse <input>").requiredOption("--source <source>").action((input, command) => print(parseRetro(readFileSync(input, "utf8"), command.source)));
+var coordination = program.command("coordination").description("Manage idempotent issue/worktree claims and dispatch records.");
+coordination.command("claim <input>").action((input) => {
+  const loaded = loadConfig(options().config);
+  print(createDispatchLedger(loaded.stateDir).claim(readJsonInput(input, "coordination identity")));
+});
 program.command("start").description("Move a planned run into implementation.").action(() => print(startRun(loadConfig(options().config))));
 program.command("verify").description("Execute every configured check and record evidence.").action(async () => print(await verifyRun({ configPath: options().config })));
 program.command("run").description("Alias for verify, compatible with the common protocol.").action(async () => print(await verifyRun({ configPath: options().config })));
@@ -1287,9 +1862,9 @@ var benchmark = program.command("benchmark").description("Aggregate reproducible
 benchmark.command("baseline <taskId>").description("Record one controlled baseline observation in a benchmark manifest.").option("--manifest <path>", "benchmark manifest path").requiredOption("--status <status>", "passed, failed, blocked, or not-run").requiredOption("--source <source>", "baseline source or run reference").option("--evidence-file <path>", "JSON file with criterion-level baseline evidence").option("--recorded-at <timestamp>", "ISO-8601 timestamp").option("--attempts <count>", "attempt count", (value) => Number(value)).option("--duration-ms <milliseconds>", "duration in milliseconds", (value) => Number(value)).option("--review-minutes <minutes>", "human review time in minutes", (value) => Number(value)).option("--escaped-incomplete <count>", "incomplete deliveries discovered after handoff", (value) => Number(value)).action((taskId, command, cliCommand) => {
   const manifest = command.manifest ?? cliCommand.parent?.opts().manifest;
   const manifestPath = manifest ?? fail("baseline requires --manifest <path>.", "INVALID_INPUT");
-  const status = ["passed", "failed", "blocked", "not-run"].includes(command.status) ? command.status : fail("status must be passed, failed, blocked, or not-run.", "INVALID_INPUT");
+  const status2 = ["passed", "failed", "blocked", "not-run"].includes(command.status) ? command.status : fail("status must be passed, failed, blocked, or not-run.", "INVALID_INPUT");
   const evidence = command.evidenceFile ? readBenchmarkEvidence(command.evidenceFile) : void 0;
-  print(recordBenchmarkObservation(manifestPath, { taskId, status, source: command.source, ...evidence ? { evidence: evidence.evidence, evidenceDigest: evidence.digest } : {}, ...command.recordedAt ? { recordedAt: command.recordedAt } : {}, ...command.attempts === void 0 ? {} : { attempts: command.attempts }, ...command.durationMs === void 0 ? {} : { durationMs: command.durationMs }, ...command.reviewMinutes === void 0 ? {} : { reviewMinutes: command.reviewMinutes }, ...command.escapedIncomplete === void 0 ? {} : { escapedIncomplete: command.escapedIncomplete } }));
+  print(recordBenchmarkObservation(manifestPath, { taskId, status: status2, source: command.source, ...evidence ? { evidence: evidence.evidence, evidenceDigest: evidence.digest } : {}, ...command.recordedAt ? { recordedAt: command.recordedAt } : {}, ...command.attempts === void 0 ? {} : { attempts: command.attempts }, ...command.durationMs === void 0 ? {} : { durationMs: command.durationMs }, ...command.reviewMinutes === void 0 ? {} : { reviewMinutes: command.reviewMinutes }, ...command.escapedIncomplete === void 0 ? {} : { escapedIncomplete: command.escapedIncomplete } }));
 });
 program.command("clean").description("Remove only configured task-owned temporary artifacts.").action(() => print(cleanTaskArtifacts(options().config)));
 process.on("SIGINT", () => {