@agentskit/harness 0.1.0 → 0.4.0

package/dist/index.js

@@ -1,11 +1,11 @@
-import { resolve, dirname, join, relative, sep } from 'path';
-import { randomUUID, createPrivateKey, createPublicKey, sign, verify, createHash } from 'crypto';
-import { existsSync, mkdirSync, openSync, writeSync, appendFileSync, closeSync, unlinkSync, readFileSync, writeFileSync, mkdtempSync, renameSync, rmSync, lstatSync, readdirSync } from 'fs';
+import { resolve, dirname, join, relative, basename, extname, sep } from 'path';
+import { createHash, randomUUID, createPrivateKey, createPublicKey, sign, verify } from 'crypto';
+import { existsSync, mkdirSync, openSync, writeSync, appendFileSync, closeSync, unlinkSync, readFileSync, writeFileSync, readdirSync, mkdtempSync, renameSync, rmSync } from 'fs';
 import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
-import { tmpdir } from 'os';
+import { cpus, loadavg, freemem, totalmem, tmpdir } from 'os';
 
-// src/constants.ts
+// src/kernel/constants.ts
 var STATES = [
   "CLARIFYING",
   "PLANNED",
@@ -23,7 +23,7 @@ var LEGAL_TRANSITIONS = {
   CLARIFYING: ["PLANNED", "BLOCKED", "CANCELLED"],
   PLANNED: ["IMPLEMENTING", "CLARIFYING", "STALE", "CANCELLED"],
   IMPLEMENTING: ["VERIFYING", "CLARIFYING", "STALE", "CANCELLED"],
-  VERIFYING: ["AWAITING_HUMAN_APPROVAL", "BLOCKED", "STALE", "CANCELLED"],
+  VERIFYING: ["AWAITING_HUMAN_APPROVAL", "COMPLETE", "BLOCKED", "STALE", "CANCELLED"],
   AWAITING_HUMAN_APPROVAL: ["AWAITING_AUTHORIZATION", "COMPLETE", "BLOCKED", "IMPLEMENTING", "STALE", "CANCELLED"],
   AWAITING_AUTHORIZATION: ["COMPLETE", "BLOCKED", "IMPLEMENTING", "STALE", "CANCELLED"],
   COMPLETE: ["STALE", "SUPERSEDED"],
@@ -35,7 +35,8 @@ var LEGAL_TRANSITIONS = {
 var REAL_CATEGORIES = /* @__PURE__ */ new Set(["endpoint", "database", "cli", "mcp", "ui"]);
 var DECISIONS = /* @__PURE__ */ new Set(["approved", "approve", "yes", "ok", "rejected", "reject", "no"]);
 
-// src/errors.ts
+// src/kernel/errors.ts
+var HARNESS_ERROR_CODES = ["HARNESS_ERROR", "INVALID_CONFIG", "INVALID_INPUT", "INVALID_STATE", "POLICY_BLOCKED", "CLARIFYING", "STALE", "WORKTREE_DIRTY", "ACTIVE_RUN", "NO_RUN", "HUMAN_APPROVAL_REQUIRED", "GIT_REQUIRED"];
 var HarnessError = class extends Error {
   code;
   constructor(message, code = "HARNESS_ERROR") {
@@ -48,7 +49,41 @@ var fail = (message, code = "HARNESS_ERROR") => {
   throw new HarnessError(message, code);
 };
 
-// src/profiles.ts
+// src/kernel/error-policy.ts
+var HARNESS_ERROR_CATALOG = {
+  HARNESS_ERROR: { disposition: "escalate", retryable: false },
+  INVALID_CONFIG: { disposition: "block", retryable: false },
+  INVALID_INPUT: { disposition: "block", retryable: false },
+  INVALID_STATE: { disposition: "block", retryable: false },
+  POLICY_BLOCKED: { disposition: "block", retryable: false },
+  CLARIFYING: { disposition: "block", retryable: false },
+  STALE: { disposition: "block", retryable: false },
+  WORKTREE_DIRTY: { disposition: "block", retryable: false },
+  ACTIVE_RUN: { disposition: "retry", retryable: true },
+  NO_RUN: { disposition: "block", retryable: false },
+  HUMAN_APPROVAL_REQUIRED: { disposition: "block", retryable: false },
+  GIT_REQUIRED: { disposition: "block", retryable: false }
+};
+var nonEmpty = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) throw new HarnessError(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var classifyHarnessError = (error) => {
+  const code = error instanceof HarnessError ? error.code : "HARNESS_ERROR";
+  const descriptor2 = HARNESS_ERROR_CATALOG[code];
+  return { code, ...descriptor2, message: error instanceof Error ? error.message : String(error) };
+};
+var validateHarnessErrorClassification = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new HarnessError("Error classification must be an object.", "INVALID_INPUT");
+  const candidate = value;
+  const code = candidate["code"];
+  if (typeof code !== "string" || !HARNESS_ERROR_CODES.includes(code)) throw new HarnessError("Error classification code is invalid.", "INVALID_INPUT");
+  const expected = HARNESS_ERROR_CATALOG[code];
+  if (candidate["disposition"] !== expected.disposition || candidate["retryable"] !== expected.retryable) throw new HarnessError(`Error classification for ${code} is inconsistent.`, "INVALID_INPUT");
+  return { code, disposition: expected.disposition, retryable: expected.retryable, message: nonEmpty(candidate["message"], "Error classification message") };
+};
+
+// src/profiles/index.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var record = (value, label) => {
   if (!isRecord(value)) fail(`${label} must be an object.`, "INVALID_CONFIG");
@@ -61,9 +96,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"]] : [];
@@ -136,7 +173,7 @@ var cleanConfiguredArtifacts = (loaded) => {
 };
 var fileContents = (path) => readFileSync(path, "utf8");
 
-// src/types.ts
+// src/kernel/types.ts
 var SURFACE_NAMES = ["logic", "endpoint", "database", "cli", "mcp", "ui", "docs"];
 var CHECK_CATEGORIES = ["build", "test", "lint", ...SURFACE_NAMES, "custom"];
 var RUN_STATES = [
@@ -153,7 +190,7 @@ var RUN_STATES = [
   "SUPERSEDED"
 ];
 
-// src/config.ts
+// src/execution/config.ts
 var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var stringValue = (value, label) => {
   if (typeof value !== "string") return fail(`${label} is required.`, "INVALID_CONFIG");
@@ -181,18 +218,20 @@ var surface = (value, name) => {
 var parseCheck = (value, index2) => {
   const record3 = asRecord(value, `checks[${index2}]`);
   const id2 = stringValue(record3["id"], `checks[${index2}].id`);
-  const category = stringValue(record3["category"], `checks[${index2}].category`);
-  if (!CHECK_CATEGORIES.includes(category)) fail(`checks[${index2}].category is invalid.`, "INVALID_CONFIG");
+  const category2 = stringValue(record3["category"], `checks[${index2}].category`);
+  if (!CHECK_CATEGORIES.includes(category2)) fail(`checks[${index2}].category is invalid.`, "INVALID_CONFIG");
   const command = stringValue(record3["command"], `checks[${index2}].command`);
-  if (REAL_CATEGORIES.has(category) && record3["execution"] !== "real") fail(`checks[${index2}] must declare execution: real.`, "INVALID_CONFIG");
+  if (REAL_CATEGORIES.has(category2) && record3["execution"] !== "real") fail(`checks[${index2}] must declare execution: real.`, "INVALID_CONFIG");
   if (record3["evidence"] !== "structured") fail(`checks[${index2}] must declare evidence: structured.`, "INVALID_CONFIG");
   if (record3["capabilities"] !== void 0 && (!Array.isArray(record3["capabilities"]) || !record3["capabilities"].every((item) => typeof item === "string"))) fail(`checks[${index2}].capabilities must be strings.`, "INVALID_CONFIG");
   const capabilities = Array.isArray(record3["capabilities"]) ? record3["capabilities"].filter((item) => typeof item === "string") : void 0;
-  if (category === "ui" && !capabilities?.includes("real-browser")) fail(`checks[${index2}] must declare real-browser.`, "INVALID_CONFIG");
-  if (category === "ui" && !capabilities?.includes("screenshot")) fail(`checks[${index2}] must declare screenshot.`, "INVALID_CONFIG");
+  if (category2 === "ui" && !capabilities?.includes("real-browser")) fail(`checks[${index2}] must declare real-browser.`, "INVALID_CONFIG");
+  if (category2 === "ui" && !capabilities?.includes("screenshot")) fail(`checks[${index2}] must declare screenshot.`, "INVALID_CONFIG");
   if (record3["required"] !== void 0 && typeof record3["required"] !== "boolean") fail(`checks[${index2}].required must be boolean.`, "INVALID_CONFIG");
+  if (record3["required"] === false && typeof record3["reason"] !== "string") fail(`checks[${index2}].reason is required when required is false.`, "INVALID_CONFIG");
   if (record3["timeoutMs"] !== void 0 && (!Number.isInteger(record3["timeoutMs"]) || typeof record3["timeoutMs"] !== "number" || record3["timeoutMs"] < 1)) fail(`checks[${index2}].timeoutMs must be positive.`, "INVALID_CONFIG");
-  return { id: id2, category, command, required: record3["required"] !== false, timeoutMs: typeof record3["timeoutMs"] === "number" ? record3["timeoutMs"] : 12e4, ...record3["execution"] === "real" ? { execution: "real" } : {}, ...capabilities ? { capabilities } : {}, evidence: "structured" };
+  const dependsOn = record3["dependsOn"] === void 0 ? void 0 : stringArray(record3["dependsOn"], `checks[${index2}].dependsOn`);
+  return { id: id2, category: category2, command, required: record3["required"] !== false, ...typeof record3["reason"] === "string" ? { reason: record3["reason"] } : {}, timeoutMs: typeof record3["timeoutMs"] === "number" ? record3["timeoutMs"] : 12e4, ...record3["execution"] === "real" ? { execution: "real" } : {}, ...capabilities ? { capabilities } : {}, ...dependsOn ? { dependsOn: [...new Set(dependsOn)] } : {}, evidence: "structured" };
 };
 var parseOutcome = (value, index2, checks) => {
   const record3 = asRecord(value, `contract.outcomes[${index2}]`);
@@ -206,10 +245,28 @@ var validateConfig = (rawValue) => {
   const raw = resolveProfile(asRecord(rawValue, "verification config"));
   if (raw["schemaVersion"] !== 1) fail("verification config schemaVersion must be 1.", "INVALID_CONFIG");
   const project = stringValue(raw["project"], "verification config project");
+  const runtimeRaw = asRecord(raw["runtime"] ?? { kind: "process" }, "runtime");
+  if (runtimeRaw["kind"] !== "process" && runtimeRaw["kind"] !== "docker") fail("runtime.kind must be process or docker.", "INVALID_CONFIG");
+  const runtime = { kind: runtimeRaw["kind"] };
+  if (raw["autonomy"] !== void 0 && raw["autonomy"] !== "controlled" && raw["autonomy"] !== "yolo") fail("autonomy must be controlled or yolo.", "INVALID_CONFIG");
+  const autonomy = raw["autonomy"] ?? "controlled";
   const contractRaw = asRecord(raw["contract"], "contract");
   const rawChecks = raw["checks"];
   const checks = Array.isArray(rawChecks) ? rawChecks.map(parseCheck) : fail("checks must be a non-empty array.", "INVALID_CONFIG");
   if (!checks.length || new Set(checks.map((check) => check.id)).size !== checks.length) fail("check ids must be unique.", "INVALID_CONFIG");
+  const checkIds = new Set(checks.map((check) => check.id));
+  for (const check of checks) for (const dependency of check.dependsOn ?? []) if (!checkIds.has(dependency) || dependency === check.id) fail(`check ${check.id} has an invalid dependency: ${dependency}.`, "INVALID_CONFIG");
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (id2) => {
+    if (visiting.has(id2)) fail(`check dependency cycle includes ${id2}.`, "INVALID_CONFIG");
+    if (visited.has(id2)) return;
+    visiting.add(id2);
+    for (const dependency of checks.find((check) => check.id === id2)?.dependsOn ?? []) visit(dependency);
+    visiting.delete(id2);
+    visited.add(id2);
+  };
+  for (const check of checks) visit(check.id);
   const scopeRaw = asRecord(contractRaw["scope"], "contract.scope");
   const scope = { inScope: stringArray(scopeRaw["inScope"], "contract.scope.inScope"), outOfScope: stringArray(scopeRaw["outOfScope"], "contract.scope.outOfScope") };
   const ambiguities = stringArray(contractRaw["ambiguities"], "contract.ambiguities");
@@ -226,13 +283,15 @@ var validateConfig = (rawValue) => {
   if (trackingRaw["required"] !== true && typeof trackingRaw["reason"] !== "string") fail("tracking.reason is required when tracking is disabled.", "INVALID_CONFIG");
   const budgetRaw = raw["budget"] === void 0 ? void 0 : asRecord(raw["budget"], "budget");
   if (budgetRaw && budgetRaw["maxDurationMs"] !== void 0 && (!Number.isInteger(budgetRaw["maxDurationMs"]) || typeof budgetRaw["maxDurationMs"] !== "number" || budgetRaw["maxDurationMs"] < 1)) fail("budget.maxDurationMs must be positive.", "INVALID_CONFIG");
+  const verificationRaw = raw["verification"] === void 0 ? void 0 : asRecord(raw["verification"], "verification");
+  if (verificationRaw && verificationRaw["maxConcurrency"] !== void 0 && (!Number.isInteger(verificationRaw["maxConcurrency"]) || typeof verificationRaw["maxConcurrency"] !== "number" || verificationRaw["maxConcurrency"] < 1)) fail("verification.maxConcurrency must be a positive integer.", "INVALID_CONFIG");
   const cleanupRaw = raw["cleanup"] === void 0 ? void 0 : asRecord(raw["cleanup"], "cleanup");
   const cleanup = cleanupRaw ? { roots: cleanupRaw["roots"] === void 0 ? void 0 : stringArray(cleanupRaw["roots"], "cleanup.roots") } : void 0;
   const benchmarkRaw = raw["benchmark"] === void 0 ? void 0 : asRecord(raw["benchmark"], "benchmark");
   const benchmark = benchmarkRaw ? { suiteId: stringValue(benchmarkRaw["suiteId"], "benchmark.suiteId"), taskId: stringValue(benchmarkRaw["taskId"], "benchmark.taskId"), mode: benchmarkRaw["mode"] === "harness" ? "harness" : fail("benchmark.mode must be harness.", "INVALID_CONFIG") } : void 0;
   const contract = { intent: stringValue(contractRaw["intent"], "contract.intent"), scope, ambiguities, outcomes };
   const tracking = { required: trackingRaw["required"] === true, ...typeof trackingRaw["target"] === "string" ? { target: trackingRaw["target"] } : {}, ...typeof trackingRaw["reason"] === "string" ? { reason: trackingRaw["reason"] } : {} };
-  return { schemaVersion: 1, project, ...typeof raw["root"] === "string" ? { root: raw["root"] } : {}, ...typeof raw["stateDir"] === "string" ? { stateDir: raw["stateDir"] } : {}, profile: typeof raw["profile"] === "string" ? raw["profile"] : "strict", contract, surfaces, checks, tracking, ...budgetRaw ? { budget: { maxDurationMs: budgetRaw["maxDurationMs"] } } : {}, ...cleanup ? { cleanup } : {}, ...benchmark ? { benchmark } : {} };
+  return { schemaVersion: 1, project, ...typeof raw["root"] === "string" ? { root: raw["root"] } : {}, ...typeof raw["stateDir"] === "string" ? { stateDir: raw["stateDir"] } : {}, profile: typeof raw["profile"] === "string" ? raw["profile"] : "strict", runtime, autonomy, contract, surfaces, checks, tracking, ...verificationRaw ? { verification: { maxConcurrency: verificationRaw["maxConcurrency"] } } : {}, ...budgetRaw ? { budget: { maxDurationMs: budgetRaw["maxDurationMs"] } } : {}, ...cleanup ? { cleanup } : {}, ...benchmark ? { benchmark } : {} };
 };
 var loadConfig = (configPath = ".codex/verification.json") => {
   const absolute = resolve(configPath);
@@ -240,12 +299,12 @@ 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) };
 };
 
-// src/state-machine.ts
+// src/kernel/state-machine.ts
 var transition = (run, to, reason, actor = "harness") => {
   if (!STATES.includes(to)) fail(`Unknown state ${to}.`, "INVALID_STATE");
   if (run.state !== to && !LEGAL_TRANSITIONS[run.state].some((state) => state === to)) fail(`Illegal transition ${run.state} -> ${to}.`, "INVALID_STATE");
@@ -260,8 +319,63 @@ var approvedDecision = (decision) => {
   return ["approved", "approve", "yes", "ok"].includes(decision);
 };
 var HARNESS_EVENT_SCHEMA_VERSION = 1;
+var HARNESS_EVENT_ENVELOPE_SCHEMA_VERSION = 2;
 var EVENT_LOG_GENESIS = "GENESIS";
-var HARNESS_EVENT_TYPES = ["run.created", "state.transitioned", "context.attached", "verification.completed", "approval.recorded", "authorization.recorded", "session.started", "session.resumed", "agent.turn.started", "policy.evaluated", "tool.approval.requested", "tool.approval.recorded", "tool.requested", "tool.execution.started", "tool.recovery.recorded", "tool.blocked", "tool.completed", "tool.failed", "session.ended"];
+var HARNESS_EVENT_TYPES = ["run.created", "state.transitioned", "context.attached", "verification.completed", "artifact.recorded", "approval.recorded", "authorization.recorded", "session.started", "session.resumed", "agent.turn.started", "policy.evaluated", "tool.approval.requested", "tool.approval.recorded", "tool.requested", "tool.execution.started", "tool.recovery.recorded", "tool.blocked", "tool.completed", "tool.failed", "session.ended"];
+var envelopeId = (value, label) => {
+  if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value)) fail(`${label} is invalid.`, "INVALID_INPUT");
+  return value;
+};
+var envelopeText = (value, label) => {
+  if (typeof value !== "string") fail(`${label} is required.`, "INVALID_INPUT");
+  const result = value.trim();
+  if (!result) fail(`${label} is required.`, "INVALID_INPUT");
+  return result;
+};
+var envelopeDigest = (value, label) => {
+  const result = envelopeText(value, label);
+  if (!/^[a-f0-9]{64}$/.test(result)) fail(`${label} must be a lowercase SHA-256 digest.`, "INVALID_INPUT");
+  return result;
+};
+var envelopeProvenance = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail("Event provenance must be an object.", "INVALID_INPUT");
+  const candidate = value;
+  return {
+    source: envelopeText(candidate["source"], "Event provenance source"),
+    component: envelopeText(candidate["component"], "Event provenance component"),
+    version: envelopeText(candidate["version"], "Event provenance version"),
+    ...candidate["actor"] === void 0 ? {} : { actor: envelopeText(candidate["actor"], "Event provenance actor") }
+  };
+};
+var validateHarnessEventEnvelope = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail("Event envelope must be an object.", "INVALID_INPUT");
+  const candidate = value;
+  if (candidate["schemaVersion"] !== HARNESS_EVENT_ENVELOPE_SCHEMA_VERSION) fail("Event envelope schemaVersion is invalid.", "INVALID_INPUT");
+  const payload = candidate["payload"];
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) fail("Event envelope payload must be an object.", "INVALID_INPUT");
+  const issueRef = candidate["issueRef"] === void 0 ? void 0 : envelopeText(candidate["issueRef"], "Event issueRef");
+  const occurredAt = envelopeText(candidate["occurredAt"], "Event occurredAt");
+  if (!Number.isFinite(Date.parse(occurredAt))) fail("Event occurredAt must be a valid timestamp.", "INVALID_INPUT");
+  return {
+    eventId: envelopeId(candidate["eventId"], "Event eventId"),
+    eventType: envelopeId(candidate["eventType"], "Event eventType"),
+    schemaVersion: HARNESS_EVENT_ENVELOPE_SCHEMA_VERSION,
+    occurredAt,
+    runId: envelopeText(candidate["runId"], "Event runId"),
+    ...issueRef === void 0 ? {} : { issueRef },
+    sourceRevision: envelopeText(candidate["sourceRevision"], "Event sourceRevision"),
+    correlationId: envelopeId(candidate["correlationId"], "Event correlationId"),
+    payload,
+    idempotencyKey: envelopeDigest(candidate["idempotencyKey"], "Event idempotencyKey"),
+    provenance: envelopeProvenance(candidate["provenance"])
+  };
+};
+var createHarnessEventEnvelope = (input) => {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) fail("Event envelope input must be an object.", "INVALID_INPUT");
+  const identity = { eventType: input.eventType, runId: input.runId, ...input.issueRef === void 0 ? {} : { issueRef: input.issueRef }, sourceRevision: input.sourceRevision, correlationId: input.correlationId, payload: input.payload, provenance: input.provenance };
+  const candidate = { ...input, schemaVersion: HARNESS_EVENT_ENVELOPE_SCHEMA_VERSION, idempotencyKey: input.idempotencyKey ?? hashJson(identity) };
+  return validateHarnessEventEnvelope(candidate);
+};
 var SESSION_EVENT_TYPES = /* @__PURE__ */ new Set(["session.started", "session.resumed", "agent.turn.started", "policy.evaluated", "tool.approval.requested", "tool.approval.recorded", "tool.requested", "tool.execution.started", "tool.recovery.recorded", "tool.blocked", "tool.completed", "tool.failed", "session.ended"]);
 var eventPath = (stateDir, runId) => join(stateDir, "runs", runId, "events.ndjson");
 var lockPath = (stateDir, runId) => `${eventPath(stateDir, runId)}.lock`;
@@ -282,14 +396,16 @@ var readLock = (stateDir, runId) => {
 var isEventType = (value) => typeof value === "string" && HARNESS_EVENT_TYPES.includes(value);
 var digest = (value) => /^[a-f0-9]{64}$/.test(value);
 var eventBody = (event) => {
-  const { eventHash: _eventHash, ...body2 } = event;
-  return body2;
+  const { eventHash: _eventHash, ...body3 } = event;
+  return body3;
 };
 var eventDigest = (event) => sha256(JSON.stringify(eventBody(event)));
 var parseEvent = (value, expectedSequence) => {
   if (typeof value !== "object" || value === null || Array.isArray(value)) fail("Event log contains a non-object record.", "HARNESS_ERROR");
   const record3 = value;
-  if (record3["schemaVersion"] !== HARNESS_EVENT_SCHEMA_VERSION || typeof record3["runId"] !== "string" || typeof record3["sequence"] !== "number" || record3["sequence"] !== expectedSequence || typeof record3["at"] !== "string" || typeof record3["sourceRevision"] !== "string" || typeof record3["configHash"] !== "string" || !isEventType(record3["type"]) || typeof record3["payload"] !== "object" || record3["payload"] === null || record3["sessionId"] !== void 0 && (typeof record3["sessionId"] !== "string" || !record3["sessionId"].trim()) || SESSION_EVENT_TYPES.has(record3["type"]) && typeof record3["sessionId"] !== "string") fail("Event log is invalid or out of order.", "HARNESS_ERROR");
+  const context = record3["correlation"];
+  const validContext = context === void 0 || typeof context === "object" && context !== null && !Array.isArray(context) && Object.entries(context).every(([key, value2]) => ["operationId", "runId", "sessionId", "turnId", "actionId", "traceId"].includes(key) && typeof value2 === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value2)) && typeof context["operationId"] === "string";
+  if (record3["schemaVersion"] !== HARNESS_EVENT_SCHEMA_VERSION || typeof record3["runId"] !== "string" || typeof record3["sequence"] !== "number" || record3["sequence"] !== expectedSequence || typeof record3["at"] !== "string" || typeof record3["sourceRevision"] !== "string" || typeof record3["configHash"] !== "string" || !isEventType(record3["type"]) || typeof record3["payload"] !== "object" || record3["payload"] === null || record3["sessionId"] !== void 0 && (typeof record3["sessionId"] !== "string" || !record3["sessionId"].trim()) || SESSION_EVENT_TYPES.has(record3["type"]) && typeof record3["sessionId"] !== "string" || !validContext) fail("Event log is invalid or out of order.", "HARNESS_ERROR");
   const hasPreviousHash = record3["previousHash"] !== void 0;
   const hasEventHash = record3["eventHash"] !== void 0;
   if (hasPreviousHash !== hasEventHash || hasPreviousHash && (typeof record3["previousHash"] !== "string" || record3["previousHash"] !== EVENT_LOG_GENESIS && !digest(record3["previousHash"]) || typeof record3["eventHash"] !== "string" || !digest(record3["eventHash"]))) fail("Event log integrity metadata is invalid.", "HARNESS_ERROR");
@@ -318,6 +434,7 @@ var FileEventStore = class {
     if (!isEventType(event.type)) fail("Event type is invalid.", "INVALID_INPUT");
     if (SESSION_EVENT_TYPES.has(event.type) && (!event.sessionId || !event.sessionId.trim())) fail("Session events require a sessionId.", "INVALID_INPUT");
     if (event.sessionId !== void 0 && !event.sessionId.trim()) fail("Event sessionId cannot be empty.", "INVALID_INPUT");
+    if (event.correlation !== void 0 && (!event.correlation.operationId || !event.correlation.operationId.trim())) fail("Event correlation operationId is required.", "INVALID_INPUT");
     const path = eventPath(this.stateDir, event.runId);
     const lock = lockPath(this.stateDir, event.runId);
     mkdirSync(join(this.stateDir, "runs", event.runId), { recursive: true });
@@ -332,8 +449,8 @@ var FileEventStore = class {
     try {
       const events = this.readUnlocked(event.runId);
       const previous = events.at(-1);
-      const body2 = { schemaVersion: HARNESS_EVENT_SCHEMA_VERSION, sequence: events.length + 1, at: (/* @__PURE__ */ new Date()).toISOString(), runId: event.runId, sourceRevision: event.sourceRevision, configHash: event.configHash, ...event.sessionId ? { sessionId: event.sessionId } : {}, ...previous?.eventHash ? { previousHash: previous.eventHash } : events.length ? {} : { previousHash: EVENT_LOG_GENESIS }, type: event.type, payload: event.payload };
-      const record3 = events.length && !previous?.eventHash ? body2 : { ...body2, eventHash: eventDigest(body2) };
+      const body3 = { schemaVersion: HARNESS_EVENT_SCHEMA_VERSION, sequence: events.length + 1, at: (/* @__PURE__ */ new Date()).toISOString(), runId: event.runId, sourceRevision: event.sourceRevision, configHash: event.configHash, ...event.correlation ? { correlation: event.correlation } : {}, ...event.sessionId ? { sessionId: event.sessionId } : {}, ...previous?.eventHash ? { previousHash: previous.eventHash } : events.length ? {} : { previousHash: EVENT_LOG_GENESIS }, type: event.type, payload: event.payload };
+      const record3 = events.length && !previous?.eventHash ? body3 : { ...body3, eventHash: eventDigest(body3) };
       appendFileSync(path, `${JSON.stringify(record3)}
 `, "utf8");
       return record3;
@@ -387,16 +504,27 @@ var recoverEventLogLock = ({ stateDir, runId, actor, maxAgeMs = 3e5 }) => {
   return fail("Event log lock owner is still alive.", "HARNESS_ERROR");
 };
 
-// src/plugins.ts
+// src/kernel/plugins.ts
 var HARNESS_PLUGIN_API_VERSION = 1;
 var createPluginSlot = (id2) => {
-  if (!id2.trim()) fail("Plugin slot id is required.", "INVALID_INPUT");
-  return { id: id2 };
+  if (typeof id2 !== "string" || !id2.trim()) fail("Plugin slot id is required.", "INVALID_INPUT");
+  return { id: id2.trim() };
 };
 var validId = (value, label) => {
-  if (!value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  if (typeof value !== "string") fail(`${label} is required.`, "INVALID_INPUT");
+  const result = value.trim();
+  if (!result) fail(`${label} is required.`, "INVALID_INPUT");
+  return result;
+};
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var validEventType = (value) => {
+  if (typeof value !== "string" || !HARNESS_EVENT_TYPES.includes(value)) fail("Plugin event type is invalid.", "INVALID_INPUT");
   return value;
 };
+var validSlot = (value) => {
+  if (!isRecord3(value)) fail("Plugin slot must be an object.", "INVALID_INPUT");
+  return { id: validId(value["id"], "Plugin slot id") };
+};
 var createPluginRegistry = () => {
   const plugins = /* @__PURE__ */ new Map();
   const contributions = /* @__PURE__ */ new Map();
@@ -443,11 +571,20 @@ var createPluginRegistry = () => {
     register(plugin) {
       ensureOpen();
       if (mounted) fail("Plugins cannot be registered after mount.", "HARNESS_ERROR");
-      validId(plugin.id, "Plugin id");
-      validId(plugin.version, "Plugin version");
-      if (plugin.apiVersion !== HARNESS_PLUGIN_API_VERSION) fail(`Unsupported plugin API version: ${String(plugin.apiVersion)}.`, "INVALID_INPUT");
-      if (plugins.has(plugin.id)) fail(`Plugin already registered: ${plugin.id}.`, "INVALID_INPUT");
-      plugins.set(plugin.id, plugin);
+      if (!isRecord3(plugin)) fail("Plugin must be an object.", "INVALID_INPUT");
+      const candidate = plugin;
+      const id2 = validId(candidate.id, "Plugin id");
+      validId(candidate.version, "Plugin version");
+      if (candidate.apiVersion !== HARNESS_PLUGIN_API_VERSION) fail(`Unsupported plugin API version: ${String(candidate.apiVersion)}.`, "INVALID_INPUT");
+      if (typeof candidate.apply !== "function") fail("Plugin apply must be a function.", "INVALID_INPUT");
+      let requires;
+      if (candidate.requires !== void 0) {
+        if (!Array.isArray(candidate.requires)) fail("Plugin requires must be an array.", "INVALID_INPUT");
+        requires = candidate.requires.map((dependency, index2) => validId(dependency, `Plugin dependency[${index2}]`));
+        if (new Set(requires).size !== requires.length) fail("Plugin dependencies must be unique.", "INVALID_INPUT");
+      }
+      if (plugins.has(id2)) fail(`Plugin already registered: ${id2}.`, "INVALID_INPUT");
+      plugins.set(id2, { ...candidate, id: id2, ...requires === void 0 ? {} : { requires } });
     },
     mount() {
       ensureOpen();
@@ -456,14 +593,17 @@ var createPluginRegistry = () => {
         for (const plugin of order()) {
           const context = {
             apiVersion: HARNESS_PLUGIN_API_VERSION,
-            register: (slot, id2, value) => registerContribution(plugin.id, slot, validId(id2, "Plugin contribution id"), value),
+            register: (slot, id2, value) => registerContribution(plugin.id, validSlot(slot), validId(id2, "Plugin contribution id"), value),
             effect: (disposer) => {
+              if (typeof disposer !== "function") fail("Plugin disposer must be a function.", "INVALID_INPUT");
               cleanups.push(disposer);
             },
             on: (type, listener) => {
-              const handlers = listeners.get(type) ?? /* @__PURE__ */ new Set();
+              const eventType = validEventType(type);
+              if (typeof listener !== "function") fail("Plugin event listener must be a function.", "INVALID_INPUT");
+              const handlers = listeners.get(eventType) ?? /* @__PURE__ */ new Set();
               handlers.add(listener);
-              listeners.set(type, handlers);
+              listeners.set(eventType, handlers);
               const disposer = () => {
                 handlers.delete(listener);
               };
@@ -486,14 +626,16 @@ var createPluginRegistry = () => {
     },
     on(type, listener) {
       ensureOpen();
-      const handlers = listeners.get(type) ?? /* @__PURE__ */ new Set();
+      const eventType = validEventType(type);
+      if (typeof listener !== "function") fail("Plugin event listener must be a function.", "INVALID_INPUT");
+      const handlers = listeners.get(eventType) ?? /* @__PURE__ */ new Set();
       handlers.add(listener);
-      listeners.set(type, handlers);
+      listeners.set(eventType, handlers);
       return () => {
         handlers.delete(listener);
       };
     },
-    contributions: (slot) => [...contributions.get(slot.id)?.values() ?? []],
+    contributions: (slot) => [...contributions.get(validSlot(slot).id)?.values() ?? []],
     dispose() {
       if (disposed) return;
       let firstError;
@@ -514,7 +656,25 @@ var createPluginRegistry = () => {
   return registry;
 };
 
-// src/context.ts
+// src/kernel/adapter-contract.ts
+var ASSURANCE_LEVELS = ["unverified", "contract-tested", "runtime-attested"];
+var nonNegative = (value, label) => {
+  if (!Number.isFinite(value) || value < 0) return fail(`${label} must be a non-negative number.`, "INVALID_INPUT");
+  return value;
+};
+var validateAdapterMetadata = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return fail("Adapter metadata must be an object.", "INVALID_INPUT");
+  const candidate = value;
+  if (!ASSURANCE_LEVELS.includes(candidate["assurance"])) return fail("Adapter assurance is invalid.", "INVALID_INPUT");
+  if (typeof candidate["telemetry"] !== "object" || candidate["telemetry"] === null || Array.isArray(candidate["telemetry"])) return fail("Adapter telemetry must be an object.", "INVALID_INPUT");
+  const telemetry = candidate["telemetry"];
+  if (telemetry["status"] !== "measured" && telemetry["status"] !== "unknown") return fail("Adapter telemetry status is invalid.", "INVALID_INPUT");
+  for (const key of ["durationMs", "inputTokens", "outputTokens", "totalTokens", "cacheHits", "cacheMisses", "memoryReads", "memoryWrites", "memoryRelevantHits", "memoryStaleHits", "contextReferences", "contextCostTokens", "externalMutations"]) if (telemetry[key] !== void 0) nonNegative(telemetry[key], `Adapter telemetry ${key}`);
+  return value;
+};
+var unknownTelemetry = () => ({ status: "unknown" });
+
+// src/context/index.ts
 var hashContextSnapshot = ({ providerId, query, references, sourceHash: sourceHash2 }) => hashJson({ providerId, query, references, sourceHash: sourceHash2 });
 var hashContextSnapshots = (snapshots) => hashJson(snapshots.map(({ providerId, query, references, sourceHash: sourceHash2, snapshotHash }) => ({ providerId, query, references, sourceHash: sourceHash2, snapshotHash })));
 var record2 = (value, label) => {
@@ -537,17 +697,23 @@ var validateContextSnapshot = (value, index2 = 0) => {
       uri: requiredString(rawReference["uri"], `context snapshot ${index2}.references[${referenceIndex}].uri`),
       ...typeof rawReference["title"] === "string" ? { title: rawReference["title"] } : {},
       ...typeof rawReference["version"] === "string" ? { version: rawReference["version"] } : {},
-      ...typeof rawReference["contentHash"] === "string" ? { contentHash: rawReference["contentHash"] } : {}
+      ...typeof rawReference["contentHash"] === "string" ? { contentHash: rawReference["contentHash"] } : {},
+      ...rawReference["relevance"] === void 0 ? {} : typeof rawReference["relevance"] === "number" && rawReference["relevance"] >= 0 && rawReference["relevance"] <= 1 ? { relevance: rawReference["relevance"] } : fail(`context snapshot ${index2}.references[${referenceIndex}].relevance must be between 0 and 1.`, "INVALID_INPUT")
     };
   });
   const scope = rawQuery["scope"] === void 0 ? void 0 : Array.isArray(rawQuery["scope"]) && rawQuery["scope"].every((item) => typeof item === "string") ? rawQuery["scope"] : fail(`context snapshot ${index2}.query.scope must be an array of strings.`, "INVALID_INPUT");
+  const assurance = raw["assurance"] === void 0 ? void 0 : ASSURANCE_LEVELS.includes(raw["assurance"]) ? raw["assurance"] : fail(`context snapshot ${index2}.assurance is invalid.`, "INVALID_INPUT");
+  const telemetry = raw["telemetry"] === void 0 ? void 0 : record2(raw["telemetry"], `context snapshot ${index2}.telemetry`);
+  if (telemetry && telemetry["status"] !== "measured" && telemetry["status"] !== "unknown") fail(`context snapshot ${index2}.telemetry.status is invalid.`, "INVALID_INPUT");
   const snapshot = {
     providerId: requiredString(raw["providerId"], `context snapshot ${index2}.providerId`),
     query: { query: requiredString(rawQuery["query"], `context snapshot ${index2}.query.query`), ...scope ? { scope } : {}, ...typeof rawQuery["sourceRevision"] === "string" ? { sourceRevision: rawQuery["sourceRevision"] } : {} },
     references,
     sourceHash: requiredString(raw["sourceHash"], `context snapshot ${index2}.sourceHash`),
     snapshotHash: requiredString(raw["snapshotHash"], `context snapshot ${index2}.snapshotHash`),
-    resolvedAt: requiredString(raw["resolvedAt"], `context snapshot ${index2}.resolvedAt`)
+    resolvedAt: requiredString(raw["resolvedAt"], `context snapshot ${index2}.resolvedAt`),
+    ...assurance === void 0 ? {} : { assurance },
+    ...telemetry === void 0 ? {} : { telemetry }
   };
   if (snapshot.snapshotHash !== hashContextSnapshot(snapshot)) fail(`context snapshot ${index2}.snapshotHash does not match its contents.`, "INVALID_INPUT");
   return snapshot;
@@ -559,7 +725,7 @@ var readContextSnapshots = (path) => {
 var validateContextSnapshots = (snapshots) => snapshots.map((snapshot, index2) => validateContextSnapshot(snapshot, index2));
 var CONTEXT_PROVIDER_SLOT = createPluginSlot("context.provider");
 
-// src/runs.ts
+// src/execution/runs.ts
 var now = () => (/* @__PURE__ */ new Date()).toISOString();
 var newRunId = () => `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
 var saveRun2 = (stateDir, run) => {
@@ -578,8 +744,7 @@ var saveRun2 = (stateDir, run) => {
     store.append({ runId: run.runId, sourceRevision: run.sourceRevision, configHash: run.configHash, type: "context.attached", payload: { providerId: snapshot.providerId, sourceHash: snapshot.sourceHash, snapshotHash: snapshot.snapshotHash, query: snapshot.query } });
   }
 };
-var createRun = async ({ loaded, baseline, supersedes, dirtyBaselineAuthorized, contextSnapshots = [], planner = "human" }) => {
-  const contractHash = hashJson(loaded.config.contract);
+var createRun = async ({ loaded, baseline, supersedes, dirtyBaselineAuthorized, contextSnapshots = [] }) => {
   const run = {
     type: "agentskit-harness-run",
     schemaVersion: 1,
@@ -587,17 +752,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 } : {}
@@ -616,8 +782,8 @@ var parseStructuredEvidence = (stdout) => {
   }
   return null;
 };
-var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var viewportValid = (viewport) => typeof viewport === "string" || isRecord3(viewport) && typeof viewport["width"] === "number" && viewport["width"] > 0 && typeof viewport["height"] === "number" && viewport["height"] > 0;
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var viewportValid = (viewport) => typeof viewport === "string" || isRecord4(viewport) && typeof viewport["width"] === "number" && viewport["width"] > 0 && typeof viewport["height"] === "number" && viewport["height"] > 0;
 var validateEvidence = (root, check, evidence, outcomeIds) => {
   if (!evidence || evidence.status !== "passed") return ["structured evidence did not pass"];
   if (!Array.isArray(evidence.criteria) || !evidence.criteria.every((id2) => typeof id2 === "string") || outcomeIds.some((id2) => !evidence.criteria.includes(id2))) return [`evidence must map criteria: ${outcomeIds.join(", ")}`];
@@ -628,7 +794,7 @@ var validateEvidence = (root, check, evidence, outcomeIds) => {
   }
   const artifacts = Array.isArray(evidence.artifacts) ? evidence.artifacts : [];
   for (const artifactValue of artifacts) {
-    if (!isRecord3(artifactValue) || typeof artifactValue["path"] !== "string" || typeof artifactValue["sha256"] !== "string") {
+    if (!isRecord4(artifactValue) || typeof artifactValue["path"] !== "string" || typeof artifactValue["sha256"] !== "string") {
       failures.push("artifact requires string path and sha256");
       continue;
     }
@@ -650,25 +816,100 @@ var git = async (root, args) => {
 };
 var sourceSnapshot = async (root, stateDir) => {
   const revision = await git(root, ["rev-parse", "HEAD"]);
+  if (!revision) fail("Current-source evidence requires a Git repository with a committed HEAD.", "GIT_REQUIRED");
   const stateRelative = relative(root, stateDir).replaceAll("\\", "/");
   const pathspec = ["--", "."];
   if (stateRelative && stateRelative !== ".." && !stateRelative.startsWith("../")) pathspec.push(`:(exclude)${stateRelative}`);
   const status = await git(root, ["status", "--porcelain=v1", "--untracked-files=all", ...pathspec]);
   const diff = await git(root, ["diff", "--no-ext-diff", "--binary", "HEAD", ...pathspec]);
   const untrackedPaths = (await git(root, ["ls-files", "--others", "--exclude-standard", "-z"])).split("\0").filter(Boolean).filter((path) => !stateRelative || path !== stateRelative && !path.startsWith(`${stateRelative}/`));
-  const untracked = untrackedPaths.flatMap((path) => {
-    const absolute = resolve(root, path);
-    try {
-      return lstatSync(absolute).isFile() ? [{ path, hash: sha256(readFileSync(absolute)) }] : [];
-    } catch {
-      return [];
-    }
-  });
+  const untracked = untrackedPaths.map((path) => ({ path, hash: sha256(readFileSync(resolve(root, path))) }));
   const fingerprint = { revision, status, diff, untracked };
-  return { revision: revision || `content:${hashJson(fingerprint)}`, status, statusHash: hashJson(fingerprint) };
+  return { revision, status, statusHash: hashJson(fingerprint) };
+};
+var thresholds = (value = {}) => {
+  const result = { warningPercent: value.warningPercent ?? 75, criticalPercent: value.criticalPercent ?? 90 };
+  if (![result.warningPercent, result.criticalPercent].every((item) => Number.isFinite(item) && item >= 0 && item <= 100) || result.warningPercent > result.criticalPercent) fail("Machine thresholds must be between 0 and 100 and warning must not exceed critical.", "INVALID_INPUT");
+  return result;
+};
+var linuxSwap = () => {
+  if (process.platform !== "linux" || !existsSync("/proc/meminfo")) return void 0;
+  const values = Object.fromEntries(readFileSync("/proc/meminfo", "utf8").split(/\r?\n/).flatMap((line) => {
+    const match = line.match(/^(SwapTotal|SwapFree):\s+(\d+)\s+kB$/);
+    return match ? [[match[1], Number(match[2])]] : [];
+  }));
+  if (!values["SwapTotal"]) return void 0;
+  return Number(((1 - (values["SwapFree"] ?? 0) / values["SwapTotal"]) * 100).toFixed(2));
+};
+var sampleMachine = () => {
+  const cpus$1 = Math.max(1, cpus().length);
+  const load1 = Math.max(0, loadavg()[0] ?? 0);
+  const memory = Math.max(0, Math.min(100, (1 - freemem() / Math.max(1, totalmem())) * 100));
+  const swapUsedPercent = linuxSwap();
+  return {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    cpus: cpus$1,
+    load1: Number(load1.toFixed(4)),
+    load1PerCpuPercent: Number(Math.min(100, load1 / cpus$1 * 100).toFixed(2)),
+    memoryUsedPercent: Number(memory.toFixed(2)),
+    rssBytes: process.memoryUsage().rss,
+    ...swapUsedPercent === void 0 ? {} : { swapUsedPercent }
+  };
+};
+var summarizeMachine = (samples, sampleIntervalMs = 5e3, limits = {}) => {
+  const limit = thresholds(limits);
+  const load = samples.map((sample) => sample.load1PerCpuPercent);
+  const memory = samples.map((sample) => sample.memoryUsedPercent);
+  const rss = samples.map((sample) => sample.rssBytes);
+  return {
+    sampleIntervalMs,
+    samples,
+    peakLoad1PerCpuPercent: Number(Math.max(...load, 0).toFixed(2)),
+    peakMemoryUsedPercent: Number(Math.max(...memory, 0).toFixed(2)),
+    peakRssBytes: Math.max(...rss, 0),
+    pressureEvents: samples.filter((sample) => sample.load1PerCpuPercent >= limit.criticalPercent || sample.memoryUsedPercent >= limit.criticalPercent || (sample.swapUsedPercent ?? 0) >= limit.criticalPercent || sample.memoryPressure === "critical").length,
+    throttleEvents: 0,
+    minimumEffectiveConcurrency: 0
+  };
+};
+var adaptiveConcurrency = (configured, sample, limits = {}) => {
+  if (!Number.isInteger(configured) || configured < 1) throw new Error("configured concurrency must be a positive integer.");
+  const limit = thresholds(limits);
+  const critical = sample.load1PerCpuPercent >= limit.criticalPercent || sample.memoryUsedPercent >= limit.criticalPercent || (sample.swapUsedPercent ?? 0) >= limit.criticalPercent || sample.memoryPressure === "critical";
+  const warning = sample.load1PerCpuPercent >= limit.warningPercent || sample.memoryUsedPercent >= limit.warningPercent || (sample.swapUsedPercent ?? 0) >= limit.warningPercent || sample.memoryPressure === "warning";
+  if (critical) return 1;
+  if (warning) return Math.min(configured, 2);
+  return configured;
+};
+var createMachineMonitor = (sampleIntervalMs = 5e3, options = {}) => {
+  const sampler = options.sample ?? sampleMachine;
+  const limits = thresholds(options.thresholds);
+  const samples = [sampler()];
+  let throttleEvents = 0;
+  const effectiveConcurrency = [];
+  const record3 = () => {
+    const sample = sampler();
+    samples.push(sample);
+    return sample;
+  };
+  const timer = setInterval(record3, sampleIntervalMs);
+  timer.unref();
+  return {
+    sample: record3,
+    observeConcurrency: (value) => effectiveConcurrency.push(value),
+    markThrottle: () => {
+      throttleEvents += 1;
+    },
+    stop: () => {
+      clearInterval(timer);
+      record3();
+      const summary = summarizeMachine(samples, sampleIntervalMs, limits);
+      return { ...summary, throttleEvents, minimumEffectiveConcurrency: effectiveConcurrency.length ? Math.min(...effectiveConcurrency) : 0 };
+    }
+  };
 };
 
-// src/verification.ts
+// src/execution/verification.ts
 var now2 = () => (/* @__PURE__ */ new Date()).toISOString();
 var requireRun = (run) => run ?? fail("No verification run exists.", "NO_RUN");
 var verificationProjection = (run) => ({ checks: run.checks, outcomes: run.outcomes, metrics: run.metrics });
@@ -694,6 +935,12 @@ var runCommand = (check, cwd) => new Promise((resolveResult) => {
     resolveResult({ exitCode: exitCode ?? 1, timedOut, stdout, stderr, durationMs: Date.now() - started });
   });
 });
+var executeCheck = async (check, cwd, checkDir, outcomes) => {
+  const result = await runCommand(check, cwd);
+  const evidence = parseStructuredEvidence(result.stdout);
+  const failures = result.exitCode === 0 && !result.timedOut && evidence ? validateEvidence(cwd, check, evidence, outcomes) : [result.timedOut ? "check timed out" : result.exitCode !== 0 ? `exit code ${result.exitCode}` : "missing final structured evidence"];
+  return { check: { id: check.id, category: check.category, status: failures.length ? "failed" : "passed", exitCode: result.exitCode, durationMs: result.durationMs, ...evidence ? { evidence } : {}, ...failures.length ? { failures } : {} }, stdout: result.stdout, stderr: result.stderr, durationMs: result.durationMs };
+};
 var currentBinding = async (loaded) => ({ source: await sourceSnapshot(loaded.root, loaded.stateDir), configHash: loaded.configHash });
 var staleRun = (loaded, run, reason) => {
   const stale = transition(run, "STALE", reason);
@@ -706,11 +953,8 @@ var isFresh = async (loaded, run) => {
   return current.configHash === run.configHash && current.source.revision === run.sourceRevision && current.source.statusHash === run.sourceStatusHash;
 };
 var planRun = async ({ configPath, decision, actor = "human", allowDirty = false, contextSnapshots = [] }) => {
-  const automatedPreparation = actor === "ci" && decision === "prepared";
-  if (!automatedPreparation) {
-    assertHuman(actor);
-    if (!approvedDecision(decision)) fail("Contract was not approved.", "CLARIFYING");
-  }
+  assertHuman(actor);
+  if (!approvedDecision(decision)) fail("Contract was not approved.", "CLARIFYING");
   const loaded = loadConfig(configPath);
   if (loaded.config.contract.ambiguities.length) fail(`Unresolved ambiguities remain: ${loaded.config.contract.ambiguities.join(" | ")}`, "CLARIFYING");
   const validatedContextSnapshots = validateContextSnapshots(contextSnapshots);
@@ -722,7 +966,7 @@ ${meaningful.join("\n")}
 Use --allow-dirty only with explicit human authorization.`, "WORKTREE_DIRTY");
   const previous = loadLatestRun(loaded.stateDir);
   if (previous && !["STALE", "SUPERSEDED"].includes(previous.state)) fail(`An active run already exists: ${previous.runId} (${previous.state}).`, "ACTIVE_RUN");
-  return createRun({ loaded, baseline, supersedes: previous?.runId, dirtyBaselineAuthorized: allowDirty, contextSnapshots: validatedContextSnapshots, planner: automatedPreparation ? "ci" : "human" });
+  return createRun({ loaded, baseline, supersedes: previous?.runId, dirtyBaselineAuthorized: allowDirty, contextSnapshots: validatedContextSnapshots });
 };
 var startRun = (loaded) => {
   const run = requireRun(loadLatestRun(loaded.stateDir));
@@ -742,42 +986,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 required16 = outcome.checks.filter((id2) => loaded.config.checks.find((check) => check.id === id2)?.required);
+    return { ...outcome, status: required16.length === 0 ? "not-applicable" : required16.every((id2) => statuses.get(id2) === "passed") ? "passed" : "failed" };
+  }), metrics: { totalDurationMs, wallDurationMs: Date.now() - verificationStarted, peakConcurrency: observedPeakConcurrency, budgetExceeded, machine: machineMonitor.stop() } };
+  const digest6 = verificationDigest(current);
+  current = { ...current, verificationDigest: digest6 };
   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: digest6, checkCount: current.checks.length, outcomeCount: current.outcomes.length, totalDurationMs, budgetExceeded } });
+  const automatic = allPassed && current.autonomy === "yolo" && !loaded.config.tracking.required && loaded.config.contract.ambiguities.length === 0;
+  const nextState = allPassed ? automatic ? "COMPLETE" : "AWAITING_HUMAN_APPROVAL" : "BLOCKED";
+  current = { ...transition(current, nextState, automatic ? "All applicable checks passed; YOLO policy permits automatic completion." : allPassed ? "All configured checks passed; human approval is required." : budgetExceeded ? "Verification budget was exceeded." : "A configured check failed or lacked structured evidence.", "harness") };
   saveRun2(loaded.stateDir, current);
   setLatest(loaded.stateDir, current);
   return current;
@@ -791,11 +1074,6 @@ var assertVerificationAttestation = (loaded, run) => {
   const event = new FileEventStore(loaded.stateDir).read(run.runId).filter((item) => item.type === "verification.completed").at(-1);
   if (!event || event.payload.verificationDigest !== expected || event.sourceRevision !== run.sourceRevision || event.configHash !== run.configHash) fail("Verification projection attestation is missing from the event log.", "HARNESS_ERROR");
 };
-var plannerForRetry = (loaded, run) => {
-  if (run.contractPreparation) return "ci";
-  if (!run.supersedes) return "human";
-  return plannerForRetry(loaded, readRun(loaded.stateDir, run.supersedes));
-};
 var recordDecision = (loaded, run, type, payload) => {
   new FileEventStore(loaded.stateDir).append({ runId: run.runId, sourceRevision: run.sourceRevision, configHash: run.configHash, type, payload: type === "authorization.recorded" ? { ...payload, target: payload.target ?? fail("tracking.target is required when authorizing.", "INVALID_CONFIG") } : payload });
 };
@@ -815,7 +1093,7 @@ var reconcileRun = async ({ configPath, runId }) => {
     if (eventLog.status !== "verified") fail("Terminal run requires a verified event log.", "HARNESS_ERROR");
     assertVerificationAttestation(loaded, run);
   }
-  if (run.state === "AWAITING_AUTHORIZATION" || run.state === "COMPLETE") {
+  if ((run.state === "AWAITING_AUTHORIZATION" || run.state === "COMPLETE") && run.autonomy !== "yolo") {
     const approval = events.filter((event) => event.type === "approval.recorded").at(-1) ?? fail("Terminal run is missing its human approval event.", "HARNESS_ERROR");
     assertDecisionProjection(run, approval.payload, run.state === "COMPLETE" && !loaded.config.tracking.required ? "COMPLETE" : "AWAITING_AUTHORIZATION");
     if (!run.humanApproval || run.humanApproval.actor !== "human" || run.humanApproval.verificationDigest !== run.verificationDigest || run.humanApproval.sourceRevision !== run.sourceRevision || run.humanApproval.contractHash !== run.contractHash) fail("Human approval projection is inconsistent with its audit event.", "HARNESS_ERROR");
@@ -877,13 +1155,77 @@ 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);
   return next;
 };
 var cleanTaskArtifacts = (configPath) => cleanConfiguredArtifacts(loadConfig(configPath));
+
+// src/kernel/capabilities.ts
+var CAPABILITY_MANIFEST_SCHEMA_VERSION = 1;
+var CAPABILITY_KINDS = ["kernel", "execution", "adapter", "composition"];
+var nonEmpty2 = (value, label) => {
+  if (typeof value !== "string") fail(`${label} is required.`, "INVALID_INPUT");
+  const result = value.trim();
+  if (!result) fail(`${label} is required.`, "INVALID_INPUT");
+  return result;
+};
+var digest2 = (value, label) => {
+  const result = nonEmpty2(value, label);
+  if (!/^[a-f0-9]{64}$/.test(result)) fail(`${label} must be a lowercase SHA-256 digest.`, "INVALID_INPUT");
+  return result;
+};
+var stringList = (value, label) => {
+  if (!Array.isArray(value)) fail(`${label} must be a non-empty string array.`, "INVALID_INPUT");
+  if (!value.length) fail(`${label} must be a non-empty string array.`, "INVALID_INPUT");
+  const items = value;
+  const result = items.map((item, index2) => nonEmpty2(item, `${label}[${index2}]`));
+  if (new Set(result).size !== result.length) fail(`${label} must not contain duplicates.`, "INVALID_INPUT");
+  return result;
+};
+var descriptor = (value, index2) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail(`capabilities[${index2}] must be an object.`, "INVALID_INPUT");
+  const candidate = value;
+  const kind = candidate["kind"];
+  if (typeof kind !== "string" || !CAPABILITY_KINDS.includes(kind)) fail(`capabilities[${index2}].kind is invalid.`, "INVALID_INPUT");
+  const dependencies = candidate["dependencies"] === void 0 ? void 0 : stringList(candidate["dependencies"], `capabilities[${index2}].dependencies`);
+  return {
+    id: nonEmpty2(candidate["id"], `capabilities[${index2}].id`),
+    version: nonEmpty2(candidate["version"], `capabilities[${index2}].version`),
+    kind,
+    entryPoint: nonEmpty2(candidate["entryPoint"], `capabilities[${index2}].entryPoint`),
+    exports: stringList(candidate["exports"], `capabilities[${index2}].exports`),
+    ...dependencies === void 0 ? {} : { dependencies }
+  };
+};
+var manifestBody = (input) => ({
+  type: "agentskit-harness-capability-manifest",
+  schemaVersion: CAPABILITY_MANIFEST_SCHEMA_VERSION,
+  package: nonEmpty2(input.package, "package"),
+  packageVersion: nonEmpty2(input.packageVersion, "packageVersion"),
+  entryPoint: nonEmpty2(input.entryPoint, "entryPoint"),
+  sourceDigest: digest2(input.sourceDigest, "sourceDigest"),
+  capabilities: (Array.isArray(input.capabilities) ? input.capabilities : fail("capabilities must be an array.", "INVALID_INPUT")).map(descriptor)
+});
+var createCapabilityManifest = (input) => {
+  const body3 = manifestBody(input);
+  if (!body3.capabilities.length) fail("capabilities must be non-empty.", "INVALID_INPUT");
+  if (new Set(body3.capabilities.map((item) => item.id)).size !== body3.capabilities.length) fail("capability ids must be unique.", "INVALID_INPUT");
+  return { ...body3, digest: hashJson(body3) };
+};
+var validateCapabilityManifest = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail("Capability manifest must be an object.", "INVALID_INPUT");
+  const candidate = value;
+  const capabilities = Array.isArray(candidate["capabilities"]) ? candidate["capabilities"] : fail("capabilities must be an array.", "INVALID_INPUT");
+  const body3 = manifestBody({ package: nonEmpty2(candidate["package"], "package"), packageVersion: nonEmpty2(candidate["packageVersion"], "packageVersion"), entryPoint: nonEmpty2(candidate["entryPoint"], "entryPoint"), sourceDigest: digest2(candidate["sourceDigest"], "sourceDigest"), capabilities });
+  if (new Set(body3.capabilities.map((item) => item.id)).size !== body3.capabilities.length) fail("capability ids must be unique.", "INVALID_INPUT");
+  if (candidate["type"] !== body3.type || candidate["schemaVersion"] !== body3.schemaVersion) fail("Capability manifest type or schemaVersion is invalid.", "INVALID_INPUT");
+  const manifestDigest = digest2(candidate["digest"], "digest");
+  if (manifestDigest !== hashJson(body3)) fail("Capability manifest digest is invalid.", "INVALID_INPUT");
+  return { ...body3, digest: manifestDigest };
+};
 var index = (root, indexPath) => JSON.parse(readFileSync(resolve(root, indexPath), "utf8"));
 var text = (entry) => [entry.id, entry.type, entry.title, entry.path, entry.description, entry.body, ...Array.isArray(entry.tags) ? entry.tags : []].filter((value) => typeof value === "string").join(" ").toLowerCase();
 var sourceHash = (document) => typeof document.contentHash === "string" && document.contentHash.length > 0 ? document.contentHash : hashJson(document);
@@ -897,23 +1239,1425 @@ var createDocBridgeContextProvider = ({ root, indexPath = ".doc-bridge/index.jso
   id: "doc-bridge",
   version: "1.0.0",
   resolve: async (query) => {
+    const started = Date.now();
     const document = index(root, indexPath);
     const contentHash = sourceHash(document);
     const entries = Array.isArray(document.knowledge) ? document.knowledge.filter((value) => typeof value === "object" && value !== null && !Array.isArray(value)).filter((entry) => matches(entry, query)).sort((left, right) => String(left.id ?? "").localeCompare(String(right.id ?? ""))).slice(0, 8) : [];
-    const references = entries.flatMap((entry) => typeof entry.id === "string" && typeof entry.path === "string" ? [{ id: entry.id, uri: `doc-bridge://${entry.path}`, ...typeof entry.title === "string" ? { title: entry.title } : {}, contentHash }] : []);
-    return { providerId: "doc-bridge", query, references, sourceHash: contentHash, snapshotHash: hashContextSnapshot({ providerId: "doc-bridge", query, references, sourceHash: contentHash }), resolvedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    const references = entries.flatMap((entry) => typeof entry.id === "string" && typeof entry.path === "string" ? [{ id: entry.id, uri: `doc-bridge://${entry.path}`, ...typeof entry.title === "string" ? { title: entry.title } : {}, contentHash: typeof entry.contentHash === "string" ? entry.contentHash : contentHash, relevance: 1 }] : []);
+    const telemetry = { status: "measured", durationMs: Date.now() - started, contextReferences: references.length, contextCostTokens: Math.max(1, Math.ceil(JSON.stringify(references).length / 4)) };
+    return { providerId: "doc-bridge", query, references, sourceHash: contentHash, snapshotHash: hashContextSnapshot({ providerId: "doc-bridge", query, references, sourceHash: contentHash }), resolvedAt: (/* @__PURE__ */ new Date()).toISOString(), assurance: "contract-tested", telemetry };
+  }
+});
+
+// src/kernel/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 digest3 = (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: digest3(base) };
+};
+var isDiscoveryCurrent = (result, current) => {
+  const reasons = [];
+  if (result.sourceRevision !== current.sourceRevision) reasons.push("source");
+  if (result.contractHash !== current.contractHash) reasons.push("contract");
+  if ((result.contextHash ?? "") !== (current.contextHash ?? "")) reasons.push("context");
+  return { current: reasons.length === 0, reasons };
+};
+
+// src/kernel/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/kernel/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 names2 = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const runtime = required3(candidate.runtime, "candidate.runtime");
+    if (names2.has(runtime)) fail("candidate.runtime values must be unique.", "INVALID_INPUT");
+    names2.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/kernel/workflow.ts
+var validId2 = (id2) => {
+  if (typeof id2 !== "string" || !id2.trim()) fail("Workflow node id must be non-empty.", "INVALID_INPUT");
+  return id2.trim();
+};
+var levels = (nodes) => {
+  const byId = new Map(nodes.map((node) => [validId2(node.id), node]));
+  if (byId.size !== nodes.length) fail("Workflow node ids must be unique.", "INVALID_INPUT");
+  const remaining = new Set(byId.keys());
+  const completed = /* @__PURE__ */ new Set();
+  const result = [];
+  while (remaining.size) {
+    const ready = [...remaining].sort().map((id2) => byId.get(id2)).filter((node) => (node.dependsOn ?? []).every((dependency) => completed.has(dependency)));
+    if (!ready.length) fail("Workflow contains an unknown dependency or cycle.", "INVALID_INPUT");
+    result.push(ready);
+    for (const node of ready) {
+      remaining.delete(node.id);
+      completed.add(node.id);
+    }
+  }
+  return result;
+};
+var runWorkflow = async (nodes, options) => {
+  if (!Number.isInteger(options.maxConcurrency) || options.maxConcurrency < 1) fail("maxConcurrency must be a positive integer.", "INVALID_INPUT");
+  const started = Date.now();
+  const results = {};
+  const order = [];
+  let peakConcurrency = 0;
+  for (const level of levels(nodes)) {
+    const remaining = [...level];
+    while (remaining.length) {
+      const batch = [];
+      const keys = /* @__PURE__ */ new Set();
+      const limit = options.currentConcurrency ? options.currentConcurrency() : options.maxConcurrency;
+      if (!Number.isInteger(limit) || limit < 1) fail("currentConcurrency must return a positive integer.", "INVALID_INPUT");
+      for (const node of remaining) {
+        const key = node.mutationKey?.trim();
+        if (batch.length >= limit || key && keys.has(key)) continue;
+        batch.push(node);
+        if (key) keys.add(key);
+      }
+      if (!batch.length) fail("Workflow could not schedule a mutation batch.", "INVALID_INPUT");
+      peakConcurrency = Math.max(peakConcurrency, batch.length);
+      const values = await Promise.all(batch.map((node) => node.run()));
+      batch.forEach((node, index2) => {
+        results[node.id] = values[index2];
+        order.push(node.id);
+      });
+      for (const node of batch) remaining.splice(remaining.indexOf(node), 1);
+    }
+  }
+  return { results, order, peakConcurrency, criticalPathMs: Date.now() - started };
+};
+
+// src/delivery/review.ts
+var runAdversarialReview = async ({ lenses, reviewer, binding: binding2, maxConcurrency = 3 }) => {
+  if (!Array.isArray(lenses) || lenses.length === 0) fail("At least one review lens is required.", "INVALID_INPUT");
+  if (!Number.isInteger(maxConcurrency) || maxConcurrency < 1) fail("maxConcurrency must be a positive integer.", "INVALID_INPUT");
+  const normalized = lenses.map((lens) => {
+    if (typeof lens !== "object" || lens === null || Array.isArray(lens) || typeof lens.id !== "string" || !lens.id.trim()) fail("Review lens id is required.", "INVALID_INPUT");
+    const maxAttempts = lens.maxAttempts ?? 1;
+    if (!Number.isInteger(maxAttempts) || maxAttempts < 1 || maxAttempts > 3) fail("Review lens maxAttempts must be between 1 and 3.", "INVALID_INPUT");
+    return { id: lens.id.trim(), maxAttempts };
+  });
+  if (new Set(normalized.map((lens) => lens.id)).size !== normalized.length) fail("Review lens ids must be unique.", "INVALID_INPUT");
+  const workflow = await runWorkflow(normalized.map((lens) => ({ id: lens.id, run: async () => {
+    let last = { status: "unverified", reason: "Reviewer returned no verdict." };
+    for (let attempt = 1; attempt <= lens.maxAttempts; attempt += 1) {
+      try {
+        const verdict = await reviewer(lens, attempt);
+        if (!verdict || !["pass", "finding", "unverified"].includes(verdict.status)) return { status: "unverified", reason: "Reviewer returned an invalid verdict." };
+        last = verdict;
+        if (verdict.status !== "unverified" || verdict.retryable !== true) return verdict;
+      } catch (error) {
+        last = { status: "unverified", reason: error instanceof Error ? error.message : String(error) };
+      }
+    }
+    return last;
+  } })), { maxConcurrency });
+  const verdicts = Object.fromEntries(Object.entries(workflow.results).sort(([left], [right]) => left.localeCompare(right)));
+  const reasons = Object.entries(verdicts).flatMap(([id2, verdict]) => verdict.status === "pass" ? [] : verdict.status === "finding" && (verdict.evidence?.trim() || verdict.reproduction?.trim()) ? [`${id2} found an issue: ${verdict.reason ?? "evidence recorded"}.`] : [`${id2} is unverified or lacks reproducible evidence.`]);
+  const base = { verdicts, reasons, binding: binding2, peakConcurrency: workflow.peakConcurrency };
+  return { decision: reasons.length ? "blocked" : "approved", ...base, digest: hashJson(base) };
+};
+
+// src/delivery/index.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 body3 = [`## 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: body3, reason: "G2 is current and the remote PR is absent.", idempotencyKey };
+};
+var createPullRequestApproval = ({ body: body3, metadata, approvedBy, candidateRevision, contractHash, configHash }) => {
+  if (approvedBy !== "human") fail("Pull request approval requires a human actor.", "HUMAN_APPROVAL_REQUIRED");
+  const normalizedBody = required4(body3, "PR body");
+  const binding2 = { approvedBy, candidateRevision: required4(candidateRevision, "candidateRevision"), contractHash: required4(contractHash, "contractHash"), configHash: required4(configHash, "configHash"), bodyHash: hashJson(normalizedBody), metadataHash: hashJson(metadata) };
+  return { ...binding2, digest: hashJson(binding2) };
+};
+var verifyPullRequestApproval = ({ approval, body: body3, metadata, candidateRevision, contractHash, configHash }) => {
+  const expected = createPullRequestApproval({ body: body3, metadata, approvedBy: "human", candidateRevision, contractHash, configHash });
+  if (approval.digest !== expected.digest || approval.bodyHash !== expected.bodyHash || approval.metadataHash !== expected.metadataHash) fail("Approved pull request content or metadata changed.", "STALE");
+  return approval;
+};
+var assessQaTransition = ({ featureValidated, g5, qaPassed, issue }) => {
+  required4(issue, "issue");
+  const base = { issue, featureValidated, g5: g5.digest, qaPassed };
+  if (!featureValidated || g5.gate !== "G5" || g5.decision !== "approved") return { decision: "blocked", target: "verification", invalidatesDownstream: false, reason: "Feature validation and approved G5 acceptance are required before moving the issue to QA.", idempotencyKey: hashJson(base) };
+  if (!qaPassed) return { decision: "return-to-verification", target: "verification", invalidatesDownstream: true, reason: "QA failed; downstream evidence is invalidated and verification must be repeated.", idempotencyKey: hashJson(base) };
+  return { decision: "move-to-qa", target: "qa", invalidatesDownstream: false, reason: "Feature validation and G5 acceptance are current.", idempotencyKey: hashJson(base) };
+};
+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/kernel/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 nonEmpty3 = (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" && !nonEmpty3(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) nonEmpty3(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 = nonEmpty3(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 digest6 = createHash("sha256").update(JSON.stringify(result)).digest("hex");
+  return { ...result, digest: digest6 };
+};
+
+// src/kernel/eval.ts
+var EVAL_MANIFEST_SCHEMA_VERSION = 1;
+var EVAL_LAYERS = ["contract", "deterministic", "integration", "quality", "regression", "resource"];
+var EVAL_COMPONENTS = ["core", "workflow", "memory", "cache", "doc-bridge", "agent-model", "orca-worktree", "runtime", "code-review", "github-linear", "eval-metrics"];
+var nonEmpty4 = (value, label) => {
+  const text7 = typeof value === "string" ? value.trim() : "";
+  if (!text7) fail(`${label} is required.`, "INVALID_INPUT");
+  return text7;
+};
+var digest4 = (value, label) => {
+  const result = nonEmpty4(value, label);
+  if (!/^[a-f0-9]{64}$/.test(result)) fail(`${label} must be a lowercase SHA-256 digest.`, "INVALID_INPUT");
+  return result;
+};
+var score = (value, label) => {
+  const numeric = typeof value === "number" ? value : Number.NaN;
+  if (!Number.isFinite(numeric) || numeric < 0 || numeric > 100) fail(`${label} must be a number between 0 and 100.`, "INVALID_INPUT");
+  return numeric;
+};
+var validateCase = (value, index2) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail(`cases[${index2}] must be an object.`, "INVALID_INPUT");
+  const candidate = value;
+  const layer = nonEmpty4(candidate["layer"], `cases[${index2}].layer`);
+  if (!EVAL_LAYERS.includes(layer)) fail(`cases[${index2}].layer is invalid.`, "INVALID_INPUT");
+  const components = candidate["components"];
+  if (!Array.isArray(components) || !components.length) fail(`cases[${index2}].components must be a non-empty array.`, "INVALID_INPUT");
+  const normalizedComponents = components.map((item, componentIndex) => {
+    const component2 = nonEmpty4(item, `cases[${index2}].components[${componentIndex}]`);
+    if (!EVAL_COMPONENTS.includes(component2)) fail(`cases[${index2}].components[${componentIndex}] is invalid.`, "INVALID_INPUT");
+    return component2;
+  });
+  if (new Set(normalizedComponents).size !== normalizedComponents.length) fail(`cases[${index2}].components must not contain duplicates.`, "INVALID_INPUT");
+  const baselineScore = candidate["baselineScore"] === void 0 ? void 0 : score(candidate["baselineScore"], `cases[${index2}].baselineScore`);
+  return {
+    id: nonEmpty4(candidate["id"], `cases[${index2}].id`),
+    layer,
+    components: normalizedComponents,
+    grader: nonEmpty4(candidate["grader"], `cases[${index2}].grader`),
+    input: nonEmpty4(candidate["input"], `cases[${index2}].input`),
+    ...candidate["critical"] === void 0 ? {} : { critical: candidate["critical"] === true },
+    ...candidate["subjective"] === void 0 ? {} : { subjective: candidate["subjective"] === true },
+    ...baselineScore === void 0 ? {} : { baselineScore }
+  };
+};
+var manifestBody2 = (value) => {
+  const casesValue = value["cases"];
+  if (!Array.isArray(casesValue) || !casesValue.length) fail("cases must be a non-empty array.", "INVALID_INPUT");
+  const cases = casesValue.map(validateCase);
+  if (new Set(cases.map((item) => item.id)).size !== cases.length) fail("case ids must be unique.", "INVALID_INPUT");
+  const layers = new Set(cases.map((item) => item.layer));
+  const missingLayers = EVAL_LAYERS.filter((layer) => !layers.has(layer));
+  if (missingLayers.length) fail(`cases must cover layers: ${missingLayers.join(", ")}.`, "INVALID_INPUT");
+  const coveredComponents = new Set(cases.flatMap((item) => item.components));
+  const missingComponents = EVAL_COMPONENTS.filter((component2) => !coveredComponents.has(component2));
+  if (missingComponents.length) fail(`cases must cover components: ${missingComponents.join(", ")}.`, "INVALID_INPUT");
+  const gradersValue = value["graders"];
+  if (!Array.isArray(gradersValue) || !gradersValue.length) fail("graders must be a non-empty array.", "INVALID_INPUT");
+  const graders = gradersValue.map((item, index2) => nonEmpty4(item, `graders[${index2}]`));
+  const thresholdsValue = value["thresholds"];
+  if (typeof thresholdsValue !== "object" || thresholdsValue === null || Array.isArray(thresholdsValue)) fail("thresholds must be an object.", "INVALID_INPUT");
+  const thresholds2 = thresholdsValue;
+  const repetitions = value["repetitions"];
+  if (!Number.isInteger(repetitions) || repetitions < 1) fail("repetitions must be a positive integer.", "INVALID_INPUT");
+  return {
+    type: "agentskit-harness-eval-manifest",
+    schemaVersion: EVAL_MANIFEST_SCHEMA_VERSION,
+    suiteId: nonEmpty4(value["suiteId"], "suiteId"),
+    name: nonEmpty4(value["name"], "name"),
+    cases,
+    graders,
+    thresholds: { subjectiveQuality: score(thresholds2["subjectiveQuality"] ?? 80, "thresholds.subjectiveQuality"), maxRegression: score(thresholds2["maxRegression"] ?? 5, "thresholds.maxRegression") },
+    repetitions,
+    provider: nonEmpty4(value["provider"], "provider"),
+    model: nonEmpty4(value["model"], "model"),
+    promptHash: digest4(value["promptHash"], "promptHash"),
+    toolHash: digest4(value["toolHash"], "toolHash"),
+    evidenceOutputs: Array.isArray(value["evidenceOutputs"]) && value["evidenceOutputs"].length ? value["evidenceOutputs"].map((item, index2) => nonEmpty4(item, `evidenceOutputs[${index2}]`)) : fail("evidenceOutputs must be a non-empty array.", "INVALID_INPUT")
+  };
+};
+var createEvalManifest = (input) => {
+  const body3 = manifestBody2(input);
+  return { ...body3, digest: hashJson(body3) };
+};
+var validateEvalManifest = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail("Eval manifest must be an object.", "INVALID_INPUT");
+  const candidate = value;
+  const body3 = manifestBody2(candidate);
+  if (candidate["type"] !== body3.type || candidate["schemaVersion"] !== body3.schemaVersion) fail("Eval manifest type or schemaVersion is invalid.", "INVALID_INPUT");
+  const manifestDigest = digest4(candidate["digest"], "digest");
+  if (manifestDigest !== hashJson(body3)) fail("Eval manifest digest is invalid.", "INVALID_INPUT");
+  return { ...body3, digest: manifestDigest };
+};
+var median = (values) => {
+  if (!values.length) return null;
+  const ordered = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(ordered.length / 2);
+  return ordered.length % 2 ? ordered[middle] : (ordered[middle - 1] + ordered[middle]) / 2;
+};
+var runEvalBattery = async ({ manifest, evaluate }) => {
+  const validated = validateEvalManifest(manifest);
+  const reports = [];
+  for (const testCase of validated.cases) {
+    const observations = [];
+    for (let repetition = 1; repetition <= validated.repetitions; repetition += 1) observations.push(await evaluate(testCase, repetition));
+    const blockers2 = [];
+    const statuses = observations.map((observation) => observation.status);
+    if (statuses.some((status) => status === "unknown" || status === "stale" || status === "unverified")) blockers2.push("unknown, stale, or unverified evidence");
+    if (statuses.some((status) => status === "failed")) blockers2.push("failed observation");
+    const values = observations.map((observation) => observation.score).filter((value) => typeof value === "number");
+    const minimum = values.length ? Math.min(...values) : null;
+    const baseline = testCase.baselineScore;
+    if (testCase.critical && (minimum === null || minimum < 100)) blockers2.push("critical case requires 100/100");
+    if (testCase.subjective && (median(values) ?? 0) < validated.thresholds.subjectiveQuality) blockers2.push(`subjective score below ${validated.thresholds.subjectiveQuality}/100`);
+    if (baseline !== void 0 && minimum !== null && minimum < baseline - validated.thresholds.maxRegression && !observations.every((observation) => observation.decision)) blockers2.push(`regression exceeds ${validated.thresholds.maxRegression} points without a decision`);
+    reports.push({ id: testCase.id, repetitions: observations.length, min: minimum, median: median(values), max: values.length ? Math.max(...values) : null, statuses, blockers: blockers2 });
+  }
+  const blockers = reports.flatMap((report) => report.blockers.map((reason) => `${report.id}: ${reason}`));
+  return { suiteId: validated.suiteId, repetitions: validated.repetitions, cases: reports, status: blockers.length ? "blocked" : "passed", blockers };
+};
+var pass = (expected, output) => typeof expected === "string" ? output === expected : expected(output);
+var runAgentEval = async ({ suite, agent, concurrency = 1 }) => {
+  if (!suite.name.trim() || !suite.cases.length) fail("Eval suite must have a name and at least one case.", "INVALID_INPUT");
+  if (!Number.isInteger(concurrency) || concurrency < 1) fail("Eval concurrency must be a positive integer.", "INVALID_INPUT");
+  const failures = [];
+  let passed = 0;
+  for (let offset = 0; offset < suite.cases.length; offset += concurrency) {
+    const batch = suite.cases.slice(offset, offset + concurrency);
+    const outputs = await Promise.all(batch.map((testCase) => agent(testCase.input)));
+    batch.forEach((testCase, index2) => {
+      if (pass(testCase.expected, outputs[index2])) passed += 1;
+      else failures.push(testCase.id);
+    });
+  }
+  return { suite: suite.name, total: suite.cases.length, passed, failed: suite.cases.length - passed, accuracy: passed / suite.cases.length, failures };
+};
+var assessAgentEval = (report, minimumAccuracy) => {
+  if (!Number.isFinite(minimumAccuracy) || minimumAccuracy < 0 || minimumAccuracy > 1) fail("minimumAccuracy must be between 0 and 1.", "INVALID_INPUT");
+  if (report.total < 1 || report.passed + report.failed !== report.total || report.accuracy !== report.passed / report.total) fail("Eval report is inconsistent.", "INVALID_INPUT");
+  return report.accuracy >= minimumAccuracy ? { status: "passed", reason: `Accuracy ${report.accuracy.toFixed(4)} meets ${minimumAccuracy.toFixed(4)}.`, report } : { status: "blocked", reason: `Accuracy ${report.accuracy.toFixed(4)} is below ${minimumAccuracy.toFixed(4)}.`, report };
+};
+
+// src/kernel/cache.ts
+var validateCacheableOperation = (operation) => {
+  if (operation !== "context" && operation !== "read-only") fail("Only context and read-only operations may use the LLM cache.", "POLICY_BLOCKED");
+  return operation;
+};
+var createLlmCacheKey = (input) => {
+  validateCacheableOperation(input.operation);
+  return hashJson(input);
+};
+var createLlmCache = () => {
+  const values = /* @__PURE__ */ new Map();
+  let hits = 0;
+  let misses = 0;
+  let invalidations = 0;
+  return {
+    assurance: "contract-tested",
+    telemetry: () => ({ status: "measured", cacheHits: hits, cacheMisses: misses }),
+    async getOrCompute(key, compute) {
+      const cached = values.get(key);
+      if (cached !== void 0) {
+        hits += 1;
+        return cached;
+      }
+      misses += 1;
+      const value = await compute();
+      values.set(key, value);
+      return value;
+    },
+    invalidate(key) {
+      if (key === void 0) {
+        invalidations += values.size;
+        values.clear();
+        return;
+      }
+      if (values.delete(key)) invalidations += 1;
+    },
+    stats: () => ({ hits, misses, invalidations })
+  };
+};
+
+// src/kernel/optimization.ts
+var nonNegative2 = (value, label) => {
+  if (!Number.isFinite(value) || value < 0) fail(`${label} must be a non-negative number.`, "INVALID_INPUT");
+  return value;
+};
+var nonNegativeInteger = (value, label) => {
+  nonNegative2(value, label);
+  if (!Number.isInteger(value)) fail(`${label} must be an integer.`, "INVALID_INPUT");
+  return value;
+};
+var required6 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var validateOptimizationObservation = (observation) => {
+  required6(observation.sourceRevision, "sourceRevision");
+  required6(observation.contractHash, "contractHash");
+  required6(observation.configHash, "configHash");
+  required6(observation.provider, "provider");
+  required6(observation.model, "model");
+  nonNegative2(observation.durationMs, "durationMs");
+  if (observation.accuracy !== void 0 && (!Number.isFinite(observation.accuracy) || observation.accuracy < 0 || observation.accuracy > 1)) fail("accuracy must be between 0 and 1.", "INVALID_INPUT");
+  if (observation.tokens) {
+    const tokens = observation.tokens;
+    for (const key of ["inputTokens", "outputTokens", "totalTokens"]) nonNegativeInteger(tokens[key], `tokens.${key}`);
+    if (tokens.totalTokens !== tokens.inputTokens + tokens.outputTokens) fail("tokens.totalTokens must equal inputTokens + outputTokens.", "INVALID_INPUT");
+    for (const key of ["cacheReadTokens", "cacheWriteTokens"]) if (tokens[key] !== void 0) nonNegativeInteger(tokens[key], `tokens.${key}`);
+  }
+  if (observation.memory) for (const key of ["reads", "writes", "relevantHits", "staleHits"]) nonNegativeInteger(observation.memory[key], `memory.${key}`);
+  if (observation.cache) {
+    for (const key of ["hits", "misses", "invalidations"]) nonNegativeInteger(observation.cache[key], `cache.${key}`);
+    if (observation.cache.tokensSaved !== void 0) nonNegativeInteger(observation.cache.tokensSaved, "cache.tokensSaved");
+  }
+  if (observation.parallelism) {
+    for (const key of ["tasks", "peakConcurrency"]) nonNegativeInteger(observation.parallelism[key], `parallelism.${key}`);
+    nonNegative2(observation.parallelism.criticalPathMs, "parallelism.criticalPathMs");
+    if (observation.parallelism.queueWaitMs !== void 0) nonNegative2(observation.parallelism.queueWaitMs, "parallelism.queueWaitMs");
+    if (observation.parallelism.tasks > 0 && observation.parallelism.peakConcurrency < 1) fail("parallelism.peakConcurrency must be positive when tasks exist.", "INVALID_INPUT");
+  }
+  return observation;
+};
+var rate = (hits, total) => total ? Number((hits / total).toFixed(4)) : void 0;
+var compareOptimization = (baseline, candidate) => {
+  validateOptimizationObservation(baseline);
+  validateOptimizationObservation(candidate);
+  for (const key of ["sourceRevision", "contractHash", "configHash", "provider", "model"]) if (baseline[key] !== candidate[key]) return { comparable: false, reason: `Bindings differ: ${key}.`, digest: hashJson({ baseline, candidate }) };
+  const result = {
+    comparable: true,
+    reason: "Observations share source, contract, configuration, provider, and model bindings.",
+    digest: hashJson({ baseline, candidate }),
+    durationDeltaMs: candidate.durationMs - baseline.durationMs,
+    ...baseline.accuracy !== void 0 && candidate.accuracy !== void 0 ? { accuracyDelta: Number((candidate.accuracy - baseline.accuracy).toFixed(4)) } : {},
+    ...baseline.tokens && candidate.tokens ? { tokenDelta: candidate.tokens.totalTokens - baseline.tokens.totalTokens } : {},
+    ...baseline.cache && candidate.cache ? { cacheHitRateDelta: (rate(candidate.cache.hits, candidate.cache.hits + candidate.cache.misses) ?? 0) - (rate(baseline.cache.hits, baseline.cache.hits + baseline.cache.misses) ?? 0) } : {},
+    ...baseline.memory && candidate.memory ? { memoryRelevantHitRateDelta: (rate(candidate.memory.relevantHits, candidate.memory.reads) ?? 0) - (rate(baseline.memory.relevantHits, baseline.memory.reads) ?? 0) } : {},
+    ...baseline.parallelism && candidate.parallelism ? { peakConcurrencyDelta: candidate.parallelism.peakConcurrency - baseline.parallelism.peakConcurrency } : {}
+  };
+  return result;
+};
+
+// src/kernel/memory.ts
+var MEMORY_SCOPES = ["issue", "project", "global"];
+var text2 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(label + " must be a non-empty string.", "INVALID_INPUT");
+  return value.trim();
+};
+var validateMemoryRecord = (record3) => {
+  text2(record3.id, "memory.id");
+  if (!MEMORY_SCOPES.includes(record3.scope)) fail("memory.scope is invalid.", "INVALID_INPUT");
+  text2(record3.summary, "memory.summary");
+  text2(record3.source, "memory.source");
+  text2(record3.sourceRevision, "memory.sourceRevision");
+  text2(record3.contentHash, "memory.contentHash");
+  if (record3.approved !== true) fail("Only approved memory may enter the shared store.", "POLICY_BLOCKED");
+  return record3;
+};
+var createInMemoryMemoryAdapter = (options = {}) => {
+  const records = /* @__PURE__ */ new Map();
+  let reads = 0;
+  let writes = 0;
+  let relevantHits = 0;
+  let staleHits = 0;
+  return {
+    id: options.id ?? "in-memory",
+    version: options.version ?? "1",
+    assurance: "contract-tested",
+    telemetry: () => ({ status: "measured", memoryReads: reads, memoryWrites: writes, memoryRelevantHits: relevantHits, memoryStaleHits: staleHits }),
+    async remember(record3) {
+      records.set(validateMemoryRecord(record3).id, record3);
+      writes += 1;
+    },
+    async recall({ query, issueId, project, sourceRevision }) {
+      reads += 1;
+      const needle = query.trim().toLowerCase();
+      const hits = [...records.values()].filter((record3) => {
+        const scopeMatch = record3.scope === "global" || (record3.scope === "issue" ? Boolean(issueId && record3.source.includes(issueId)) : Boolean(project && record3.source.includes(project)));
+        return scopeMatch && (!needle || `${record3.summary} ${record3.source}`.toLowerCase().includes(needle));
+      }).map((record3) => ({ record: record3, relevant: true, stale: sourceRevision !== void 0 && record3.sourceRevision !== sourceRevision }));
+      relevantHits += hits.length;
+      staleHits += hits.filter((hit) => hit.stale).length;
+      return hits;
+    }
+  };
+};
+var createKvMemoryAdapter = (store, options = {}) => {
+  const indexKey = "agentskit-harness:memory:index";
+  let reads = 0;
+  let writes = 0;
+  let relevantHits = 0;
+  let staleHits = 0;
+  const matches2 = (record3, query, issueId, project) => {
+    const scopeMatch = record3.scope === "global" || (record3.scope === "issue" ? Boolean(issueId && record3.source.includes(issueId)) : Boolean(project && record3.source.includes(project)));
+    return scopeMatch && (!query || `${record3.summary} ${record3.source}`.toLowerCase().includes(query));
+  };
+  return {
+    id: options.id ?? "agentskit-kv",
+    version: options.version ?? "1",
+    assurance: "contract-tested",
+    telemetry: () => ({ status: "measured", memoryReads: reads, memoryWrites: writes, memoryRelevantHits: relevantHits, memoryStaleHits: staleHits }),
+    async remember(record3) {
+      const valid = validateMemoryRecord(record3);
+      const ids = await store.get(indexKey);
+      const index2 = Array.isArray(ids) ? ids.filter((id2) => typeof id2 === "string") : [];
+      if (!index2.includes(valid.id)) await store.set(indexKey, [...index2, valid.id].sort());
+      await store.set(`agentskit-harness:memory:${valid.id}`, valid);
+      writes += 1;
+    },
+    async recall({ query, issueId, project, sourceRevision }) {
+      reads += 1;
+      const ids = await store.get(indexKey);
+      const records = Array.isArray(ids) ? await Promise.all(ids.filter((id2) => typeof id2 === "string").map((id2) => store.get(`agentskit-harness:memory:${id2}`))) : [];
+      const hits = records.filter((record3) => Boolean(record3 && typeof record3 === "object" && record3.approved === true)).filter((record3) => matches2(record3, query.trim().toLowerCase(), issueId, project)).map((record3) => ({ record: record3, relevant: true, stale: sourceRevision !== void 0 && record3.sourceRevision !== sourceRevision }));
+      relevantHits += hits.length;
+      staleHits += hits.filter((hit) => hit.stale).length;
+      return hits;
+    }
+  };
+};
+
+// src/kernel/phase-executor.ts
+var PHASE_MODES = ["safe", "yolo", "dry-run"];
+var PHASE_EFFECTS = ["read", "write", "external"];
+var PHASE_EFFECT_ACTIONS = ["allow", "preview", "block", "escalate"];
+var PHASE_DECISIONS = ["pass", "block", "escalate", "retry", "cancel", "resume"];
+var requiredId = (value, label) => {
+  if (typeof value !== "string") return fail(`${label} must be a non-empty string.`, "INVALID_INPUT");
+  if (!value.trim()) return fail(`${label} must be a non-empty string.`, "INVALID_INPUT");
+  return value.trim();
+};
+var names = (values, label) => {
+  if (values === void 0) return [];
+  if (!Array.isArray(values)) fail(`${label} must be an array.`, "INVALID_INPUT");
+  const normalized = values.map((value, index2) => requiredId(value, `${label}[${index2}]`));
+  if (new Set(normalized).size !== normalized.length) fail(`${label} must contain unique names.`, "INVALID_INPUT");
+  return normalized;
+};
+var boundedPositive = (value, label, fallback) => {
+  const result = value ?? fallback;
+  if (!Number.isInteger(result) || result < 1 || result > 100) fail(`${label} must be a bounded positive integer (1-100).`, "INVALID_INPUT");
+  return result;
+};
+var duration = (value, label) => {
+  if (value === void 0) return void 0;
+  if (!Number.isInteger(value) || value < 1) fail(`${label} must be a positive integer.`, "INVALID_INPUT");
+  return value;
+};
+var defaultEffects = (mode) => mode === "dry-run" ? { read: "allow", write: "preview", external: "preview" } : mode === "safe" ? { read: "allow", write: "allow", external: "escalate" } : { read: "allow", write: "allow", external: "allow" };
+var normalize = (profile) => {
+  if (typeof profile !== "object" || profile === null || Array.isArray(profile)) return fail("profile must be an object.", "INVALID_INPUT");
+  const id2 = requiredId(profile.id, "profile.id");
+  if (!PHASE_MODES.includes(profile.mode)) fail("profile.mode is invalid.", "INVALID_INPUT");
+  if (!Array.isArray(profile.phases) || !profile.phases.length) fail("profile.phases must be non-empty.", "INVALID_INPUT");
+  profile.phases.forEach((phase2, index2) => {
+    if (typeof phase2 !== "object" || phase2 === null || Array.isArray(phase2)) fail(`phases[${index2}] must be an object.`, "INVALID_INPUT");
+  });
+  const ids = profile.phases.map((phase2, index2) => requiredId(phase2.id, `phases[${index2}].id`));
+  if (new Set(ids).size !== ids.length) fail("Phase ids must be unique.", "INVALID_INPUT");
+  const known = new Set(ids);
+  const outputOwners = /* @__PURE__ */ new Map();
+  const phases = profile.phases.map((phase2, index2) => {
+    if (typeof phase2 !== "object" || phase2 === null || Array.isArray(phase2)) return fail(`phases[${index2}] must be an object.`, "INVALID_INPUT");
+    if (!PHASE_EFFECTS.includes(phase2.effect)) fail(`phases[${index2}].effect is invalid.`, "INVALID_INPUT");
+    const dependsOn = names(phase2.dependsOn, `phases[${index2}].dependsOn`);
+    if (dependsOn.includes(ids[index2])) fail(`phases[${index2}] cannot depend on itself.`, "INVALID_INPUT");
+    if (dependsOn.some((dependency) => !known.has(dependency))) fail(`phases[${index2}] has an unknown dependency.`, "INVALID_INPUT");
+    const inputs = names(phase2.inputs, `phases[${index2}].inputs`);
+    const outputs = names(phase2.outputs, `phases[${index2}].outputs`);
+    for (const output of outputs) {
+      const owner = outputOwners.get(output);
+      if (owner) fail(`Output ${output} is declared by both ${owner} and ${ids[index2]}.`, "INVALID_INPUT");
+      outputOwners.set(output, ids[index2]);
+    }
+    const gates = names(phase2.gates, `phases[${index2}].gates`);
+    const maxAttempts = boundedPositive(phase2.retries?.maxAttempts, `phases[${index2}].retries.maxAttempts`, 1);
+    return { id: ids[index2], effect: phase2.effect, inputs, outputs, dependsOn, gates, ...maxAttempts > 1 ? { retries: { maxAttempts } } : {}, ...duration(phase2.budgetMs, `phases[${index2}].budgetMs`) ? { budgetMs: phase2.budgetMs } : {} };
+  });
+  const defaults = defaultEffects(profile.mode);
+  const effectPolicy = { ...defaults, ...profile.effectPolicy ?? {} };
+  for (const effect of PHASE_EFFECTS) if (!PHASE_EFFECT_ACTIONS.includes(effectPolicy[effect])) fail(`effectPolicy.${effect} is invalid.`, "INVALID_INPUT");
+  const maxConcurrency = boundedPositive(profile.maxConcurrency, "profile.maxConcurrency", 1);
+  const budgetMs = duration(profile.budgetMs, "profile.budgetMs");
+  calculateLevels(phases);
+  return { id: id2, mode: profile.mode, phases, effectPolicy, maxConcurrency, ...budgetMs ? { budgetMs } : {} };
+};
+var calculateLevels = (phases) => {
+  const byId = new Map(phases.map((phase2) => [phase2.id, phase2]));
+  const remaining = new Set(byId.keys());
+  const completed = /* @__PURE__ */ new Set();
+  const levels2 = [];
+  while (remaining.size) {
+    const ready = [...remaining].sort().filter((id2) => (byId.get(id2)?.dependsOn ?? []).every((dependency) => completed.has(dependency)));
+    if (!ready.length) fail("Phase profile contains an unknown dependency or cycle.", "INVALID_INPUT");
+    levels2.push(ready);
+    ready.forEach((id2) => {
+      remaining.delete(id2);
+      completed.add(id2);
+    });
+  }
+  return levels2;
+};
+var createPhaseProfile = (profile) => normalize(profile);
+var planPhaseProfile = (profile) => {
+  const normalized = normalize(profile);
+  return { profileId: normalized.id, mode: normalized.mode, levels: calculateLevels(normalized.phases), phases: normalized.phases, effectPolicy: normalized.effectPolicy, maxConcurrency: normalized.maxConcurrency, ...normalized.budgetMs ? { budgetMs: normalized.budgetMs } : {} };
+};
+var resultDecision = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail("Phase handler must return a decision object.", "INVALID_INPUT");
+  const result = value;
+  if (!PHASE_DECISIONS.includes(result.decision)) fail("Phase handler returned an invalid decision.", "INVALID_INPUT");
+  if (result.outputs !== void 0 && (typeof result.outputs !== "object" || result.outputs === null || Array.isArray(result.outputs))) fail("Phase outputs must be an object.", "INVALID_INPUT");
+  return result;
+};
+var gateDecision = (value) => typeof value === "boolean" ? { decision: value ? "pass" : "block" } : value;
+var packet = (phaseIds, ambiguities) => ambiguities.length ? { id: "phase-preflight", phaseIds: [...phaseIds].sort(), ambiguities } : void 0;
+var timeout = async (operation, budgetMs) => {
+  if (budgetMs === void 0) return operation;
+  let timer;
+  const limit = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`phase budget exceeded after ${budgetMs}ms`)), budgetMs);
+  });
+  try {
+    return await Promise.race([operation, limit]);
+  } finally {
+    if (timer) clearTimeout(timer);
   }
