@agentskit/harness 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,11 +1,11 @@
 import { resolve, dirname, join, relative, basename, extname, sep } from 'path';
 import { createHash, randomUUID, createPrivateKey, createPublicKey, sign, verify } from 'crypto';
-import { existsSync, mkdirSync, openSync, writeSync, appendFileSync, closeSync, unlinkSync, readFileSync, writeFileSync, mkdtempSync, renameSync, rmSync, readdirSync } from 'fs';
+import { 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 { cpus, loadavg, freemem, totalmem, tmpdir } from 'os';
 
-// src/constants.ts
+// src/kernel/constants.ts
 var STATES = [
   "CLARIFYING",
   "PLANNED",
@@ -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");
@@ -138,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 = [
@@ -155,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");
@@ -269,7 +304,7 @@ var loadConfig = (configPath = ".codex/verification.json") => {
   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");
@@ -284,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`;
@@ -306,8 +396,8 @@ 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) => {
@@ -359,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.correlation ? { correlation: event.correlation } : {}, ...event.sessionId ? { sessionId: event.sessionId } : {}, ...previous?.eventHash ? { previousHash: previous.eventHash } : events.length ? {} : { previousHash: EVENT_LOG_GENESIS }, type: event.type, payload: event.payload };
-      const record3 = events.length && !previous?.eventHash ? body2 : { ...body2, eventHash: eventDigest(body2) };
+      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;
@@ -414,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();
@@ -470,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();
@@ -483,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);
               };
@@ -513,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;
@@ -541,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) => {
@@ -564,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;
@@ -586,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) => {
@@ -643,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(", ")}`];
@@ -655,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;
     }
@@ -770,7 +909,7 @@ var createMachineMonitor = (sampleIntervalMs = 5e3, options = {}) => {
   };
 };
 
-// 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 });
@@ -912,13 +1051,13 @@ var verifyRun = async ({ configPath }) => {
   const budgetExceeded = loaded.config.budget?.maxDurationMs !== void 0 && totalDurationMs > loaded.config.budget.maxDurationMs;
   const allPassed = loaded.config.checks.every((check) => !check.required || statuses.get(check.id) === "passed") && !budgetExceeded;
   current = { ...current, outcomes: current.outcomes.map((outcome) => {
-    const required15 = outcome.checks.filter((id2) => loaded.config.checks.find((check) => check.id === id2)?.required);
-    return { ...outcome, status: required15.length === 0 ? "not-applicable" : required15.every((id2) => statuses.get(id2) === "passed") ? "passed" : "failed" };
+    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 digest3 = verificationDigest(current);
-  current = { ...current, verificationDigest: digest3 };
+  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: digest3, checkCount: current.checks.length, outcomeCount: current.outcomes.length, totalDurationMs, budgetExceeded } });
+  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") };
@@ -1023,6 +1162,70 @@ var retryRun = async ({ configPath }) => {
   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);
@@ -1036,15 +1239,17 @@ 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/discovery.ts
+// src/kernel/discovery.ts
 var required = (value, label) => {
   if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
   return value.trim();
@@ -1078,7 +1283,7 @@ var validate = (input) => {
   }
   return { assumptions };
 };
-var digest2 = (result) => hashJson(result);
+var digest3 = (result) => hashJson(result);
 var assessDiscovery = (input) => {
   const { assumptions } = validate(input);
   const human = input.ambiguities.filter((ambiguity) => ambiguity.material);
@@ -1103,7 +1308,7 @@ var assessDiscovery = (input) => {
     } } : {},
     decisionLog
   };
-  return { ...base, digest: digest2(base) };
+  return { ...base, digest: digest3(base) };
 };
 var isDiscoveryCurrent = (result, current) => {
   const reasons = [];
@@ -1113,7 +1318,7 @@ var isDiscoveryCurrent = (result, current) => {
   return { current: reasons.length === 0, reasons };
 };
 
-// src/wip.ts
+// 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) => {
@@ -1145,7 +1350,7 @@ var assessWip = ({ entries, candidate, maxInFlight = 3 }) => {
   return { decision: "admit", inFlight, counts, reason: `WIP slot available (${inFlight.length}/${maxInFlight}).` };
 };
 
-// src/experiment.ts
+// src/kernel/experiment.ts
 var required3 = (value, label) => {
   if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
   return value.trim();
@@ -1157,11 +1362,11 @@ var comparable = (candidate, baseline) => {
 };
 var selectRuntime = (candidates) => {
   if (!Array.isArray(candidates) || candidates.length < 2) fail("At least two runtime candidates are required.", "INVALID_INPUT");
-  const names = /* @__PURE__ */ new Set();
+  const names2 = /* @__PURE__ */ new Set();
   for (const candidate of candidates) {
     const runtime = required3(candidate.runtime, "candidate.runtime");
-    if (names.has(runtime)) fail("candidate.runtime values must be unique.", "INVALID_INPUT");
-    names.add(runtime);
+    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]);
@@ -1172,7 +1377,92 @@ var selectRuntime = (candidates) => {
   return { decision: "selected", selected, eligible, reason: "Selected by human minutes, duration, cost, then Orca tie-break." };
 };
 
-// src/delivery.ts
+// 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();
@@ -1216,8 +1506,26 @@ var composePullRequest = ({ draft, g2, remote }) => {
     if (remote.candidateRevision !== draft.candidateRevision || !remote.url) return { decision: "blocked", reason: "Confirmed remote PR does not match the candidate revision.", idempotencyKey };
     return { decision: "reuse", reason: "The idempotent remote PR already exists for this candidate revision.", idempotencyKey };
   }
-  const body2 = [`## Contract`, `- Issue: ${draft.issueId}`, `- Candidate: ${draft.candidateRevision}`, `- Contract: ${draft.contractHash}`, `- Configuration: ${draft.configHash}`, "", "## G2 evidence", ...draft.evidence.map((item) => `- ${item}`), "", "## Documentation", ...draft.documentation.map((item) => `- ${item}`), "", "## Risk and rollback", `- Risk: ${draft.risk}`, `- Rollback: ${draft.rollback}`, "", "## Later gates", ...draft.pendingCriteria.length ? draft.pendingCriteria.map((item) => `- Pending: ${item}`) : ["- None."]].join("\n");
-  return { decision: "create", body: body2, reason: "G2 is current and the remote PR is absent.", idempotencyKey };
+  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");
@@ -1267,7 +1575,7 @@ var assessAcceptance = ({ production, acceptanceRequired, accepted, notApplicabl
   return assessed("G5", "approved", acceptanceRequired ? [] : [`Acceptance is not applicable: ${notApplicableReason}.`], production.binding);
 };
 
-// src/pilot.ts
+// src/kernel/pilot.ts
 var required5 = (value, label) => {
   if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
   return value.trim();
@@ -1296,7 +1604,7 @@ var assessPilot = (manifest) => {
   return { ...base, digest: hashJson({ ...manifest, ...base }) };
 };
 var IMPROVEMENT_CYCLE_STEPS = ["adversarial-review", "g2-preflight", "baseline-record", "pilot-execution", "comparison"];
-var nonEmpty = (value, label) => {
+var nonEmpty3 = (value, label) => {
   if (typeof value !== "string" || !value.trim()) return fail(`${label} must be a non-empty string.`, "INVALID_INPUT");
   return value.trim();
 };
@@ -1315,14 +1623,14 @@ var validateIteration = (iteration, index2) => {
     if (typeof result !== "object" || result === null || Array.isArray(result)) return fail(`iterations[${index2}].steps[${stepIndex}] must be an object.`, "INVALID_INPUT");
     if (result.step !== IMPROVEMENT_CYCLE_STEPS[stepIndex]) return fail(`iterations[${index2}].steps[${stepIndex}] must be ${IMPROVEMENT_CYCLE_STEPS[stepIndex]}.`, "INVALID_INPUT");
     if (!["passed", "failed", "blocked", "pending"].includes(result.status)) return fail(`iterations[${index2}].steps[${stepIndex}].status is invalid.`, "INVALID_INPUT");
-    if (result.status !== "passed" && !nonEmpty(result.reason, `iterations[${index2}].steps[${stepIndex}].reason`)) return fail(`iterations[${index2}].steps[${stepIndex}].reason is required when the step does not pass.`, "INVALID_INPUT");
+    if (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) nonEmpty(iteration.adjustment, `iterations[${index2}].adjustment`);
+  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 = nonEmpty(input.cycleId, "cycleId");
+  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");
@@ -1342,11 +1650,129 @@ var assessImprovementCycle = (input) => {
   const reasons = complete ? ["All five cycle steps passed."] : iterations.length >= input.maxIterations ? ["Maximum cycle iterations reached; human adjustment is required."] : latest.adjustment ? ["A failed or blocked step remains; repeat with the recorded adjustment."] : ["A failed or blocked step remains; an explicit adjustment is required before repeating."];
   const decision = complete ? "complete" : iterations.length >= input.maxIterations || !latest.adjustment ? "blocked" : "repeat";
   const result = { type: "agentskit-harness-improvement-cycle", cycleId, decision, ...decision === "repeat" ? { nextIteration: latest.iteration + 1 } : {}, reasons, matrix };
-  const digest3 = createHash("sha256").update(JSON.stringify(result)).digest("hex");
-  return { ...result, digest: digest3 };
+  const digest6 = createHash("sha256").update(JSON.stringify(result)).digest("hex");
+  return { ...result, digest: digest6 };
 };
 
-// src/eval.ts
+// 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");
@@ -1369,7 +1795,7 @@ var assessAgentEval = (report, minimumAccuracy) => {
   return report.accuracy >= minimumAccuracy ? { status: "passed", reason: `Accuracy ${report.accuracy.toFixed(4)} meets ${minimumAccuracy.toFixed(4)}.`, report } : { status: "blocked", reason: `Accuracy ${report.accuracy.toFixed(4)} is below ${minimumAccuracy.toFixed(4)}.`, report };
 };
 
-// src/cache.ts
+// 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;
@@ -1384,6 +1810,8 @@ var createLlmCache = () => {
   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) {
@@ -1407,13 +1835,13 @@ var createLlmCache = () => {
   };
 };
 
-// src/optimization.ts
-var nonNegative = (value, label) => {
+// 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) => {
-  nonNegative(value, label);
+  nonNegative2(value, label);
   if (!Number.isInteger(value)) fail(`${label} must be an integer.`, "INVALID_INPUT");
   return value;
 };
@@ -1427,7 +1855,7 @@ var validateOptimizationObservation = (observation) => {
   required6(observation.configHash, "configHash");
   required6(observation.provider, "provider");
   required6(observation.model, "model");
-  nonNegative(observation.durationMs, "durationMs");
+  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;
@@ -1442,8 +1870,8 @@ var validateOptimizationObservation = (observation) => {
   }
   if (observation.parallelism) {
     for (const key of ["tasks", "peakConcurrency"]) nonNegativeInteger(observation.parallelism[key], `parallelism.${key}`);
-    nonNegative(observation.parallelism.criticalPathMs, "parallelism.criticalPathMs");
-    if (observation.parallelism.queueWaitMs !== void 0) nonNegative(observation.parallelism.queueWaitMs, "parallelism.queueWaitMs");
+    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;
@@ -1467,7 +1895,7 @@ var compareOptimization = (baseline, candidate) => {
   return result;
 };
 
-// src/memory.ts
+// 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");
@@ -1485,23 +1913,38 @@ var validateMemoryRecord = (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();
-      return [...records.values()].filter((record3) => {
+      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));
@@ -1509,80 +1952,712 @@ var createKvMemoryAdapter = (store, options = {}) => {
   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}`))) : [];
-      return records.filter((record3) => Boolean(record3 && typeof record3 === "object" && record3.approved === true)).filter((record3) => matches2(record3, query.trim().toLowerCase(), issueId, project)).map((record3) => ({ record: record3, relevant: true, stale: sourceRevision !== void 0 && record3.sourceRevision !== sourceRevision }));
+      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/workflow.ts
-var validId2 = (id2) => {
-  if (typeof id2 !== "string" || !id2.trim()) fail("Workflow node id must be non-empty.", "INVALID_INPUT");
-  return id2.trim();
+// 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 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");
+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 result = [];
+  const levels2 = [];
   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);
-    }
+    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 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);
+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 (!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);
+      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;
   }
-  return { results, order, peakConcurrency, criticalPathMs: Date.now() - started };
+  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 improvementRate = (baseline, current) => baseline === void 0 || current === void 0 || baseline === 0 ? null : Number(((baseline - current) / baseline).toFixed(4));
 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);
@@ -1628,8 +2703,8 @@ var summarize = (runs) => {
     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) => {
@@ -1656,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");
@@ -1669,7 +2744,7 @@ var nonNegativeNumber = (value, label) => {
   const result = value;
   return result;
 };
-var nonNegativeInteger2 = (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;
@@ -1687,7 +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;
-    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`) };
+    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));
@@ -1700,10 +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 = nonNegativeInteger2(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 reviewMinutes2 = nonNegativeNumber(observation["reviewMinutes"], `benchmark.observations[${index2}].reviewMinutes`);
-    const escapedIncomplete = nonNegativeInteger2(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) => {
@@ -1783,19 +2858,19 @@ var benchmarkRuns = (stateDir, manifest) => {
   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 required7 = (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 = required7(sessionId, "sessionId");
-  const adapterId = required7(adapter.id, "adapter.id");
-  const adapterVersion = required7(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");
@@ -1846,18 +2921,18 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
   };
   const complete = (input) => {
     open();
-    const actionId = required7(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: required7(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 = required7(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: required7(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;
   };
@@ -1865,24 +2940,24 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
     sessionId: id2,
     startTurn: (inputHash, turnId = randomUUID()) => {
       open();
-      const turn = required7(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: required7(inputHash, "inputHash") });
+      const event = append("agent.turn.started", { turnId: turn, inputHash: required8(inputHash, "inputHash") });
       turns.add(turn);
       return event;
     },
     requestTool: (input) => {
       open();
-      const turnId = required7(input.turnId, "turnId");
+      const turnId = required8(input.turnId, "turnId");
       if (!turns.has(turnId)) fail(`Turn does not exist: ${turnId}.`, "INVALID_STATE");
-      const actionId = required7(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 = required7(input.toolId, "toolId");
-      const argumentsHash = required7(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 = required7(decision.policyId, "policyId");
-      const reason = required7(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") {
@@ -1900,7 +2975,7 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
     },
     approveTool: (input) => {
       open();
-      const actionId = required7(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;
@@ -1914,7 +2989,7 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
     },
     recoverTool: (input) => {
       open();
-      const actionId = required7(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");
@@ -1932,7 +3007,7 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
     failTool: failAction,
     executeTool: async (input) => {
       open();
-      const actionId = required7(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");
@@ -1975,8 +3050,8 @@ var createSessionRecorder = ({ stateDir, run, adapter, policy, runtime, sessionI
   return recorder;
 };
 
-// src/policy.ts
-var required8 = (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();
 };
@@ -1984,30 +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 = required8(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) => required8(toolId, `rules[${index2}].toolIds`)), reason: required8(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");
-      required8(request.actionId, "request.actionId");
-      required8(request.turnId, "request.turnId");
-      const toolId = required8(request.toolId, "request.toolId");
-      required8(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 createConfiguredToolRuntime = ({ runtime, process: process2, docker }) => runtime.kind === "docker" ? createDockerToolRuntime(docker) : createProcessToolRuntime(process2);
-var required9 = (value, label) => {
+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;
 };
@@ -2017,7 +3092,7 @@ var positiveNumber = (value, label) => {
   return normalized;
 };
 var absolutePath = (value, label) => {
-  const normalized = required9(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;
 };
@@ -2035,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 = required9(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 = required9(request.actionId, "request.actionId");
-      const turnId = required9(request.turnId, "request.turnId");
-      const toolId = required9(request.toolId, "request.toolId");
-      const argumentsHash = required9(request.argumentsHash, "request.argumentsHash");
+      const 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);
       }
@@ -2076,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 = required9(tool.toolId, `tools[${index2}].toolId`);
-    const command = required9(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 = required9(request.actionId, "request.actionId");
-      const turnId = required9(request.turnId, "request.turnId");
-      const toolId = required9(request.toolId, "request.toolId");
-      const argumentsHash = required9(request.argumentsHash, "request.argumentsHash");
+      const 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;
@@ -2159,17 +3240,17 @@ var createDockerToolRuntime = ({
   pull = "never"
 }) => {
   if (!Array.isArray(tools)) fail("Docker runtime tools must be an array.", "INVALID_INPUT");
-  const command = required9(dockerCommand, "dockerCommand");
-  const memory = required9(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 = required9(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 = required9(tool.toolId, `tools[${index2}].toolId`);
-    const image = required9(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`);
@@ -2221,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);
@@ -2231,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);
@@ -2239,7 +3323,7 @@ var createDockerToolRuntime = ({
     }
   };
 };
-var required10 = (value, label) => {
+var required11 = (value, label) => {
   if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
   return value.trim();
 };
@@ -2249,20 +3333,20 @@ var parse = (value, label) => {
   try {
     const raw = JSON.parse(value);
     const identity = {
-      tracker: required10(raw["tracker"], `${label}.tracker`),
-      repository: required10(raw["repository"], `${label}.repository`),
-      issue: required10(raw["issue"], `${label}.issue`),
-      worktree: required10(raw["worktree"], `${label}.worktree`),
-      branch: required10(raw["branch"], `${label}.branch`)
+      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: required10(raw["key"], `${label}.key`), leaseId: required10(raw["leaseId"], `${label}.leaseId`), owner: required10(raw["owner"], `${label}.owner`), claimedAt: required10(raw["claimedAt"], `${label}.claimedAt`) };
+    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 = required10(stateDir, "stateDir");
+  const root = required11(stateDir, "stateDir");
   const claimsDir = join(root, "coordination", "claims");
   const ledgerPath = join(root, "coordination", "dispatch-ledger.ndjson");
   mkdirSync(claimsDir, { recursive: true });
@@ -2290,13 +3374,13 @@ var createDispatchLedger = (stateDir) => {
   return {
     claim: (input) => {
       const identity = {
-        tracker: required10(input.tracker, "tracker"),
-        repository: required10(input.repository, "repository"),
-        issue: required10(input.issue, "issue"),
-        worktree: required10(input.worktree, "worktree"),
-        branch: required10(input.branch, "branch")
+        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 = required10(input.owner, "owner");
+      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") };
@@ -2317,27 +3401,27 @@ var createDispatchLedger = (stateDir) => {
       return { decision: "claimed", lease };
     },
     recordDispatch: ({ lease, idempotencyKey, commandDigest }) => {
-      const id2 = required10(idempotencyKey, "idempotencyKey");
-      const digest3 = required10(commandDigest, "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: digest3 };
+      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(required10(lease.key, "lease.key"));
+      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: required10(reason, "reason") };
+      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 = required10(key, "key");
+      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);
@@ -2345,7 +3429,7 @@ var createDispatchLedger = (stateDir) => {
       const current = parse(readFileSync(path, "utf8"), "claim");
       if (Date.now() - Date.parse(current.claimedAt) < maxAgeMs) fail("Dispatch lease is not old enough to recover.", "HARNESS_ERROR");
       unlinkSync(path);
-      const record3 = { ...current, action: "recover", at: now3(), reason: required10(input.reason, "reason") };
+      const record3 = { ...current, action: "recover", at: now3(), reason: required11(input.reason, "reason") };
       append(record3);
       return record3;
     },
@@ -2353,73 +3437,6 @@ var createDispatchLedger = (stateDir) => {
     records
   };
 };
-
-// src/resilience.ts
-var positiveInteger = (value, label) => {
-  if (!Number.isInteger(value) || value < 1) fail(`${label} must be a positive integer.`, "INVALID_INPUT");
-  return value;
-};
-var nonNegativeInteger3 = (value, label) => {
-  if (!Number.isInteger(value) || value < 0) fail(`${label} must be a non-negative integer.`, "INVALID_INPUT");
-  return value;
-};
-var classifyFailure = (error) => {
-  const value = error;
-  const code = typeof value?.code === "string" ? value.code.toUpperCase() : "";
-  const message = typeof value?.message === "string" ? value.message : String(error);
-  const text5 = `${code} ${message}`.toLowerCase();
-  if (/quota|rate.?limit|too many requests|429/.test(text5)) return { class: "quota", retryable: true, reason: message };
-  if (/timeout|timed out|deadline/.test(text5)) return { class: "timeout", retryable: true, reason: message };
-  if (/policy|forbidden|permission|approval/.test(text5)) return { class: "policy", retryable: false, reason: message };
-  if (/invalid|schema|argument|config|validation/.test(text5)) return { class: "validation", retryable: false, reason: message };
-  if (/network|connection|econn|503|502|external/.test(text5)) return { class: "external", retryable: true, reason: message };
-  return { class: "unknown", retryable: false, reason: message };
-};
-var recoveryDelayMs = (attempt, policy) => {
-  positiveInteger(attempt, "attempt");
-  nonNegativeInteger3(policy.baseDelayMs, "baseDelayMs");
-  nonNegativeInteger3(policy.maxDelayMs, "maxDelayMs");
-  if (policy.maxDelayMs < policy.baseDelayMs) fail("maxDelayMs must be greater than or equal to baseDelayMs.", "INVALID_INPUT");
-  return Math.min(policy.maxDelayMs, policy.baseDelayMs * 2 ** Math.max(0, attempt - 1));
-};
-var wait = (delayMs, sleep) => delayMs > 0 ? sleep(delayMs) : Promise.resolve();
-var runWithRecovery = async (operation, options) => {
-  const maxAttempts = positiveInteger(options.maxAttempts, "maxAttempts");
-  const baseDelayMs = nonNegativeInteger3(options.baseDelayMs, "baseDelayMs");
-  const maxDelayMs = nonNegativeInteger3(options.maxDelayMs, "maxDelayMs");
-  if (maxDelayMs < baseDelayMs) fail("maxDelayMs must be greater than or equal to baseDelayMs.", "INVALID_INPUT");
-  if (options.timeoutMs !== void 0) positiveInteger(options.timeoutMs, "timeoutMs");
-  const sleep = options.sleep ?? ((delayMs) => new Promise((resolve6) => setTimeout(resolve6, delayMs)));
-  const observations = [];
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    const controller = new AbortController();
-    let timer;
-    try {
-      const operationPromise = operation(controller.signal, attempt);
-      const value = options.timeoutMs === void 0 ? await operationPromise : await Promise.race([
-        operationPromise,
-        new Promise((_, reject) => {
-          timer = setTimeout(() => {
-            controller.abort();
-            reject(new Error("operation timed out"));
-          }, options.timeoutMs);
-        })
-      ]);
-      return { status: "completed", attempts: attempt, observations, value };
-    } catch (error) {
-      const failure = classifyFailure(error);
-      const delayMs = failure.retryable && attempt < maxAttempts ? recoveryDelayMs(attempt, { baseDelayMs, maxDelayMs }) : 0;
-      const observation = { attempt, failure, delayMs };
-      observations.push(observation);
-      options.onObservation?.(observation);
-      if (!failure.retryable || attempt >= maxAttempts) return { status: "failed", attempts: attempt, observations, failure };
-      await wait(delayMs, sleep);
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-  }
-  return fail("Recovery loop exhausted unexpectedly.", "HARNESS_ERROR");
-};
 var DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".txt", ".adoc", ".rst"]);
 var TEST_SUFFIXES = [".test.", ".spec.", "__tests__"];
 var SHELL_META = /[;&|`$()<>\n\r]/;
@@ -2454,9 +3471,9 @@ var planFilePreflight = (files, options = {}) => {
   return { files: unique2, codeFiles, testFiles, docsOnly, checks: docsOnly ? [] : ["lint", "typecheck", ...testFiles.length ? ["test"] : []] };
 };
 
-// src/block.ts
+// src/kernel/block.ts
 var BLOCK_STATUSES = ["todo", "picked", "development", "validation", "pr-open", "merged", "post-merge", "done", "blocked", "scope-cut"];
-var text3 = (value, label) => {
+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) => {
@@ -2483,17 +3500,17 @@ var validateBlockManifest = (value) => {
     for (const key of ["maxMinutes", "maxAttempts"]) if (candidate[key] !== void 0 && (!Number.isInteger(candidate[key]) || candidate[key] < 1)) fail(`budget.${key} must be a positive integer.`, "INVALID_INPUT");
     budget = { ...candidate["maxMinutes"] === void 0 ? {} : { maxMinutes: candidate["maxMinutes"] }, ...candidate["maxAttempts"] === void 0 ? {} : { maxAttempts: candidate["maxAttempts"] } };
   }
-  return { schemaVersion: 1, id: text3(raw["id"], "id"), title: text3(raw["title"], "title"), tracker: text3(raw["tracker"], "tracker"), repository: text3(raw["repository"], "repository"), acceptanceCriteria: criteria, dependencies, wave, status, ...budget ? { budget } : {}, ...raw["humanGates"] === void 0 ? {} : { humanGates: list(raw["humanGates"], "humanGates") }, ...raw["sourceHash"] === void 0 ? {} : { sourceHash: text3(raw["sourceHash"], "sourceHash") } };
+  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) => text3(item, "completedDependencies[]")));
+  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 text4 = (value, label) => {
+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) => {
@@ -2504,8 +3521,8 @@ var category = (heading) => {
   return "other";
 };
 var parseRetro = (markdown, source, recordedAt = (/* @__PURE__ */ new Date()).toISOString()) => {
-  const input = text4(markdown, "markdown");
-  const origin = text4(source, "source");
+  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";
@@ -2525,7 +3542,7 @@ var parseRetro = (markdown, source, recordedAt = (/* @__PURE__ */ new Date()).to
 };
 var promoteLearnings = (records, input) => {
   if (input.actor !== "human") fail("Learning promotion requires a human actor.", "HUMAN_APPROVAL_REQUIRED");
-  const ids = new Set(input.ids.map((id2) => text4(id2, "ids[]")));
+  const 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));
@@ -2533,12 +3550,12 @@ var promoteLearnings = (records, input) => {
   return result;
 };
 
-// src/status.ts
-var required11 = (value, label) => {
+// 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 = required11(input.sourceRevision, "sourceRevision");
+  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) => {
@@ -2549,20 +3566,20 @@ var createStatusSnapshot = (input) => {
     return { ...value, id: value.id.trim() };
   }).sort((left, right) => left.id.localeCompare(right.id));
   if (input.metrics !== void 0 && Object.entries(input.metrics).some(([key, value]) => !key.trim() || typeof value !== "number" || !Number.isFinite(value) || value < 0)) fail("metrics must contain finite non-negative numbers.", "INVALID_INPUT");
-  const body2 = { schemaVersion: 1, generatedAt: input.generatedAt, sourceRevision, blocks, ...input.machine ? { machine: input.machine } : {}, ...input.metrics ? { metrics: input.metrics } : {}, ...input.next ? { next: required11(input.next, "next") } : {} };
-  return { ...body2, digest: hashJson(body2) };
+  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: required11(raw.generatedAt, "generatedAt"), sourceRevision: required11(raw.sourceRevision, "sourceRevision"), blocks: raw.blocks, ...raw.machine ? { machine: raw.machine } : {}, ...raw.metrics ? { metrics: raw.metrics } : {}, ...raw.next ? { next: raw.next } : {} });
+  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/model-policy.ts
+// src/kernel/model-policy.ts
 var MODEL_ROLES = ["orchestrator", "reviewer", "builder", "watcher"];
-var required12 = (value, label) => {
+var required13 = (value, label) => {
   if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
   return value.trim();
 };
@@ -2572,7 +3589,7 @@ var createModelPolicy = (bindings) => {
     if (typeof binding2 !== "object" || binding2 === null || Array.isArray(binding2)) fail(`bindings[${index2}] must be an object.`, "INVALID_INPUT");
     if (!MODEL_ROLES.includes(binding2.role)) fail(`bindings[${index2}].role is invalid.`, "INVALID_INPUT");
     if (binding2.maxTokens !== void 0 && (!Number.isInteger(binding2.maxTokens) || binding2.maxTokens < 1)) fail(`bindings[${index2}].maxTokens must be a positive integer.`, "INVALID_INPUT");
-    return { role: binding2.role, provider: required12(binding2.provider, `bindings[${index2}].provider`), model: required12(binding2.model, `bindings[${index2}].model`), ...binding2.maxTokens === void 0 ? {} : { maxTokens: binding2.maxTokens } };
+    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) };
@@ -2580,42 +3597,69 @@ var createModelPolicy = (bindings) => {
 var modelFor = (policy, role) => policy.bindings.find((binding2) => binding2.role === role) ?? fail(`No model binding exists for role: ${role}.`, "INVALID_STATE");
 
 // src/adapters/orca.ts
-var required13 = (value, label) => {
+var required14 = (value, label) => {
   if (typeof value !== "string" || !value.trim()) fail(`${label} is required.`, "INVALID_INPUT");
   return value.trim();
 };
 var createOrcaDispatchPlan = (input) => {
-  const repository = required13(input.repository, "repository");
-  const worktree = required13(input.worktree, "worktree");
-  const branch = required13(input.branch, "branch");
-  const baseBranch = required13(input.baseBranch, "baseBranch");
-  const goalFile = required13(input.goalFile, "goalFile");
-  const agent = required13(input.agent ?? "default", "agent");
+  const 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 required14 = (value, label) => {
+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: required14(input.tracker, "tracker"), issue: required14(input.issue, "issue"), ...input.from ? { from: required14(input.from, "from") } : {}, to: required14(input.to, "to"), reason: required14(input.reason, "reason") };
+  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) => {
-  const adapterId = required14(id2, "id");
-  return { id: adapterId, transition: async (input) => {
-    const transition2 = createTrackingTransition(input);
-    await handler(transition2);
-    return 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;
 };
@@ -2640,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 digest3 = 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);
@@ -2655,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: digest3, 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") } };
@@ -2680,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"));
@@ -2699,6 +3743,6 @@ var readEvidenceTrustStore = (path) => {
   });
 };
 
-export { BENCHMARK_SCHEMA_VERSION, BLOCK_STATUSES, CONTEXT_PROVIDER_SLOT, EVENT_LOG_GENESIS, EVIDENCE_BUNDLE_SCHEMA_VERSION, FileEventStore, HARNESS_EVENT_SCHEMA_VERSION, HARNESS_EVENT_TYPES, HARNESS_PLUGIN_API_VERSION, HarnessError, IMPROVEMENT_CYCLE_STEPS, LEARNING_STATUSES, LEGAL_TRANSITIONS, MEMORY_SCOPES, MODEL_ROLES, STATES, WIP_STATES, adaptiveConcurrency, approveRun, approvedDecision, assertHuman, assessAcceptance, assessAgentEval, assessBlock, assessDiscovery, assessImprovementCycle, assessIntegration, assessPilot, assessPreflight, assessProduction, assessWip, assessWorktreeCleanup, authorizeRun, benchmarkRuns, cancelRun, classifyFailure, cleanTaskArtifacts, compareOptimization, composePullRequest, createConfiguredToolRuntime, createDispatchLedger, createDocBridgeContextProvider, createDockerToolRuntime, createInMemoryMemoryAdapter, createKvMemoryAdapter, createLlmCache, createLlmCacheKey, createMachineMonitor, createModelPolicy, createOrcaDispatchPlan, createPluginRegistry, createPluginSlot, createPolicyGate, createProcessToolRuntime, createSessionRecorder, createStatusSnapshot, createToolRuntime, createTrackingAdapter, createTrackingTransition, exportEvidenceBundle, hashContextSnapshot, hashContextSnapshots, inspectEventLogLock, isDiscoveryCurrent, loadBenchmarkManifest, loadConfig, loadLatestRun, modelFor, parseRetro, planFilePreflight, planRun, promoteLearnings, readContextSnapshots, readEvidenceTrustStore, reconcileRun, recordBenchmarkObservation, recoverEventLogLock, recoveryDelayMs, retryRun, runAgentEval, runWithRecovery, runWorkflow, sampleMachine, selectRuntime, startRun, summarizeMachine, transition, validateBenchmarkManifest, validateBlockManifest, validateCacheableOperation, validateConfig, validateContextSnapshot, validateContextSnapshots, validateMemoryRecord, validateOptimizationObservation, validateSafeCommand, validateStatusSnapshot, verifyEvidenceBundle, verifyRun };
+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