@agentskit/harness 0.1.0 → 0.4.0

package/dist/index.d.ts

@@ -3,7 +3,7 @@ declare const LEGAL_TRANSITIONS: {
     readonly CLARIFYING: readonly ["PLANNED", "BLOCKED", "CANCELLED"];
     readonly PLANNED: readonly ["IMPLEMENTING", "CLARIFYING", "STALE", "CANCELLED"];
     readonly IMPLEMENTING: readonly ["VERIFYING", "CLARIFYING", "STALE", "CANCELLED"];
-    readonly VERIFYING: readonly ["AWAITING_HUMAN_APPROVAL", "BLOCKED", "STALE", "CANCELLED"];
+    readonly VERIFYING: readonly ["AWAITING_HUMAN_APPROVAL", "COMPLETE", "BLOCKED", "STALE", "CANCELLED"];
     readonly AWAITING_HUMAN_APPROVAL: readonly ["AWAITING_AUTHORIZATION", "COMPLETE", "BLOCKED", "IMPLEMENTING", "STALE", "CANCELLED"];
     readonly AWAITING_AUTHORIZATION: readonly ["COMPLETE", "BLOCKED", "IMPLEMENTING", "STALE", "CANCELLED"];
     readonly COMPLETE: readonly ["STALE", "SUPERSEDED"];
@@ -13,12 +13,50 @@ declare const LEGAL_TRANSITIONS: {
     readonly SUPERSEDED: readonly [];
 };
 
-type HarnessErrorCode = 'HARNESS_ERROR' | 'INVALID_CONFIG' | 'INVALID_INPUT' | 'INVALID_STATE' | 'POLICY_BLOCKED' | 'CLARIFYING' | 'STALE' | 'WORKTREE_DIRTY' | 'ACTIVE_RUN' | 'NO_RUN' | 'HUMAN_APPROVAL_REQUIRED';
+declare const HARNESS_ERROR_CODES: readonly ["HARNESS_ERROR", "INVALID_CONFIG", "INVALID_INPUT", "INVALID_STATE", "POLICY_BLOCKED", "CLARIFYING", "STALE", "WORKTREE_DIRTY", "ACTIVE_RUN", "NO_RUN", "HUMAN_APPROVAL_REQUIRED", "GIT_REQUIRED"];
+type HarnessErrorCode = typeof HARNESS_ERROR_CODES[number];
 declare class HarnessError extends Error {
     readonly code: HarnessErrorCode;
     constructor(message: string, code?: HarnessErrorCode);
 }
 
+type HarnessErrorDisposition = 'retry' | 'block' | 'escalate';
+interface HarnessErrorClassification {
+    readonly code: HarnessErrorCode;
+    readonly disposition: HarnessErrorDisposition;
+    readonly retryable: boolean;
+    readonly message: string;
+}
+type ErrorDescriptor = Readonly<Pick<HarnessErrorClassification, 'disposition' | 'retryable'>>;
+declare const HARNESS_ERROR_CATALOG: Readonly<Record<HarnessErrorCode, ErrorDescriptor>>;
+declare const classifyHarnessError: (error: unknown) => HarnessErrorClassification;
+declare const validateHarnessErrorClassification: (value: unknown) => HarnessErrorClassification;
+
+declare const ASSURANCE_LEVELS: readonly ["unverified", "contract-tested", "runtime-attested"];
+type AssuranceLevel = typeof ASSURANCE_LEVELS[number];
+interface AdapterTelemetry {
+    readonly status: 'measured' | 'unknown';
+    readonly durationMs?: number;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly totalTokens?: number;
+    readonly cacheHits?: number;
+    readonly cacheMisses?: number;
+    readonly memoryReads?: number;
+    readonly memoryWrites?: number;
+    readonly memoryRelevantHits?: number;
+    readonly memoryStaleHits?: number;
+    readonly contextReferences?: number;
+    readonly contextCostTokens?: number;
+    readonly externalMutations?: number;
+}
+interface AdapterMetadata {
+    readonly assurance: AssuranceLevel;
+    readonly telemetry: AdapterTelemetry;
+}
+declare const validateAdapterMetadata: (value: unknown) => AdapterMetadata;
+declare const unknownTelemetry: () => AdapterTelemetry;
+
 interface ToolExecutionRequest {
     readonly actionId: string;
     readonly turnId: string;
@@ -32,6 +70,9 @@ interface ToolDefinition {
     readonly execute: (request: ToolExecutionRequest) => Promise<unknown> | unknown;
 }
 interface ToolRuntime {
+    readonly assurance?: AssuranceLevel;
+    readonly isolation?: 'none' | 'sandboxed';
+    readonly telemetry?: () => AdapterTelemetry;
     execute(request: Omit<ToolExecutionRequest, 'signal'>): Promise<ToolExecutionResult>;
 }
 interface ProcessToolDefinition {
@@ -69,6 +110,11 @@ interface DockerRuntimeEvidence {
     readonly cpus: string;
     readonly pidsLimit: number;
 }
+declare const createConfiguredToolRuntime: ({ runtime, process, docker }: {
+    readonly runtime: RuntimeConfig;
+    readonly process: Parameters<typeof createProcessToolRuntime>[0];
+    readonly docker: Parameters<typeof createDockerToolRuntime>[0];
+}) => ToolRuntime;
 type ToolExecutionResult = {
     readonly status: 'completed';
     readonly resultHash: string;
@@ -103,9 +149,42 @@ declare const createDockerToolRuntime: ({ tools, timeoutMs, maxOutputBytes, dock
 }) => ToolRuntime;
 
 declare const HARNESS_EVENT_SCHEMA_VERSION: 1;
+declare const HARNESS_EVENT_ENVELOPE_SCHEMA_VERSION: 2;
 declare const EVENT_LOG_GENESIS: "GENESIS";
-declare const HARNESS_EVENT_TYPES: readonly ["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"];
+declare const HARNESS_EVENT_TYPES: readonly ["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"];
 type HarnessEventType = typeof HARNESS_EVENT_TYPES[number];
+interface HarnessEventProvenance {
+    readonly source: string;
+    readonly component: string;
+    readonly version: string;
+    readonly actor?: string;
+}
+interface HarnessEventEnvelope {
+    readonly eventId: string;
+    readonly eventType: string;
+    readonly schemaVersion: typeof HARNESS_EVENT_ENVELOPE_SCHEMA_VERSION;
+    readonly occurredAt: string;
+    readonly runId: string;
+    readonly issueRef?: string;
+    readonly sourceRevision: string;
+    readonly correlationId: string;
+    readonly payload: Readonly<Record<string, unknown>>;
+    readonly idempotencyKey: string;
+    readonly provenance: HarnessEventProvenance;
+}
+type HarnessEventEnvelopeInput = Omit<HarnessEventEnvelope, 'schemaVersion' | 'idempotencyKey'> & {
+    readonly idempotencyKey?: string;
+};
+declare const validateHarnessEventEnvelope: (value: unknown) => HarnessEventEnvelope;
+declare const createHarnessEventEnvelope: (input: HarnessEventEnvelopeInput) => HarnessEventEnvelope;
+interface HarnessEventContext {
+    readonly operationId: string;
+    readonly runId?: string;
+    readonly sessionId?: string;
+    readonly turnId?: string;
+    readonly actionId?: string;
+    readonly traceId?: string;
+}
 interface HarnessEventPayloads {
     readonly 'run.created': {
         readonly project: string;
@@ -132,6 +211,14 @@ interface HarnessEventPayloads {
         readonly totalDurationMs: number;
         readonly budgetExceeded: boolean;
     };
+    readonly 'artifact.recorded': {
+        readonly artifactId: string;
+        readonly artifactType: string;
+        readonly artifactVersion: number;
+        readonly artifactHash: string;
+        readonly phase: string;
+        readonly representation: 'json+markdown';
+    };
     readonly 'approval.recorded': {
         readonly decision: 'approved' | 'rejected';
         readonly resultingState: RunState;
@@ -238,6 +325,7 @@ type HarnessEvent<K extends HarnessEventType = HarnessEventType> = K extends Har
     readonly at: string;
     readonly sourceRevision: string;
     readonly configHash: string;
+    readonly correlation?: HarnessEventContext;
     readonly previousHash?: string;
     readonly eventHash?: string;
     readonly sessionId?: string;
@@ -331,6 +419,7 @@ interface ContextReference {
     readonly title?: string;
     readonly version?: string;
     readonly contentHash?: string;
+    readonly relevance?: number;
 }
 interface ContextSnapshot {
     readonly providerId: string;
@@ -339,6 +428,8 @@ interface ContextSnapshot {
     readonly sourceHash: string;
     readonly snapshotHash: string;
     readonly resolvedAt: string;
+    readonly assurance?: AssuranceLevel;
+    readonly telemetry?: AdapterTelemetry;
 }
 interface ContextProvider {
     readonly id: string;
@@ -382,7 +473,9 @@ interface VerificationCheck {
     readonly category: CheckCategory;
     readonly command: string;
     readonly required: boolean;
+    readonly reason?: string;
     readonly timeoutMs: number;
+    readonly dependsOn?: readonly string[];
     readonly execution?: 'real';
     readonly capabilities?: readonly string[];
     readonly evidence: 'structured';
@@ -397,16 +490,25 @@ interface BenchmarkBinding {
     readonly taskId: string;
     readonly mode: 'harness';
 }
+interface RuntimeConfig {
+    readonly kind: 'process' | 'docker';
+}
+type AutonomyMode = 'controlled' | 'yolo';
 interface VerificationConfig {
     readonly schemaVersion: 1;
     readonly project: string;
     readonly root?: string;
     readonly stateDir?: string;
     readonly profile: string;
+    readonly autonomy: AutonomyMode;
+    readonly runtime: RuntimeConfig;
     readonly contract: TaskContract;
     readonly surfaces: Readonly<Record<SurfaceName, SurfaceRequirement>>;
     readonly checks: readonly VerificationCheck[];
     readonly tracking: TrackingConfig;
+    readonly verification?: {
+        readonly maxConcurrency?: number;
+    };
     readonly budget?: {
         readonly maxDurationMs?: number;
     };
@@ -446,14 +548,14 @@ interface StructuredEvidence {
 interface CheckResult {
     readonly id: string;
     readonly category: CheckCategory;
-    readonly status: 'pending' | 'passed' | 'failed';
+    readonly status: 'pending' | 'passed' | 'failed' | 'not-applicable';
     readonly exitCode?: number;
     readonly durationMs?: number;
     readonly evidence?: StructuredEvidence;
     readonly failures?: readonly string[];
 }
 interface RunOutcome extends ContractOutcome {
-    readonly status: 'pending' | 'passed' | 'failed';
+    readonly status: 'pending' | 'passed' | 'failed' | 'not-applicable';
 }
 interface EvidenceReference {
     readonly checkId: string;
@@ -471,18 +573,11 @@ interface VerificationRun {
     readonly sourceRevision: string;
     readonly sourceStatusHash: string;
     readonly baseline: SourceSnapshot;
-    /** A human-approved plan, retained for backwards compatibility with v1 runs. */
-    readonly contractApproval?: {
+    readonly contractApproval: {
         readonly actor: 'human';
         readonly at: string;
         readonly contractHash: string;
     };
-    /** An automated preparation is never an approval and cannot complete a run. */
-    readonly contractPreparation?: {
-        readonly actor: 'ci';
-        readonly at: string;
-        readonly contractHash: string;
-    };
     readonly checks: readonly CheckResult[];
     readonly outcomes: readonly RunOutcome[];
     readonly transitions: readonly StateTransition[];
@@ -493,9 +588,13 @@ interface VerificationRun {
     readonly benchmark?: BenchmarkBinding;
     readonly supersedes?: string;
     readonly dirtyBaselineAuthorized?: boolean;
+    readonly autonomy: AutonomyMode;
     readonly metrics?: {
         readonly totalDurationMs: number;
+        readonly wallDurationMs?: number;
+        readonly peakConcurrency?: number;
         readonly budgetExceeded: boolean;
+        readonly machine?: MachineMetrics;
     };
     readonly humanApproval?: {
         readonly actor: 'human';
@@ -513,6 +612,27 @@ interface VerificationRun {
         readonly verificationDigest?: string;
     };
 }
+interface MachineSample {
+    readonly at: string;
+    readonly cpus: number;
+    readonly load1: number;
+    readonly load1PerCpuPercent: number;
+    readonly memoryUsedPercent: number;
+    readonly rssBytes: number;
+    readonly swapUsedPercent?: number;
+    readonly memoryPressure?: 'normal' | 'warning' | 'critical';
+    readonly interferingProcesses?: readonly string[];
+}
+interface MachineMetrics {
+    readonly sampleIntervalMs: number;
+    readonly samples: readonly MachineSample[];
+    readonly peakLoad1PerCpuPercent: number;
+    readonly peakMemoryUsedPercent: number;
+    readonly peakRssBytes: number;
+    readonly pressureEvents: number;
+    readonly throttleEvents: number;
+    readonly minimumEffectiveConcurrency: number;
+}
 interface RunReconciliation {
     readonly status: 'verified';
     readonly runId: string;
@@ -578,60 +698,998 @@ declare const cleanTaskArtifacts: (configPath: string) => {
     readonly cleaned: readonly string[];
 };
 
+declare const CAPABILITY_MANIFEST_SCHEMA_VERSION: 1;
+declare const CAPABILITY_KINDS: readonly ["kernel", "execution", "adapter", "composition"];
+type CapabilityKind = typeof CAPABILITY_KINDS[number];
+interface CapabilityDescriptor {
+    readonly id: string;
+    readonly version: string;
+    readonly kind: CapabilityKind;
+    readonly entryPoint: string;
+    readonly exports: readonly string[];
+    readonly dependencies?: readonly string[];
+}
+interface CapabilityManifest {
+    readonly type: 'agentskit-harness-capability-manifest';
+    readonly schemaVersion: typeof CAPABILITY_MANIFEST_SCHEMA_VERSION;
+    readonly package: string;
+    readonly packageVersion: string;
+    readonly entryPoint: string;
+    readonly sourceDigest: string;
+    readonly capabilities: readonly CapabilityDescriptor[];
+    readonly digest: string;
+}
+interface CapabilityManifestInput {
+    readonly package: string;
+    readonly packageVersion: string;
+    readonly entryPoint: string;
+    readonly sourceDigest: string;
+    readonly capabilities: readonly CapabilityDescriptor[];
+}
+declare const createCapabilityManifest: (input: CapabilityManifestInput) => CapabilityManifest;
+declare const validateCapabilityManifest: (value: unknown) => CapabilityManifest;
+
 interface DocBridgeContextProviderOptions {
     readonly root: string;
     readonly indexPath?: string;
 }
 declare const createDocBridgeContextProvider: ({ root, indexPath }: DocBridgeContextProviderOptions) => ContextProvider;
 
-declare const BENCHMARK_SCHEMA_VERSION: 1;
-type BenchmarkObservationStatus = 'passed' | 'failed' | 'blocked' | 'not-run';
-type BenchmarkImprovementDirection = 'improved' | 'regressed' | 'unchanged' | 'unavailable';
-type BenchmarkConfidence = 'insufficient' | 'directional' | 'reliable';
-interface BenchmarkPolicy {
-    readonly minComparableTasks: number;
-    readonly maxDurationRegressionRate: number;
-    readonly minCompletedRunsPerTask: number;
-    readonly minBaselineSamplesPerTask: number;
-    readonly requireZeroEscapedIncomplete: boolean;
-}
-interface BenchmarkQualityGate {
-    readonly status: 'passed' | 'failed' | 'insufficient-data';
-    readonly confidence: BenchmarkConfidence;
-    readonly comparableTaskCount: number;
-    readonly policy: BenchmarkPolicy;
-    readonly durationRegressionTaskIds: readonly string[];
-    readonly escapedIncompleteTaskIds: readonly string[];
+interface DiscoveryOption {
+    readonly id: string;
+    readonly summary: string;
+    readonly impact: string;
+}
+interface DiscoveryAmbiguity {
+    readonly id: string;
+    readonly question: string;
+    readonly material: boolean;
+    readonly options: readonly DiscoveryOption[];
+    readonly recommendedOptionId: string;
+    readonly assumptionId?: string;
+}
+interface ApprovedAssumption {
+    readonly id: string;
+    readonly policyId: string;
+    readonly resolution: string;
+}
+interface DiscoveryInput {
+    readonly issueId: string;
+    readonly sourceRevision: string;
+    readonly contractHash: string;
+    readonly contextHash?: string;
+    readonly ambiguities: readonly DiscoveryAmbiguity[];
+    readonly approvedAssumptions?: readonly ApprovedAssumption[];
+}
+interface DecisionPacket {
+    readonly issueId: string;
+    readonly contractHash: string;
+    readonly sourceRevision: string;
+    readonly contextHash?: string;
+    readonly decisions: readonly {
+        readonly id: string;
+        readonly question: string;
+        readonly options: readonly DiscoveryOption[];
+        readonly recommendedOptionId: string;
+    }[];
+}
+interface DiscoveryDecisionLogEntry {
+    readonly ambiguityId: string;
+    readonly kind: 'human-decision-required' | 'approved-assumption';
+    readonly detail: string;
+    readonly policyId?: string;
+}
+interface DiscoveryResult {
+    readonly version: 1;
+    readonly issueId: string;
+    readonly sourceRevision: string;
+    readonly contractHash: string;
+    readonly contextHash?: string;
+    readonly status: 'ready' | 'awaiting-decision';
+    readonly packet?: DecisionPacket;
+    readonly decisionLog: readonly DiscoveryDecisionLogEntry[];
+    readonly digest: string;
+}
+interface DiscoveryCurrentInput {
+    readonly sourceRevision: string;
+    readonly contractHash: string;
+    readonly contextHash?: string;
+}
+interface DiscoveryCurrentResult {
+    readonly current: boolean;
+    readonly reasons: readonly ('source' | 'contract' | 'context')[];
+}
+declare const assessDiscovery: (input: DiscoveryInput) => DiscoveryResult;
+declare const isDiscoveryCurrent: (result: DiscoveryResult, current: DiscoveryCurrentInput) => DiscoveryCurrentResult;
+
+declare const WIP_STATES: readonly ["ready", "implementing", "blocked", "awaiting-decision", "awaiting-acceptance", "done", "cancelled"];
+type WipState = typeof WIP_STATES[number];
+interface WipEntry {
+    readonly issueId: string;
+    readonly state: WipState;
+}
+interface WipAssessmentInput {
+    readonly entries: readonly WipEntry[];
+    readonly candidate: {
+        readonly issueId: string;
+        readonly kind: 'new' | 'resume';
+    };
+    readonly maxInFlight?: number;
+}
+interface WipAssessment {
+    readonly decision: 'admit' | 'hold';
+    readonly inFlight: readonly WipEntry[];
+    readonly counts: Readonly<Record<WipState, number>>;
+    readonly reason: string;
+}
+declare const assessWip: ({ entries, candidate, maxInFlight }: WipAssessmentInput) => WipAssessment;
+
+interface RuntimeExperimentCandidate {
+    readonly runtime: string;
+    readonly sourceRevision: string;
+    readonly contractHash: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly configurationHash: string;
+    readonly hardGatesPassed: boolean;
+    readonly humanMinutes: number;
+    readonly durationMs: number;
+    readonly cost: number;
+}
+interface RuntimeExperimentResult {
+    readonly decision: 'selected' | 'blocked';
+    readonly selected?: RuntimeExperimentCandidate;
+    readonly eligible: readonly RuntimeExperimentCandidate[];
+    readonly reason: string;
+}
+declare const selectRuntime: (candidates: readonly RuntimeExperimentCandidate[]) => RuntimeExperimentResult;
+
+interface ReviewLens {
+    readonly id: string;
+    readonly maxAttempts?: number;
+}
+interface ReviewVerdict {
+    readonly status: 'pass' | 'finding' | 'unverified';
+    readonly reason?: string;
+    readonly evidence?: string;
+    readonly reproduction?: string;
+    readonly retryable?: boolean;
+}
+interface AdversarialReviewResult {
+    readonly decision: 'approved' | 'blocked';
+    readonly verdicts: Readonly<Record<string, ReviewVerdict>>;
     readonly reasons: readonly string[];
+    readonly binding: GateBinding;
+    readonly digest: string;
+    readonly peakConcurrency: number;
+}
+declare const runAdversarialReview: ({ lenses, reviewer, binding, maxConcurrency }: {
+    readonly lenses: readonly ReviewLens[];
+    readonly reviewer: (lens: ReviewLens, attempt: number) => Promise<ReviewVerdict> | ReviewVerdict;
+    readonly binding: GateBinding;
+    readonly maxConcurrency?: number;
+}) => Promise<AdversarialReviewResult>;
+
+type CriterionStatus = 'passed' | 'failed' | 'pending' | 'not-applicable';
+interface GateCriterion {
+    readonly id: string;
+    readonly gate: 'G2' | 'G3' | 'G4' | 'G5';
+    readonly status: CriterionStatus;
+    readonly reason?: string;
 }
-interface BenchmarkTask {
+interface GateBinding {
+    readonly candidateRevision: string;
+    readonly contractHash: string;
+    readonly configHash: string;
+}
+interface GateAssessment {
+    readonly gate: 'G2' | 'G3' | 'G4' | 'G5';
+    readonly decision: 'approved' | 'blocked' | 'awaiting-acceptance';
+    readonly reasons: readonly string[];
+    readonly binding: GateBinding;
+    readonly digest: string;
+}
+declare const assessPreflight: ({ criteria, repairAttempts, implementerId, reviewerId, reviewKind, reviewApproved, binding: current }: {
+    readonly criteria: readonly GateCriterion[];
+    readonly repairAttempts?: number;
+    readonly implementerId: string;
+    readonly reviewerId?: string;
+    readonly reviewKind?: "adversarial";
+    readonly reviewApproved: boolean;
+    readonly binding: GateBinding;
+}) => GateAssessment;
+interface PullRequestDraft {
+    readonly issueId: string;
+    readonly candidateRevision: string;
+    readonly contractHash: string;
+    readonly configHash: string;
+    readonly g2Digest: string;
+    readonly evidence: readonly string[];
+    readonly documentation: readonly string[];
+    readonly risk: string;
+    readonly rollback: string;
+    readonly pendingCriteria: readonly string[];
+}
+declare const composePullRequest: ({ draft, g2, remote }: {
+    readonly draft: PullRequestDraft;
+    readonly g2: GateAssessment;
+    readonly remote?: {
+        readonly state: "missing" | "confirmed" | "uncertain";
+        readonly url?: string;
+        readonly candidateRevision?: string;
+    };
+}) => {
+    readonly decision: "create" | "reuse" | "blocked";
+    readonly body?: string;
+    readonly reason: string;
+    readonly idempotencyKey: string;
+};
+interface PullRequestApproval {
+    readonly approvedBy: 'human';
+    readonly candidateRevision: string;
+    readonly contractHash: string;
+    readonly configHash: string;
+    readonly bodyHash: string;
+    readonly metadataHash: string;
+    readonly digest: string;
+}
+declare const createPullRequestApproval: ({ body, metadata, approvedBy, candidateRevision, contractHash, configHash }: {
+    readonly body: string;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly approvedBy: "human";
+    readonly candidateRevision: string;
+    readonly contractHash: string;
+    readonly configHash: string;
+}) => PullRequestApproval;
+declare const verifyPullRequestApproval: ({ approval, body, metadata, candidateRevision, contractHash, configHash }: {
+    readonly approval: PullRequestApproval;
+    readonly body: string;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly candidateRevision: string;
+    readonly contractHash: string;
+    readonly configHash: string;
+}) => PullRequestApproval;
+interface QaTransitionAssessment {
+    readonly decision: 'move-to-qa' | 'return-to-verification' | 'blocked';
+    readonly target: 'qa' | 'verification';
+    readonly invalidatesDownstream: boolean;
+    readonly reason: string;
+    readonly idempotencyKey: string;
+}
+declare const assessQaTransition: ({ featureValidated, g5, qaPassed, issue }: {
+    readonly featureValidated: boolean;
+    readonly g5: GateAssessment;
+    readonly qaPassed: boolean;
+    readonly issue: string;
+}) => QaTransitionAssessment;
+declare const assessIntegration: ({ g2, candidateRevision, evidenceRevision, contractHash, configHash, ci }: {
+    readonly g2: GateAssessment;
+    readonly candidateRevision: string;
+    readonly evidenceRevision: string;
+    readonly contractHash: string;
+    readonly configHash: string;
+    readonly ci: CriterionStatus;
+}) => GateAssessment;
+declare const assessWorktreeCleanup: ({ branch, candidateRevision, contractHash, configHash, remoteBranchRevision, remotePr, integration }: {
+    readonly branch: string;
+    readonly candidateRevision: string;
+    readonly contractHash: string;
+    readonly configHash: string;
+    readonly remoteBranchRevision?: string;
+    readonly remotePr: "confirmed" | "missing" | "uncertain";
+    readonly integration: GateAssessment;
+}) => {
+    readonly decision: "clean" | "preserve";
+    readonly reason: string;
+};
+interface RepositoryProfile {
+    readonly deploy: string;
+    readonly rollback: string;
+    readonly urls: readonly string[];
+    readonly featureFlag: string;
+    readonly syntheticTenant: string;
+    readonly observability: readonly string[];
+    readonly sensitivePaths: readonly string[];
+    readonly owners: readonly string[];
+    readonly approvedBy: string;
+}
+interface ProductionEvidence {
+    readonly tenant: string;
+    readonly realFlow: string;
+    readonly logs: readonly string[];
+    readonly metrics: readonly string[];
+}
+declare const assessProduction: ({ profile, integration, artifact, isolated, acceptanceArtifact, lowRisk, observationMinutes, technicalPassed, evidence, containmentPreauthorized, containmentAction, linkedDefect }: {
+    readonly profile: RepositoryProfile;
+    readonly integration: GateAssessment;
+    readonly artifact: string;
+    readonly isolated: boolean;
+    readonly acceptanceArtifact?: string;
+    readonly lowRisk?: boolean;
+    readonly observationMinutes: number;
+    readonly technicalPassed: boolean;
+    readonly evidence: ProductionEvidence;
+    readonly containmentPreauthorized: boolean;
+    readonly containmentAction?: string;
+    readonly linkedDefect?: string;
+}) => GateAssessment;
+declare const assessAcceptance: ({ production, acceptanceRequired, accepted, notApplicableReason, materialChange }: {
+    readonly production: GateAssessment;
+    readonly acceptanceRequired: boolean;
+    readonly accepted: boolean;
+    readonly notApplicableReason?: string;
+    readonly materialChange: boolean;
+}) => GateAssessment;
+
+interface PilotEntry {
+    readonly issueId: string;
+    readonly classification: 'normal' | 'incident' | 'sensitive';
+    readonly status: 'included' | 'excluded' | 'aborted';
+    readonly reason?: string;
+}
+interface PilotManifest {
+    readonly policyHash: string;
+    readonly baselineReference: string;
+    readonly entries: readonly PilotEntry[];
+}
+interface PilotAssessment {
+    readonly decision: 'ready' | 'blocked';
+    readonly included: readonly string[];
+    readonly reasons: readonly string[];
+    readonly digest: string;
+}
+declare const assessPilot: (manifest: PilotManifest) => PilotAssessment;
+
+declare const IMPROVEMENT_CYCLE_STEPS: readonly ["adversarial-review", "g2-preflight", "baseline-record", "pilot-execution", "comparison"];
+type ImprovementCycleStep = typeof IMPROVEMENT_CYCLE_STEPS[number];
+type CycleStepStatus = 'passed' | 'failed' | 'blocked' | 'pending';
+interface CycleStepResult {
+    readonly step: ImprovementCycleStep;
+    readonly status: CycleStepStatus;
+    readonly reason?: string;
+}
+interface CycleIterationMetrics {
+    readonly durationMs?: number;
+    readonly humanMinutes?: number;
+    readonly attempts?: number;
+    readonly escapedIncomplete?: number;
+}
+interface ImprovementCycleIteration {
+    readonly iteration: number;
+    readonly steps: readonly CycleStepResult[];
+    readonly adjustment?: string;
+    readonly metrics?: CycleIterationMetrics;
+}
+interface ImprovementCycleInput {
+    readonly cycleId: string;
+    readonly maxIterations: number;
+    readonly iterations: readonly ImprovementCycleIteration[];
+}
+interface CycleMatrixRow {
+    readonly iteration: number;
+    readonly passedSteps: number;
+    readonly totalSteps: number;
+    readonly passRate: number;
+    readonly statuses: Readonly<Record<ImprovementCycleStep, CycleStepStatus>>;
+    readonly adjustment?: string;
+    readonly metrics?: CycleIterationMetrics;
+}
+interface ImprovementCycleAssessment {
+    readonly type: 'agentskit-harness-improvement-cycle';
+    readonly cycleId: string;
+    readonly decision: 'complete' | 'repeat' | 'blocked';
+    readonly nextIteration?: number;
+    readonly reasons: readonly string[];
+    readonly matrix: readonly CycleMatrixRow[];
+    readonly digest: string;
+}
+declare const assessImprovementCycle: (input: ImprovementCycleInput) => ImprovementCycleAssessment;
+
+type EvalExpectation = string | ((output: string) => boolean);
+interface AgentEvalCase {
     readonly id: string;
-    readonly title: string;
-    readonly acceptanceCriteria: readonly string[];
-    /** Product/runtime surfaces exercised by the task. */
-    readonly surfaces?: readonly SurfaceName[];
-    readonly kind?: string;
-    readonly prompt?: BenchmarkTaskFile;
-    readonly source?: BenchmarkTaskSource;
-    readonly scope?: BenchmarkTaskScope;
-}
-interface BenchmarkTaskFile {
-    readonly path: string;
-    readonly sha256: string;
+    readonly input: string;
+    readonly expected: EvalExpectation;
 }
-interface BenchmarkTaskSource {
-    readonly repository: string;
-    readonly path: string;
-    readonly revision: string;
+interface AgentEvalSuite {
+    readonly name: string;
+    readonly cases: readonly AgentEvalCase[];
+}
+interface AgentEvalReport {
+    readonly suite: string;
+    readonly total: number;
+    readonly passed: number;
+    readonly failed: number;
+    readonly accuracy: number;
+    readonly failures: readonly string[];
+}
+declare const EVAL_MANIFEST_SCHEMA_VERSION: 1;
+declare const EVAL_LAYERS: readonly ["contract", "deterministic", "integration", "quality", "regression", "resource"];
+declare const EVAL_COMPONENTS: readonly ["core", "workflow", "memory", "cache", "doc-bridge", "agent-model", "orca-worktree", "runtime", "code-review", "github-linear", "eval-metrics"];
+type EvalLayer = typeof EVAL_LAYERS[number];
+type EvalComponent = typeof EVAL_COMPONENTS[number];
+type EvalObservationStatus = 'passed' | 'failed' | 'unknown' | 'stale' | 'unverified';
+interface EvalCaseDefinition {
+    readonly id: string;
+    readonly layer: EvalLayer;
+    readonly components: readonly EvalComponent[];
+    readonly grader: string;
+    readonly input: string;
+    readonly critical?: boolean;
+    readonly subjective?: boolean;
+    readonly baselineScore?: number;
+}
+interface EvalManifest {
+    readonly type: 'agentskit-harness-eval-manifest';
+    readonly schemaVersion: typeof EVAL_MANIFEST_SCHEMA_VERSION;
+    readonly suiteId: string;
+    readonly name: string;
+    readonly cases: readonly EvalCaseDefinition[];
+    readonly graders: readonly string[];
+    readonly thresholds: {
+        readonly subjectiveQuality: number;
+        readonly maxRegression: number;
+    };
+    readonly repetitions: number;
+    readonly provider: string;
+    readonly model: string;
+    readonly promptHash: string;
+    readonly toolHash: string;
+    readonly evidenceOutputs: readonly string[];
+    readonly digest: string;
+}
+interface EvalObservation {
+    readonly status: EvalObservationStatus;
+    readonly score?: number;
+    readonly evidence?: string;
+    readonly decision?: string;
+}
+interface EvalCaseReport {
+    readonly id: string;
+    readonly repetitions: number;
+    readonly min: number | null;
+    readonly median: number | null;
+    readonly max: number | null;
+    readonly statuses: readonly EvalObservationStatus[];
+    readonly blockers: readonly string[];
+}
+interface EvalBatteryReport {
+    readonly suiteId: string;
+    readonly repetitions: number;
+    readonly cases: readonly EvalCaseReport[];
+    readonly status: 'passed' | 'blocked';
+    readonly blockers: readonly string[];
+}
+declare const createEvalManifest: (input: Omit<EvalManifest, "type" | "schemaVersion" | "digest">) => EvalManifest;
+declare const validateEvalManifest: (value: unknown) => EvalManifest;
+declare const runEvalBattery: ({ manifest, evaluate }: {
+    readonly manifest: EvalManifest;
+    readonly evaluate: (testCase: EvalCaseDefinition, repetition: number) => Promise<EvalObservation>;
+}) => Promise<EvalBatteryReport>;
+declare const runAgentEval: ({ suite, agent, concurrency }: {
+    readonly suite: AgentEvalSuite;
+    readonly agent: (input: string) => Promise<string>;
+    readonly concurrency?: number;
+}) => Promise<AgentEvalReport>;
+declare const assessAgentEval: (report: AgentEvalReport, minimumAccuracy: number) => {
+    readonly status: "passed" | "blocked";
+    readonly reason: string;
+    readonly report: AgentEvalReport;
+};
+
+interface LlmCacheKeyInput {
+    readonly sourceRevision: string;
+    readonly contractHash: string;
+    readonly configHash: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly systemPromptHash: string;
+    readonly inputHash: string;
+    readonly contextHash?: string;
+    readonly toolSchemaHash?: string;
+    readonly operation: 'context' | 'read-only';
+}
+interface LlmCacheStats {
+    readonly hits: number;
+    readonly misses: number;
+    readonly invalidations: number;
+}
+declare const validateCacheableOperation: (operation: unknown) => "context" | "read-only";
+declare const createLlmCacheKey: (input: LlmCacheKeyInput) => string;
+interface LlmCache<T> {
+    readonly assurance?: AssuranceLevel;
+    readonly telemetry?: () => AdapterTelemetry;
+    getOrCompute(key: string, compute: () => Promise<T>): Promise<T>;
+    invalidate(key?: string): void;
+    stats(): LlmCacheStats;
+}
+declare const createLlmCache: <T>() => LlmCache<T>;
+
+interface TokenUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly totalTokens: number;
+    readonly cacheReadTokens?: number;
+    readonly cacheWriteTokens?: number;
+}
+interface MemoryUsage {
+    readonly reads: number;
+    readonly writes: number;
+    readonly relevantHits: number;
+    readonly staleHits: number;
+}
+interface CacheUsage {
+    readonly hits: number;
+    readonly misses: number;
+    readonly invalidations: number;
+    readonly tokensSaved?: number;
+}
+interface ParallelismUsage {
+    readonly tasks: number;
+    readonly peakConcurrency: number;
+    readonly criticalPathMs: number;
+    readonly queueWaitMs?: number;
+}
+interface OptimizationObservation {
+    readonly sourceRevision: string;
+    readonly contractHash: string;
+    readonly configHash: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly durationMs: number;
+    readonly accuracy?: number;
+    readonly tokens?: TokenUsage;
+    readonly memory?: MemoryUsage;
+    readonly cache?: CacheUsage;
+    readonly parallelism?: ParallelismUsage;
+}
+declare const validateOptimizationObservation: (observation: OptimizationObservation) => OptimizationObservation;
+interface OptimizationComparison {
+    readonly comparable: boolean;
+    readonly reason: string;
+    readonly digest: string;
+    readonly durationDeltaMs?: number;
+    readonly tokenDelta?: number;
+    readonly accuracyDelta?: number;
+    readonly cacheHitRateDelta?: number;
+    readonly memoryRelevantHitRateDelta?: number;
+    readonly peakConcurrencyDelta?: number;
 }
-interface BenchmarkSuiteSource {
-    readonly repository: string;
+declare const compareOptimization: (baseline: OptimizationObservation, candidate: OptimizationObservation) => OptimizationComparison;
+
+declare const MEMORY_SCOPES: readonly ["issue", "project", "global"];
+type MemoryScope = typeof MEMORY_SCOPES[number];
+interface AgentMemoryRecord {
+    readonly id: string;
+    readonly scope: MemoryScope;
+    readonly summary: string;
+    readonly source: string;
+    readonly sourceRevision: string;
+    readonly contentHash: string;
+    readonly approved: true;
+}
+interface AgentMemoryHit {
+    readonly record: AgentMemoryRecord;
+    readonly relevant: boolean;
+    readonly stale: boolean;
+}
+interface AgentMemoryAdapter {
+    readonly id: string;
+    readonly version: string;
+    readonly assurance?: AssuranceLevel;
+    readonly telemetry?: () => AdapterTelemetry;
+    remember(record: AgentMemoryRecord): Promise<void>;
+    recall(input: {
+        readonly query: string;
+        readonly issueId?: string;
+        readonly project?: string;
+        readonly sourceRevision?: string;
+    }): Promise<readonly AgentMemoryHit[]>;
+}
+interface AgentMemoryKvStore {
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+}
+declare const validateMemoryRecord: (record: AgentMemoryRecord) => AgentMemoryRecord;
+/** Minimal deterministic adapter for replay/tests; production uses @agentskit/memory through the same seam. */
+declare const createInMemoryMemoryAdapter: (options?: {
+    readonly id?: string;
+    readonly version?: string;
+}) => AgentMemoryAdapter;
+/** Bridges AgentsKit's KV memory stores without making the Harness depend on a backend. */
+declare const createKvMemoryAdapter: (store: AgentMemoryKvStore, options?: {
+    readonly id?: string;
+    readonly version?: string;
+}) => AgentMemoryAdapter;
+
+interface WorkflowNode<T> {
+    readonly id: string;
+    readonly dependsOn?: readonly string[];
+    /** Nodes sharing a mutation key are serialized even when otherwise independent. */
+    readonly mutationKey?: string;
+    readonly run: () => Promise<T>;
+}
+interface WorkflowResult<T> {
+    readonly results: Readonly<Record<string, T>>;
+    readonly order: readonly string[];
+    readonly peakConcurrency: number;
+    readonly criticalPathMs: number;
+}
+declare const runWorkflow: <T>(nodes: readonly WorkflowNode<T>[], options: {
+    readonly maxConcurrency: number;
+    readonly currentConcurrency?: () => number;
+}) => Promise<WorkflowResult<T>>;
+
+declare const PHASE_MODES: readonly ["safe", "yolo", "dry-run"];
+type PhaseMode = typeof PHASE_MODES[number];
+declare const PHASE_EFFECTS: readonly ["read", "write", "external"];
+type PhaseEffect = typeof PHASE_EFFECTS[number];
+declare const PHASE_EFFECT_ACTIONS: readonly ["allow", "preview", "block", "escalate"];
+type PhaseEffectAction = typeof PHASE_EFFECT_ACTIONS[number];
+declare const PHASE_DECISIONS: readonly ["pass", "block", "escalate", "retry", "cancel", "resume"];
+type PhaseDecision = typeof PHASE_DECISIONS[number];
+interface PhaseRetryPolicy {
+    readonly maxAttempts: number;
+}
+interface PhaseDefinition {
+    readonly id: string;
+    readonly inputs?: readonly string[];
+    readonly outputs?: readonly string[];
+    readonly dependsOn?: readonly string[];
+    readonly gates?: readonly string[];
+    readonly retries?: PhaseRetryPolicy;
+    readonly budgetMs?: number;
+    readonly effect: PhaseEffect;
+}
+interface PhaseEffectPolicy {
+    readonly read: PhaseEffectAction;
+    readonly write: PhaseEffectAction;
+    readonly external: PhaseEffectAction;
+}
+interface PhaseProfile {
+    readonly id: string;
+    readonly mode: PhaseMode;
+    readonly phases: readonly PhaseDefinition[];
+    readonly effectPolicy?: Partial<PhaseEffectPolicy>;
+    readonly maxConcurrency?: number;
+    readonly budgetMs?: number;
+}
+interface NormalizedPhaseProfile extends Omit<PhaseProfile, 'effectPolicy' | 'maxConcurrency'> {
+    readonly effectPolicy: PhaseEffectPolicy;
+    readonly maxConcurrency: number;
+}
+interface PhaseRoutePlan {
+    readonly profileId: string;
+    readonly mode: PhaseMode;
+    readonly levels: readonly (readonly string[])[];
+    readonly phases: readonly PhaseDefinition[];
+    readonly effectPolicy: PhaseEffectPolicy;
+    readonly maxConcurrency: number;
+    readonly budgetMs?: number;
+}
+interface PhaseAmbiguity {
+    readonly id: string;
+    readonly question: string;
+    readonly options?: readonly string[];
+    readonly suggestion?: string;
+}
+interface PhaseDecisionPacket {
+    readonly id: 'phase-preflight';
+    readonly phaseIds: readonly string[];
+    readonly ambiguities: readonly PhaseAmbiguity[];
+}
+interface PhaseContext {
+    readonly phase: PhaseDefinition;
+    readonly attempt: number;
+    readonly mode: PhaseMode;
+    readonly inputs: Readonly<Record<string, unknown>>;
+    readonly outputs: Readonly<Record<string, unknown>>;
+    readonly dryRun: boolean;
+}
+interface PhaseHandlerResult {
+    readonly decision: PhaseDecision;
+    readonly outputs?: Readonly<Record<string, unknown>>;
+    readonly reason?: string;
+}
+type PhaseHandler = (context: PhaseContext) => PhaseHandlerResult | Promise<PhaseHandlerResult>;
+type PhaseGateResult = boolean | {
+    readonly decision: Exclude<PhaseDecision, 'retry' | 'cancel' | 'resume' | 'pass'> | 'pass';
+    readonly reason?: string;
+};
+type PhaseGateEvaluator = (context: PhaseContext) => PhaseGateResult | Promise<PhaseGateResult>;
+interface PhasePreflightResult {
+    readonly decision?: 'pass' | 'block' | 'escalate';
+    readonly reason?: string;
+    readonly ambiguities?: readonly PhaseAmbiguity[];
+}
+type PhasePreflight = (context: PhaseContext) => PhasePreflightResult | Promise<PhasePreflightResult>;
+interface PhaseExecution {
+    readonly id: string;
+    readonly effect: PhaseEffect;
+    readonly decision: PhaseDecision;
+    readonly attempts: number;
+    readonly skipped: boolean;
+    readonly reason?: string;
+    readonly outputs?: Readonly<Record<string, unknown>>;
+}
+interface PhaseResumeState {
+    readonly completed: Readonly<Record<string, Pick<PhaseExecution, 'decision' | 'outputs'>>>;
+    readonly outputs?: Readonly<Record<string, unknown>>;
+}
+interface ExecutePhaseProfileOptions {
+    readonly inputs?: Readonly<Record<string, unknown>>;
+    readonly handlers?: Readonly<Record<string, PhaseHandler>>;
+    readonly gates?: Readonly<Record<string, PhaseGateEvaluator>>;
+    readonly preflight?: PhasePreflight;
+    readonly resume?: PhaseResumeState;
+    readonly now?: () => number;
+}
+interface PhaseExecutionReport {
+    readonly status: 'passed' | 'blocked' | 'escalated' | 'cancelled' | 'dry-run';
+    readonly plan: PhaseRoutePlan;
+    readonly phases: readonly PhaseExecution[];
+    readonly order: readonly string[];
+    readonly outputs: Readonly<Record<string, unknown>>;
+    readonly resumed: boolean;
+    readonly decisionPacket?: PhaseDecisionPacket;
+    readonly durationMs: number;
+}
+declare const createPhaseProfile: (profile: PhaseProfile) => NormalizedPhaseProfile;
+declare const planPhaseProfile: (profile: PhaseProfile) => PhaseRoutePlan;
+declare const executePhaseProfile: (profile: PhaseProfile, options?: ExecutePhaseProfileOptions) => Promise<PhaseExecutionReport>;
+
+declare const ARTIFACT_SCHEMA_VERSION: 1;
+declare const ARTIFACT_TYPES: readonly ["plan", "finding", "decision", "repair", "blocker", "approval", "phase"];
+type ArtifactType = typeof ARTIFACT_TYPES[number];
+interface ArtifactEnvelope<T = unknown> {
+    readonly type: 'agentskit-harness-artifact';
+    readonly schemaVersion: typeof ARTIFACT_SCHEMA_VERSION;
+    readonly artifactId: string;
+    readonly artifactType: ArtifactType;
+    readonly artifactVersion: number;
+    readonly runId: string;
+    readonly issueRef: string;
+    readonly sourceRevision: string;
+    readonly contractHash: string;
+    readonly configHash: string;
+    readonly contextHash: string;
+    readonly phase: string;
+    readonly createdAt: string;
+    readonly payload: T;
+    readonly payloadHash: string;
+    readonly artifactHash: string;
+}
+type ArtifactEnvelopeInput<T = unknown> = Omit<ArtifactEnvelope<T>, 'type' | 'schemaVersion' | 'artifactId' | 'createdAt' | 'payloadHash' | 'artifactHash'> & {
+    readonly artifactId?: string;
+    readonly createdAt?: string;
+    readonly payloadHash?: string;
+    readonly artifactHash?: string;
+};
+interface ArtifactBinding {
+    readonly runId: string;
+    readonly issueRef: string;
+    readonly sourceRevision: string;
+    readonly contractHash: string;
+    readonly configHash: string;
+    readonly contextHash: string;
+    readonly phase?: string;
+}
+declare const validateArtifactEnvelope: <T = unknown>(value: unknown) => ArtifactEnvelope<T>;
+declare const createArtifactEnvelope: <T>(input: ArtifactEnvelopeInput<T>) => ArtifactEnvelope<T>;
+declare const renderArtifactMarkdown: (artifact: ArtifactEnvelope) => string;
+declare const artifactFilePath: (stateDir: string, runId: string, id: string) => string;
+declare const artifactMarkdownPath: (stateDir: string, runId: string, id: string) => string;
+declare class FileArtifactStore {
+    private readonly stateDir;
+    constructor(stateDir: string);
+    write<T>(input: ArtifactEnvelope<T>): ArtifactEnvelope<T>;
+    read<T = unknown>(runId: string, id: string): ArtifactEnvelope<T>;
+    list(runId: string): readonly ArtifactEnvelope[];
+}
+declare const artifactIsFresh: (artifact: ArtifactEnvelope, binding: ArtifactBinding) => boolean;
+declare const resumeStateFromArtifacts: (artifacts: readonly ArtifactEnvelope[]) => PhaseResumeState;
+declare const createPhaseArtifact: (base: Omit<ArtifactEnvelopeInput, "artifactType" | "phase" | "payload">, execution: PhaseExecution) => ArtifactEnvelope;
+declare const readArtifactFile: (path: string) => ArtifactEnvelope;
+declare const artifactDigest: (artifact: ArtifactEnvelope) => string;
+
+declare const QUALITY_DIMENSIONS: readonly ["correctness", "completeness", "speed", "cost", "resource", "reliability"];
+type QualityDimension = typeof QUALITY_DIMENSIONS[number];
+type MetricStatus = 'measured' | 'unknown';
+interface PhaseTokenMetrics {
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly cacheReadTokens?: number;
+    readonly cacheWriteTokens?: number;
+    readonly costUsd?: number;
+}
+interface PhaseMachineMetrics {
+    readonly cpuPercent?: number;
+    readonly memoryUsedPercent?: number;
+    readonly peakConcurrency?: number;
+    readonly queueWaitMs?: number;
+    readonly contentionMs?: number;
+    readonly saturationPercent?: number;
+}
+interface PhaseTelemetry {
+    readonly phaseId: string;
+    readonly durationMs?: number;
+    readonly attempts?: number;
+    readonly outcome: 'pass' | 'block' | 'escalate' | 'cancel' | 'unknown';
+    readonly failureClass?: string;
+    readonly evidenceCoverage?: number;
+    readonly tokens?: PhaseTokenMetrics;
+    readonly machine?: PhaseMachineMetrics;
+}
+interface QualityDimensionScore {
+    readonly score: number | null;
+    readonly status: MetricStatus;
+    readonly baselineDelta: number | null;
+    readonly source: string;
+}
+interface QualityMatrix {
+    readonly type: 'agentskit-harness-quality-matrix';
+    readonly schemaVersion: 1;
+    readonly dimensions: Readonly<Record<QualityDimension, QualityDimensionScore>>;
+    readonly overall: QualityDimensionScore;
+    readonly phaseCount: number;
+    readonly unknownMetricCount: number;
+    readonly blockers: readonly WatchdogBlocker[];
+    readonly digest: string;
+}
+interface WatchdogBudget {
+    readonly maxDurationMs?: number;
+    readonly maxTotalTokens?: number;
+    readonly maxMemoryUsedPercent?: number;
+    readonly maxSaturationPercent?: number;
+}
+interface WatchdogBlocker {
+    readonly class: 'budget' | 'resource' | 'contention';
+    readonly reason: string;
+    readonly phaseId?: string;
+}
+interface WatchdogResult {
+    readonly status: 'ok' | 'blocked';
+    readonly blockers: readonly WatchdogBlocker[];
+}
+declare const validatePhaseTelemetry: (value: unknown) => PhaseTelemetry;
+declare const evaluateWatchdog: ({ phases, budget }: {
+    readonly phases: readonly PhaseTelemetry[];
+    readonly budget: WatchdogBudget;
+}) => WatchdogResult;
+declare const createQualityMatrix: ({ phases, baseline, budget }: {
+    readonly phases: readonly PhaseTelemetry[];
+    readonly baseline?: readonly PhaseTelemetry[];
+    readonly budget?: WatchdogBudget;
+}) => QualityMatrix;
+
+declare const COMPATIBILITY_SCHEMA_VERSION: 1;
+declare const COMPATIBILITY_COMPONENTS: readonly ["core", "memory", "eval", "doc-bridge", "code-review", "adapter-boundary", "runtime"];
+type CompatibilityComponentId = typeof COMPATIBILITY_COMPONENTS[number];
+type CompatibilityStatus = 'passed' | 'failed' | 'unknown';
+interface CompatibilityComponent {
+    readonly id: CompatibilityComponentId;
+    readonly package: string;
+    readonly version: string;
     readonly revision: string;
-    readonly taskDefinition: string;
+    readonly repository: string;
+    readonly adapterBoundary: 'real-adapter';
+    readonly testCommand: string;
+    readonly evalCommand: string;
+    readonly previousVersion: string;
+    readonly noHarnessBaseline: string;
+    readonly migrationEvidence: string;
+    readonly rollbackEvidence: string;
+}
+interface CompatibilityManifest {
+    readonly type: 'agentskit-harness-compatibility-manifest';
+    readonly schemaVersion: typeof COMPATIBILITY_SCHEMA_VERSION;
+    readonly harnessVersion: string;
+    readonly sourceRevision: string;
+    readonly components: readonly CompatibilityComponent[];
+    readonly evidenceOutputs: readonly string[];
+    readonly digest: string;
+}
+interface CompatibilityObservation {
+    readonly componentId: CompatibilityComponentId;
+    readonly status: CompatibilityStatus;
+    readonly evidence?: string;
+    readonly previousVersion?: string;
+    readonly noHarnessBaseline?: string;
+}
+interface CompatibilityReport {
+    readonly status: 'passed' | 'blocked';
+    readonly componentCount: number;
+    readonly observations: readonly CompatibilityObservation[];
+    readonly blockers: readonly string[];
+}
+declare const createCompatibilityManifest: (input: Omit<CompatibilityManifest, "type" | "schemaVersion" | "digest">) => CompatibilityManifest;
+declare const validateCompatibilityManifest: (value: unknown) => CompatibilityManifest;
+declare const assessCompatibility: ({ manifest, observations }: {
+    readonly manifest: CompatibilityManifest;
+    readonly observations: readonly CompatibilityObservation[];
+}) => CompatibilityReport;
+
+type FailureClass = 'quota' | 'timeout' | 'policy' | 'validation' | 'external' | 'unknown';
+interface FailureClassification {
+    readonly class: FailureClass;
+    readonly retryable: boolean;
+    readonly reason: string;
+}
+interface RecoveryPolicy {
+    readonly maxAttempts: number;
+    readonly baseDelayMs: number;
+    readonly maxDelayMs: number;
+    readonly timeoutMs?: number;
+}
+interface RecoveryObservation {
+    readonly attempt: number;
+    readonly failure: FailureClassification;
+    readonly delayMs: number;
+}
+interface RecoveryResult<T> {
+    readonly value?: T;
+    readonly status: 'completed' | 'failed';
+    readonly attempts: number;
+    readonly observations: readonly RecoveryObservation[];
+    readonly failure?: FailureClassification;
+}
+declare const classifyFailure: (error: unknown) => FailureClassification;
+declare const recoveryDelayMs: (attempt: number, policy: Pick<RecoveryPolicy, "baseDelayMs" | "maxDelayMs">) => number;
+declare const runWithRecovery: <T>(operation: (signal: AbortSignal, attempt: number) => Promise<T>, options: RecoveryPolicy & {
+    readonly sleep?: (delayMs: number) => Promise<void>;
+    readonly onObservation?: (observation: RecoveryObservation) => void;
+}) => Promise<RecoveryResult<T>>;
+
+interface CodingAgentRequest {
+    readonly issueRef: string;
+    readonly prompt: string;
+    readonly sourceRevision: string;
+    readonly contextHash?: string;
+    readonly signal: AbortSignal;
 }
-interface BenchmarkTaskScope {
-    readonly read: readonly string[];
-    readonly write: readonly string[];
+interface AgentUsage {
+    readonly status: 'measured' | 'unknown';
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly totalTokens?: number;
+}
+interface CodingAgentResult {
+    readonly status: 'completed' | 'failed' | 'timeout' | 'cancelled';
+    readonly output: Readonly<Record<string, unknown>>;
+    readonly diff: string;
+    readonly usage: AgentUsage;
+    readonly durationMs: number;
+    readonly failure?: FailureClassification;
+    readonly metadata: AdapterMetadata;
+}
+interface CodingAgentHandlerResult {
+    readonly output: Readonly<Record<string, unknown>>;
+    readonly diff: string;
+    readonly usage?: AgentUsage;
+}
+interface CodingAgentAdapter {
+    readonly id: string;
+    readonly version: string;
+    readonly assurance: AssuranceLevel;
+    execute(request: Omit<CodingAgentRequest, 'signal'> & {
+        readonly signal?: AbortSignal;
+    }): Promise<CodingAgentResult>;
+}
+declare const createCodingAgentAdapter: ({ id, version, assurance, timeoutMs, execute }: {
+    readonly id: string;
+    readonly version: string;
+    readonly assurance?: AssuranceLevel;
+    readonly timeoutMs?: number;
+    readonly execute: (request: CodingAgentRequest) => Promise<CodingAgentHandlerResult> | CodingAgentHandlerResult;
+}) => CodingAgentAdapter;
+
+declare const BENCHMARK_SCHEMA_VERSION: 1;
+type BenchmarkObservationStatus = 'passed' | 'failed' | 'blocked' | 'not-run';
+type BenchmarkImprovementDirection = 'improved' | 'regressed' | 'unchanged' | 'unavailable';
+interface BenchmarkTask {
+    readonly id: string;
+    readonly title: string;
+    readonly acceptanceCriteria: readonly string[];
 }
 interface BenchmarkObservation {
     readonly taskId: string;
@@ -641,11 +1699,6 @@ interface BenchmarkObservation {
     readonly recordedAt: string;
     readonly attempts?: number;
     readonly durationMs?: number;
-    readonly durationSamplesMs?: readonly number[];
-    /** Fraction of repeated samples whose task artifact passed acceptance validation. */
-    readonly artifactAcceptanceRate?: number;
-    /** Fraction of repeated samples whose verification protocol completed. */
-    readonly protocolCompletionRate?: number;
     readonly reviewMinutes?: number;
     readonly escapedIncomplete?: number;
     readonly evidence?: readonly BenchmarkObservationEvidence[];
@@ -661,10 +1714,8 @@ interface BenchmarkManifest {
     readonly schemaVersion: typeof BENCHMARK_SCHEMA_VERSION;
     readonly suiteId: string;
     readonly name: string;
-    readonly provenance?: BenchmarkSuiteSource;
     readonly tasks: readonly BenchmarkTask[];
     readonly observations: readonly BenchmarkObservation[];
-    readonly policy?: BenchmarkPolicy;
 }
 interface BenchmarkRun {
     readonly runId: string;
@@ -688,26 +1739,20 @@ interface BenchmarkRun {
         readonly total: number;
         readonly attached: number;
     };
-    /** Optional artifact outcome emitted by structured benchmark evidence. */
-    readonly artifactAcceptanceRate?: number;
     readonly escapedIncomplete?: number;
     readonly humanApproved: boolean;
     readonly humanReviewMinutes?: number;
     readonly authorized: boolean;
+    readonly machine?: MachineMetrics;
     readonly benchmark?: BenchmarkBinding;
 }
 interface BenchmarkComparison {
     readonly taskId: string;
     readonly title: string;
-    readonly comparability: 'comparable' | 'missing-baseline' | 'baseline-not-run' | 'baseline-evidence-missing' | 'baseline-incomplete' | 'baseline-samples-insufficient' | 'harness-not-run' | 'harness-not-complete';
+    readonly comparability: 'comparable' | 'missing-baseline' | 'baseline-not-run' | 'baseline-evidence-missing' | 'harness-not-run' | 'harness-not-complete';
     readonly comparable: boolean;
-    readonly baselineDeliveryComplete: boolean;
     readonly baseline?: BenchmarkObservation;
     readonly baselineEvidenceCoverageRate: number | null;
-    readonly baselineSampleCount: number;
-    readonly baselineArtifactAcceptanceRate: number | null;
-    readonly baselineProtocolCompletionRate: number | null;
-    readonly baselineMedianDurationMs?: number;
     readonly improvement: {
         readonly durationRate: number | null;
         readonly duration: BenchmarkImprovementDirection;
@@ -715,36 +1760,21 @@ interface BenchmarkComparison {
         readonly attempts: BenchmarkImprovementDirection;
         readonly reviewRate: number | null;
         readonly review: BenchmarkImprovementDirection;
-        readonly artifactAcceptanceRate: number | null;
-        readonly artifactAcceptance: BenchmarkImprovementDirection;
-        readonly artifactAcceptanceDelta: number | null;
-        readonly protocolCompletionRate: number | null;
-        readonly protocolCompletion: BenchmarkImprovementDirection;
-        readonly protocolCompletionDelta: number | null;
         readonly escapedIncompleteRate: number | null;
         readonly escapedIncomplete: BenchmarkImprovementDirection;
     };
     readonly harness: {
         readonly attempts: number;
-        readonly retryCount: number;
-        readonly completedRuns: number;
-        readonly durationSamplesMs: readonly number[];
-        readonly medianDurationMs?: number;
         readonly latestState: RunState | 'NOT_RUN';
         readonly latestRunId?: string;
         readonly latestDurationMs?: number;
         readonly checkPassRate: number | null;
         readonly outcomePassRate: number | null;
         readonly evidenceCoverageRate: number | null;
-        readonly artifactAcceptanceRate?: number;
-        readonly artifactAcceptanceSampleCount: number;
-        readonly protocolCompletionRate: number | null;
-        readonly protocolCompletionSampleCount: number;
         readonly humanApproved: boolean;
         readonly escapedIncomplete?: number;
         readonly humanReviewMinutes?: number;
     };
-    readonly confidence: BenchmarkConfidence;
     readonly durationDeltaMs?: number;
     readonly attemptDelta?: number;
     readonly reviewDeltaMinutes?: number;
@@ -759,12 +1789,6 @@ interface BenchmarkSummary {
     readonly firstAttemptRuns: number;
     readonly humanApprovedRuns: number;
     readonly authorizedRuns: number;
-    readonly effectiveRunCount: number;
-    readonly effectiveCompleteRuns: number;
-    readonly effectiveCompletionRate: number | null;
-    readonly effectiveCheckPassRate: number | null;
-    readonly effectiveOutcomePassRate: number | null;
-    readonly effectiveEvidenceCoverageRate: number | null;
     readonly checkPassRate: number | null;
     readonly outcomePassRate: number | null;
     readonly evidenceCoverageRate: number | null;
@@ -788,7 +1812,6 @@ interface BenchmarkReport {
         readonly comparableTaskCount: number;
     };
     readonly comparisons: readonly BenchmarkComparison[];
-    readonly qualityGate: BenchmarkQualityGate;
 }
 interface BenchmarkObservationInput {
     readonly taskId: string;
@@ -797,9 +1820,6 @@ interface BenchmarkObservationInput {
     readonly recordedAt?: string;
     readonly attempts?: number;
     readonly durationMs?: number;
-    readonly durationSamplesMs?: readonly number[];
-    readonly artifactAcceptanceRate?: number;
-    readonly protocolCompletionRate?: number;
     readonly reviewMinutes?: number;
     readonly escapedIncomplete?: number;
     readonly evidence?: readonly BenchmarkObservationEvidence[];
@@ -810,33 +1830,6 @@ declare const loadBenchmarkManifest: (path: string) => BenchmarkManifest;
 declare const recordBenchmarkObservation: (path: string, input: BenchmarkObservationInput) => BenchmarkManifest;
 declare const benchmarkRuns: (stateDir: string, manifest?: BenchmarkManifest) => BenchmarkReport;
 
-type ExternalCodingBenchmarkStatus = 'ok' | 'partial' | 'fail' | 'timeout';
-interface ExternalCodingBenchmarkRow {
-    readonly providerId: string;
-    readonly status: ExternalCodingBenchmarkStatus;
-    readonly completenessScore: number;
-    readonly fileEditCount: number;
-    readonly summary: string;
-    readonly durationMs?: number;
-    readonly inputTokens?: number;
-    readonly outputTokens?: number;
-    readonly costUsd?: number;
-    readonly successPassed?: boolean;
-}
-interface ExternalCodingBenchmarkReport {
-    readonly kind: string;
-    readonly prompt: string;
-    readonly dryRun: boolean;
-    readonly isolateWorktrees: boolean;
-    readonly repoRoot: string;
-    readonly rows: readonly ExternalCodingBenchmarkRow[];
-}
-/**
- * Validates the stable report shape emitted by AgentsKit OS coding benchmarks.
- * Provider heuristics remain observations; this function never grants human acceptance.
- */
-declare const validateExternalCodingBenchmarkReport: (value: unknown) => ExternalCodingBenchmarkReport;
-
 interface PolicyRule {
     readonly id: string;
     readonly effect: 'allow' | 'block' | 'approve';
@@ -915,6 +1908,229 @@ interface SessionRecorder {
 }
 declare const createSessionRecorder: ({ stateDir, run, adapter, policy, runtime, sessionId, resume }: AgentSessionOptions) => SessionRecorder;
 
+interface MachineThresholds {
+    readonly warningPercent: number;
+    readonly criticalPercent: number;
+}
+declare const sampleMachine: () => MachineSample;
+declare const summarizeMachine: (samples: readonly MachineSample[], sampleIntervalMs?: number, limits?: Partial<MachineThresholds>) => MachineMetrics;
+declare const adaptiveConcurrency: (configured: number, sample: MachineSample, limits?: Partial<MachineThresholds>) => number;
+declare const createMachineMonitor: (sampleIntervalMs?: number, options?: {
+    readonly sample?: () => MachineSample;
+    readonly thresholds?: Partial<MachineThresholds>;
+}) => {
+    readonly sample: () => MachineSample;
+    readonly observeConcurrency: (value: number) => void;
+    readonly markThrottle: () => void;
+    readonly stop: () => MachineMetrics;
+};
+
+interface CoordinationIdentity {
+    readonly tracker: string;
+    readonly repository: string;
+    readonly issue: string;
+    readonly worktree: string;
+    readonly branch: string;
+}
+interface DispatchLease extends CoordinationIdentity {
+    readonly key: string;
+    readonly leaseId: string;
+    readonly owner: string;
+    readonly claimedAt: string;
+}
+interface ClaimResult {
+    readonly decision: 'claimed' | 'already-claimed';
+    readonly lease: DispatchLease;
+}
+interface DispatchRecord extends DispatchLease {
+    readonly action: 'dispatch' | 'release' | 'recover';
+    readonly at: string;
+    readonly idempotencyKey?: string;
+    readonly commandDigest?: string;
+    readonly reason?: string;
+}
+interface DispatchLedger {
+    claim(identity: CoordinationIdentity & {
+        readonly owner: string;
+    }): ClaimResult;
+    recordDispatch(input: {
+        readonly lease: DispatchLease;
+        readonly idempotencyKey: string;
+        readonly commandDigest: string;
+    }): {
+        readonly decision: 'recorded' | 'duplicate';
+        readonly record: DispatchRecord;
+    };
+    release(lease: DispatchLease, reason?: string): DispatchRecord;
+    recover(key: string, input: {
+        readonly actor: string;
+        readonly maxAgeMs?: number;
+        readonly reason: string;
+    }): DispatchRecord;
+    active(): readonly DispatchLease[];
+    records(): readonly DispatchRecord[];
+}
+declare const createDispatchLedger: (stateDir: string) => DispatchLedger;
+
+interface ChangedFile {
+    readonly path: string;
+    readonly status?: string;
+}
+interface FilePreflightPlan {
+    readonly files: readonly string[];
+    readonly codeFiles: readonly string[];
+    readonly testFiles: readonly string[];
+    readonly docsOnly: boolean;
+    readonly checks: readonly ('lint' | 'typecheck' | 'test')[];
+}
+declare const validateSafeCommand: (command: string) => {
+    readonly valid: true;
+    readonly command: string;
+};
+declare const planFilePreflight: (files: readonly ChangedFile[], options?: {
+    readonly testRoots?: readonly string[];
+    readonly includeTests?: boolean;
+}) => FilePreflightPlan;
+
+declare const BLOCK_STATUSES: readonly ["todo", "picked", "development", "validation", "pr-open", "merged", "post-merge", "done", "blocked", "scope-cut"];
+type BlockStatus = typeof BLOCK_STATUSES[number];
+interface BlockManifest {
+    readonly schemaVersion: 1;
+    readonly id: string;
+    readonly title: string;
+    readonly tracker: string;
+    readonly repository: string;
+    readonly acceptanceCriteria: readonly string[];
+    readonly dependencies: readonly string[];
+    readonly wave: number;
+    readonly status: BlockStatus;
+    readonly budget?: {
+        readonly maxMinutes?: number;
+        readonly maxAttempts?: number;
+    };
+    readonly humanGates?: readonly string[];
+    readonly sourceHash?: string;
+}
+interface BlockAssessment {
+    readonly status: 'ready' | 'blocked';
+    readonly manifestHash: string;
+    readonly blockers: readonly string[];
+    readonly next: readonly string[];
+}
+declare const validateBlockManifest: (value: unknown) => BlockManifest;
+declare const assessBlock: (manifest: BlockManifest, completedDependencies?: readonly string[]) => BlockAssessment;
+
+declare const LEARNING_STATUSES: readonly ["proposed", "promoted", "rejected"];
+type LearningStatus = typeof LEARNING_STATUSES[number];
+interface LearningRecord {
+    readonly id: string;
+    readonly source: string;
+    readonly category: 'worked' | 'problem' | 'adjustment' | 'other';
+    readonly text: string;
+    readonly status: LearningStatus;
+    readonly recordedAt: string;
+}
+declare const parseRetro: (markdown: string, source: string, recordedAt?: string) => readonly LearningRecord[];
+declare const promoteLearnings: (records: readonly LearningRecord[], input: {
+    readonly actor: string;
+    readonly ids: readonly string[];
+    readonly status?: "promoted" | "rejected";
+}) => readonly LearningRecord[];
+
+interface StatusBlock {
+    readonly id: string;
+    readonly status: BlockStatus;
+    readonly owner?: string;
+    readonly issue?: string;
+    readonly branch?: string;
+    readonly revision?: string;
+    readonly blockers?: readonly string[];
+}
+interface StatusSnapshot {
+    readonly schemaVersion: 1;
+    readonly generatedAt: string;
+    readonly sourceRevision: string;
+    readonly blocks: readonly StatusBlock[];
+    readonly machine?: MachineMetrics;
+    readonly metrics?: Readonly<Record<string, number>>;
+    readonly next?: string;
+    readonly digest: string;
+}
+declare const createStatusSnapshot: (input: Omit<StatusSnapshot, "schemaVersion" | "digest">) => StatusSnapshot;
+declare const validateStatusSnapshot: (value: unknown) => StatusSnapshot;
+
+declare const MODEL_ROLES: readonly ["orchestrator", "reviewer", "builder", "watcher"];
+type ModelRole = typeof MODEL_ROLES[number];
+interface ModelBinding {
+    readonly role: ModelRole;
+    readonly provider: string;
+    readonly model: string;
+    readonly maxTokens?: number;
+}
+interface ModelPolicy {
+    readonly bindings: readonly ModelBinding[];
+    readonly digest: string;
+}
+declare const createModelPolicy: (bindings: readonly ModelBinding[]) => ModelPolicy;
+declare const modelFor: (policy: ModelPolicy, role: ModelRole) => ModelBinding;
+
+interface OrcaDispatchInput {
+    readonly repository: string;
+    readonly worktree: string;
+    readonly branch: string;
+    readonly baseBranch: string;
+    readonly goalFile: string;
+    readonly agent?: string;
+}
+interface OrcaDispatchPlan {
+    readonly argv: readonly string[];
+    readonly commandDigest: string;
+    readonly idempotencyKey: string;
+}
+type OrcaLeaseState = 'acquired' | 'resumed' | 'conflict' | 'released';
+interface OrcaLifecycleInput {
+    readonly issueRef: string;
+    readonly repository: string;
+    readonly worktree: string;
+    readonly branch: string;
+    readonly leaseState: OrcaLeaseState;
+    readonly issueLock: 'held' | 'missing';
+    readonly expectedRemoteSha?: string;
+    readonly observedRemoteSha?: string;
+    readonly cleanupRequested?: boolean;
+}
+interface OrcaLifecycleProjection {
+    readonly status: 'ready' | 'resume' | 'blocked' | 'escalated';
+    readonly leaseState: OrcaLeaseState;
+    readonly worktreeKey: string;
+    readonly issueLock: 'held' | 'missing';
+    readonly remoteShaConfirmed: boolean;
+    readonly cleanupAllowed: boolean;
+    readonly assurance: AssuranceLevel;
+    readonly telemetry: AdapterTelemetry;
+}
+declare const createOrcaDispatchPlan: (input: OrcaDispatchInput) => OrcaDispatchPlan;
+declare const createOrcaLifecycleProjection: (input: OrcaLifecycleInput) => OrcaLifecycleProjection;
+
+interface TrackingTransition {
+    readonly tracker: string;
+    readonly issue: string;
+    readonly from?: string;
+    readonly to: string;
+    readonly reason: string;
+    readonly idempotencyKey: string;
+}
+interface TrackingAdapter {
+    readonly id: string;
+    readonly assurance?: AssuranceLevel;
+    readonly telemetry?: () => AdapterTelemetry;
+    transition(input: Omit<TrackingTransition, 'idempotencyKey'>): Promise<TrackingTransition>;
+}
+declare const createTrackingTransition: (input: Omit<TrackingTransition, "idempotencyKey">) => TrackingTransition;
+declare const createTrackingAdapter: (id: string, handler: (input: TrackingTransition) => Promise<void> | void, options?: {
+    readonly dryRun?: boolean;
+}) => TrackingAdapter;
+
 declare const EVIDENCE_BUNDLE_SCHEMA_VERSION: 1;
 interface EvidenceBundleFile {
     readonly path: string;
@@ -965,4 +2181,4 @@ declare const verifyEvidenceBundle: (path: string, { trustedKeys }?: {
 }) => EvidenceBundleVerification;
 declare const readEvidenceTrustStore: (path: string) => readonly TrustedEvidenceKey[];
 
-export { type AgentAdapter, type AgentSessionOptions, BENCHMARK_SCHEMA_VERSION, type BenchmarkBinding, type BenchmarkComparison, type BenchmarkConfidence, type BenchmarkImprovementDirection, type BenchmarkManifest, type BenchmarkObservation, type BenchmarkObservationEvidence, type BenchmarkObservationInput, type BenchmarkObservationStatus, type BenchmarkPolicy, type BenchmarkQualityGate, type BenchmarkReport, type BenchmarkRun, type BenchmarkSuiteSource, type BenchmarkSummary, type BenchmarkTask, type BenchmarkTaskFile, type BenchmarkTaskScope, type BenchmarkTaskSource, CHECK_CATEGORIES, CONTEXT_PROVIDER_SLOT, type CheckCategory, type CheckResult, type ContextProvider, type ContextQuery, type ContextReference, type ContextSnapshot, type ContractOutcome, type ContractScope, type Disposer, type DockerMount, type DockerRuntimeEvidence, type DockerToolDefinition, EVENT_LOG_GENESIS, EVIDENCE_BUNDLE_SCHEMA_VERSION, type EventLogLock, type EventLogLockRecovery, type EventLogLockStatus, type EventLogVerification, type EventStore, type EvidenceArtifact, type EvidenceBundle, type EvidenceBundleFile, type EvidenceBundleSignature, type EvidenceBundleVerification, type EvidenceReference, type ExternalCodingBenchmarkReport, type ExternalCodingBenchmarkRow, type ExternalCodingBenchmarkStatus, FileEventStore, HARNESS_EVENT_SCHEMA_VERSION, HARNESS_EVENT_TYPES, HARNESS_PLUGIN_API_VERSION, HarnessError, type HarnessEvent, type HarnessEventInput, type HarnessEventListener, type HarnessEventPayloads, type HarnessEventType, type HarnessPlugin, type HarnessPluginContext, LEGAL_TRANSITIONS, type LoadedConfig, type PluginContribution, type PluginRegistry, type PluginSlot, type PolicyDecision, type PolicyGate, type PolicyRequest, type PolicyRule, type ProcessToolDefinition, RUN_STATES, type RunOutcome, type RunReconciliation, type RunState, STATES, SURFACE_NAMES, type SessionRecorder, type SourceSnapshot, type StateTransition, type StructuredEvidence, type SurfaceName, type SurfaceRequirement, type TaskContract, type ToolDefinition, type ToolExecutionRequest, type ToolExecutionResult, type ToolRuntime, type TrackingConfig, type TrustedEvidenceKey, type VerificationCheck, type VerificationConfig, type VerificationRun, approveRun, approvedDecision, assertHuman, authorizeRun, benchmarkRuns, cancelRun, cleanTaskArtifacts, createDocBridgeContextProvider, createDockerToolRuntime, createPluginRegistry, createPluginSlot, createPolicyGate, createProcessToolRuntime, createSessionRecorder, createToolRuntime, exportEvidenceBundle, hashContextSnapshot, hashContextSnapshots, inspectEventLogLock, loadBenchmarkManifest, loadConfig, loadLatestRun, planRun, readContextSnapshots, readEvidenceTrustStore, reconcileRun, recordBenchmarkObservation, recoverEventLogLock, retryRun, startRun, transition, validateBenchmarkManifest, validateConfig, validateContextSnapshot, validateContextSnapshots, validateExternalCodingBenchmarkReport, verifyEvidenceBundle, verifyRun };
+export { ARTIFACT_SCHEMA_VERSION, ARTIFACT_TYPES, ASSURANCE_LEVELS, type AdapterMetadata, type AdapterTelemetry, type AdversarialReviewResult, type AgentAdapter, type AgentEvalCase, type AgentEvalReport, type AgentEvalSuite, type AgentMemoryAdapter, type AgentMemoryHit, type AgentMemoryKvStore, type AgentMemoryRecord, type AgentSessionOptions, type AgentUsage, type ApprovedAssumption, type ArtifactBinding, type ArtifactEnvelope, type ArtifactEnvelopeInput, type ArtifactType, type AssuranceLevel, type AutonomyMode, BENCHMARK_SCHEMA_VERSION, BLOCK_STATUSES, type BenchmarkBinding, type BenchmarkComparison, type BenchmarkImprovementDirection, type BenchmarkManifest, type BenchmarkObservation, type BenchmarkObservationEvidence, type BenchmarkObservationInput, type BenchmarkObservationStatus, type BenchmarkReport, type BenchmarkRun, type BenchmarkSummary, type BenchmarkTask, type BlockAssessment, type BlockManifest, type BlockStatus, CAPABILITY_KINDS, CAPABILITY_MANIFEST_SCHEMA_VERSION, CHECK_CATEGORIES, COMPATIBILITY_COMPONENTS, COMPATIBILITY_SCHEMA_VERSION, CONTEXT_PROVIDER_SLOT, type CacheUsage, type CapabilityDescriptor, type CapabilityKind, type CapabilityManifest, type CapabilityManifestInput, type ChangedFile, type CheckCategory, type CheckResult, type ClaimResult, type CodingAgentAdapter, type CodingAgentHandlerResult, type CodingAgentRequest, type CodingAgentResult, type CompatibilityComponent, type CompatibilityComponentId, type CompatibilityManifest, type CompatibilityObservation, type CompatibilityReport, type CompatibilityStatus, type ContextProvider, type ContextQuery, type ContextReference, type ContextSnapshot, type ContractOutcome, type ContractScope, type CoordinationIdentity, type CriterionStatus, type CycleIterationMetrics, type CycleMatrixRow, type CycleStepResult, type CycleStepStatus, type DecisionPacket, type DiscoveryAmbiguity, type DiscoveryCurrentInput, type DiscoveryCurrentResult, type DiscoveryDecisionLogEntry, type DiscoveryInput, type DiscoveryOption, type DiscoveryResult, type DispatchLease, type DispatchLedger, type DispatchRecord, type Disposer, type DockerMount, type DockerRuntimeEvidence, type DockerToolDefinition, EVAL_COMPONENTS, EVAL_LAYERS, EVAL_MANIFEST_SCHEMA_VERSION, EVENT_LOG_GENESIS, EVIDENCE_BUNDLE_SCHEMA_VERSION, type EvalBatteryReport, type EvalCaseDefinition, type EvalCaseReport, type EvalComponent, type EvalExpectation, type EvalLayer, type EvalManifest, type EvalObservation, type EvalObservationStatus, type EventLogLock, type EventLogLockRecovery, type EventLogLockStatus, type EventLogVerification, type EventStore, type EvidenceArtifact, type EvidenceBundle, type EvidenceBundleFile, type EvidenceBundleSignature, type EvidenceBundleVerification, type EvidenceReference, type ExecutePhaseProfileOptions, type FailureClass, type FailureClassification, FileArtifactStore, FileEventStore, type FilePreflightPlan, type GateAssessment, type GateBinding, type GateCriterion, HARNESS_ERROR_CATALOG, HARNESS_ERROR_CODES, HARNESS_EVENT_ENVELOPE_SCHEMA_VERSION, HARNESS_EVENT_SCHEMA_VERSION, HARNESS_EVENT_TYPES, HARNESS_PLUGIN_API_VERSION, HarnessError, type HarnessErrorClassification, type HarnessErrorDisposition, type HarnessEvent, type HarnessEventContext, type HarnessEventEnvelope, type HarnessEventEnvelopeInput, type HarnessEventInput, type HarnessEventListener, type HarnessEventPayloads, type HarnessEventProvenance, type HarnessEventType, type HarnessPlugin, type HarnessPluginContext, IMPROVEMENT_CYCLE_STEPS, type ImprovementCycleAssessment, type ImprovementCycleInput, type ImprovementCycleIteration, type ImprovementCycleStep, LEARNING_STATUSES, LEGAL_TRANSITIONS, type LearningRecord, type LearningStatus, type LlmCache, type LlmCacheKeyInput, type LlmCacheStats, type LoadedConfig, MEMORY_SCOPES, MODEL_ROLES, type MachineMetrics, type MachineSample, type MachineThresholds, type MemoryScope, type MemoryUsage, type MetricStatus, type ModelBinding, type ModelPolicy, type ModelRole, type NormalizedPhaseProfile, type OptimizationComparison, type OptimizationObservation, type OrcaDispatchInput, type OrcaDispatchPlan, type OrcaLeaseState, type OrcaLifecycleInput, type OrcaLifecycleProjection, PHASE_DECISIONS, PHASE_EFFECTS, PHASE_EFFECT_ACTIONS, PHASE_MODES, type ParallelismUsage, type PhaseAmbiguity, type PhaseContext, type PhaseDecision, type PhaseDecisionPacket, type PhaseDefinition, type PhaseEffect, type PhaseEffectAction, type PhaseEffectPolicy, type PhaseExecution, type PhaseExecutionReport, type PhaseGateEvaluator, type PhaseGateResult, type PhaseHandler, type PhaseHandlerResult, type PhaseMachineMetrics, type PhaseMode, type PhasePreflight, type PhasePreflightResult, type PhaseProfile, type PhaseResumeState, type PhaseRetryPolicy, type PhaseRoutePlan, type PhaseTelemetry, type PhaseTokenMetrics, type PilotAssessment, type PilotEntry, type PilotManifest, type PluginContribution, type PluginRegistry, type PluginSlot, type PolicyDecision, type PolicyGate, type PolicyRequest, type PolicyRule, type ProcessToolDefinition, type ProductionEvidence, type PullRequestApproval, type PullRequestDraft, QUALITY_DIMENSIONS, type QaTransitionAssessment, type QualityDimension, type QualityDimensionScore, type QualityMatrix, RUN_STATES, type RecoveryObservation, type RecoveryPolicy, type RecoveryResult, type RepositoryProfile, type ReviewLens, type ReviewVerdict, type RunOutcome, type RunReconciliation, type RunState, type RuntimeConfig, type RuntimeExperimentCandidate, type RuntimeExperimentResult, STATES, SURFACE_NAMES, type SessionRecorder, type SourceSnapshot, type StateTransition, type StatusBlock, type StatusSnapshot, type StructuredEvidence, type SurfaceName, type SurfaceRequirement, type TaskContract, type TokenUsage, type ToolDefinition, type ToolExecutionRequest, type ToolExecutionResult, type ToolRuntime, type TrackingAdapter, type TrackingConfig, type TrackingTransition, type TrustedEvidenceKey, type VerificationCheck, type VerificationConfig, type VerificationRun, WIP_STATES, type WatchdogBlocker, type WatchdogBudget, type WatchdogResult, type WipAssessment, type WipAssessmentInput, type WipEntry, type WipState, type WorkflowNode, type WorkflowResult, 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 };