+};
+var executePhaseProfile = async (profile, options = {}) => {
+  const plan = planPhaseProfile(profile);
+  const started = (options.now ?? Date.now)();
+  const inputValues = { ...options.inputs ?? {} };
+  const outputValues = { ...options.resume?.outputs ?? {} };
+  const completed = options.resume?.completed ?? {};
+  const phasesById = new Map(plan.phases.map((phase2) => [phase2.id, phase2]));
+  const mutating = plan.phases.filter((phase2) => phase2.effect !== "read");
+  const preflightAmbiguities = [];
+  const preflightAmbiguityPhaseIds = /* @__PURE__ */ new Set();
+  const preflightBlocked = [];
+  const preflightEscalated = [];
+  for (const phase2 of mutating) {
+    const action = plan.effectPolicy[phase2.effect];
+    if (action === "block") {
+      preflightBlocked.push({ id: phase2.id, effect: phase2.effect, decision: "block", attempts: 0, skipped: true, reason: `Effect ${phase2.effect} is blocked by profile policy.` });
+      continue;
+    }
+    if (action === "escalate") {
+      preflightEscalated.push({ id: phase2.id, effect: phase2.effect, decision: "escalate", attempts: 0, skipped: true, reason: `Effect ${phase2.effect} requires escalation in ${plan.mode} mode.` });
+      continue;
+    }
+    if (!options.preflight && action === "allow") {
+      preflightBlocked.push({ id: phase2.id, effect: phase2.effect, decision: "block", attempts: 0, skipped: true, reason: `Preflight is required before ${phase2.effect} effects.` });
+      continue;
+    }
+    if (!options.preflight) continue;
+    const context = { phase: phase2, attempt: 0, mode: plan.mode, inputs: inputValues, outputs: outputValues, dryRun: action === "preview" };
+    const check = await options.preflight(context);
+    if (check.ambiguities?.length) {
+      preflightAmbiguityPhaseIds.add(phase2.id);
+      preflightAmbiguities.push(...check.ambiguities);
+    }
+    if (check.decision === "block") preflightBlocked.push({ id: phase2.id, effect: phase2.effect, decision: "block", attempts: 0, skipped: true, ...check.reason ? { reason: check.reason } : {} });
+    if (check.decision === "escalate") preflightEscalated.push({ id: phase2.id, effect: phase2.effect, decision: "escalate", attempts: 0, skipped: true, ...check.reason ? { reason: check.reason } : {} });
+  }
+  const decisionPacket = packet([...preflightAmbiguityPhaseIds, ...preflightEscalated.map((phase2) => phase2.id)], preflightAmbiguities);
+  if (decisionPacket || preflightEscalated.length) return { status: "escalated", plan, phases: [...preflightBlocked, ...preflightEscalated], order: [], outputs: outputValues, resumed: false, ...decisionPacket ? { decisionPacket } : {}, durationMs: (options.now ?? Date.now)() - started };
+  if (preflightBlocked.length) return { status: "blocked", plan, phases: preflightBlocked, order: [], outputs: outputValues, resumed: false, durationMs: (options.now ?? Date.now)() - started };
+  const executions = [];
+  let resumed = false;
+  let dryRun = false;
+  const statusOf = (phase2, decision, attempts, skipped, reason, outputs) => ({ id: phase2.id, effect: phase2.effect, decision, attempts, skipped, ...reason ? { reason } : {}, ...outputs ? { outputs } : {} });
+  const runPhase = async (phase2, levelOutputs) => {
+    const prior = completed[phase2.id];
+    if (prior && (prior.decision === "pass" || prior.decision === "resume")) {
+      resumed = true;
+      const restored = prior.outputs ?? {};
+      return { execution: statusOf(phase2, "resume", 0, true, "Resumed from a completed phase.", restored), outputs: restored };
+    }
+    const action = plan.effectPolicy[phase2.effect];
+    if (action === "block") return { execution: statusOf(phase2, "block", 0, true, `Effect ${phase2.effect} is blocked by profile policy.`), outputs: {} };
+    if (action === "escalate") return { execution: statusOf(phase2, "escalate", 0, true, `Effect ${phase2.effect} requires escalation in ${plan.mode} mode.`), outputs: {} };
+    if (action === "preview") {
+      dryRun = true;
+      return { execution: statusOf(phase2, "pass", 0, true, "Effect previewed; handler was not invoked."), outputs: {} };
+    }
+    const values = { ...inputValues, ...levelOutputs };
+    const inputs = {};
+    for (const name of phase2.inputs ?? []) {
+      if (!(name in values)) return { execution: statusOf(phase2, "block", 0, true, `Missing phase input: ${name}.`), outputs: {} };
+      inputs[name] = values[name];
+    }
+    const handler = options.handlers?.[phase2.id];
+    if (!handler) return { execution: statusOf(phase2, "block", 0, true, `No handler registered for phase ${phase2.id}.`), outputs: {} };
+    const gateContext = (attempt) => ({ phase: phase2, attempt, mode: plan.mode, inputs, outputs: levelOutputs, dryRun: false });
+    for (const gateId of phase2.gates ?? []) {
+      const evaluator = options.gates?.[gateId];
+      if (!evaluator) return { execution: statusOf(phase2, "block", 0, true, `No evaluator registered for gate ${gateId}.`), outputs: {} };
+      const gate = gateDecision(await evaluator(gateContext(0)));
+      if (gate.decision !== "pass") return { execution: statusOf(phase2, gate.decision, 0, true, gate.reason ?? `Gate ${gateId} did not pass.`), outputs: {} };
+    }
+    const maxAttempts = phase2.retries?.maxAttempts ?? 1;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      let result;
+      try {
+        result = resultDecision(await timeout(Promise.resolve(handler(gateContext(attempt))), phase2.budgetMs));
+      } catch (error) {
+        return { execution: statusOf(phase2, "block", attempt, false, error instanceof Error ? error.message : String(error)), outputs: {} };
+      }
+      if (result.decision === "retry") {
+        if (attempt < maxAttempts) continue;
+        return { execution: statusOf(phase2, "block", attempt, false, result.reason ?? "Phase retry budget exhausted."), outputs: {} };
+      }
+      if (result.decision === "pass" || result.decision === "resume") {
+        const produced = { ...result.outputs ?? {} };
+        const declared = new Set(phase2.outputs ?? []);
+        if ([...Object.keys(produced)].some((name) => !declared.has(name))) return { execution: statusOf(phase2, "block", attempt, false, "Phase returned an undeclared output."), outputs: {} };
+        if ([...phase2.outputs ?? []].some((name) => !(name in produced))) return { execution: statusOf(phase2, "block", attempt, false, "Phase did not produce every declared output."), outputs: {} };
+        return { execution: statusOf(phase2, result.decision, attempt, false, result.reason, produced), outputs: produced };
+      }
+      return { execution: statusOf(phase2, result.decision, attempt, false, result.reason), outputs: {} };
+    }
+    return { execution: statusOf(phase2, "block", maxAttempts, false, "Phase did not resolve."), outputs: {} };
+  };
+  for (const level of plan.levels) {
+    if (plan.budgetMs !== void 0 && (options.now ?? Date.now)() - started > plan.budgetMs) {
+      const phase2 = phasesById.get(level[0]);
+      executions.push(statusOf(phase2, "block", 0, true, `Profile budget exceeded after ${plan.budgetMs}ms.`));
+      break;
+    }
+    const levelSnapshot = { ...outputValues };
+    const workflow = await runWorkflow(level.map((id2) => ({ id: id2, run: () => runPhase(phasesById.get(id2), levelSnapshot) })), { maxConcurrency: plan.maxConcurrency });
+    let stop = false;
+    for (const id2 of level) {
+      const step = workflow.results[id2];
+      executions.push(step.execution);
+      if (step.execution.decision === "pass" || step.execution.decision === "resume") Object.assign(outputValues, step.outputs);
+      else stop = true;
+    }
+    if (plan.budgetMs !== void 0 && (options.now ?? Date.now)() - started > plan.budgetMs && executions.length) {
+      const last = executions.length - 1;
+      executions[last] = { ...executions[last], decision: "block", reason: `Profile budget exceeded after ${plan.budgetMs}ms.` };
+      stop = true;
+    }
+    if (stop) break;
+  }
+  const failed = executions.find((execution) => execution.decision === "block" || execution.decision === "escalate" || execution.decision === "cancel");
+  const status = failed?.decision === "cancel" ? "cancelled" : failed?.decision === "escalate" ? "escalated" : failed ? "blocked" : dryRun ? "dry-run" : "passed";
+  return { status, plan, phases: executions, order: executions.map((execution) => execution.id), outputs: outputValues, resumed, durationMs: (options.now ?? Date.now)() - started };
+};
+var ARTIFACT_SCHEMA_VERSION = 1;
+var ARTIFACT_TYPES = ["plan", "finding", "decision", "repair", "blocker", "approval", "phase"];
+var text3 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) return fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var digest5 = (value, label) => {
+  const result = text3(value, label);
+  if (!/^[a-f0-9]{64}$/.test(result)) fail(`${label} must be a lowercase SHA-256 digest.`, "INVALID_INPUT");
+  return result;
+};
+var artifactId = (value) => {
+  const result = text3(value, "Artifact artifactId");
+  if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(result)) fail("Artifact artifactId is invalid.", "INVALID_INPUT");
+  return result;
+};
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var artifactBody = (artifact) => ({
+  type: artifact.type,
+  schemaVersion: artifact.schemaVersion,
+  artifactId: artifact.artifactId,
+  artifactType: artifact.artifactType,
+  artifactVersion: artifact.artifactVersion,
+  runId: artifact.runId,
+  issueRef: artifact.issueRef,
+  sourceRevision: artifact.sourceRevision,
+  contractHash: artifact.contractHash,
+  configHash: artifact.configHash,
+  contextHash: artifact.contextHash,
+  phase: artifact.phase,
+  payload: artifact.payload,
+  payloadHash: artifact.payloadHash
 });
+var expectedArtifactHash = (artifact) => hashJson(artifactBody(artifact));
+var validateArtifactEnvelope = (value) => {
+  if (!isRecord5(value)) return fail("Artifact envelope must be an object.", "INVALID_INPUT");
+  if (value["type"] !== "agentskit-harness-artifact" || value["schemaVersion"] !== ARTIFACT_SCHEMA_VERSION) fail("Artifact envelope type or schemaVersion is invalid.", "INVALID_INPUT");
+  if (!ARTIFACT_TYPES.includes(value["artifactType"])) fail("Artifact artifactType is invalid.", "INVALID_INPUT");
+  if (!Number.isInteger(value["artifactVersion"]) || value["artifactVersion"] < 1) fail("Artifact artifactVersion must be a positive integer.", "INVALID_INPUT");
+  const createdAt = text3(value["createdAt"], "Artifact createdAt");
+  if (!Number.isFinite(Date.parse(createdAt))) fail("Artifact createdAt must be a valid timestamp.", "INVALID_INPUT");
+  const payloadHash = digest5(value["payloadHash"], "Artifact payloadHash");
+  if (hashJson(value["payload"]) !== payloadHash) fail("Artifact payloadHash does not match payload.", "INVALID_INPUT");
+  const artifact = {
+    type: "agentskit-harness-artifact",
+    schemaVersion: ARTIFACT_SCHEMA_VERSION,
+    artifactId: artifactId(value["artifactId"]),
+    artifactType: value["artifactType"],
+    artifactVersion: value["artifactVersion"],
+    runId: text3(value["runId"], "Artifact runId"),
+    issueRef: text3(value["issueRef"], "Artifact issueRef"),
+    sourceRevision: text3(value["sourceRevision"], "Artifact sourceRevision"),
+    contractHash: digest5(value["contractHash"], "Artifact contractHash"),
+    configHash: digest5(value["configHash"], "Artifact configHash"),
+    contextHash: digest5(value["contextHash"], "Artifact contextHash"),
+    phase: text3(value["phase"], "Artifact phase"),
+    createdAt,
+    payload: value["payload"],
+    payloadHash
+  };
+  if (digest5(value["artifactHash"], "Artifact artifactHash") !== expectedArtifactHash(artifact)) fail("Artifact artifactHash does not match envelope.", "INVALID_INPUT");
+  return { ...artifact, artifactHash: value["artifactHash"] };
+};
+var createArtifactEnvelope = (input) => {
+  if (!ARTIFACT_TYPES.includes(input.artifactType)) fail("Artifact artifactType is invalid.", "INVALID_INPUT");
+  const payloadHash = input.payloadHash ?? hashJson(input.payload);
+  if (payloadHash !== hashJson(input.payload)) fail("Artifact payloadHash does not match payload.", "INVALID_INPUT");
+  const identity = {
+    type: "agentskit-harness-artifact",
+    schemaVersion: ARTIFACT_SCHEMA_VERSION,
+    artifactType: input.artifactType,
+    artifactVersion: input.artifactVersion,
+    runId: input.runId,
+    issueRef: input.issueRef,
+    sourceRevision: input.sourceRevision,
+    contractHash: input.contractHash,
+    configHash: input.configHash,
+    contextHash: input.contextHash,
+    phase: input.phase,
+    payload: input.payload,
+    payloadHash
+  };
+  const id2 = input.artifactId ?? hashJson(identity);
+  const artifact = {
+    ...identity,
+    artifactId: id2,
+    createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const artifactHash = input.artifactHash ?? expectedArtifactHash(artifact);
+  return validateArtifactEnvelope({ ...artifact, artifactHash });
+};
+var renderArtifactMarkdown = (artifact) => [
+  `# ${artifact.artifactType} artifact ${artifact.artifactId}`,
+  "",
+  `- Schema: ${artifact.schemaVersion}`,
+  `- Version: ${artifact.artifactVersion}`,
+  `- Run: ${artifact.runId}`,
+  `- Issue: ${artifact.issueRef}`,
+  `- Phase: ${artifact.phase}`,
+  `- Source revision: ${artifact.sourceRevision}`,
+  `- Contract hash: ${artifact.contractHash}`,
+  `- Configuration hash: ${artifact.configHash}`,
+  `- Context hash: ${artifact.contextHash}`,
+  `- Artifact hash: ${artifact.artifactHash}`,
+  "",
+  "## Payload",
+  "",
+  "```json",
+  JSON.stringify(artifact.payload, null, 2),
+  "```",
+  ""
+].join("\n");
+var artifactFilePath = (stateDir, runId, id2) => join(stateDir, "runs", runId, "artifacts", `${id2}.json`);
+var artifactMarkdownPath = (stateDir, runId, id2) => join(stateDir, "runs", runId, "artifacts", `${id2}.md`);
+var FileArtifactStore = class {
+  constructor(stateDir) {
+    this.stateDir = stateDir;
+  }
+  stateDir;
+  write(input) {
+    const artifact = validateArtifactEnvelope(input);
+    const path = artifactFilePath(this.stateDir, artifact.runId, artifact.artifactId);
+    mkdirSync(join(this.stateDir, "runs", artifact.runId, "artifacts"), { recursive: true });
+    if (existsSync(path)) {
+      const existing = validateArtifactEnvelope(JSON.parse(readFileSync(path, "utf8")));
+      if (existing.artifactHash !== artifact.artifactHash) fail(`Artifact ${artifact.artifactId} already exists with different content.`, "HARNESS_ERROR");
+      return existing;
+    }
+    writeFileSync(path, `${JSON.stringify(artifact, null, 2)}
+`, "utf8");
+    writeFileSync(artifactMarkdownPath(this.stateDir, artifact.runId, artifact.artifactId), renderArtifactMarkdown(artifact), "utf8");
+    new FileEventStore(this.stateDir).append({
+      runId: artifact.runId,
+      sourceRevision: artifact.sourceRevision,
+      configHash: artifact.configHash,
+      type: "artifact.recorded",
+      payload: { artifactId: artifact.artifactId, artifactType: artifact.artifactType, artifactVersion: artifact.artifactVersion, artifactHash: artifact.artifactHash, phase: artifact.phase, representation: "json+markdown" }
+    });
+    return artifact;
+  }
+  read(runId, id2) {
+    return validateArtifactEnvelope(JSON.parse(readFileSync(artifactFilePath(this.stateDir, runId, artifactId(id2)), "utf8")));
+  }
+  list(runId) {
+    const directory = join(this.stateDir, "runs", runId, "artifacts");
+    if (!existsSync(directory)) return [];
+    return readdirSync(directory).filter((name) => name.endsWith(".json")).sort().map((name) => validateArtifactEnvelope(JSON.parse(readFileSync(join(directory, name), "utf8"))));
+  }
+};
+var artifactIsFresh = (artifact, binding2) => artifact.runId === binding2.runId && artifact.issueRef === binding2.issueRef && artifact.sourceRevision === binding2.sourceRevision && artifact.contractHash === binding2.contractHash && artifact.configHash === binding2.configHash && artifact.contextHash === binding2.contextHash && (binding2.phase === void 0 || artifact.phase === binding2.phase);
+var resumeStateFromArtifacts = (artifacts) => {
+  const completed = {};
+  const outputs = {};
+  for (const artifact of artifacts.filter((item) => item.artifactType === "phase").sort((left, right) => left.phase.localeCompare(right.phase) || left.artifactVersion - right.artifactVersion)) {
+    if (!isRecord5(artifact.payload) || artifact.payload["decision"] !== "pass") continue;
+    const phaseOutputs = isRecord5(artifact.payload["outputs"]) ? artifact.payload["outputs"] : {};
+    completed[artifact.phase] = { decision: "pass", outputs: phaseOutputs };
+    Object.assign(outputs, phaseOutputs);
+  }
+  return { completed, outputs };
+};
+var createPhaseArtifact = (base, execution) => createArtifactEnvelope({ ...base, artifactType: "phase", phase: execution.id, payload: { decision: execution.decision, outputs: execution.outputs ?? {} } });
+var readArtifactFile = (path) => validateArtifactEnvelope(JSON.parse(readFileSync(path, "utf8")));
+var artifactDigest = (artifact) => sha256(JSON.stringify(artifact));
+
+// src/kernel/quality.ts
+var QUALITY_DIMENSIONS = ["correctness", "completeness", "speed", "cost", "resource", "reliability"];
+var finite = (value, label, max) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || max !== void 0 && value > max) return fail(`${label} is invalid.`, "INVALID_INPUT");
+  return value;
+};
+var integer = (value, label) => {
+  const result = finite(value, label);
+  if (!Number.isInteger(result)) return fail(`${label} must be an integer.`, "INVALID_INPUT");
+  return result;
+};
+var phase = (value) => {
+  if (typeof value !== "string" || !value.trim()) return fail("phaseId is required.", "INVALID_INPUT");
+  return value.trim();
+};
+var validatePhaseTelemetry = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return fail("Phase telemetry must be an object.", "INVALID_INPUT");
+  const raw = value;
+  const outcome = raw["outcome"];
+  if (!["pass", "block", "escalate", "cancel", "unknown"].includes(outcome)) return fail("Phase telemetry outcome is invalid.", "INVALID_INPUT");
+  const tokens = raw["tokens"] === void 0 ? void 0 : raw["tokens"];
+  if (tokens) {
+    for (const key of ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "costUsd"]) if (tokens[key] !== void 0) finite(tokens[key], `tokens.${key}`);
+  }
+  const machine = raw["machine"] === void 0 ? void 0 : raw["machine"];
+  if (machine) {
+    for (const key of ["cpuPercent", "memoryUsedPercent", "peakConcurrency", "queueWaitMs", "contentionMs", "saturationPercent"]) if (machine[key] !== void 0) finite(machine[key], `machine.${key}`, ["cpuPercent", "memoryUsedPercent", "saturationPercent"].includes(key) ? 100 : void 0);
+  }
+  return {
+    phaseId: phase(raw["phaseId"]),
+    ...raw["durationMs"] === void 0 ? {} : { durationMs: finite(raw["durationMs"], "durationMs") },
+    ...raw["attempts"] === void 0 ? {} : { attempts: integer(raw["attempts"], "attempts") },
+    outcome,
+    ...raw["failureClass"] === void 0 ? {} : { failureClass: phase(raw["failureClass"]) },
+    ...raw["evidenceCoverage"] === void 0 ? {} : { evidenceCoverage: finite(raw["evidenceCoverage"], "evidenceCoverage", 1) },
+    ...tokens ? { tokens } : {},
+    ...machine ? { machine } : {}
+  };
+};
+var average = (values) => values.length ? Number((values.reduce((sum, value) => sum + value, 0) / values.length).toFixed(2)) : null;
+var score2 = (value, source, baseline = null) => ({ score: value === null ? null : Math.max(0, Math.min(100, Number(value.toFixed(2)))), status: value === null ? "unknown" : "measured", baselineDelta: value === null || baseline === null ? null : Number((value - baseline).toFixed(2)), source });
+var evaluateWatchdog = ({ phases, budget }) => {
+  const blockers = [];
+  const duration5 = phases.every((phase2) => phase2.durationMs !== void 0) ? phases.reduce((sum, phase2) => sum + (phase2.durationMs ?? 0), 0) : void 0;
+  const totalTokens = phases.every((phase2) => phase2.tokens?.inputTokens !== void 0 && phase2.tokens.outputTokens !== void 0) ? phases.reduce((sum, phase2) => sum + (phase2.tokens?.inputTokens ?? 0) + (phase2.tokens?.outputTokens ?? 0), 0) : void 0;
+  if (budget.maxDurationMs !== void 0 && duration5 !== void 0 && duration5 > budget.maxDurationMs) blockers.push({ class: "budget", reason: `Duration budget exceeded: ${duration5}ms > ${budget.maxDurationMs}ms.` });
+  if (budget.maxTotalTokens !== void 0 && totalTokens !== void 0 && totalTokens > budget.maxTotalTokens) blockers.push({ class: "budget", reason: `Token budget exceeded: ${totalTokens} > ${budget.maxTotalTokens}.` });
+  for (const phase2 of phases) {
+    if (budget.maxMemoryUsedPercent !== void 0 && phase2.machine?.memoryUsedPercent !== void 0 && phase2.machine.memoryUsedPercent > budget.maxMemoryUsedPercent) blockers.push({ class: "resource", phaseId: phase2.phaseId, reason: `Memory saturation exceeded: ${phase2.machine.memoryUsedPercent}% > ${budget.maxMemoryUsedPercent}%.` });
+    if (budget.maxSaturationPercent !== void 0 && phase2.machine?.saturationPercent !== void 0 && phase2.machine.saturationPercent > budget.maxSaturationPercent) blockers.push({ class: "contention", phaseId: phase2.phaseId, reason: `Saturation exceeded: ${phase2.machine.saturationPercent}% > ${budget.maxSaturationPercent}%.` });
+  }
+  return { status: blockers.length ? "blocked" : "ok", blockers };
+};
+var createQualityMatrix = ({ phases, baseline, budget = {} }) => {
+  const current = phases.map(validatePhaseTelemetry);
+  const prior = baseline?.map(validatePhaseTelemetry) ?? [];
+  const currentDurations = current.flatMap((phase2) => phase2.durationMs === void 0 ? [] : [phase2.durationMs]);
+  const priorDurations = prior.flatMap((phase2) => phase2.durationMs === void 0 ? [] : [phase2.durationMs]);
+  const currentTokens = current.flatMap((phase2) => phase2.tokens?.inputTokens !== void 0 && phase2.tokens.outputTokens !== void 0 ? [phase2.tokens.inputTokens + phase2.tokens.outputTokens] : []);
+  const priorTokens = prior.flatMap((phase2) => phase2.tokens?.inputTokens !== void 0 && phase2.tokens.outputTokens !== void 0 ? [phase2.tokens.inputTokens + phase2.tokens.outputTokens] : []);
+  const correctness = score2(average(current.map((phase2) => phase2.evidenceCoverage === void 0 ? 0 : phase2.evidenceCoverage * 100)), "mean evidence coverage");
+  const completeness = score2(current.length ? current.filter((phase2) => phase2.outcome === "pass").length / current.length * 100 : null, "passed phases / total phases");
+  const speed = score2(currentDurations.length && priorDurations.length ? average(priorDurations) / Math.max(1, average(currentDurations)) * 100 : null, "baseline duration / current duration", 100);
+  const cost = score2(currentTokens.length && priorTokens.length ? average(priorTokens) / Math.max(1, average(currentTokens)) * 100 : null, "baseline tokens / current tokens", 100);
+  const resourceValues = current.flatMap((phase2) => phase2.machine?.cpuPercent !== void 0 && phase2.machine.memoryUsedPercent !== void 0 ? [100 - Math.max(phase2.machine.cpuPercent, phase2.machine.memoryUsedPercent)] : []);
+  const resource = score2(average(resourceValues), "100 - max(cpu%, memory%)");
+  const reliability = score2(current.length ? current.filter((phase2) => phase2.outcome === "pass").length / current.length * 100 : null, "passed phases / total phases");
+  const dimensions = { correctness, completeness, speed, cost, resource, reliability };
+  const measured = Object.values(dimensions).filter((item) => item.score !== null).map((item) => item.score);
+  const overall = score2(average(measured), "mean of measured dimensions");
+  const unknownMetricCount = Object.values(dimensions).filter((item) => item.status === "unknown").length + current.filter((phase2) => phase2.durationMs === void 0 || phase2.tokens === void 0 || phase2.machine === void 0).length;
+  const blockers = evaluateWatchdog({ phases: current, budget }).blockers;
+  const body3 = { type: "agentskit-harness-quality-matrix", schemaVersion: 1, dimensions, overall, phaseCount: current.length, unknownMetricCount, blockers };
+  return { ...body3, digest: hashJson(body3) };
+};
+
+// src/kernel/compatibility.ts
+var COMPATIBILITY_SCHEMA_VERSION = 1;
+var COMPATIBILITY_COMPONENTS = ["core", "memory", "eval", "doc-bridge", "code-review", "adapter-boundary", "runtime"];
+var text4 = (value, label) => {
+  const result = typeof value === "string" ? value.trim() : "";
+  if (!result) fail(`${label} is required.`, "INVALID_INPUT");
+  return result;
+};
+var sha = (value, label) => {
+  const result = text4(value, label);
+  if (!/^[a-f0-9]{40,64}$/.test(result)) fail(`${label} must be a pinned git revision.`, "INVALID_INPUT");
+  return result;
+};
+var component = (value, index2) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail(`components[${index2}] must be an object.`, "INVALID_INPUT");
+  const candidate = value;
+  const id2 = text4(candidate["id"], `components[${index2}].id`);
+  if (!COMPATIBILITY_COMPONENTS.includes(id2)) fail(`components[${index2}].id is invalid.`, "INVALID_INPUT");
+  if (candidate["adapterBoundary"] !== "real-adapter") fail(`components[${index2}] must use the real-adapter boundary.`, "INVALID_INPUT");
+  return {
+    id: id2,
+    package: text4(candidate["package"], `components[${index2}].package`),
+    version: text4(candidate["version"], `components[${index2}].version`),
+    revision: sha(candidate["revision"], `components[${index2}].revision`),
+    repository: text4(candidate["repository"], `components[${index2}].repository`),
+    adapterBoundary: "real-adapter",
+    testCommand: text4(candidate["testCommand"], `components[${index2}].testCommand`),
+    evalCommand: text4(candidate["evalCommand"], `components[${index2}].evalCommand`),
+    previousVersion: text4(candidate["previousVersion"], `components[${index2}].previousVersion`),
+    noHarnessBaseline: text4(candidate["noHarnessBaseline"], `components[${index2}].noHarnessBaseline`),
+    migrationEvidence: text4(candidate["migrationEvidence"], `components[${index2}].migrationEvidence`),
+    rollbackEvidence: text4(candidate["rollbackEvidence"], `components[${index2}].rollbackEvidence`)
+  };
+};
+var body = (value) => {
+  const componentsValue = value["components"];
+  if (!Array.isArray(componentsValue) || !componentsValue.length) fail("components must be a non-empty array.", "INVALID_INPUT");
+  const components = componentsValue.map(component);
+  if (new Set(components.map((item) => item.id)).size !== components.length) fail("component ids must be unique.", "INVALID_INPUT");
+  const missing = COMPATIBILITY_COMPONENTS.filter((id2) => !components.some((item) => item.id === id2));
+  if (missing.length) fail(`components must cover: ${missing.join(", ")}.`, "INVALID_INPUT");
+  const outputs = value["evidenceOutputs"];
+  if (!Array.isArray(outputs) || !outputs.length) fail("evidenceOutputs must be a non-empty array.", "INVALID_INPUT");
+  return {
+    type: "agentskit-harness-compatibility-manifest",
+    schemaVersion: COMPATIBILITY_SCHEMA_VERSION,
+    harnessVersion: text4(value["harnessVersion"], "harnessVersion"),
+    sourceRevision: sha(value["sourceRevision"], "sourceRevision"),
+    components,
+    evidenceOutputs: outputs.map((item, index2) => text4(item, `evidenceOutputs[${index2}]`))
+  };
+};
+var createCompatibilityManifest = (input) => {
+  const value = body(input);
+  return { ...value, digest: hashJson(value) };
+};
+var validateCompatibilityManifest = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail("Compatibility manifest must be an object.", "INVALID_INPUT");
+  const candidate = value;
+  const valueBody = body(candidate);
+  if (candidate["type"] !== valueBody.type || candidate["schemaVersion"] !== valueBody.schemaVersion) fail("Compatibility manifest type or schemaVersion is invalid.", "INVALID_INPUT");
+  const digest6 = text4(candidate["digest"], "digest");
+  if (digest6 !== hashJson(valueBody)) fail("Compatibility manifest digest is invalid.", "INVALID_INPUT");
+  return { ...valueBody, digest: digest6 };
+};
+var assessCompatibility = ({ manifest, observations }) => {
+  const validated = validateCompatibilityManifest(manifest);
+  const expected = new Set(validated.components.map((item) => item.id));
+  const seen = /* @__PURE__ */ new Set();
+  const blockers = [];
+  observations.forEach((observation) => {
+    if (!expected.has(observation.componentId) || seen.has(observation.componentId)) blockers.push(`${observation.componentId}: unexpected or duplicate observation`);
+    seen.add(observation.componentId);
+    if (observation.status !== "passed") blockers.push(`${observation.componentId}: ${observation.status} compatibility evidence`);
+    if (!observation.evidence) blockers.push(`${observation.componentId}: missing evidence`);
+  });
+  validated.components.forEach((item) => {
+    if (!seen.has(item.id)) blockers.push(`${item.id}: missing observation`);
+    const observation = observations.find((candidate) => candidate.componentId === item.id);
+    if (observation && observation.previousVersion !== item.previousVersion) blockers.push(`${item.id}: previous version binding mismatch`);
+    if (observation && observation.noHarnessBaseline !== item.noHarnessBaseline) blockers.push(`${item.id}: no-Harness baseline binding mismatch`);
+  });
+  return { status: blockers.length ? "blocked" : "passed", componentCount: validated.components.length, observations, blockers };
+};
+
+// src/kernel/resilience.ts
+var positiveInteger = (value, label) => {
+  if (!Number.isInteger(value) || value < 1) fail(`${label} must be a positive integer.`, "INVALID_INPUT");
+  return value;
+};
+var nonNegativeInteger2 = (value, label) => {
+  if (!Number.isInteger(value) || value < 0) fail(`${label} must be a non-negative integer.`, "INVALID_INPUT");
+  return value;
+};
+var classifyFailure = (error) => {
+  const value = error;
+  const code = typeof value?.code === "string" ? value.code.toUpperCase() : "";
+  const message = typeof value?.message === "string" ? value.message : String(error);
+  const text7 = `${code} ${message}`.toLowerCase();
+  if (/quota|rate.?limit|too many requests|429/.test(text7)) return { class: "quota", retryable: true, reason: message };
+  if (/timeout|timed out|deadline/.test(text7)) return { class: "timeout", retryable: true, reason: message };
+  if (/policy|forbidden|permission|approval/.test(text7)) return { class: "policy", retryable: false, reason: message };
+  if (/invalid|schema|argument|config|validation/.test(text7)) return { class: "validation", retryable: false, reason: message };
+  if (/network|connection|econn|503|502|external/.test(text7)) return { class: "external", retryable: true, reason: message };
+  return { class: "unknown", retryable: false, reason: message };
+};
+var recoveryDelayMs = (attempt, policy) => {
+  positiveInteger(attempt, "attempt");
+  nonNegativeInteger2(policy.baseDelayMs, "baseDelayMs");
+  nonNegativeInteger2(policy.maxDelayMs, "maxDelayMs");
+  if (policy.maxDelayMs < policy.baseDelayMs) fail("maxDelayMs must be greater than or equal to baseDelayMs.", "INVALID_INPUT");
+  return Math.min(policy.maxDelayMs, policy.baseDelayMs * 2 ** Math.max(0, attempt - 1));
+};
+var wait = (delayMs, sleep) => delayMs > 0 ? sleep(delayMs) : Promise.resolve();
+var runWithRecovery = async (operation, options) => {
+  const maxAttempts = positiveInteger(options.maxAttempts, "maxAttempts");
+  const baseDelayMs = nonNegativeInteger2(options.baseDelayMs, "baseDelayMs");
+  const maxDelayMs = nonNegativeInteger2(options.maxDelayMs, "maxDelayMs");
+  if (maxDelayMs < baseDelayMs) fail("maxDelayMs must be greater than or equal to baseDelayMs.", "INVALID_INPUT");
+  if (options.timeoutMs !== void 0) positiveInteger(options.timeoutMs, "timeoutMs");
+  const sleep = options.sleep ?? ((delayMs) => new Promise((resolve6) => setTimeout(resolve6, delayMs)));
+  const observations = [];
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const controller = new AbortController();
+    let timer;
+    try {
+      const operationPromise = operation(controller.signal, attempt);
+      const value = options.timeoutMs === void 0 ? await operationPromise : await Promise.race([
+        operationPromise,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            controller.abort();
+            reject(new Error("operation timed out"));
+          }, options.timeoutMs);
+        })
+      ]);
+      return { status: "completed", attempts: attempt, observations, value };
+    } catch (error) {
+      const failure = classifyFailure(error);
+      const delayMs = failure.retryable && attempt < maxAttempts ? recoveryDelayMs(attempt, { baseDelayMs, maxDelayMs }) : 0;
+      const observation = { attempt, failure, delayMs };
+      observations.push(observation);
+      options.onObservation?.(observation);
+      if (!failure.retryable || attempt >= maxAttempts) return { status: "failed", attempts: attempt, observations, failure };
+      await wait(delayMs, sleep);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  return fail("Recovery loop exhausted unexpectedly.", "HARNESS_ERROR");
+};
+
+// src/adapters/agent.ts
+var required7 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) return fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var duration2 = (value) => Number.isFinite(value) && value >= 0 ? value : fail("Agent durationMs must be non-negative.", "INVALID_INPUT");
+var usage = (value) => {
+  if (value === void 0) return { status: "unknown" };
+  if (value.status !== "measured" && value.status !== "unknown") return fail("Agent usage status is invalid.", "INVALID_INPUT");
+  for (const key of ["inputTokens", "outputTokens", "totalTokens"]) if (value[key] !== void 0 && (!Number.isFinite(value[key]) || value[key] < 0)) return fail(`Agent usage ${key} must be non-negative.`, "INVALID_INPUT");
+  return value;
+};
+var createCodingAgentAdapter = ({ id: id2, version, assurance = "contract-tested", timeoutMs = 12e4, execute }) => {
+  const adapterId = required7(id2, "agent.id");
+  const adapterVersion = required7(version, "agent.version");
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 1) return fail("agent.timeoutMs must be a positive integer.", "INVALID_INPUT");
+  return {
+    id: adapterId,
+    version: adapterVersion,
+    assurance,
+    execute: async (request) => {
+      const issueRef = required7(request.issueRef, "agent.issueRef");
+      const prompt = required7(request.prompt, "agent.prompt");
+      const sourceRevision = required7(request.sourceRevision, "agent.sourceRevision");
+      const controller = new AbortController();
+      const signal = request.signal;
+      if (signal?.aborted) return { status: "cancelled", output: {}, diff: "", usage: { status: "unknown" }, durationMs: 0, failure: { class: "policy", retryable: false, reason: "Agent execution was cancelled before start." }, metadata: { assurance, telemetry: { status: "measured", durationMs: 0 } } };
+      const onAbort = () => controller.abort();
+      signal?.addEventListener("abort", onAbort, { once: true });
+      const started = Date.now();
+      let timer;
+      let timedOut = false;
+      try {
+        const operation = Promise.resolve(execute({ issueRef, prompt, sourceRevision, ...request.contextHash ? { contextHash: request.contextHash } : {}, signal: controller.signal }));
+        const timeout2 = new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+            reject(new Error("agent execution timed out"));
+          }, timeoutMs);
+        });
+        const result = await Promise.race([operation, timeout2]);
+        if (!result || typeof result !== "object" || Array.isArray(result) || typeof result.output !== "object" || result.output === null || Array.isArray(result.output) || typeof result.diff !== "string") return fail("Agent result must contain structured output and diff.", "INVALID_INPUT");
+        const measuredUsage = usage(result.usage);
+        const durationMs = duration2(Date.now() - started);
+        return { status: "completed", output: result.output, diff: result.diff, usage: measuredUsage, durationMs, metadata: { assurance, telemetry: { status: measuredUsage.status, durationMs, ...measuredUsage.inputTokens === void 0 ? {} : { inputTokens: measuredUsage.inputTokens }, ...measuredUsage.outputTokens === void 0 ? {} : { outputTokens: measuredUsage.outputTokens }, ...measuredUsage.totalTokens === void 0 ? {} : { totalTokens: measuredUsage.totalTokens } } } };
+      } catch (error) {
+        const failure = timedOut ? { class: "timeout", retryable: true, reason: "Agent execution timed out." } : classifyFailure(error);
+        const status = timedOut ? "timeout" : controller.signal.aborted ? "cancelled" : "failed";
+        return { status, output: {}, diff: "", usage: { status: "unknown" }, durationMs: duration2(Date.now() - started), failure, metadata: { assurance, telemetry: { status: "unknown", durationMs: duration2(Date.now() - started) } } };
+      } finally {
+        if (timer) clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+      }
+    }
+  };
+};
 var BENCHMARK_SCHEMA_VERSION = 1;
 var percentage = (part, total) => total ? Number((part / total).toFixed(4)) : null;
-var DEFAULT_POLICY = { minComparableTasks: 3, maxDurationRegressionRate: 0.2, minCompletedRunsPerTask: 3, minBaselineSamplesPerTask: 3, requireZeroEscapedIncomplete: true };
 var improvementRate = (baseline, current) => baseline === void 0 || current === void 0 || baseline === 0 ? null : Number(((baseline - current) / baseline).toFixed(4));
-var increaseRate = (baseline, current) => baseline === void 0 || current === void 0 || baseline === 0 ? null : Number(((current - baseline) / baseline).toFixed(4));
-var increaseDelta = (baseline, current) => baseline === void 0 || current === null ? null : Number((current - baseline).toFixed(4));
-var increaseDirection = (rate2, delta) => delta === null ? improvementDirection(rate2) : delta > 0 ? "improved" : delta < 0 ? "regressed" : "unchanged";
 var improvementDirection = (rate2) => rate2 === null ? "unavailable" : rate2 > 0 ? "improved" : rate2 < 0 ? "regressed" : "unchanged";
 var count = (items, predicate) => items.filter(predicate).length;
-var median = (values) => {
+var median2 = (values) => {
   if (!values.length) return null;
   const sorted = [...values].sort((left, right) => left - right);
   const middle = Math.floor(sorted.length / 2);
@@ -926,25 +2670,13 @@ var reviewMinutes = (run) => {
   const elapsed = Date.parse(run.humanApproval.at) - Date.parse(reviewStart);
   return Number.isFinite(elapsed) && elapsed >= 0 ? Number((elapsed / 6e4).toFixed(2)) : void 0;
 };
-var confidence = (comparable, completedRuns, policy) => !comparable ? "insufficient" : completedRuns >= policy.minCompletedRunsPerTask ? "reliable" : "directional";
-var artifactAcceptanceRate = (run) => {
-  const rates = run.checks.flatMap((check) => {
-    const evidence = check.evidence;
-    if (!evidence) return [];
-    const direct = typeof evidence["artifactAcceptanceRate"] === "number" ? [evidence["artifactAcceptanceRate"]] : [];
-    const reports = Array.isArray(evidence["reports"]) ? evidence["reports"].flatMap((report) => typeof report === "object" && report !== null && typeof report["artifactAcceptanceRate"] === "number" ? [report["artifactAcceptanceRate"]] : []) : [];
-    return [...direct, ...reports].filter((rate2) => Number.isFinite(rate2) && rate2 >= 0 && rate2 <= 1);
-  });
-  return rates.length ? Number((rates.reduce((total, rate2) => total + rate2, 0) / rates.length).toFixed(4)) : void 0;
-};
 var projectRun = (run) => {
   const checks = { total: run.checks.length, passed: count(run.checks, (check) => check.status === "passed"), failed: count(run.checks, (check) => check.status === "failed") };
   const outcomes = { total: run.outcomes.length, passed: count(run.outcomes, (outcome) => outcome.status === "passed"), failed: count(run.outcomes, (outcome) => outcome.status === "failed") };
   const evidence = { total: run.checks.length, attached: count(run.checks, (check) => check.evidence !== void 0) };
-  const acceptanceRate = artifactAcceptanceRate(run);
   const humanReviewMinutes = reviewMinutes(run);
   const escapedIncomplete = run.state === "COMPLETE" && checks.failed === 0 && outcomes.failed === 0 && evidence.attached === evidence.total ? 0 : void 0;
-  return { runId: run.runId, state: run.state, sourceRevision: run.sourceRevision, configHash: run.configHash, contractHash: run.contractHash, ...run.supersedes ? { supersedes: run.supersedes } : {}, ...run.metrics ? { durationMs: run.metrics.totalDurationMs } : {}, checks, outcomes, evidence, ...acceptanceRate === void 0 ? {} : { artifactAcceptanceRate: acceptanceRate }, ...escapedIncomplete === void 0 ? {} : { escapedIncomplete }, humanApproved: run.humanApproval !== void 0, ...humanReviewMinutes === void 0 ? {} : { humanReviewMinutes }, authorized: run.authorization !== void 0, ...run.benchmark ? { benchmark: run.benchmark } : {} };
+  return { runId: run.runId, state: run.state, sourceRevision: run.sourceRevision, configHash: run.configHash, contractHash: run.contractHash, ...run.supersedes ? { supersedes: run.supersedes } : {}, ...run.metrics ? { durationMs: run.metrics.totalDurationMs } : {}, checks, outcomes, evidence, ...escapedIncomplete === void 0 ? {} : { escapedIncomplete }, humanApproved: run.humanApproval !== void 0, ...humanReviewMinutes === void 0 ? {} : { humanReviewMinutes }, authorized: run.authorization !== void 0, ...run.metrics?.machine ? { machine: run.metrics.machine } : {}, ...run.benchmark ? { benchmark: run.benchmark } : {} };
 };
 var summarize = (runs) => {
   const stateCounts = Object.fromEntries(RUN_STATES.map((state) => [state, count(runs, (run) => run.state === state)]));
@@ -955,14 +2687,6 @@ var summarize = (runs) => {
   const evidenceTotal = runs.reduce((total, run) => total + run.evidence.total, 0);
   const evidenceAttached = runs.reduce((total, run) => total + run.evidence.attached, 0);
   const firstAttempts = runs.filter((run) => !run.supersedes);
-  const superseded = new Set(runs.flatMap((run) => run.supersedes ? [run.supersedes] : []));
-  const effectiveRuns = runs.filter((run) => !superseded.has(run.runId));
-  const effectiveChecksTotal = effectiveRuns.reduce((total, run) => total + run.checks.total, 0);
-  const effectiveChecksPassed = effectiveRuns.reduce((total, run) => total + run.checks.passed, 0);
-  const effectiveOutcomesTotal = effectiveRuns.reduce((total, run) => total + run.outcomes.total, 0);
-  const effectiveOutcomesPassed = effectiveRuns.reduce((total, run) => total + run.outcomes.passed, 0);
-  const effectiveEvidenceTotal = effectiveRuns.reduce((total, run) => total + run.evidence.total, 0);
-  const effectiveEvidenceAttached = effectiveRuns.reduce((total, run) => total + run.evidence.attached, 0);
   const durations = runs.flatMap((run) => run.durationMs === void 0 ? [] : [run.durationMs]);
   return {
     totalRuns: runs.length,
@@ -973,20 +2697,14 @@ 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),
     firstAttemptApprovalRate: percentage(count(firstAttempts, (run) => run.humanApproved), firstAttempts.length),
     retryRate: percentage(count(runs, (run) => run.supersedes !== void 0), runs.length),
     staleRate: percentage(stateCounts.STALE, runs.length),
-    averageDurationMs: durations.length ? Math.round(durations.reduce((total, duration3) => total + duration3, 0) / durations.length) : null,
-    medianDurationMs: median(durations)
+    averageDurationMs: durations.length ? Math.round(durations.reduce((total, duration5) => total + duration5, 0) / durations.length) : null,
+    medianDurationMs: median2(durations)
   };
 };
 var readRuns = (stateDir) => {
@@ -1013,7 +2731,7 @@ var sha2562 = (value, label) => {
   if (!/^[a-f0-9]{64}$/.test(result)) return fail(`${label} must be a lowercase SHA-256 digest.`, "INVALID_CONFIG");
   return result;
 };
-var stringList = (value, label) => {
+var stringList2 = (value, label) => {
   if (!Array.isArray(value)) return fail(`${label} must be a non-empty string array.`, "INVALID_CONFIG");
   const items = value;
   if (!items.length || !items.every((item) => typeof item === "string" && Boolean(item.trim()))) return fail(`${label} must be a non-empty string array.`, "INVALID_CONFIG");
@@ -1026,73 +2744,16 @@ var nonNegativeNumber = (value, label) => {
   const result = value;
   return result;
 };
-var nonNegativeInteger = (value, label) => {
+var nonNegativeInteger3 = (value, label) => {
   const result = nonNegativeNumber(value, label);
   if (result !== void 0 && !Number.isInteger(result)) return fail(`${label} must be an integer.`, "INVALID_CONFIG");
   return result;
 };
-var rate = (value, label) => {
-  const result = nonNegativeNumber(value, label);
-  if (result !== void 0 && result > 1) return fail(`${label} must be between 0 and 1.`, "INVALID_CONFIG");
-  return result;
-};
 var timestamp = (value, label) => {
   const result = nonEmptyString(value, label);
   if (!Number.isFinite(Date.parse(result))) return fail(`${label} must be a valid timestamp.`, "INVALID_CONFIG");
   return result;
 };
-var relativePath = (value, label) => {
-  const result = nonEmptyString(value, label);
-  if (result.startsWith("/") || result.split("/").includes("..")) return fail(`${label} must be a repository-relative path.`, "INVALID_CONFIG");
-  return result;
-};
-var taskFile = (value, label) => {
-  if (value === void 0) return void 0;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return fail(`${label} must be an object.`, "INVALID_CONFIG");
-  const raw = value;
-  return { path: relativePath(raw["path"], `${label}.path`), sha256: sha2562(raw["sha256"], `${label}.sha256`) ?? fail(`${label}.sha256 is required.`, "INVALID_CONFIG") };
-};
-var taskSource = (value, label) => {
-  if (value === void 0) return void 0;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return fail(`${label} must be an object.`, "INVALID_CONFIG");
-  const raw = value;
-  return { repository: nonEmptyString(raw["repository"], `${label}.repository`), path: relativePath(raw["path"], `${label}.path`), revision: nonEmptyString(raw["revision"], `${label}.revision`) };
-};
-var suiteSource = (value, label) => {
-  if (value === void 0) return void 0;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return fail(`${label} must be an object.`, "INVALID_CONFIG");
-  const raw = value;
-  return { repository: nonEmptyString(raw["repository"], `${label}.repository`), revision: nonEmptyString(raw["revision"], `${label}.revision`), taskDefinition: relativePath(raw["taskDefinition"], `${label}.taskDefinition`) };
-};
-var taskScope = (value, label) => {
-  if (value === void 0) return void 0;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return fail(`${label} must be an object.`, "INVALID_CONFIG");
-  const raw = value;
-  return { read: stringList(raw["read"], `${label}.read`), write: stringList(raw["write"], `${label}.write`) };
-};
-var taskSurfaces = (value, label) => {
-  if (value === void 0) return void 0;
-  if (!Array.isArray(value) || !value.length) return fail(`${label} must be a non-empty array.`, "INVALID_CONFIG");
-  const surfaces = value.map((item, index2) => nonEmptyString(item, `${label}[${index2}]`));
-  if (surfaces.some((surface2) => !SURFACE_NAMES.includes(surface2))) fail(`${label} contains an unknown surface.`, "INVALID_CONFIG");
-  if (new Set(surfaces).size !== surfaces.length) fail(`${label} must contain unique surfaces.`, "INVALID_CONFIG");
-  return surfaces;
-};
-var benchmarkPolicy = (value) => {
-  if (value === void 0) return void 0;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return fail("benchmark.policy must be an object.", "INVALID_CONFIG");
-  const raw = value;
-  const minComparableTasks = nonNegativeInteger(raw["minComparableTasks"], "benchmark.policy.minComparableTasks");
-  const maxDurationRegressionRate = nonNegativeNumber(raw["maxDurationRegressionRate"], "benchmark.policy.maxDurationRegressionRate");
-  const minCompletedRunsPerTask = nonNegativeInteger(raw["minCompletedRunsPerTask"], "benchmark.policy.minCompletedRunsPerTask");
-  const minBaselineSamplesPerTask = nonNegativeInteger(raw["minBaselineSamplesPerTask"] ?? 1, "benchmark.policy.minBaselineSamplesPerTask");
-  if (minComparableTasks === void 0 || minComparableTasks < 1) return fail("benchmark.policy.minComparableTasks must be at least 1.", "INVALID_CONFIG");
-  if (maxDurationRegressionRate === void 0 || maxDurationRegressionRate > 1) return fail("benchmark.policy.maxDurationRegressionRate must be between 0 and 1.", "INVALID_CONFIG");
-  if (minCompletedRunsPerTask === void 0 || minCompletedRunsPerTask < 1) return fail("benchmark.policy.minCompletedRunsPerTask must be at least 1.", "INVALID_CONFIG");
-  if (minBaselineSamplesPerTask === void 0 || minBaselineSamplesPerTask < 1) return fail("benchmark.policy.minBaselineSamplesPerTask must be at least 1.", "INVALID_CONFIG");
-  if (typeof raw["requireZeroEscapedIncomplete"] !== "boolean") return fail("benchmark.policy.requireZeroEscapedIncomplete must be boolean.", "INVALID_CONFIG");
-  return { minComparableTasks, maxDurationRegressionRate, minCompletedRunsPerTask, minBaselineSamplesPerTask, requireZeroEscapedIncomplete: raw["requireZeroEscapedIncomplete"] };
-};
 var validateBenchmarkManifest = (value) => {
   if (typeof value !== "object" || value === null || Array.isArray(value)) fail("benchmark manifest must be an object.", "INVALID_CONFIG");
   const raw = value;
@@ -1101,12 +2762,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: stringList2(task["acceptanceCriteria"], `benchmark.tasks[${index2}].acceptanceCriteria`) };
   });
   if (new Set(tasks.map((task) => task.id)).size !== tasks.length) fail("benchmark task ids must be unique.", "INVALID_CONFIG");
   const taskIds = new Set(tasks.map((task) => task.id));
@@ -1119,14 +2775,10 @@ var validateBenchmarkManifest = (value) => {
     const taskId = nonEmptyString(observation["taskId"], `benchmark.observations[${index2}].taskId`);
     if (!taskIds.has(taskId)) fail(`benchmark observation references unknown task: ${taskId}.`, "INVALID_CONFIG");
     const task = tasks.find((candidate) => candidate.id === taskId) ?? fail(`benchmark observation references unknown task: ${taskId}.`, "INVALID_CONFIG");
-    const attempts = nonNegativeInteger(observation["attempts"], `benchmark.observations[${index2}].attempts`);
+    const attempts = nonNegativeInteger3(observation["attempts"], `benchmark.observations[${index2}].attempts`);
     const durationMs = nonNegativeNumber(observation["durationMs"], `benchmark.observations[${index2}].durationMs`);
-    const durationSamplesMs = observation["durationSamplesMs"] === void 0 ? void 0 : Array.isArray(observation["durationSamplesMs"]) ? observation["durationSamplesMs"].map((sample, sampleIndex) => nonNegativeNumber(sample, `benchmark.observations[${index2}].durationSamplesMs[${sampleIndex}]`) ?? fail(`benchmark.observations[${index2}].durationSamplesMs must contain numbers.`, "INVALID_CONFIG")) : fail(`benchmark.observations[${index2}].durationSamplesMs must be an array.`, "INVALID_CONFIG");
-    if (durationSamplesMs && !durationSamplesMs.length) fail(`benchmark.observations[${index2}].durationSamplesMs must not be empty.`, "INVALID_CONFIG");
-    const artifactAcceptanceRate2 = rate(observation["artifactAcceptanceRate"], `benchmark.observations[${index2}].artifactAcceptanceRate`);
-    const protocolCompletionRate = rate(observation["protocolCompletionRate"], `benchmark.observations[${index2}].protocolCompletionRate`);
     const reviewMinutes2 = nonNegativeNumber(observation["reviewMinutes"], `benchmark.observations[${index2}].reviewMinutes`);
-    const escapedIncomplete = nonNegativeInteger(observation["escapedIncomplete"], `benchmark.observations[${index2}].escapedIncomplete`);
+    const escapedIncomplete = nonNegativeInteger3(observation["escapedIncomplete"], `benchmark.observations[${index2}].escapedIncomplete`);
     const evidenceDigest = sha2562(observation["evidenceDigest"], `benchmark.observations[${index2}].evidenceDigest`);
     const rawEvidence = observation["evidence"] === void 0 ? void 0 : Array.isArray(observation["evidence"]) ? observation["evidence"] : fail(`benchmark.observations[${index2}].evidence must be an array.`, "INVALID_CONFIG");
     const evidence = rawEvidence?.map((item2, evidenceIndex) => {
@@ -1139,12 +2791,10 @@ var validateBenchmarkManifest = (value) => {
       return { criterion, status: evidenceStatus, source: nonEmptyString(entry["source"], `benchmark.observations[${index2}].evidence[${evidenceIndex}].source`) };
     });
     if (evidence && new Set(evidence.map((entry) => entry.criterion)).size !== evidence.length) fail(`benchmark.observations[${index2}].evidence criteria must be unique.`, "INVALID_CONFIG");
-    return { taskId, mode: "baseline", status, source: nonEmptyString(observation["source"], `benchmark.observations[${index2}].source`), recordedAt: timestamp(observation["recordedAt"], `benchmark.observations[${index2}].recordedAt`), ...attempts === void 0 ? {} : { attempts }, ...durationMs === void 0 ? {} : { durationMs }, ...durationSamplesMs === void 0 ? {} : { durationSamplesMs }, ...artifactAcceptanceRate2 === void 0 ? {} : { artifactAcceptanceRate: artifactAcceptanceRate2 }, ...protocolCompletionRate === void 0 ? {} : { protocolCompletionRate }, ...reviewMinutes2 === void 0 ? {} : { reviewMinutes: reviewMinutes2 }, ...escapedIncomplete === void 0 ? {} : { escapedIncomplete }, ...evidence === void 0 ? {} : { evidence }, ...evidenceDigest === void 0 ? {} : { evidenceDigest } };
+    return { taskId, mode: "baseline", status, source: nonEmptyString(observation["source"], `benchmark.observations[${index2}].source`), recordedAt: timestamp(observation["recordedAt"], `benchmark.observations[${index2}].recordedAt`), ...attempts === void 0 ? {} : { attempts }, ...durationMs === void 0 ? {} : { durationMs }, ...reviewMinutes2 === void 0 ? {} : { reviewMinutes: reviewMinutes2 }, ...escapedIncomplete === void 0 ? {} : { escapedIncomplete }, ...evidence === void 0 ? {} : { evidence }, ...evidenceDigest === void 0 ? {} : { evidenceDigest } };
   });
   if (new Set(observations.map((observation) => observation.taskId)).size !== observations.length) fail("benchmark allows at most one baseline observation per task.", "INVALID_CONFIG");
-  const provenance = suiteSource(raw["provenance"], "benchmark.provenance");
-  const policy = benchmarkPolicy(raw["policy"]);
-  return { type: "agentskit-harness-benchmark-manifest", schemaVersion: BENCHMARK_SCHEMA_VERSION, suiteId: nonEmptyString(raw["suiteId"], "benchmark.suiteId"), name: nonEmptyString(raw["name"], "benchmark.name"), ...provenance === void 0 ? {} : { provenance }, tasks, observations, ...policy === void 0 ? {} : { policy } };
+  return { type: "agentskit-harness-benchmark-manifest", schemaVersion: BENCHMARK_SCHEMA_VERSION, suiteId: nonEmptyString(raw["suiteId"], "benchmark.suiteId"), name: nonEmptyString(raw["name"], "benchmark.name"), tasks, observations };
 };
 var loadBenchmarkManifest = (path) => {
   try {
@@ -1170,9 +2820,6 @@ var recordBenchmarkObservation = (path, input) => {
       recordedAt: input.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
       ...input.attempts === void 0 ? {} : { attempts: input.attempts },
       ...input.durationMs === void 0 ? {} : { durationMs: input.durationMs },
-      ...input.durationSamplesMs === void 0 ? {} : { durationSamplesMs: input.durationSamplesMs },
-      ...input.artifactAcceptanceRate === void 0 ? {} : { artifactAcceptanceRate: input.artifactAcceptanceRate },
-      ...input.protocolCompletionRate === void 0 ? {} : { protocolCompletionRate: input.protocolCompletionRate },
       ...input.reviewMinutes === void 0 ? {} : { reviewMinutes: input.reviewMinutes },
       ...input.escapedIncomplete === void 0 ? {} : { escapedIncomplete: input.escapedIncomplete },
       ...input.evidence === void 0 ? {} : { evidence: input.evidence },
@@ -1191,111 +2838,39 @@ var recordBenchmarkObservation = (path, input) => {
   }
   return observation;
 };
-var comparisons = (runs, manifest, policy) => manifest.tasks.map((task) => {
+var comparisons = (runs, manifest) => manifest.tasks.map((task) => {
   const taskRuns = runs.filter((run) => run.benchmark?.suiteId === manifest.suiteId && run.benchmark.taskId === task.id);
   const latest = taskRuns.at(-1);
   const baseline = manifest.observations.find((observation) => observation.taskId === task.id);
   const coveredCriteria = new Set((baseline?.evidence ?? []).map((entry) => entry.criterion));
   const baselineEvidenceCoverageRate = baseline ? percentage(coveredCriteria.size, task.acceptanceCriteria.length) : null;
   const baselineEvidenceComplete = baselineEvidenceCoverageRate === 1;
-  const baselineEvidencePassed = baselineEvidenceComplete && (baseline?.evidence?.every((entry) => entry.status === "passed") ?? false);
-  const baselineDeliveryComplete = baseline?.status === "passed" && baselineEvidencePassed;
-  const baselineDurationSamples = baseline?.durationSamplesMs ?? (baseline?.durationMs === void 0 ? [] : [baseline.durationMs]);
-  const baselineMedianDurationMs = median(baselineDurationSamples);
-  const baselineSamplesSufficient = baselineDurationSamples.length >= policy.minBaselineSamplesPerTask;
-  const comparable = baseline !== void 0 && baseline.status !== "not-run" && baselineEvidenceComplete && baselineDeliveryComplete && baselineSamplesSufficient && latest?.state === "COMPLETE";
-  const comparability = comparable ? "comparable" : baseline === void 0 ? "missing-baseline" : baseline.status === "not-run" ? "baseline-not-run" : !baselineEvidenceComplete ? "baseline-evidence-missing" : latest === void 0 ? "harness-not-run" : latest.state !== "COMPLETE" ? "harness-not-complete" : !baselineDeliveryComplete ? "baseline-incomplete" : "baseline-samples-insufficient";
-  const completedTaskRuns = taskRuns.filter((run) => run.state === "COMPLETE");
-  const durationSamplesMs = completedTaskRuns.flatMap((run) => run.durationMs === void 0 ? [] : [run.durationMs]);
-  const medianDurationMs = median(durationSamplesMs);
-  const retryCount = count(taskRuns, (run) => run.supersedes !== void 0);
-  const attempts = retryCount + (taskRuns.length ? 1 : 0);
-  const durationRate = comparable ? improvementRate(baselineMedianDurationMs ?? void 0, medianDurationMs ?? void 0) : null;
-  const attemptsRate = comparable ? improvementRate(baseline?.attempts, attempts) : null;
-  const reviewRate = comparable ? improvementRate(baseline?.reviewMinutes, latest?.humanReviewMinutes) : null;
-  const acceptanceSamples = taskRuns.flatMap((run) => run.artifactAcceptanceRate === void 0 ? [] : [run.artifactAcceptanceRate]);
-  const harnessArtifactAcceptanceRate = acceptanceSamples.length ? Number((acceptanceSamples.reduce((total, rate2) => total + rate2, 0) / acceptanceSamples.length).toFixed(4)) : null;
-  const artifactAcceptanceImprovementRate = increaseRate(baseline?.artifactAcceptanceRate, harnessArtifactAcceptanceRate ?? void 0);
-  const artifactAcceptanceDelta = increaseDelta(baseline?.artifactAcceptanceRate, harnessArtifactAcceptanceRate);
-  const completedRuns = completedTaskRuns.length;
-  const harnessProtocolCompletionRate = taskRuns.length ? percentage(completedRuns, taskRuns.length) : null;
-  const protocolCompletionImprovementRate = increaseRate(baseline?.protocolCompletionRate, harnessProtocolCompletionRate ?? void 0);
-  const protocolCompletionDelta = increaseDelta(baseline?.protocolCompletionRate, harnessProtocolCompletionRate);
-  const escapedIncompleteRate = improvementRate(baseline?.escapedIncomplete, latest?.escapedIncomplete);
-  return { taskId: task.id, title: task.title, comparability, comparable, baselineDeliveryComplete, baselineEvidenceCoverageRate, baselineSampleCount: baselineDurationSamples.length, baselineArtifactAcceptanceRate: baseline?.artifactAcceptanceRate ?? null, baselineProtocolCompletionRate: baseline?.protocolCompletionRate ?? null, ...baselineMedianDurationMs === null ? {} : { baselineMedianDurationMs }, improvement: { durationRate, duration: improvementDirection(durationRate), attemptsRate, attempts: improvementDirection(attemptsRate), reviewRate, review: improvementDirection(reviewRate), artifactAcceptanceRate: artifactAcceptanceImprovementRate, artifactAcceptance: increaseDirection(artifactAcceptanceImprovementRate, artifactAcceptanceDelta), artifactAcceptanceDelta, protocolCompletionRate: protocolCompletionImprovementRate, protocolCompletion: increaseDirection(protocolCompletionImprovementRate, protocolCompletionDelta), protocolCompletionDelta, escapedIncompleteRate, escapedIncomplete: improvementDirection(escapedIncompleteRate) }, ...baseline ? { baseline } : {}, harness: { attempts, retryCount, completedRuns, durationSamplesMs, ...medianDurationMs === null ? {} : { medianDurationMs }, ...harnessArtifactAcceptanceRate === null ? {} : { artifactAcceptanceRate: harnessArtifactAcceptanceRate }, artifactAcceptanceSampleCount: acceptanceSamples.length, protocolCompletionRate: harnessProtocolCompletionRate, protocolCompletionSampleCount: taskRuns.length, latestState: latest?.state ?? "NOT_RUN", ...latest ? { latestRunId: latest.runId } : {}, ...latest?.durationMs === void 0 ? {} : { latestDurationMs: latest.durationMs }, checkPassRate: latest ? percentage(latest.checks.passed, latest.checks.total) : null, outcomePassRate: latest ? percentage(latest.outcomes.passed, latest.outcomes.total) : null, evidenceCoverageRate: latest ? percentage(latest.evidence.attached, latest.evidence.total) : null, ...latest?.escapedIncomplete === void 0 ? {} : { escapedIncomplete: latest.escapedIncomplete }, ...latest?.humanReviewMinutes === void 0 ? {} : { humanReviewMinutes: latest.humanReviewMinutes }, humanApproved: latest?.humanApproved ?? false }, confidence: confidence(comparable, completedRuns, policy), ...comparable && baselineMedianDurationMs !== null && medianDurationMs !== null ? { durationDeltaMs: medianDurationMs - baselineMedianDurationMs } : {}, ...comparable && baseline?.attempts !== void 0 ? { attemptDelta: attempts - baseline.attempts } : {}, ...comparable && baseline?.reviewMinutes !== void 0 && latest?.humanReviewMinutes !== void 0 ? { reviewDeltaMinutes: latest.humanReviewMinutes - baseline.reviewMinutes } : {}, ...baseline?.escapedIncomplete !== void 0 && latest?.escapedIncomplete !== void 0 ? { escapedIncompleteDelta: latest.escapedIncomplete - baseline.escapedIncomplete } : {} };
+  const comparable2 = baseline !== void 0 && baseline.status !== "not-run" && baselineEvidenceComplete && latest?.state === "COMPLETE";
+  const comparability = comparable2 ? "comparable" : baseline === void 0 ? "missing-baseline" : baseline.status === "not-run" ? "baseline-not-run" : !baselineEvidenceComplete ? "baseline-evidence-missing" : latest === void 0 ? "harness-not-run" : "harness-not-complete";
+  const durationRate = comparable2 ? improvementRate(baseline?.durationMs, latest?.durationMs) : null;
+  const attemptsRate = comparable2 ? improvementRate(baseline?.attempts, taskRuns.length) : null;
+  const reviewRate = comparable2 ? improvementRate(baseline?.reviewMinutes, latest?.humanReviewMinutes) : null;
+  const escapedIncompleteRate = comparable2 ? improvementRate(baseline?.escapedIncomplete, latest?.escapedIncomplete) : null;
+  return { taskId: task.id, title: task.title, comparability, comparable: comparable2, baselineEvidenceCoverageRate, improvement: { durationRate, duration: improvementDirection(durationRate), attemptsRate, attempts: improvementDirection(attemptsRate), reviewRate, review: improvementDirection(reviewRate), escapedIncompleteRate, escapedIncomplete: improvementDirection(escapedIncompleteRate) }, ...baseline ? { baseline } : {}, harness: { attempts: taskRuns.length, latestState: latest?.state ?? "NOT_RUN", ...latest ? { latestRunId: latest.runId } : {}, ...latest?.durationMs === void 0 ? {} : { latestDurationMs: latest.durationMs }, checkPassRate: latest ? percentage(latest.checks.passed, latest.checks.total) : null, outcomePassRate: latest ? percentage(latest.outcomes.passed, latest.outcomes.total) : null, evidenceCoverageRate: latest ? percentage(latest.evidence.attached, latest.evidence.total) : null, ...latest?.escapedIncomplete === void 0 ? {} : { escapedIncomplete: latest.escapedIncomplete }, ...latest?.humanReviewMinutes === void 0 ? {} : { humanReviewMinutes: latest.humanReviewMinutes }, humanApproved: latest?.humanApproved ?? false }, ...comparable2 && baseline?.durationMs !== void 0 && latest?.durationMs !== void 0 ? { durationDeltaMs: latest.durationMs - baseline.durationMs } : {}, ...comparable2 && baseline?.attempts !== void 0 ? { attemptDelta: taskRuns.length - baseline.attempts } : {}, ...comparable2 && baseline?.reviewMinutes !== void 0 && latest?.humanReviewMinutes !== void 0 ? { reviewDeltaMinutes: latest.humanReviewMinutes - baseline.reviewMinutes } : {}, ...comparable2 && baseline?.escapedIncomplete !== void 0 && latest?.escapedIncomplete !== void 0 ? { escapedIncompleteDelta: latest.escapedIncomplete - baseline.escapedIncomplete } : {} };
 });
 var benchmarkRuns = (stateDir, manifest) => {
   const runs = readRuns(stateDir).map(projectRun).sort((left, right) => left.runId.localeCompare(right.runId));
-  const policy = manifest?.policy ?? DEFAULT_POLICY;
-  const reportComparisons = manifest ? comparisons(runs, manifest, policy) : [];
-  const comparable = reportComparisons.filter((comparison) => comparison.comparable);
-  const durationRegressionTaskIds = comparable.filter((comparison) => (comparison.improvement.durationRate ?? 0) < -policy.maxDurationRegressionRate).map((comparison) => comparison.taskId);
-  const escapedIncompleteTaskIds = comparable.filter((comparison) => comparison.harness.escapedIncomplete !== 0).map((comparison) => comparison.taskId);
-  const reasons = [];
-  if (comparable.length < policy.minComparableTasks) reasons.push(`requires at least ${policy.minComparableTasks} comparable tasks`);
-  const incompleteBaselineTaskIds = reportComparisons.filter((comparison) => comparison.comparability === "baseline-incomplete").map((comparison) => comparison.taskId);
-  if (incompleteBaselineTaskIds.length) reasons.push(`baseline delivery incomplete: ${incompleteBaselineTaskIds.join(", ")}`);
-  const baselineSampleGaps = reportComparisons.filter((comparison) => comparison.baselineSampleCount < policy.minBaselineSamplesPerTask).map((comparison) => `${comparison.taskId} (${comparison.baselineSampleCount}/${policy.minBaselineSamplesPerTask})`);
-  if (baselineSampleGaps.length) reasons.push(`requires ${policy.minBaselineSamplesPerTask} baseline samples per task: ${baselineSampleGaps.join(", ")}`);
-  if (durationRegressionTaskIds.length) reasons.push(`duration regression exceeds ${policy.maxDurationRegressionRate * 100}%: ${durationRegressionTaskIds.join(", ")}`);
-  if (policy.requireZeroEscapedIncomplete && escapedIncompleteTaskIds.length) reasons.push(`escaped incomplete delivery: ${escapedIncompleteTaskIds.join(", ")}`);
-  const confidenceLevel = comparable.length < policy.minComparableTasks ? "insufficient" : comparable.every((comparison) => comparison.confidence === "reliable") ? "reliable" : "directional";
-  const qualityGate = { status: comparable.length < policy.minComparableTasks ? "insufficient-data" : reasons.length ? "failed" : "passed", confidence: confidenceLevel, comparableTaskCount: comparable.length, policy, durationRegressionTaskIds, escapedIncompleteTaskIds, reasons };
-  return { type: "agentskit-harness-benchmark", schemaVersion: BENCHMARK_SCHEMA_VERSION, stateDir, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), runs, summary: summarize(runs), comparisons: reportComparisons, qualityGate, ...manifest ? { manifest: { suiteId: manifest.suiteId, taskCount: manifest.tasks.length, baselineCount: manifest.observations.length, comparableTaskCount: comparable.length } } : {} };
-};
-
-// src/coding-benchmark.ts
-var text2 = (value, label) => {
-  if (typeof value !== "string" || !value.trim()) fail(`${label} must be a non-empty string.`, "INVALID_INPUT");
-  return value.trim();
-};
-var numberValue = (value, label, integer = false) => {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || integer && !Number.isInteger(value)) fail(`${label} must be a non-negative ${integer ? "integer" : "number"}.`, "INVALID_INPUT");
-  return value;
+  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 validateExternalCodingBenchmarkReport = (value) => {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) fail("coding benchmark report must be an object.", "INVALID_INPUT");
-  const raw = value;
-  if (!["edit", "fix-bug", "add-feature", "refactor", "add-test", "review-pr", "free-form"].includes(text2(raw["kind"], "report.kind"))) fail("report.kind is not a supported coding task kind.", "INVALID_INPUT");
-  if (typeof raw["dryRun"] !== "boolean" || typeof raw["isolateWorktrees"] !== "boolean") fail("report.dryRun and report.isolateWorktrees must be booleans.", "INVALID_INPUT");
-  if (!Array.isArray(raw["rows"]) || raw["rows"].length === 0) fail("report.rows must contain at least one provider result.", "INVALID_INPUT");
-  const rows = raw["rows"].map((item, index2) => {
-    if (typeof item !== "object" || item === null || Array.isArray(item)) fail(`report.rows[${index2}] must be an object.`, "INVALID_INPUT");
-    const row = item;
-    const status = text2(row["status"], `report.rows[${index2}].status`);
-    if (!["ok", "partial", "fail", "timeout"].includes(status)) fail(`report.rows[${index2}].status is invalid.`, "INVALID_INPUT");
-    const completenessScore = numberValue(row["completenessScore"], `report.rows[${index2}].completenessScore`);
-    if (completenessScore > 100) fail(`report.rows[${index2}].completenessScore must be between 0 and 100.`, "INVALID_INPUT");
-    const optional = (key) => row[key] === void 0 ? void 0 : numberValue(row[key], `report.rows[${index2}].${key}`);
-    return {
-      providerId: text2(row["providerId"], `report.rows[${index2}].providerId`),
-      status,
-      completenessScore,
-      fileEditCount: numberValue(row["fileEditCount"], `report.rows[${index2}].fileEditCount`, true),
-      summary: text2(row["summary"], `report.rows[${index2}].summary`),
-      ...optional("durationMs") === void 0 ? {} : { durationMs: optional("durationMs") },
-      ...optional("inputTokens") === void 0 ? {} : { inputTokens: optional("inputTokens") },
-      ...optional("outputTokens") === void 0 ? {} : { outputTokens: optional("outputTokens") },
-      ...optional("costUsd") === void 0 ? {} : { costUsd: optional("costUsd") },
-      ...row["successPassed"] === void 0 ? {} : typeof row["successPassed"] !== "boolean" ? fail(`report.rows[${index2}].successPassed must be a boolean.`, "INVALID_INPUT") : { successPassed: row["successPassed"] }
-    };
-  });
-  if (new Set(rows.map((row) => row.providerId)).size !== rows.length) fail("coding benchmark provider ids must be unique.", "INVALID_INPUT");
-  return { kind: text2(raw["kind"], "report.kind"), prompt: text2(raw["prompt"], "report.prompt"), dryRun: raw["dryRun"], isolateWorktrees: raw["isolateWorktrees"], repoRoot: text2(raw["repoRoot"], "report.repoRoot"), rows };
-};
-var required = (value, label) => {
+var required8 = (value, label) => {
   if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
   return value.trim();
 };
-var duration = (value) => {
+var duration3 = (value) => {
   if (!Number.isFinite(value) || value < 0) fail("Tool durationMs must be a non-negative number.", "INVALID_INPUT");
   return value;
 };
 var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionId = randomUUID(), resume = false }) => {
   if (run.state !== "IMPLEMENTING") fail(`Agent sessions can only start during IMPLEMENTING, not ${run.state}.`, "INVALID_STATE");
-  const id2 = required(sessionId, "sessionId");
-  const adapterId = required(adapter.id, "adapter.id");
-  const adapterVersion = required(adapter.version, "adapter.version");
+  const id2 = required8(sessionId, "sessionId");
+  const adapterId = required8(adapter.id, "adapter.id");
+  const adapterVersion = required8(adapter.version, "adapter.version");
   if (!policy || typeof policy.evaluate !== "function") fail("policy.evaluate is required.", "INVALID_INPUT");
   if (!runtime || typeof runtime.execute !== "function") fail("runtime.execute is required.", "INVALID_INPUT");
   if (!Array.isArray(adapter.capabilities) || adapter.capabilities.some((capability) => typeof capability !== "string" || !capability.trim())) fail("adapter.capabilities must contain non-empty strings.", "INVALID_INPUT");
@@ -1346,18 +2921,18 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
   };
   const complete = (input) => {
     open();
-    const actionId = required(input.actionId, "actionId");
+    const actionId = required8(input.actionId, "actionId");
     if (!pending.has(actionId)) fail(`Tool action is not pending: ${actionId}.`, "INVALID_STATE");
-    const event = append("tool.completed", { actionId, resultHash: required(input.resultHash, "resultHash"), durationMs: duration(input.durationMs), ...input.runtimeEvidence ? { runtimeEvidence: input.runtimeEvidence } : {} });
+    const event = append("tool.completed", { actionId, resultHash: required8(input.resultHash, "resultHash"), durationMs: duration3(input.durationMs), ...input.runtimeEvidence ? { runtimeEvidence: input.runtimeEvidence } : {} });
     pending.delete(actionId);
     return event;
   };
   const failAction = (input) => {
     open();
-    const actionId = required(input.actionId, "actionId");
+    const actionId = required8(input.actionId, "actionId");
     if (!pending.has(actionId)) fail(`Tool action is not pending: ${actionId}.`, "INVALID_STATE");
     if (typeof input.retryable !== "boolean") fail("retryable must be boolean.", "INVALID_INPUT");
-    const event = append("tool.failed", { actionId, errorCode: required(input.errorCode, "errorCode"), retryable: input.retryable, durationMs: duration(input.durationMs), ...input.runtimeEvidence ? { runtimeEvidence: input.runtimeEvidence } : {} });
+    const event = append("tool.failed", { actionId, errorCode: required8(input.errorCode, "errorCode"), retryable: input.retryable, durationMs: duration3(input.durationMs), ...input.runtimeEvidence ? { runtimeEvidence: input.runtimeEvidence } : {} });
     pending.delete(actionId);
     return event;
   };
@@ -1365,24 +2940,24 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
     sessionId: id2,
     startTurn: (inputHash, turnId = randomUUID()) => {
       open();
-      const turn = required(turnId, "turnId");
+      const turn = required8(turnId, "turnId");
       if (turns.has(turn)) fail(`Turn already exists: ${turn}.`, "INVALID_STATE");
-      const event = append("agent.turn.started", { turnId: turn, inputHash: required(inputHash, "inputHash") });
+      const event = append("agent.turn.started", { turnId: turn, inputHash: required8(inputHash, "inputHash") });
       turns.add(turn);
       return event;
     },
     requestTool: (input) => {
       open();
-      const turnId = required(input.turnId, "turnId");
+      const turnId = required8(input.turnId, "turnId");
       if (!turns.has(turnId)) fail(`Turn does not exist: ${turnId}.`, "INVALID_STATE");
-      const actionId = required(input.actionId ?? randomUUID(), "actionId");
+      const actionId = required8(input.actionId ?? randomUUID(), "actionId");
       if (actions.has(actionId)) fail(`Tool action already exists: ${actionId}.`, "INVALID_STATE");
-      const toolId = required(input.toolId, "toolId");
-      const argumentsHash = required(input.argumentsHash, "argumentsHash");
+      const toolId = required8(input.toolId, "toolId");
+      const argumentsHash = required8(input.argumentsHash, "argumentsHash");
       const decision = policy.evaluate({ actionId, turnId, toolId, argumentsHash });
       if (!decision || decision.decision !== "allow" && decision.decision !== "block" && decision.decision !== "approve") fail("Policy decision is invalid.", "HARNESS_ERROR");
-      const policyId = required(decision.policyId, "policyId");
-      const reason = required(decision.reason, "policy reason");
+      const policyId = required8(decision.policyId, "policyId");
+      const reason = required8(decision.reason, "policy reason");
       append("policy.evaluated", { actionId, turnId, toolId, decision: decision.decision, policyId, reason });
       actions.add(actionId);
       if (decision.decision === "block") {
@@ -1400,7 +2975,7 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
     },
     approveTool: (input) => {
       open();
-      const actionId = required(input.actionId, "actionId");
+      const actionId = required8(input.actionId, "actionId");
       const approval = approvals.get(actionId) ?? fail(`Tool action is not awaiting human approval: ${actionId}.`, "INVALID_STATE");
       if (input.actor !== void 0 && input.actor !== "human") fail("Tool approval requires a human actor.", "HUMAN_APPROVAL_REQUIRED");
       const decision = input.decision;
@@ -1414,7 +2989,7 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
     },
     recoverTool: (input) => {
       open();
-      const actionId = required(input.actionId, "actionId");
+      const actionId = required8(input.actionId, "actionId");
       const action = pending.get(actionId) ?? fail(`Tool action is not pending: ${actionId}.`, "INVALID_STATE");
       if (!action.executionStarted) fail(`Tool action does not require recovery: ${actionId}.`, "INVALID_STATE");
       if (input.actor !== void 0 && input.actor !== "human") fail("Tool recovery requires a human actor.", "HUMAN_APPROVAL_REQUIRED");
@@ -1432,7 +3007,7 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
     failTool: failAction,
     executeTool: async (input) => {
       open();
-      const actionId = required(input.actionId, "actionId");
+      const actionId = required8(input.actionId, "actionId");
       const action = pending.get(actionId) ?? fail(`Tool action is not pending: ${actionId}.`, "INVALID_STATE");
       if (action.executionStarted) fail(`Tool action requires human recovery decision: ${actionId}.`, "HUMAN_APPROVAL_REQUIRED");
       if (executing.has(actionId)) fail(`Tool action is already executing: ${actionId}.`, "INVALID_STATE");
@@ -1475,8 +3050,8 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
   return recorder;
 };
 
-// src/policy.ts
-var required2 = (value, label) => {
+// src/kernel/policy.ts
+var required9 = (value, label) => {
   if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
   return value.trim();
 };
@@ -1484,29 +3059,30 @@ var createPolicyGate = ({ rules }) => {
   if (!Array.isArray(rules)) fail("Policy rules must be an array.", "INVALID_INPUT");
   const normalized = rules.map((rule, index2) => {
     if (typeof rule !== "object" || rule === null || Array.isArray(rule)) fail(`rules[${index2}] must be an object.`, "INVALID_INPUT");
-    const id2 = required2(rule.id, `rules[${index2}].id`);
+    const id2 = required9(rule.id, `rules[${index2}].id`);
     if (rule.effect !== "allow" && rule.effect !== "block" && rule.effect !== "approve") fail(`rules[${index2}].effect is invalid.`, "INVALID_INPUT");
     if (!Array.isArray(rule.toolIds) || !rule.toolIds.length || rule.toolIds.some((toolId) => typeof toolId !== "string" || !toolId.trim())) fail(`rules[${index2}].toolIds must contain non-empty strings.`, "INVALID_INPUT");
-    return { id: id2, effect: rule.effect, toolIds: rule.toolIds.map((toolId) => required2(toolId, `rules[${index2}].toolIds`)), reason: required2(rule.reason, `rules[${index2}].reason`) };
+    return { id: id2, effect: rule.effect, toolIds: rule.toolIds.map((toolId) => required9(toolId, `rules[${index2}].toolIds`)), reason: required9(rule.reason, `rules[${index2}].reason`) };
   });
   if (new Set(normalized.map((rule) => rule.id)).size !== normalized.length) fail("Policy rules must have unique ids.", "INVALID_INPUT");
   return {
     evaluate: (request) => {
       if (typeof request !== "object" || request === null || Array.isArray(request)) fail("Policy request must be an object.", "INVALID_INPUT");
-      required2(request.actionId, "request.actionId");
-      required2(request.turnId, "request.turnId");
-      const toolId = required2(request.toolId, "request.toolId");
-      required2(request.argumentsHash, "request.argumentsHash");
+      required9(request.actionId, "request.actionId");
+      required9(request.turnId, "request.turnId");
+      const toolId = required9(request.toolId, "request.toolId");
+      required9(request.argumentsHash, "request.argumentsHash");
       const rule = normalized.find((candidate) => candidate.toolIds.includes(toolId));
       return rule ? { decision: rule.effect, policyId: rule.id, reason: rule.reason } : { decision: "block", policyId: "default-deny", reason: `No policy rule allows tool: ${toolId}.` };
     }
   };
 };
-var required3 = (value, label) => {
+var createConfiguredToolRuntime = ({ runtime, process: process2, docker }) => runtime.kind === "docker" ? createDockerToolRuntime(docker) : createProcessToolRuntime(process2);
+var required10 = (value, label) => {
   if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
   return value.trim();
 };
-var duration2 = (value) => {
+var duration4 = (value) => {
   if (!Number.isFinite(value) || value < 0) fail("Tool durationMs must be a non-negative number.", "INVALID_INPUT");
   return value;
 };
@@ -1516,7 +3092,7 @@ var positiveNumber = (value, label) => {
   return normalized;
 };
 var absolutePath = (value, label) => {
-  const normalized = required3(value, label);
+  const normalized = required10(value, label);
   if (!normalized.startsWith("/") || normalized.includes(",")) fail(`${label} must be an absolute path without commas.`, "INVALID_INPUT");
   return normalized;
 };
@@ -1534,35 +3110,38 @@ var createToolRuntime = ({ tools, timeoutMs = 3e4 }) => {
   if (!Number.isInteger(timeoutMs) || timeoutMs < 1) fail("Runtime timeoutMs must be a positive integer.", "INVALID_INPUT");
   const normalized = tools.map((tool, index2) => {
     if (typeof tool !== "object" || tool === null || Array.isArray(tool)) fail(`tools[${index2}] must be an object.`, "INVALID_INPUT");
-    const toolId = required3(tool.toolId, `tools[${index2}].toolId`);
+    const toolId = required10(tool.toolId, `tools[${index2}].toolId`);
     if (typeof tool.execute !== "function") fail(`tools[${index2}].execute is required.`, "INVALID_INPUT");
     return { toolId, execute: tool.execute };
   });
   if (new Set(normalized.map((tool) => tool.toolId)).size !== normalized.length) fail("Runtime tools must have unique ids.", "INVALID_INPUT");
   return {
+    assurance: "contract-tested",
+    isolation: "none",
+    telemetry: () => ({ status: "unknown" }),
     execute: async (request) => {
       const started = Date.now();
-      const actionId = required3(request.actionId, "request.actionId");
-      const turnId = required3(request.turnId, "request.turnId");
-      const toolId = required3(request.toolId, "request.toolId");
-      const argumentsHash = required3(request.argumentsHash, "request.argumentsHash");
+      const actionId = required10(request.actionId, "request.actionId");
+      const turnId = required10(request.turnId, "request.turnId");
+      const toolId = required10(request.toolId, "request.toolId");
+      const argumentsHash = required10(request.argumentsHash, "request.argumentsHash");
       const tool = normalized.find((candidate) => candidate.toolId === toolId);
-      if (!tool) return { status: "failed", errorCode: "TOOL_NOT_FOUND", retryable: false, durationMs: duration2(Date.now() - started) };
+      if (!tool) return { status: "failed", errorCode: "TOOL_NOT_FOUND", retryable: false, durationMs: duration4(Date.now() - started) };
       const controller = new AbortController();
       let timedOut = false;
       let timer;
       try {
-        const timeout = new Promise((_, reject) => {
+        const timeout2 = new Promise((_, reject) => {
           timer = setTimeout(() => {
             timedOut = true;
             controller.abort();
             reject(new Error("Tool execution timed out."));
           }, timeoutMs);
         });
-        const result = await Promise.race([Promise.resolve(tool.execute({ actionId, turnId, toolId, argumentsHash, arguments: request.arguments, signal: controller.signal })), timeout]);
-        return { status: "completed", resultHash: hashJson(result === void 0 ? null : result), durationMs: duration2(Date.now() - started) };
+        const result = await Promise.race([Promise.resolve(tool.execute({ actionId, turnId, toolId, argumentsHash, arguments: request.arguments, signal: controller.signal })), timeout2]);
+        return { status: "completed", resultHash: hashJson(result === void 0 ? null : result), durationMs: duration4(Date.now() - started) };
       } catch {
-        return { status: "failed", errorCode: timedOut ? "TIMEOUT" : "RUNTIME_ERROR", retryable: true, durationMs: duration2(Date.now() - started) };
+        return { status: "failed", errorCode: timedOut ? "TIMEOUT" : "RUNTIME_ERROR", retryable: true, durationMs: duration4(Date.now() - started) };
       } finally {
         if (timer) clearTimeout(timer);
       }
@@ -1575,20 +3154,23 @@ var createProcessToolRuntime = ({ tools, timeoutMs = 3e4, maxOutputBytes = 10485
   if (!Number.isInteger(maxOutputBytes) || maxOutputBytes < 1) fail("Process runtime maxOutputBytes must be a positive integer.", "INVALID_INPUT");
   const normalized = tools.map((tool, index2) => {
     if (typeof tool !== "object" || tool === null || Array.isArray(tool)) fail(`tools[${index2}] must be an object.`, "INVALID_INPUT");
-    const toolId = required3(tool.toolId, `tools[${index2}].toolId`);
-    const command = required3(tool.command, `tools[${index2}].command`);
+    const toolId = required10(tool.toolId, `tools[${index2}].toolId`);
+    const command = required10(tool.command, `tools[${index2}].command`);
     if (tool.args !== void 0 && (!Array.isArray(tool.args) || tool.args.some((arg) => typeof arg !== "string"))) fail(`tools[${index2}].args must contain strings.`, "INVALID_INPUT");
     if (tool.env !== void 0 && (typeof tool.env !== "object" || tool.env === null || Array.isArray(tool.env) || Object.values(tool.env).some((value) => typeof value !== "string"))) fail(`tools[${index2}].env must contain string values.`, "INVALID_INPUT");
     return { toolId, command, args: tool.args ? [...tool.args] : [], ...tool.cwd ? { cwd: tool.cwd } : {}, env: tool.env ? { ...tool.env } : { PATH: process.env["PATH"] ?? "" } };
   });
   if (new Set(normalized.map((tool) => tool.toolId)).size !== normalized.length) fail("Process runtime tools must have unique ids.", "INVALID_INPUT");
   return {
+    assurance: "contract-tested",
+    isolation: "none",
+    telemetry: () => ({ status: "unknown" }),
     execute: async (request) => {
       const started = Date.now();
-      const actionId = required3(request.actionId, "request.actionId");
-      const turnId = required3(request.turnId, "request.turnId");
-      const toolId = required3(request.toolId, "request.toolId");
-      const argumentsHash = required3(request.argumentsHash, "request.argumentsHash");
+      const actionId = required10(request.actionId, "request.actionId");
+      const turnId = required10(request.turnId, "request.turnId");
+      const toolId = required10(request.toolId, "request.toolId");
+      const argumentsHash = required10(request.argumentsHash, "request.argumentsHash");
       const tool = normalized.find((candidate) => candidate.toolId === toolId);
       if (!tool) return { status: "failed", errorCode: "TOOL_NOT_FOUND", retryable: false, durationMs: Date.now() - started };
       let input;
@@ -1598,7 +3180,7 @@ var createProcessToolRuntime = ({ tools, timeoutMs = 3e4, maxOutputBytes = 10485
         return { status: "failed", errorCode: "SERIALIZATION_ERROR", retryable: false, durationMs: Date.now() - started };
       }
       return new Promise((resolve6) => {
-        const child = spawn(tool.command, tool.args, { cwd: tool.cwd, env: tool.env, shell: false, stdio: ["pipe", "pipe", "pipe"] });
+        const child = spawn(tool.command, [...tool.args], { cwd: tool.cwd, env: tool.env, shell: false, stdio: ["pipe", "pipe", "pipe"] });
         let stdout = "";
         let timedOut = false;
         let outputLimit = false;
@@ -1658,17 +3240,17 @@ var createDockerToolRuntime = ({
   pull = "never"
 }) => {
   if (!Array.isArray(tools)) fail("Docker runtime tools must be an array.", "INVALID_INPUT");
-  const command = required3(dockerCommand, "dockerCommand");
-  const memory = required3(memoryLimit, "memoryLimit");
+  const command = required10(dockerCommand, "dockerCommand");
+  const memory = required10(memoryLimit, "memoryLimit");
   const cpu = positiveNumber(cpus, "cpus");
   if (!Number.isInteger(pidsLimit) || pidsLimit < 1) fail("pidsLimit must be a positive integer.", "INVALID_INPUT");
-  const normalizedUser = required3(user, "user");
+  const normalizedUser = required10(user, "user");
   if (normalizedUser.includes(" ")) fail("user must not contain spaces.", "INVALID_INPUT");
   if (pull !== "never" && pull !== "missing" && pull !== "always") fail("pull must be never, missing, or always.", "INVALID_INPUT");
   const normalized = tools.map((tool, index2) => {
     if (typeof tool !== "object" || tool === null || Array.isArray(tool)) fail(`tools[${index2}] must be an object.`, "INVALID_INPUT");
-    const toolId = required3(tool.toolId, `tools[${index2}].toolId`);
-    const image = required3(tool.image, `tools[${index2}].image`);
+    const toolId = required10(tool.toolId, `tools[${index2}].toolId`);
+    const image = required10(tool.image, `tools[${index2}].image`);
     if (!Array.isArray(tool.command) || tool.command.length === 0 || tool.command.some((part) => typeof part !== "string" || !part.trim())) fail(`tools[${index2}].command must be a non-empty string array.`, "INVALID_INPUT");
     if (tool.args !== void 0 && (!Array.isArray(tool.args) || tool.args.some((arg) => typeof arg !== "string"))) fail(`tools[${index2}].args must contain strings.`, "INVALID_INPUT");
     const env = dockerEnvironment(tool.env, `tools[${index2}].env`);
@@ -1720,6 +3302,9 @@ var createDockerToolRuntime = ({
   if (new Set(normalized.map((tool) => tool.toolId)).size !== normalized.length) fail("Docker runtime tools must have unique ids.", "INVALID_INPUT");
   const processRuntime = createProcessToolRuntime({ tools: normalized, timeoutMs, maxOutputBytes });
   return {
+    assurance: "runtime-attested",
+    isolation: "sandboxed",
+    telemetry: () => ({ status: "unknown" }),
     execute: async (request) => {
       const tool = normalized.find((candidate) => candidate.toolId === request.toolId);
       if (!tool) return processRuntime.execute(request);
@@ -1730,7 +3315,7 @@ var createDockerToolRuntime = ({
         imageDigest = inspected.stdout.trim();
         if (!/^sha256:[a-f0-9]{64}$/.test(imageDigest)) throw new Error("Docker image inspection did not return a digest.");
       } catch {
-        return { status: "failed", errorCode: "IMAGE_UNAVAILABLE", retryable: true, durationMs: duration2(Date.now() - started), runtimeEvidence: tool.evidence };
+        return { status: "failed", errorCode: "IMAGE_UNAVAILABLE", retryable: true, durationMs: duration4(Date.now() - started), runtimeEvidence: tool.evidence };
       }
       const runtimeEvidence = { ...tool.evidence, imageDigest, profileHash: hashJson({ ...tool.evidence, imageDigest }) };
       const result = await processRuntime.execute(request);
@@ -1738,8 +3323,343 @@ var createDockerToolRuntime = ({
     }
   };
 };
+var required11 = (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: required11(raw["tracker"], `${label}.tracker`),
+      repository: required11(raw["repository"], `${label}.repository`),
+      issue: required11(raw["issue"], `${label}.issue`),
+      worktree: required11(raw["worktree"], `${label}.worktree`),
+      branch: required11(raw["branch"], `${label}.branch`)
+    };
+    return { ...identity, key: required11(raw["key"], `${label}.key`), leaseId: required11(raw["leaseId"], `${label}.leaseId`), owner: required11(raw["owner"], `${label}.owner`), claimedAt: required11(raw["claimedAt"], `${label}.claimedAt`) };
+  } catch (error) {
+    if (error instanceof SyntaxError) fail(`${label} contains invalid JSON.`, "HARNESS_ERROR");
+    throw error;
+  }
+};
+var createDispatchLedger = (stateDir) => {
+  const root = required11(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: required11(input.tracker, "tracker"),
+        repository: required11(input.repository, "repository"),
+        issue: required11(input.issue, "issue"),
+        worktree: required11(input.worktree, "worktree"),
+        branch: required11(input.branch, "branch")
+      };
+      const owner = required11(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 = required11(idempotencyKey, "idempotencyKey");
+      const digest6 = required11(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: digest6 };
+      append(record3);
+      return { decision: "recorded", record: record3 };
+    },
+    release: (lease, reason = "lease released") => {
+      const path = claimPath(required11(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: required11(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 = required11(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: required11(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 SHELL_META = /[;&|`$()<>\n\r]/;
+var normalizedPath = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} must be a non-empty path.`, "INVALID_INPUT");
+  const path = value.trim().replaceAll("\\", "/");
+  if (path.startsWith("/") || path.split("/").includes("..")) fail(`${label} must be repository-relative.`, "INVALID_INPUT");
+  return path;
+};
+var validateSafeCommand = (command) => {
+  if (typeof command !== "string" || !command.trim()) fail("command must be a non-empty string.", "INVALID_INPUT");
+  const value = command.trim();
+  if (SHELL_META.test(value)) fail("command contains shell metacharacters; use argv-based execution.", "POLICY_BLOCKED");
+  return { valid: true, command: value };
+};
+var isTest = (path) => TEST_SUFFIXES.some((suffix) => path.includes(suffix)) || /(^|\/)(test|tests|__tests__)\//.test(path);
+var isDoc = (path) => DOC_EXTENSIONS.has(extname(path).toLowerCase());
+var planFilePreflight = (files, options = {}) => {
+  if (!Array.isArray(files)) fail("files must be an array.", "INVALID_INPUT");
+  const unique2 = [...new Set(files.map((file, index2) => normalizedPath(file.path, `files[${index2}].path`)))].sort();
+  const codeFiles = unique2.filter((path) => !isDoc(path) && !isTest(path));
+  const existingTests = unique2.filter(isTest);
+  const roots = (options.testRoots ?? ["test", "tests", "__tests__"]).map((root, index2) => normalizedPath(root, `testRoots[${index2}]`));
+  const colocated = options.includeTests === false ? [] : codeFiles.flatMap((path) => {
+    const file = basename(path);
+    const directory = dirname(path);
+    const stem = file.includes(".") ? file.slice(0, file.lastIndexOf(".")) : file;
+    return [join(directory, `${stem}.test.ts`), join(directory, `${stem}.spec.ts`)].filter((candidate) => unique2.includes(candidate));
+  });
+  const testFiles = [...new Set([...existingTests, ...colocated, ...unique2.filter((path) => roots.some((root) => path === root || path.startsWith(`${root}/`)))].sort())];
+  const docsOnly = unique2.length > 0 && codeFiles.length === 0 && existingTests.length === 0;
+  return { files: unique2, codeFiles, testFiles, docsOnly, checks: docsOnly ? [] : ["lint", "typecheck", ...testFiles.length ? ["test"] : []] };
+};
+
+// src/kernel/block.ts
+var BLOCK_STATUSES = ["todo", "picked", "development", "validation", "pr-open", "merged", "post-merge", "done", "blocked", "scope-cut"];
+var text5 = (value, label) => {
+  return typeof value === "string" && value.trim() ? value.trim() : fail(`${label} must be a non-empty string.`, "INVALID_INPUT");
+};
+var list = (value, label) => {
+  if (!Array.isArray(value)) return fail(`${label} must be an array of non-empty strings.`, "INVALID_INPUT");
+  if (!value.every((item) => typeof item === "string" && Boolean(item.trim()))) return fail(`${label} must be an array of non-empty strings.`, "INVALID_INPUT");
+  return [...new Set(value.map((item) => item.trim()))];
+};
+var validateBlockManifest = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail("block manifest must be an object.", "INVALID_INPUT");
+  const raw = value;
+  if (raw["schemaVersion"] !== 1) fail("block manifest schemaVersion must be 1.", "INVALID_INPUT");
+  const criteria = list(raw["acceptanceCriteria"], "acceptanceCriteria");
+  if (!criteria.length) fail("acceptanceCriteria must not be empty.", "INVALID_INPUT");
+  const dependencies = list(raw["dependencies"] ?? [], "dependencies");
+  const wave = raw["wave"];
+  if (!Number.isInteger(wave) || wave < 1) fail("wave must be a positive integer.", "INVALID_INPUT");
+  const status = raw["status"];
+  if (!BLOCK_STATUSES.includes(status)) fail("status is invalid.", "INVALID_INPUT");
+  const budgetRaw = raw["budget"];
+  let budget;
+  if (budgetRaw !== void 0) {
+    if (typeof budgetRaw !== "object" || budgetRaw === null || Array.isArray(budgetRaw)) fail("budget must be an object.", "INVALID_INPUT");
+    const candidate = budgetRaw;
+    for (const key of ["maxMinutes", "maxAttempts"]) if (candidate[key] !== void 0 && (!Number.isInteger(candidate[key]) || candidate[key] < 1)) fail(`budget.${key} must be a positive integer.`, "INVALID_INPUT");
+    budget = { ...candidate["maxMinutes"] === void 0 ? {} : { maxMinutes: candidate["maxMinutes"] }, ...candidate["maxAttempts"] === void 0 ? {} : { maxAttempts: candidate["maxAttempts"] } };
+  }
+  return { schemaVersion: 1, id: text5(raw["id"], "id"), title: text5(raw["title"], "title"), tracker: text5(raw["tracker"], "tracker"), repository: text5(raw["repository"], "repository"), acceptanceCriteria: criteria, dependencies, wave, status, ...budget ? { budget } : {}, ...raw["humanGates"] === void 0 ? {} : { humanGates: list(raw["humanGates"], "humanGates") }, ...raw["sourceHash"] === void 0 ? {} : { sourceHash: text5(raw["sourceHash"], "sourceHash") } };
+};
+var assessBlock = (manifest, completedDependencies = []) => {
+  const value = validateBlockManifest(manifest);
+  const completed = new Set(completedDependencies.map((item) => text5(item, "completedDependencies[]")));
+  const blockers = value.dependencies.filter((dependency) => !completed.has(dependency));
+  const next = blockers.length ? [`Complete dependencies: ${blockers.join(", ")}`] : value.status === "blocked" ? ["Resolve the recorded blocker before dispatch."] : ["Dispatch the block with the frozen acceptance criteria."];
+  return { status: blockers.length || value.status === "blocked" ? "blocked" : "ready", manifestHash: hashJson(value), blockers, next };
+};
+var LEARNING_STATUSES = ["proposed", "promoted", "rejected"];
+var text6 = (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 = text6(markdown, "markdown");
+  const origin = text6(source, "source");
+  if (!Number.isFinite(Date.parse(recordedAt))) fail("recordedAt must be a valid timestamp.", "INVALID_INPUT");
+  const records = [];
+  let current = "other";
+  for (const line of input.split(/\r?\n/)) {
+    const heading = line.match(/^#{1,6}\s+(.+)$/);
+    if (heading) {
+      current = category(heading[1] ?? "");
+      continue;
+    }
+    const item = line.match(/^\s*[-*]\s+(?:\[[ xX]\]\s+)?(.+?)\s*$/);
+    if (!item?.[1]?.trim()) continue;
+    const value = item[1].trim();
+    const id2 = `L-${createHash("sha256").update(`${origin}|${current}|${value}`).digest("hex").slice(0, 12)}`;
+    if (!records.some((record3) => record3.id === id2)) records.push({ id: id2, source: origin, category: current, text: value, status: "proposed", recordedAt });
+  }
+  return records;
+};
+var promoteLearnings = (records, input) => {
+  if (input.actor !== "human") fail("Learning promotion requires a human actor.", "HUMAN_APPROVAL_REQUIRED");
+  const ids = new Set(input.ids.map((id2) => text6(id2, "ids[]")));
+  const status = input.status ?? "promoted";
+  const result = records.map((record3) => ids.has(record3.id) ? { ...record3, status } : record3);
+  const unknown = [...ids].filter((id2) => !records.some((record3) => record3.id === id2));
+  if (unknown.length) fail(`Unknown learning IDs: ${unknown.join(", ")}`, "INVALID_INPUT");
+  return result;
+};
+
+// src/kernel/status.ts
+var required12 = (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 = required12(input.sourceRevision, "sourceRevision");
+  if (!Number.isFinite(Date.parse(input.generatedAt))) fail("generatedAt must be a valid timestamp.", "INVALID_INPUT");
+  if (!Array.isArray(input.blocks)) fail("blocks must be an array.", "INVALID_INPUT");
+  const blocks = input.blocks.map((block, index2) => {
+    if (typeof block !== "object" || block === null || Array.isArray(block)) fail(`blocks[${index2}] must be an object.`, "INVALID_INPUT");
+    const value = block;
+    if (!(typeof value.id === "string" && value.id.trim())) fail(`blocks[${index2}].id is required.`, "INVALID_INPUT");
+    if (!["todo", "picked", "development", "validation", "pr-open", "merged", "post-merge", "done", "blocked", "scope-cut"].includes(value.status)) fail(`blocks[${index2}].status is invalid.`, "INVALID_INPUT");
+    return { ...value, id: value.id.trim() };
+  }).sort((left, right) => left.id.localeCompare(right.id));
+  if (input.metrics !== void 0 && Object.entries(input.metrics).some(([key, value]) => !key.trim() || typeof value !== "number" || !Number.isFinite(value) || value < 0)) fail("metrics must contain finite non-negative numbers.", "INVALID_INPUT");
+  const body3 = { schemaVersion: 1, generatedAt: input.generatedAt, sourceRevision, blocks, ...input.machine ? { machine: input.machine } : {}, ...input.metrics ? { metrics: input.metrics } : {}, ...input.next ? { next: required12(input.next, "next") } : {} };
+  return { ...body3, digest: hashJson(body3) };
+};
+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: required12(raw.generatedAt, "generatedAt"), sourceRevision: required12(raw.sourceRevision, "sourceRevision"), blocks: raw.blocks, ...raw.machine ? { machine: raw.machine } : {}, ...raw.metrics ? { metrics: raw.metrics } : {}, ...raw.next ? { next: raw.next } : {} });
+  if (raw.schemaVersion !== 1 || raw.digest !== snapshot.digest) fail("status snapshot digest or schemaVersion is invalid.", "HARNESS_ERROR");
+  return snapshot;
+};
+
+// src/kernel/model-policy.ts
+var MODEL_ROLES = ["orchestrator", "reviewer", "builder", "watcher"];
+var required13 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var createModelPolicy = (bindings) => {
+  if (!Array.isArray(bindings) || !bindings.length) fail("bindings must be a non-empty array.", "INVALID_INPUT");
+  const normalized = bindings.map((binding2, index2) => {
+    if (typeof binding2 !== "object" || binding2 === null || Array.isArray(binding2)) fail(`bindings[${index2}] must be an object.`, "INVALID_INPUT");
+    if (!MODEL_ROLES.includes(binding2.role)) fail(`bindings[${index2}].role is invalid.`, "INVALID_INPUT");
+    if (binding2.maxTokens !== void 0 && (!Number.isInteger(binding2.maxTokens) || binding2.maxTokens < 1)) fail(`bindings[${index2}].maxTokens must be a positive integer.`, "INVALID_INPUT");
+    return { role: binding2.role, provider: required13(binding2.provider, `bindings[${index2}].provider`), model: required13(binding2.model, `bindings[${index2}].model`), ...binding2.maxTokens === void 0 ? {} : { maxTokens: binding2.maxTokens } };
+  });
+  if (new Set(normalized.map((binding2) => binding2.role)).size !== normalized.length) fail("Each model role may be bound only once.", "INVALID_INPUT");
+  return { bindings: normalized, digest: hashJson(normalized) };
+};
+var modelFor = (policy, role) => policy.bindings.find((binding2) => binding2.role === role) ?? fail(`No model binding exists for role: ${role}.`, "INVALID_STATE");
+
+// src/adapters/orca.ts
+var required14 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var createOrcaDispatchPlan = (input) => {
+  const repository = required14(input.repository, "repository");
+  const worktree = required14(input.worktree, "worktree");
+  const branch = required14(input.branch, "branch");
+  const baseBranch = required14(input.baseBranch, "baseBranch");
+  const goalFile = required14(input.goalFile, "goalFile");
+  const agent = required14(input.agent ?? "default", "agent");
+  const argv = ["orca", "worktree", "create", "--repo", repository, "--name", worktree, "--base-branch", baseBranch, "--agent", agent, "--prompt-file", goalFile];
+  validateSafeCommand(argv.join(" "));
+  const identity = { repository, worktree, branch, baseBranch, goalFile, agent };
+  return { argv, commandDigest: hashJson(argv), idempotencyKey: hashJson(identity) };
+};
+var createOrcaLifecycleProjection = (input) => {
+  const issueRef = required14(input.issueRef, "issueRef");
+  const repository = required14(input.repository, "repository");
+  const worktree = required14(input.worktree, "worktree");
+  const branch = required14(input.branch, "branch");
+  if (!["acquired", "resumed", "conflict", "released"].includes(input.leaseState)) fail("leaseState is invalid.", "INVALID_INPUT");
+  if (input.issueLock !== "held" && input.issueLock !== "missing") fail("issueLock is invalid.", "INVALID_INPUT");
+  const expected = input.expectedRemoteSha?.trim();
+  const observed = input.observedRemoteSha?.trim();
+  const remoteShaConfirmed = Boolean(expected && observed && expected === observed);
+  const cleanupAllowed = input.cleanupRequested === true && remoteShaConfirmed && input.leaseState === "released";
+  const status = input.leaseState === "conflict" || input.issueLock === "missing" ? "blocked" : input.cleanupRequested === true && !remoteShaConfirmed ? "escalated" : input.leaseState === "resumed" ? "resume" : "ready";
+  return { status, leaseState: input.leaseState, worktreeKey: hashJson({ issueRef, repository, worktree, branch }), issueLock: input.issueLock, remoteShaConfirmed, cleanupAllowed, assurance: "contract-tested", telemetry: { status: "measured", durationMs: 0 } };
+};
+
+// src/adapters/tracking.ts
+var required15 = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
+  return value.trim();
+};
+var createTrackingTransition = (input) => {
+  const transition2 = { tracker: required15(input.tracker, "tracker"), issue: required15(input.issue, "issue"), ...input.from ? { from: required15(input.from, "from") } : {}, to: required15(input.to, "to"), reason: required15(input.reason, "reason") };
+  return { ...transition2, idempotencyKey: hashJson(transition2) };
+};
+var createTrackingAdapter = (id2, handler, options = {}) => {
+  const adapterId = required15(id2, "id");
+  const completed = /* @__PURE__ */ new Set();
+  let writes = 0;
+  return {
+    id: adapterId,
+    assurance: "contract-tested",
+    telemetry: () => ({ status: "measured", externalMutations: writes }),
+    transition: async (input) => {
+      const transition2 = createTrackingTransition(input);
+      if (!completed.has(transition2.idempotencyKey)) {
+        if (!options.dryRun) {
+          await handler(transition2);
+          writes += 1;
+        }
+        completed.add(transition2.idempotencyKey);
+      }
+      return transition2;
+    }
+  };
+};
 var EVIDENCE_BUNDLE_SCHEMA_VERSION = 1;
-var body = (bundle) => {
+var body2 = (bundle) => {
   const { payloadHash: _payloadHash, signature: _signature, ...unsigned } = bundle;
   return unsigned;
 };
@@ -1764,7 +3684,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 digest6 = run.verificationDigest ?? fail("Only a reconciled COMPLETE run can be exported.", "INVALID_STATE");
   if (reconciliation.state !== "COMPLETE") fail("Only a reconciled COMPLETE run can be exported.", "INVALID_STATE");
   const eventLog = new FileEventStore(loaded.stateDir);
   eventLog.read(run.runId);
@@ -1779,7 +3699,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: digest6, 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") } };
@@ -1804,7 +3724,7 @@ var verifyEvidenceBundle = (path, { trustedKeys = [] } = {}) => {
     if (sha256(content) !== file.sha256) fail(`Evidence bundle file hash mismatch: ${file.path}`, "HARNESS_ERROR");
   }
   if (!paths.has(`runs/${bundle.runId}/run.json`) || !paths.has(`runs/${bundle.runId}/events.ndjson`)) fail("Evidence bundle is missing the run projection or event log.", "HARNESS_ERROR");
-  if (sha256(JSON.stringify(body(bundle))) !== bundle.payloadHash) fail("Evidence bundle payload hash mismatch.", "HARNESS_ERROR");
+  if (sha256(JSON.stringify(body2(bundle))) !== bundle.payloadHash) fail("Evidence bundle payload hash mismatch.", "HARNESS_ERROR");
   let valid = false;
   try {
     valid = verify(null, Buffer.from(bundle.payloadHash), createPublicKey(bundle.signature.publicKeyPem), Buffer.from(bundle.signature.signatureBase64, "base64"));
@@ -1823,6 +3743,6 @@ var readEvidenceTrustStore = (path) => {
   });
 };
 
-export { BENCHMARK_SCHEMA_VERSION, CONTEXT_PROVIDER_SLOT, EVENT_LOG_GENESIS, EVIDENCE_BUNDLE_SCHEMA_VERSION, FileEventStore, HARNESS_EVENT_SCHEMA_VERSION, HARNESS_EVENT_TYPES, HARNESS_PLUGIN_API_VERSION, HarnessError, LEGAL_TRANSITIONS, STATES, approveRun, approvedDecision, assertHuman, authorizeRun, benchmarkRuns, cancelRun, cleanTaskArtifacts, createDocBridgeContextProvider, createDockerToolRuntime, createPluginRegistry, createPluginSlot, createPolicyGate, createProcessToolRuntime, createSessionRecorder, createToolRuntime, exportEvidenceBundle, hashContextSnapshot, hashContextSnapshots, inspectEventLogLock, loadBenchmarkManifest, loadConfig, loadLatestRun, planRun, readContextSnapshots, readEvidenceTrustStore, reconcileRun, recordBenchmarkObservation, recoverEventLogLock, retryRun, startRun, transition, validateBenchmarkManifest, validateConfig, validateContextSnapshot, validateContextSnapshots, validateExternalCodingBenchmarkReport, verifyEvidenceBundle, verifyRun };
+export { ARTIFACT_SCHEMA_VERSION, ARTIFACT_TYPES, ASSURANCE_LEVELS, BENCHMARK_SCHEMA_VERSION, BLOCK_STATUSES, CAPABILITY_KINDS, CAPABILITY_MANIFEST_SCHEMA_VERSION, COMPATIBILITY_COMPONENTS, COMPATIBILITY_SCHEMA_VERSION, CONTEXT_PROVIDER_SLOT, EVAL_COMPONENTS, EVAL_LAYERS, EVAL_MANIFEST_SCHEMA_VERSION, EVENT_LOG_GENESIS, EVIDENCE_BUNDLE_SCHEMA_VERSION, FileArtifactStore, FileEventStore, HARNESS_ERROR_CATALOG, HARNESS_ERROR_CODES, HARNESS_EVENT_ENVELOPE_SCHEMA_VERSION, HARNESS_EVENT_SCHEMA_VERSION, HARNESS_EVENT_TYPES, HARNESS_PLUGIN_API_VERSION, HarnessError, IMPROVEMENT_CYCLE_STEPS, LEARNING_STATUSES, LEGAL_TRANSITIONS, MEMORY_SCOPES, MODEL_ROLES, PHASE_DECISIONS, PHASE_EFFECTS, PHASE_EFFECT_ACTIONS, PHASE_MODES, QUALITY_DIMENSIONS, STATES, WIP_STATES, adaptiveConcurrency, approveRun, approvedDecision, artifactDigest, artifactFilePath, artifactIsFresh, artifactMarkdownPath, assertHuman, assessAcceptance, assessAgentEval, assessBlock, assessCompatibility, assessDiscovery, assessImprovementCycle, assessIntegration, assessPilot, assessPreflight, assessProduction, assessQaTransition, assessWip, assessWorktreeCleanup, authorizeRun, benchmarkRuns, cancelRun, classifyFailure, classifyHarnessError, cleanTaskArtifacts, compareOptimization, composePullRequest, createArtifactEnvelope, createCapabilityManifest, createCodingAgentAdapter, createCompatibilityManifest, createConfiguredToolRuntime, createDispatchLedger, createDocBridgeContextProvider, createDockerToolRuntime, createEvalManifest, createHarnessEventEnvelope, createInMemoryMemoryAdapter, createKvMemoryAdapter, createLlmCache, createLlmCacheKey, createMachineMonitor, createModelPolicy, createOrcaDispatchPlan, createOrcaLifecycleProjection, createPhaseArtifact, createPhaseProfile, createPluginRegistry, createPluginSlot, createPolicyGate, createProcessToolRuntime, createPullRequestApproval, createQualityMatrix, createSessionRecorder, createStatusSnapshot, createToolRuntime, createTrackingAdapter, createTrackingTransition, evaluateWatchdog, executePhaseProfile, exportEvidenceBundle, hashContextSnapshot, hashContextSnapshots, inspectEventLogLock, isDiscoveryCurrent, loadBenchmarkManifest, loadConfig, loadLatestRun, modelFor, parseRetro, planFilePreflight, planPhaseProfile, planRun, promoteLearnings, readArtifactFile, readContextSnapshots, readEvidenceTrustStore, reconcileRun, recordBenchmarkObservation, recoverEventLogLock, recoveryDelayMs, renderArtifactMarkdown, resumeStateFromArtifacts, retryRun, runAdversarialReview, runAgentEval, runEvalBattery, runWithRecovery, runWorkflow, sampleMachine, selectRuntime, startRun, summarizeMachine, transition, unknownTelemetry, validateAdapterMetadata, validateArtifactEnvelope, validateBenchmarkManifest, validateBlockManifest, validateCacheableOperation, validateCapabilityManifest, validateCompatibilityManifest, validateConfig, validateContextSnapshot, validateContextSnapshots, validateEvalManifest, validateHarnessErrorClassification, validateHarnessEventEnvelope, validateMemoryRecord, validateOptimizationObservation, validatePhaseTelemetry, validateSafeCommand, validateStatusSnapshot, verifyEvidenceBundle, verifyPullRequestApproval, verifyRun };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map