@agentskit/harness 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { z } from 'zod';
+
 declare const STATES: readonly ["CLARIFYING", "PLANNED", "IMPLEMENTING", "VERIFYING", "AWAITING_HUMAN_APPROVAL", "AWAITING_AUTHORIZATION", "COMPLETE", "BLOCKED", "STALE", "CANCELLED", "SUPERSEDED"];
 declare const LEGAL_TRANSITIONS: {
     readonly CLARIFYING: readonly ["PLANNED", "BLOCKED", "CANCELLED"];
@@ -13,12 +15,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' | 'GIT_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 +72,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 {
@@ -108,9 +151,34 @@ 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;
@@ -145,6 +213,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;
@@ -345,6 +421,7 @@ interface ContextReference {
     readonly title?: string;
     readonly version?: string;
     readonly contentHash?: string;
+    readonly relevance?: number;
 }
 interface ContextSnapshot {
     readonly providerId: string;
@@ -353,6 +430,8 @@ interface ContextSnapshot {
     readonly sourceHash: string;
     readonly snapshotHash: string;
     readonly resolvedAt: string;
+    readonly assurance?: AssuranceLevel;
+    readonly telemetry?: AdapterTelemetry;
 }
 interface ContextProvider {
     readonly id: string;
@@ -385,7 +464,7 @@ interface ContractOutcome {
     readonly statement: string;
     readonly checks: readonly string[];
 }
-interface TaskContract {
+interface TaskContract$1 {
     readonly intent: string;
     readonly scope: ContractScope;
     readonly ambiguities: readonly string[];
@@ -425,7 +504,7 @@ interface VerificationConfig {
     readonly profile: string;
     readonly autonomy: AutonomyMode;
     readonly runtime: RuntimeConfig;
-    readonly contract: TaskContract;
+    readonly contract: TaskContract$1;
     readonly surfaces: Readonly<Record<SurfaceName, SurfaceRequirement>>;
     readonly checks: readonly VerificationCheck[];
     readonly tracking: TrackingConfig;
@@ -621,6 +700,37 @@ 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;
@@ -736,6 +846,32 @@ interface RuntimeExperimentResult {
 }
 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;
@@ -790,6 +926,44 @@ declare const composePullRequest: ({ draft, g2, remote }: {
     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;
@@ -931,6 +1105,69 @@ interface AgentEvalReport {
     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>;
@@ -962,6 +1199,8 @@ interface LlmCacheStats {
 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;
@@ -1039,6 +1278,8 @@ interface AgentMemoryHit {
 interface AgentMemoryAdapter {
     readonly id: string;
     readonly version: string;
+    readonly assurance?: AssuranceLevel;
+    readonly telemetry?: () => AdapterTelemetry;
     remember(record: AgentMemoryRecord): Promise<void>;
     recall(input: {
         readonly query: string;
@@ -1081,6 +1322,369 @@ declare const runWorkflow: <T>(nodes: readonly WorkflowNode<T>[], options: {
     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 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 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';
@@ -1370,37 +1974,6 @@ interface DispatchLedger {
 }
 declare const createDispatchLedger: (stateDir: string) => DispatchLedger;
 
-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 ChangedFile {
     readonly path: string;
     readonly status?: string;
@@ -1508,15 +2081,50 @@ interface OrcaDispatchInput {
     readonly worktree: string;
     readonly branch: string;
     readonly baseBranch: string;
-    readonly goalFile: string;
+    /** Prompt file path (`--prompt-file`) — mutually exclusive with `prompt`. */
+    readonly goalFile?: string;
+    /** Inline prompt text (`--prompt`) — mutually exclusive with `goalFile`. */
+    readonly prompt?: string;
     readonly agent?: string;
+    /** `worktree-only`: create the checkout without launching an agent; the caller opens its own terminal (`orca terminal create --command …`). */
+    readonly launch?: 'agent' | 'worktree-only';
+    /** Linear identifier or URL recorded on the worktree (`--linear-issue`). */
+    readonly linearIssue?: string;
+    /** Free-text Orca comment shown on the worktree card (`--comment`). */
+    readonly comment?: string;
+    /** Detach the new worktree from the caller's lineage (`--no-parent`). */
+    readonly noParent?: boolean;
+    readonly orcaBin?: 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;
@@ -1528,10 +2136,14 @@ interface TrackingTransition {
 }
 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) => TrackingAdapter;
+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 {
@@ -1583,4 +2195,1480 @@ declare const verifyEvidenceBundle: (path: string, { trustedKeys }?: {
 }) => EvidenceBundleVerification;
 declare const readEvidenceTrustStore: (path: string) => readonly TrustedEvidenceKey[];
 
-export { type AgentAdapter, type AgentEvalCase, type AgentEvalReport, type AgentEvalSuite, type AgentMemoryAdapter, type AgentMemoryHit, type AgentMemoryKvStore, type AgentMemoryRecord, type AgentSessionOptions, type ApprovedAssumption, 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, CHECK_CATEGORIES, CONTEXT_PROVIDER_SLOT, type CacheUsage, type ChangedFile, type CheckCategory, type CheckResult, type ClaimResult, 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, EVENT_LOG_GENESIS, EVIDENCE_BUNDLE_SCHEMA_VERSION, type EvalExpectation, type EventLogLock, type EventLogLockRecovery, type EventLogLockStatus, type EventLogVerification, type EventStore, type EvidenceArtifact, type EvidenceBundle, type EvidenceBundleFile, type EvidenceBundleSignature, type EvidenceBundleVerification, type EvidenceReference, type FailureClass, type FailureClassification, FileEventStore, type FilePreflightPlan, type GateAssessment, type GateBinding, type GateCriterion, HARNESS_EVENT_SCHEMA_VERSION, HARNESS_EVENT_TYPES, HARNESS_PLUGIN_API_VERSION, HarnessError, type HarnessEvent, type HarnessEventContext, type HarnessEventInput, type HarnessEventListener, type HarnessEventPayloads, 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 ModelBinding, type ModelPolicy, type ModelRole, type OptimizationComparison, type OptimizationObservation, type OrcaDispatchInput, type OrcaDispatchPlan, type ParallelismUsage, 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 PullRequestDraft, RUN_STATES, type RecoveryObservation, type RecoveryPolicy, type RecoveryResult, type RepositoryProfile, 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 WipAssessment, type WipAssessmentInput, type WipEntry, type WipState, type WorkflowNode, type WorkflowResult, 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 };
+interface CommandResult {
+    readonly code: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly timedOut: boolean;
+    readonly durationMs: number;
+}
+interface CommandRunOptions {
+    readonly timeoutMs?: number;
+    readonly cwd?: string;
+    readonly env?: NodeJS.ProcessEnv;
+}
+/** Shell-free command execution seam. Adapters receive it; composition supplies the real one; tests supply fakes. */
+interface CommandRunner {
+    run(argv: readonly string[], options?: CommandRunOptions): Promise<CommandResult>;
+}
+/** Resolve an executable on PATH without spawning a shell. Honours PATHEXT on Windows. */
+declare const findExecutable: (name: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform) => string | null;
+/** Parse the `{ ok, result }` envelope every `orca … --json` command prints. Returns null when the payload is not an envelope. */
+declare const parseJsonEnvelope: (stdout: string) => {
+    readonly ok: boolean;
+    readonly result: unknown;
+    readonly error?: string;
+} | null;
+
+interface OrcaCliOptions {
+    readonly bin?: string;
+    readonly timeoutMs?: number;
+    readonly cwd?: string;
+}
+interface OrcaStatus {
+    readonly appRunning: boolean;
+    readonly runtimeReady: boolean;
+    readonly runtimeState: string;
+    readonly appVersion: string | null;
+    readonly runtimeId: string | null;
+}
+interface OrcaWorktree {
+    readonly id: string;
+    readonly repoId: string;
+    readonly repo: string;
+    readonly path: string;
+    readonly branch: string;
+    readonly displayName: string;
+    readonly workspaceStatus: string;
+    readonly isArchived: boolean;
+    readonly isMainWorktree: boolean;
+    readonly liveTerminalCount: number;
+    readonly lastActivityAt: number | null;
+    readonly linkedLinearIssue: string | null;
+    readonly comment: string;
+}
+type OrcaAgentHookState = 'installed' | 'not_installed' | 'unknown';
+declare const compareVersions: (left: string, right: string) => number;
+declare const parseOrcaVersion: (stdout: string) => string | null;
+declare const parseOrcaStatus: (result: unknown) => OrcaStatus;
+declare const parseOrcaWorktrees: (result: unknown) => readonly OrcaWorktree[];
+declare const parseOrcaAgentHooks: (result: unknown) => Readonly<Record<string, OrcaAgentHookState>>;
+/** Run one `orca … --json` command and return the unwrapped `result`, failing closed on any transport or envelope error. */
+declare const orcaJson: (runner: CommandRunner, args: readonly string[], options?: OrcaCliOptions) => Promise<unknown>;
+declare const orcaVersion: (runner: CommandRunner, options?: OrcaCliOptions) => Promise<string | null>;
+declare const orcaStatus: (runner: CommandRunner, options?: OrcaCliOptions) => Promise<OrcaStatus>;
+declare const orcaWorktrees: (runner: CommandRunner, options?: OrcaCliOptions) => Promise<readonly OrcaWorktree[]>;
+declare const orcaAgentHooks: (runner: CommandRunner, options?: OrcaCliOptions) => Promise<Readonly<Record<string, OrcaAgentHookState>>>;
+declare const orcaAccountList: (runner: CommandRunner, options?: OrcaCliOptions) => Promise<unknown>;
+interface OrcaCreatedWorktree {
+    readonly id: string;
+    readonly path: string;
+    readonly branch: string;
+    readonly agentTerminalHandle: string | null;
+    readonly raw: unknown;
+}
+declare const parseOrcaWorktreeCreate: (result: unknown) => OrcaCreatedWorktree;
+/** Execute a `createOrcaDispatchPlan` argv (first element is the orca binary). */
+declare const orcaWorktreeCreate: (runner: CommandRunner, argv: readonly string[], options?: OrcaCliOptions) => Promise<OrcaCreatedWorktree>;
+declare const orcaWorktreeSetArgv: (input: {
+    readonly worktree: string;
+    readonly comment?: string;
+    readonly workspaceStatus?: string;
+    readonly linearIssue?: string | null;
+    readonly displayName?: string;
+}, bin?: string) => readonly string[];
+declare const orcaWorktreeSet: (runner: CommandRunner, input: Parameters<typeof orcaWorktreeSetArgv>[0], options?: OrcaCliOptions) => Promise<unknown>;
+declare const orcaWorktreeRemove: (runner: CommandRunner, input: {
+    readonly worktree: string;
+    readonly force?: boolean;
+}, options?: OrcaCliOptions) => Promise<unknown>;
+interface OrcaTerminal {
+    readonly handle: string;
+    readonly title: string;
+    readonly worktreeId: string | null;
+    readonly status: string;
+    readonly command: string | null;
+    readonly branch: string | null;
+    readonly preview: string;
+    readonly lastOutputAt: number | null;
+    readonly raw: Record<string, unknown>;
+}
+declare const parseOrcaTerminals: (result: unknown) => readonly OrcaTerminal[];
+declare const orcaTerminalList: (runner: CommandRunner, input?: {
+    readonly worktree?: string;
+    readonly limit?: number;
+}, options?: OrcaCliOptions) => Promise<readonly OrcaTerminal[]>;
+declare const orcaTerminalCreate: (runner: CommandRunner, input: {
+    readonly worktree: string;
+    readonly command: string;
+    readonly title?: string;
+}, options?: OrcaCliOptions) => Promise<{
+    readonly handle: string;
+    readonly raw: unknown;
+}>;
+interface OrcaSendReceipt {
+    readonly accepted: boolean;
+    readonly requestId: string | null;
+    readonly stages: readonly string[];
+    readonly warnings: readonly string[];
+}
+declare const parseOrcaSendReceipt: (result: unknown) => OrcaSendReceipt;
+declare const orcaTerminalSend: (runner: CommandRunner, input: {
+    readonly terminal: string;
+    readonly text: string;
+    readonly enter?: boolean;
+    readonly waitSubmitSeconds?: number;
+}, options?: OrcaCliOptions) => Promise<OrcaSendReceipt>;
+declare const orcaTerminalWait: (runner: CommandRunner, input: {
+    readonly terminal: string;
+    readonly for: "exit" | "tui-idle";
+    readonly timeoutMs: number;
+}, options?: OrcaCliOptions) => Promise<{
+    readonly satisfied: boolean;
+    readonly raw: unknown;
+}>;
+declare const orcaTerminalScreen: (runner: CommandRunner, input: {
+    readonly terminal: string;
+}, options?: OrcaCliOptions) => Promise<string>;
+interface OrcaAutomation {
+    readonly id: string;
+    readonly name: string;
+    readonly enabled: boolean;
+    readonly trigger: string;
+    readonly provider: string | null;
+    readonly raw: Record<string, unknown>;
+}
+declare const parseOrcaAutomations: (result: unknown) => readonly OrcaAutomation[];
+declare const orcaAutomationsList: (runner: CommandRunner, options?: OrcaCliOptions) => Promise<readonly OrcaAutomation[]>;
+interface OrcaAutomationSpec {
+    readonly name: string;
+    readonly trigger: string;
+    readonly prompt: string;
+    readonly provider: string;
+    readonly precheck?: string;
+    readonly precheckTimeoutSec?: number;
+    readonly workspace?: string;
+    readonly repo?: string;
+    readonly host?: string;
+    readonly reuseSession?: boolean;
+    readonly enabled?: boolean;
+}
+declare const orcaAutomationCreateArgv: (spec: OrcaAutomationSpec, bin?: string) => readonly string[];
+declare const orcaAutomationEditArgv: (id: string, spec: OrcaAutomationSpec, bin?: string) => readonly string[];
+declare const orcaAutomationRemove: (runner: CommandRunner, id: string, options?: OrcaCliOptions) => Promise<unknown>;
+declare const orcaAutomationRun: (runner: CommandRunner, id: string, options?: OrcaCliOptions) => Promise<unknown>;
+declare const orcaAutomationRuns: (runner: CommandRunner, id: string, options?: OrcaCliOptions) => Promise<unknown>;
+
+type UsageWindowKind = 'session' | 'weekly' | 'monthly' | string;
+interface UsageWindow {
+    readonly kind: UsageWindowKind;
+    readonly usedPercent: number;
+    readonly windowMinutes: number | null;
+    readonly resetsAt: string | null;
+}
+interface ProviderUsage {
+    /** `ok` when Orca reported live usage, `unavailable` when Orca could not, `unknown` when Orca did not mention the provider. */
+    readonly status: 'ok' | 'unavailable' | 'unknown';
+    readonly error: string | null;
+    readonly windows: readonly UsageWindow[];
+    readonly exhausted: boolean;
+    /** Earliest reset among exhausted windows, ISO-8601. */
+    readonly resetsAt: string | null;
+    readonly hasAuth: boolean | null;
+}
+type ProviderAuthStatus = 'ok' | 'unknown' | 'missing';
+interface ProviderAvailability {
+    readonly id: string;
+    readonly binary: string | null;
+    readonly hookState: 'installed' | 'not_installed' | 'unknown';
+    readonly auth: ProviderAuthStatus;
+    readonly usage: ProviderUsage;
+    readonly probe: 'passed' | 'failed' | 'skipped';
+    readonly coolingDownUntil: string | null;
+    readonly available: boolean;
+    readonly reasons: readonly string[];
+}
+interface ProviderSpec {
+    readonly id: string;
+    readonly bin: string;
+    readonly auth: 'subscription' | 'api-key' | 'none';
+    readonly envKeys: readonly string[];
+    readonly orcaUsageKey: string;
+    readonly probe?: readonly string[];
+}
+interface DetectProvidersInput {
+    readonly providers: readonly ProviderSpec[];
+    readonly accountList: unknown;
+    readonly agentHooks: Readonly<Record<string, 'installed' | 'not_installed' | 'unknown'>>;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly platform?: NodeJS.Platform;
+    readonly exhaustedPercent?: number;
+    readonly cooldowns?: Readonly<Record<string, string>>;
+    readonly now?: () => Date;
+    readonly runner?: CommandRunner;
+    readonly probeTimeoutMs?: number;
+}
+declare const parseUsageWindows: (entry: unknown) => readonly UsageWindow[];
+/** Read one provider's usage out of `orca account list --json` → `result`. */
+declare const parseProviderUsage: (accountList: unknown, usageKey: string, exhaustedPercent?: number) => ProviderUsage;
+declare const authStatusFor: (spec: ProviderSpec, usage: ProviderUsage, env: NodeJS.ProcessEnv) => ProviderAuthStatus;
+/** Detect which coding-agent CLIs can take work right now. Pure over its inputs except the optional probe. */
+declare const detectProviders: (input: DetectProvidersInput) => Promise<readonly ProviderAvailability[]>;
+/** Exponential cooldown: initial × 2^attempts, capped. Returns the ISO instant the provider may be retried. */
+declare const cooldownUntil: (attempt: number, initialMin: number, maxMin: number, from: Date, resetsAt?: string | null) => string;
+
+interface LoopIssue {
+    readonly id: string;
+    readonly identifier: string;
+    readonly title: string;
+    readonly url: string;
+    readonly state: string;
+    readonly stateType: string;
+    readonly assignee: string | null;
+    readonly assigneeId: string | null;
+    readonly labels: readonly string[];
+    readonly priority: number;
+    readonly priorityLabel: string;
+    readonly project: string | null;
+    readonly branchName: string | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface LinearQueueFilter {
+    readonly states: readonly string[];
+    readonly excludeLabels: readonly string[];
+    readonly requireLabels: readonly string[];
+    readonly projects: readonly string[];
+    readonly order: readonly ('priority' | 'updatedAt' | 'createdAt')[];
+    readonly maxQueue: number;
+}
+interface LinearListInput {
+    readonly bin?: string;
+    readonly workspaceId: string;
+    readonly teamKey: string;
+    readonly assignee: string;
+    readonly state: string;
+    readonly limit: number;
+}
+declare const parseLinearIssues: (result: unknown) => readonly LoopIssue[];
+declare const buildListIssuesArgv: (input: LinearListInput) => readonly string[];
+declare const filterAndOrderQueue: (issues: readonly LoopIssue[], filter: LinearQueueFilter) => readonly LoopIssue[];
+interface FetchQueueInput extends Omit<LinearListInput, 'state' | 'limit'> {
+    readonly filter: LinearQueueFilter;
+    readonly pageLimit?: number;
+    readonly orca?: OrcaCliOptions;
+}
+/** One `list-issues` call per configured state (Orca keeps only the last repeated `--state`), then filter/order locally. */
+declare const fetchLinearQueue: (runner: CommandRunner, input: FetchQueueInput) => Promise<readonly LoopIssue[]>;
+interface LinearIssueDetail extends LoopIssue {
+    readonly description: string;
+    readonly comments: readonly {
+        readonly author: string | null;
+        readonly body: string;
+        readonly createdAt: string;
+    }[];
+    readonly raw: unknown;
+}
+declare const parseLinearIssueDetail: (result: unknown) => LinearIssueDetail;
+interface LinearWriteOptions {
+    readonly bin?: string;
+    readonly workspaceId: string;
+    readonly orca?: OrcaCliOptions;
+}
+declare const fetchLinearIssue: (runner: CommandRunner, identifier: string, options: LinearWriteOptions) => Promise<LinearIssueDetail>;
+/** Deterministic UUID (v4 layout) derived from a stable key, for Orca's `--write-id` idempotency. */
+declare const writeIdFor: (key: string) => string;
+declare const linearStatusSetArgv: (input: {
+    readonly issue: string;
+    readonly to: string;
+    readonly workspaceId: string;
+}, bin?: string) => readonly string[];
+declare const linearCommentAddArgv: (input: {
+    readonly issue: string;
+    readonly body: string;
+    readonly workspaceId: string;
+    readonly writeId?: string;
+}, bin?: string) => readonly string[];
+declare const linearLabelArgv: (input: {
+    readonly issue: string;
+    readonly labels: readonly string[];
+    readonly workspaceId: string;
+    readonly action: "add" | "remove";
+}, bin?: string) => readonly string[];
+declare const linearAttachArgv: (input: {
+    readonly issue: string;
+    readonly url: string;
+    readonly title?: string;
+    readonly workspaceId: string;
+    readonly writeId?: string;
+}, bin?: string) => readonly string[];
+declare const linearStatusSet: (runner: CommandRunner, input: {
+    readonly issue: string;
+    readonly to: string;
+}, options: LinearWriteOptions) => Promise<unknown>;
+declare const linearCommentAdd: (runner: CommandRunner, input: {
+    readonly issue: string;
+    readonly body: string;
+    readonly dedupeKey?: string;
+}, options: LinearWriteOptions) => Promise<unknown>;
+declare const linearLabelAdd: (runner: CommandRunner, input: {
+    readonly issue: string;
+    readonly labels: readonly string[];
+}, options: LinearWriteOptions) => Promise<unknown>;
+declare const linearLabelRemove: (runner: CommandRunner, input: {
+    readonly issue: string;
+    readonly labels: readonly string[];
+}, options: LinearWriteOptions) => Promise<unknown>;
+declare const linearAttach: (runner: CommandRunner, input: {
+    readonly issue: string;
+    readonly url: string;
+    readonly title?: string;
+    readonly dedupeKey?: string;
+}, options: LinearWriteOptions) => Promise<unknown>;
+/** Harness `TrackingAdapter` over Linear: each transition becomes one `status set`, deduped by the harness idempotency key. */
+declare const createLinearTrackingAdapter: (runner: CommandRunner, options: LinearWriteOptions & {
+    readonly dryRun?: boolean;
+}) => TrackingAdapter;
+
+declare const LOOP_CONFIG_FILE = "loop.config.yaml";
+/** Optional, gitignored per-machine overlay merged over the versioned config (e.g. `linear.person`, `machine.minFreeRamGb`). */
+declare const LOOP_LOCAL_CONFIG_FILE = "loop.config.local.yaml";
+declare const LOOP_CONFIG_SCHEMA_VERSION = 1;
+declare const LoopConfigSchema: z.ZodObject<{
+    schemaVersion: z.ZodDefault<z.ZodLiteral<1>>;
+    project: z.ZodObject<{
+        name: z.ZodString;
+        repo: z.ZodString;
+        baseBranch: z.ZodDefault<z.ZodString>;
+        root: z.ZodDefault<z.ZodString>;
+        stateDir: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    orca: z.ZodPrefault<z.ZodObject<{
+        bin: z.ZodDefault<z.ZodString>;
+        repoSelector: z.ZodOptional<z.ZodString>;
+        workspaceSelector: z.ZodOptional<z.ZodString>;
+        host: z.ZodOptional<z.ZodString>;
+        minVersion: z.ZodDefault<z.ZodString>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    linear: z.ZodObject<{
+        workspaceId: z.ZodString;
+        teamKey: z.ZodString;
+        person: z.ZodString;
+        people: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        states: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        excludeLabels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        requireLabels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        projects: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        order: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            createdAt: "createdAt";
+            priority: "priority";
+            updatedAt: "updatedAt";
+        }>>>;
+        maxQueue: z.ZodDefault<z.ZodNumber>;
+        inProgressState: z.ZodDefault<z.ZodString>;
+        reviewState: z.ZodDefault<z.ZodString>;
+        doneState: z.ZodDefault<z.ZodString>;
+        blockedLabel: z.ZodDefault<z.ZodString>;
+        needsInfoLabel: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    models: z.ZodObject<{
+        orchestrator: z.ZodArray<z.ZodArray<z.ZodString>>;
+        reviewer: z.ZodArray<z.ZodArray<z.ZodString>>;
+        builder: z.ZodArray<z.ZodArray<z.ZodString>>;
+        watcher: z.ZodArray<z.ZodArray<z.ZodString>>;
+        cooldown: z.ZodPrefault<z.ZodObject<{
+            initialMin: z.ZodDefault<z.ZodNumber>;
+            maxMin: z.ZodDefault<z.ZodNumber>;
+            probeBeforeReenable: z.ZodDefault<z.ZodBoolean>;
+            exhaustedPercent: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+            bin: z.ZodString;
+            auth: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                subscription: "subscription";
+                "api-key": "api-key";
+            }>>;
+            envKeys: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            orcaAgent: z.ZodOptional<z.ZodString>;
+            orcaUsageKey: z.ZodOptional<z.ZodString>;
+            tui: z.ZodString;
+            probe: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            headless: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            reviewProvider: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    machine: z.ZodPrefault<z.ZodObject<{
+        floor: z.ZodDefault<z.ZodNumber>;
+        ceiling: z.ZodOptional<z.ZodNumber>;
+        minFreeRamGb: z.ZodDefault<z.ZodNumber>;
+        warningPercent: z.ZodDefault<z.ZodNumber>;
+        criticalPercent: z.ZodDefault<z.ZodNumber>;
+        agentRssMb: z.ZodDefault<z.ZodNumber>;
+        wslCap: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    delivery: z.ZodObject<{
+        verifyCommand: z.ZodString;
+        review: z.ZodPrefault<z.ZodObject<{
+            cli: z.ZodDefault<z.ZodString>;
+            mode: z.ZodDefault<z.ZodEnum<{
+                isolated: "isolated";
+                "trusted-local": "trusted-local";
+            }>>;
+            transport: z.ZodOptional<z.ZodEnum<{
+                headless: "headless";
+                acp: "acp";
+                auto: "auto";
+            }>>;
+            profile: z.ZodDefault<z.ZodEnum<{
+                fast: "fast";
+                full: "full";
+            }>>;
+            votes: z.ZodDefault<z.ZodNumber>;
+            concurrency: z.ZodDefault<z.ZodNumber>;
+            minSeverity: z.ZodDefault<z.ZodEnum<{
+                blocker: "blocker";
+                nit: "nit";
+                med: "med";
+                high: "high";
+            }>>;
+            deadlineMs: z.ZodDefault<z.ZodNumber>;
+            maxCalls: z.ZodDefault<z.ZodNumber>;
+            post: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        merge: z.ZodPrefault<z.ZodObject<{
+            auto: z.ZodDefault<z.ZodBoolean>;
+            method: z.ZodDefault<z.ZodEnum<{
+                squash: "squash";
+                merge: "merge";
+                rebase: "rebase";
+            }>>;
+            requireChecks: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        maxFixRounds: z.ZodDefault<z.ZodNumber>;
+        workerIdleTimeoutMin: z.ZodDefault<z.ZodNumber>;
+        selfEditPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        ignoreChecks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        requiredChecks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        cleanupWorktree: z.ZodDefault<z.ZodBoolean>;
+        returnState: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    contract: z.ZodPrefault<z.ZodObject<{
+        maxIssueChars: z.ZodDefault<z.ZodNumber>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxContextReferences: z.ZodDefault<z.ZodNumber>;
+        reuseHours: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    schedule: z.ZodPrefault<z.ZodObject<{
+        tick: z.ZodDefault<z.ZodString>;
+        deliver: z.ZodDefault<z.ZodString>;
+        precheckTimeoutSec: z.ZodDefault<z.ZodNumber>;
+        harnessCommand: z.ZodDefault<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        namePrefix: z.ZodDefault<z.ZodString>;
+        runner: z.ZodDefault<z.ZodEnum<{
+            agent: "agent";
+            precheck: "precheck";
+        }>>;
+        stageTimeoutSec: z.ZodDefault<z.ZodNumber>;
+        timezone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type LoopConfigInput = z.input<typeof LoopConfigSchema>;
+type LoopConfig = z.output<typeof LoopConfigSchema>;
+type LoopProviderConfig = LoopConfig['models']['providers'][string];
+interface ModelReference {
+    readonly provider: string;
+    readonly model: string;
+}
+interface LoadedLoopConfig {
+    readonly path: string;
+    /** Present when a `loop.config.local.yaml` overlay was merged in. */
+    readonly localPath?: string;
+    readonly root: string;
+    readonly stateDir: string;
+    readonly config: LoopConfig;
+    readonly configHash: string;
+}
+declare const parseModelRef: (value: string) => ModelReference;
+declare const tiersFor: (config: LoopConfig, role: ModelRole) => readonly (readonly ModelReference[])[];
+declare const validateLoopConfig: (value: unknown) => LoopConfig;
+/** Recursive merge: objects merge key by key, arrays and scalars from the overlay replace the base. */
+declare const mergeLoopConfig: (base: unknown, overlay: unknown) => unknown;
+declare const parseLoopConfigText: (text: string, localText?: string) => LoopConfig;
+declare const loadLoopConfig: (path?: string) => LoadedLoopConfig;
+/** Effective Orca agent id and usage key for a provider. */
+declare const providerIdentity: (config: LoopConfig, provider: string) => {
+    readonly orcaAgent: string;
+    readonly orcaUsageKey: string;
+    readonly settings: LoopProviderConfig;
+};
+declare const renderTuiCommand: (settings: LoopProviderConfig, model: string) => string;
+/** Substitute `{model}` / `{prompt}` inside each headless argv element; the prompt stays one argv element, never shell-joined. */
+declare const renderHeadlessArgv: (settings: LoopProviderConfig, model: string, prompt: string) => readonly string[] | null;
+
+/** Real, shell-free command runner for the loop composition layer. Output is capped; timeouts kill the process group. */
+declare const createProcessRunner: (defaults?: {
+    readonly timeoutMs?: number;
+    readonly maxOutputBytes?: number;
+    readonly env?: NodeJS.ProcessEnv;
+}) => CommandRunner;
+
+interface SlotAssessment {
+    readonly sample: MachineSample;
+    readonly platform: string;
+    readonly wsl: boolean;
+    readonly freeRamGb: number;
+    readonly ceiling: number;
+    readonly adaptive: number;
+    readonly ramBound: number;
+    readonly maxAgents: number;
+    readonly running: number;
+    readonly free: number;
+    readonly reasons: readonly string[];
+}
+interface SlotInput {
+    readonly machine: LoopConfig['machine'];
+    readonly running: number;
+    readonly sample?: MachineSample;
+    readonly platform?: NodeJS.Platform;
+    readonly osRelease?: string;
+    readonly freeBytes?: number;
+    readonly totalBytes?: number;
+}
+/** Parse `vm_stat` (macOS): reclaimable = free + inactive + speculative + purgeable pages. */
+declare const parseVmStat: (output: string) => number | null;
+/** Parse `/proc/meminfo` (Linux): MemAvailable already accounts for reclaimable cache. */
+declare const parseMemInfo: (text: string) => number | null;
+/** Bytes the OS can hand to a new process now — not just "free" pages, which macOS keeps near zero on purpose. */
+declare const availableMemoryBytes: (platform?: NodeJS.Platform) => number;
+declare const isWsl: (platform?: NodeJS.Platform, osRelease?: string, env?: NodeJS.ProcessEnv) => boolean;
+/** How many coding agents this machine can host right now: floor ≤ min(adaptive, RAM-bound, WSL cap) and never below the floor. */
+declare const assessSlots: (input: SlotInput) => SlotAssessment;
+
+interface RoutingSkip {
+    readonly tier: number;
+    readonly ref: ModelReference;
+    readonly reasons: readonly string[];
+}
+interface RoutingDecision {
+    readonly role: ModelRole;
+    readonly selected: (ModelReference & {
+        readonly tier: number;
+        readonly orcaAgent: string;
+        readonly tui: string;
+    }) | null;
+    readonly skipped: readonly RoutingSkip[];
+}
+/** Walk the role's tiers in order; inside a tier keep declaration order; first available provider wins. */
+declare const selectModel: (config: LoopConfig, role: ModelRole, availability: readonly ProviderAvailability[]) => RoutingDecision;
+declare const routeAllRoles: (config: LoopConfig, availability: readonly ProviderAvailability[]) => Readonly<Record<ModelRole, RoutingDecision>>;
+interface RankedModel extends ModelReference {
+    readonly tier: number;
+    readonly orcaAgent: string;
+    readonly tui: string;
+}
+/** Every available candidate for a role in preference order (tier, then declaration order). */
+declare const rankModels: (config: LoopConfig, role: ModelRole, availability: readonly ProviderAvailability[]) => readonly RankedModel[];
+
+interface CooldownEntry {
+    readonly attempts: number;
+    readonly until: string;
+    readonly reason: string;
+    readonly markedAt: string;
+}
+type CooldownState = Readonly<Record<string, CooldownEntry>>;
+declare const cooldownPath: (stateDir: string) => string;
+declare const readCooldowns: (stateDir: string) => CooldownState;
+/** Active cooldowns as provider → ISO until, dropping expired entries. */
+declare const activeCooldowns: (state: CooldownState, now?: Date) => Readonly<Record<string, string>>;
+declare const markProviderExhausted: (stateDir: string, provider: string, options: {
+    readonly initialMin: number;
+    readonly maxMin: number;
+    readonly reason: string;
+    readonly resetsAt?: string | null;
+    readonly now?: Date;
+}) => CooldownEntry;
+declare const clearProviderCooldown: (stateDir: string, provider: string) => void;
+
+type DoctorCheckStatus = 'passed' | 'warning' | 'failed';
+interface DoctorCheck {
+    readonly id: string;
+    readonly status: DoctorCheckStatus;
+    readonly detail: string;
+}
+interface LoopDoctorReport {
+    readonly status: 'passed' | 'failed';
+    readonly generatedAt: string;
+    readonly config: {
+        readonly path: string;
+        readonly hash: string;
+        readonly project: string;
+        readonly repo: string;
+        readonly person: string;
+        readonly stateDir: string;
+    };
+    readonly orca: {
+        readonly binary: string | null;
+        readonly version: string | null;
+        readonly minVersion: string;
+        readonly status: OrcaStatus | null;
+        readonly error: string | null;
+    };
+    readonly providers: readonly ProviderAvailability[];
+    readonly routing: Readonly<Record<string, RoutingDecision>>;
+    readonly machine: SlotAssessment;
+    readonly workers: {
+        readonly running: number;
+        readonly worktrees: readonly Pick<OrcaWorktree, 'id' | 'branch' | 'workspaceStatus' | 'linkedLinearIssue' | 'liveTerminalCount'>[];
+        readonly error: string | null;
+    };
+    readonly queue: {
+        readonly count: number;
+        readonly top: readonly Pick<LoopIssue, 'identifier' | 'title' | 'state' | 'priorityLabel' | 'branchName'>[];
+        readonly error: string | null;
+    };
+    readonly checks: readonly DoctorCheck[];
+}
+interface LoopDoctorInput {
+    readonly configPath?: string;
+    readonly loaded?: LoadedLoopConfig;
+    readonly runner: CommandRunner;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly platform?: NodeJS.Platform;
+    readonly now?: () => Date;
+    readonly probe?: boolean;
+    readonly queueTop?: number;
+}
+declare const providerSpecs: (config: LoopConfig) => readonly ProviderSpec[];
+/** Count worktrees the loop treats as live workers: not archived, not the main checkout, with a live terminal or a linked Linear issue. */
+declare const countRunningWorkers: (worktrees: readonly OrcaWorktree[]) => number;
+declare const runLoopDoctor: (input: LoopDoctorInput) => Promise<LoopDoctorReport>;
+
+interface GitHubCliOptions {
+    readonly bin?: string;
+    readonly timeoutMs?: number;
+    readonly cwd?: string;
+}
+type CheckOutcome = 'success' | 'failure' | 'pending' | 'skipped' | 'neutral' | 'unknown';
+interface PullRequestCheck {
+    readonly name: string;
+    readonly outcome: CheckOutcome;
+    readonly kind: 'check-run' | 'status' | 'unknown';
+}
+interface PullRequestSnapshot {
+    readonly number: number;
+    readonly url: string;
+    readonly title: string;
+    readonly state: 'OPEN' | 'CLOSED' | 'MERGED' | 'UNKNOWN';
+    readonly isDraft: boolean;
+    readonly author: string | null;
+    readonly authorIsBot: boolean;
+    readonly headRef: string;
+    readonly headSha: string;
+    readonly baseRef: string;
+    readonly mergeable: 'MERGEABLE' | 'CONFLICTING' | 'UNKNOWN';
+    readonly mergeState: string;
+    readonly reviewDecision: string;
+    readonly labels: readonly string[];
+    readonly files: readonly string[];
+    readonly checks: readonly PullRequestCheck[];
+    readonly updatedAt: string | null;
+}
+interface ChecksAssessment {
+    readonly status: 'green' | 'pending' | 'red' | 'missing';
+    readonly failing: readonly string[];
+    readonly pending: readonly string[];
+    readonly missingRequired: readonly string[];
+}
+declare const PR_FIELDS: readonly ["number", "url", "title", "state", "isDraft", "author", "headRefName", "headRefOid", "baseRefName", "mergeable", "mergeStateStatus", "reviewDecision", "labels", "files", "statusCheckRollup", "updatedAt"];
+declare const parsePullRequest: (value: unknown) => PullRequestSnapshot;
+/** Green only when every non-skipped check succeeded (or was neutral) and every required name was observed. A missing required check is never "green". */
+declare const assessChecks: (checks: readonly PullRequestCheck[], required?: readonly string[], ignore?: readonly string[]) => ChecksAssessment;
+/** Files matched by the configured self-edit globs (`**` = any depth, `*` = one path segment). */
+declare const touchesProtectedPaths: (files: readonly string[], patterns: readonly string[]) => readonly string[];
+declare const githubPullRequest: (runner: CommandRunner, input: {
+    readonly repo: string;
+    readonly number: number;
+}, options?: GitHubCliOptions) => Promise<PullRequestSnapshot>;
+/** Open PRs whose head branch equals `head` (exact match); empty when none. */
+declare const githubPullRequestsForBranch: (runner: CommandRunner, input: {
+    readonly repo: string;
+    readonly head: string;
+    readonly state?: "open" | "merged" | "closed" | "all";
+}, options?: GitHubCliOptions) => Promise<readonly PullRequestSnapshot[]>;
+declare const githubOpenPullRequests: (runner: CommandRunner, input: {
+    readonly repo: string;
+    readonly limit?: number;
+}, options?: GitHubCliOptions) => Promise<readonly PullRequestSnapshot[]>;
+/** Squash/merge via REST with optimistic concurrency on the reviewed head SHA; GitHub refuses when the head moved. */
+declare const githubMergeArgv: (input: {
+    readonly repo: string;
+    readonly number: number;
+    readonly headSha: string;
+    readonly method: "squash" | "merge" | "rebase";
+    readonly title?: string;
+}, bin?: string) => readonly string[];
+declare const githubMerge: (runner: CommandRunner, input: Parameters<typeof githubMergeArgv>[0], options?: GitHubCliOptions) => Promise<{
+    readonly merged: boolean;
+    readonly sha: string | null;
+    readonly message: string;
+}>;
+declare const githubCommentArgv: (input: {
+    readonly repo: string;
+    readonly number: number;
+    readonly body: string;
+}, bin?: string) => readonly string[];
+declare const githubComment: (runner: CommandRunner, input: Parameters<typeof githubCommentArgv>[0], options?: GitHubCliOptions) => Promise<void>;
+/** Issue/PR comments whose body contains `marker` — used for one-comment-per-head dedupe. */
+declare const githubCommentExists: (runner: CommandRunner, input: {
+    readonly repo: string;
+    readonly number: number;
+    readonly marker: string;
+}, options?: GitHubCliOptions) => Promise<boolean>;
+
+declare const CONTRACT_SCHEMA_VERSION = 1;
+declare const CONTRACT_OPEN = "<<<LOOP_CONTRACT";
+declare const CONTRACT_CLOSE = "LOOP_CONTRACT>>>";
+declare const ContractOutcomeSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    check: z.ZodObject<{
+        kind: z.ZodEnum<{
+            test: "test";
+            command: "command";
+            manual: "manual";
+        }>;
+        command: z.ZodOptional<z.ZodString>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const TaskContractSchema: z.ZodObject<{
+    intent: z.ZodString;
+    scope: z.ZodObject<{
+        inScope: z.ZodArray<z.ZodString>;
+        outOfScope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    outcomes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        check: z.ZodObject<{
+            kind: z.ZodEnum<{
+                test: "test";
+                command: "command";
+                manual: "manual";
+            }>;
+            command: z.ZodOptional<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    ambiguities: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        blocking: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    touchpoints: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    risks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type TaskContract = z.output<typeof TaskContractSchema>;
+interface StoredContract {
+    readonly schemaVersion: typeof CONTRACT_SCHEMA_VERSION;
+    readonly issue: string;
+    readonly issueUpdatedAt: string;
+    readonly generatedAt: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly contract: TaskContract;
+    readonly digest: string;
+    readonly assessment: ContractAssessment;
+    readonly source: 'llm' | 'manual';
+}
+interface ContractAssessment {
+    readonly dispatchable: boolean;
+    readonly reasons: readonly string[];
+}
+/** Dispatch only when at least one outcome maps to an executable check and no blocking ambiguity remains. */
+declare const assessContract: (contract: TaskContract) => ContractAssessment;
+declare const contractPath: (stateDir: string, identifier: string) => string;
+declare const readStoredContract: (stateDir: string, identifier: string) => StoredContract | null;
+declare const writeStoredContract: (stateDir: string, stored: StoredContract) => string;
+/** A cached contract is fresh when the issue has not changed since and it is younger than `reuseHours`. */
+declare const contractIsFresh: (stored: StoredContract, issue: Pick<LinearIssueDetail, "updatedAt">, reuseHours: number, now: Date) => boolean;
+/** Wrap untrusted text so the model treats it as data; the closing sentinel is unforgeable because we strip it from the payload. */
+declare const untrusted: (label: string, text: string) => string;
+declare const renderContractPrompt: (input: {
+    readonly issue: LinearIssueDetail;
+    readonly config: LoopConfig;
+    readonly references: readonly ContextReference[];
+}) => string;
+declare const parseContractOutput: (stdout: string) => TaskContract;
+declare const resolveDocContext: (root: string, query: string, max: number) => Promise<readonly ContextReference[]>;
+interface ProviderFailure {
+    readonly provider: string;
+    readonly model: string;
+    readonly kind: 'auth' | 'quota' | 'timeout' | 'output' | 'other';
+    readonly detail: string;
+}
+interface GenerateContractInput {
+    readonly runner: CommandRunner;
+    readonly config: LoopConfig;
+    readonly root: string;
+    readonly issue: LinearIssueDetail;
+    /** Preferred candidate list; falls back to `orchestrator.selected` when omitted. */
+    readonly candidates?: readonly RankedModel[];
+    readonly orchestrator?: RoutingDecision;
+    readonly now?: () => Date;
+    readonly references?: readonly ContextReference[];
+    /** Called when a candidate fails for a provider-level reason (auth/quota/timeout) before the next one is tried. */
+    readonly onProviderFailure?: (failure: ProviderFailure) => void;
+}
+declare const classifyProviderFailure: (detail: string, timedOut?: boolean) => ProviderFailure["kind"];
+declare const generateContract: (input: GenerateContractInput) => Promise<StoredContract>;
+
+interface WorkerBriefInput {
+    readonly issue: LinearIssueDetail;
+    readonly contract: StoredContract;
+    readonly config: LoopConfig;
+    readonly branch: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly maxIssueChars?: number;
+}
+/** The prompt a worker receives in its Orca terminal. Issue text is data; the contract and the rules are the instructions. */
+declare const renderWorkerBrief: (input: WorkerBriefInput) => string;
+
+type TickOutcome = 'dispatched' | 'dry-run' | 'skipped' | 'escalated' | 'failed';
+interface TickCandidateResult {
+    readonly issue: string;
+    readonly outcome: TickOutcome;
+    readonly reason: string;
+    readonly branch?: string;
+    readonly worktree?: string;
+    readonly worktreeId?: string;
+    readonly terminal?: string | null;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly argv?: readonly string[];
+    readonly contractDigest?: string;
+}
+interface TickReport {
+    readonly status: 'ok' | 'idle' | 'blocked';
+    readonly generatedAt: string;
+    readonly dryRun: boolean;
+    readonly slots: Pick<SlotAssessment, 'maxAgents' | 'running' | 'free' | 'reasons'>;
+    readonly routing: {
+        readonly orchestrator: string | null;
+        readonly builder: string | null;
+    };
+    readonly queue: {
+        readonly total: number;
+        readonly busy: readonly string[];
+        readonly candidates: readonly string[];
+    };
+    readonly results: readonly TickCandidateResult[];
+    readonly notes: readonly string[];
+}
+interface DispatchRecordFile {
+    readonly issue: string;
+    readonly worktreeId: string;
+    readonly worktree: string;
+    readonly branch: string;
+    readonly terminal: string | null;
+    readonly provider: string;
+    readonly model: string;
+    readonly contractDigest: string;
+    readonly leaseKey: string;
+    readonly leaseId: string;
+    readonly dispatchedAt: string;
+    readonly url: string;
+}
+interface TickInput {
+    readonly configPath?: string;
+    readonly loaded?: LoadedLoopConfig;
+    readonly runner: CommandRunner;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly platform?: NodeJS.Platform;
+    readonly now?: () => Date;
+    readonly dryRun?: boolean;
+    /** Upper bound on dispatches this tick, independent of free slots. */
+    readonly maxDispatch?: number;
+    /** Restrict the tick to one issue identifier (still subject to slots and filters). */
+    readonly onlyIssue?: string;
+    /** Skip contract generation when nothing is cached (dry runs); the candidate is reported instead of dispatched. */
+    readonly skipContractGeneration?: boolean;
+    readonly owner?: string;
+    /** Test seam: override live machine sampling. */
+    readonly machine?: Pick<SlotInput, 'sample' | 'freeBytes' | 'totalBytes' | 'osRelease'>;
+    /** Wall-clock budget for this tick; candidates that would not fit are left for the next tick. */
+    readonly budgetMs?: number;
+}
+/** Launch the worker in a fresh terminal with the configured TUI command and hand it the brief. Returns the terminal handle. */
+declare const launchWorkerTerminal: (input: {
+    readonly runner: CommandRunner;
+    readonly config: LoopConfig;
+    readonly worktreeId: string;
+    readonly command: string;
+    readonly title: string;
+    readonly brief: string;
+    readonly idleTimeoutMs?: number;
+}) => Promise<{
+    readonly terminal: string;
+    readonly accepted: boolean;
+    readonly idle: boolean;
+}>;
+/** Worktree name: last branch segment, lowercase, safe charset, ≤ 60 chars. */
+declare const worktreeNameFor: (issue: Pick<LoopIssue, "identifier" | "branchName">) => string;
+declare const branchFor: (issue: Pick<LoopIssue, "identifier" | "branchName">, person: string) => string;
+/** Issues the loop must not touch: active leases, worktrees already linked to the issue, or a worktree sitting on the issue's branch. */
+declare const busyIssues: (queue: readonly LoopIssue[], leases: readonly DispatchLease[], worktrees: readonly OrcaWorktree[], person: string) => ReadonlySet<string>;
+declare const dispatchRecordPath: (stateDir: string, identifier: string) => string;
+declare const readDispatchRecord: (stateDir: string, identifier: string) => DispatchRecordFile | null;
+declare const appendLoopEvent: (stateDir: string, event: Record<string, unknown>) => void;
+interface LoopState {
+    readonly providers: readonly ProviderAvailability[];
+    readonly routing: Readonly<Record<string, RoutingDecision>>;
+    readonly worktrees: readonly OrcaWorktree[];
+    readonly slots: SlotAssessment;
+    readonly queue: readonly LoopIssue[];
+    readonly leases: readonly DispatchLease[];
+    readonly busy: ReadonlySet<string>;
+    readonly candidates: readonly LoopIssue[];
+}
+declare const gatherLoopState: (input: {
+    readonly loaded: LoadedLoopConfig;
+    readonly runner: CommandRunner;
+    readonly ledger: DispatchLedger;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly platform?: NodeJS.Platform;
+    readonly now: () => Date;
+    readonly onlyIssue?: string;
+    readonly machine?: TickInput["machine"];
+}) => Promise<LoopState>;
+/** Read-only: exit-0 semantics for Orca `--precheck`. Work exists when a slot is free, a builder is routable, and a candidate waits. */
+declare const precheckTick: (input: Omit<TickInput, "dryRun" | "maxDispatch">) => Promise<{
+    readonly work: boolean;
+    readonly reason: string;
+    readonly free: number;
+    readonly candidates: number;
+}>;
+declare const runTick: (input: TickInput) => Promise<TickReport>;
+
+/** agentskit-review severities, weakest first. */
+declare const REVIEW_SEVERITIES: readonly ["nit", "med", "high", "blocker"];
+type ReviewSeverity = typeof REVIEW_SEVERITIES[number];
+interface ReviewFinding {
+    readonly severity: ReviewSeverity;
+    readonly file: string | null;
+    readonly line: number | null;
+    readonly title: string;
+    readonly detail: string;
+    readonly category: string | null;
+}
+interface CodeReviewOutcome {
+    /** `clean` = no finding at/above the floor; `findings` = blocking findings; `incomplete` = coverage/provider/tool failure. */
+    readonly status: 'clean' | 'findings' | 'incomplete';
+    readonly exitCode: number | null;
+    readonly findings: readonly ReviewFinding[];
+    readonly blocking: readonly ReviewFinding[];
+    readonly summary: string;
+    readonly provider: string;
+    readonly model: string | null;
+    readonly resultParsed: boolean;
+}
+interface CodeReviewInput {
+    readonly cli: string;
+    readonly repo: string;
+    readonly number: number;
+    readonly provider: string;
+    readonly model?: string;
+    /** `trusted-local` keeps the caller's env so CLI logins work; omitted = agentskit-review's isolated default. */
+    readonly mode?: 'trusted-local' | 'isolated';
+    /** agentskit-review transport override (`headless` needed for current grok-cli; ACP is broken on submit_batched_findings). */
+    readonly transport?: 'acp' | 'headless' | 'auto';
+    readonly profile: string;
+    readonly votes: number;
+    readonly concurrency?: number;
+    readonly minSeverity: ReviewSeverity;
+    readonly deadlineMs: number;
+    readonly maxCalls: number;
+    readonly post: boolean;
+    readonly resultFile: string;
+    readonly sarifFile?: string;
+    readonly cwd?: string;
+    readonly env?: NodeJS.ProcessEnv;
+}
+declare const severityRank: (severity: string) => number;
+declare const atLeast: (severity: string, floor: ReviewSeverity) => boolean;
+/** Read findings out of the `--result` JSON (the agent's review object) tolerating shape drift across CLI versions. */
+declare const parseReviewResult: (value: unknown) => {
+    readonly findings: readonly ReviewFinding[];
+    readonly blocking: boolean | null;
+    readonly incomplete: boolean | null;
+};
+declare const buildReviewArgv: (input: CodeReviewInput) => readonly string[];
+/** Run one review. Exit 0 = clean, 1 = findings at/above the floor, 2 = incomplete; the `--result` file refines the verdict. */
+declare const runCodeReview: (runner: CommandRunner, input: CodeReviewInput) => Promise<CodeReviewOutcome>;
+/** Compact, worker-facing rendering of blocking findings for a fix round. */
+declare const renderFindingsForWorker: (findings: readonly ReviewFinding[], max?: number) => string;
+
+type DeliverOutcome = 'waiting' | 'reviewed' | 'fix-round' | 'nudged' | 'merged' | 'held' | 'blocked' | 'stuck' | 'abandoned' | 'failed' | 'dry-run';
+interface DeliverResult {
+    readonly issue: string;
+    readonly outcome: DeliverOutcome;
+    readonly reason: string;
+    readonly pr?: number;
+    readonly head?: string;
+    readonly review?: Pick<CodeReviewOutcome, 'status' | 'summary' | 'provider' | 'model'>;
+    readonly actions: readonly string[];
+}
+interface DeliverReport {
+    readonly status: 'ok' | 'idle';
+    readonly generatedAt: string;
+    readonly dryRun: boolean;
+    readonly reviewer: string | null;
+    readonly results: readonly DeliverResult[];
+    readonly notes: readonly string[];
+}
+interface DeliveryState {
+    readonly issue: string;
+    readonly prNumber: number | null;
+    readonly reviews: Readonly<Record<string, {
+        readonly status: CodeReviewOutcome['status'];
+        readonly at: string;
+        readonly provider: string;
+        readonly model: string | null;
+        readonly blocking: number;
+        readonly attempts: number;
+    }>>;
+    readonly fixRounds: number;
+    readonly nudges: readonly {
+        readonly kind: 'idle' | 'conflict' | 'ci' | 'review';
+        readonly at: string;
+        readonly head: string | null;
+    }[];
+    readonly heldFor: string | null;
+    readonly finishedAt: string | null;
+    readonly finalOutcome: DeliverOutcome | null;
+}
+interface DeliverInput {
+    readonly configPath?: string;
+    readonly loaded?: LoadedLoopConfig;
+    readonly runner: CommandRunner;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly platform?: NodeJS.Platform;
+    readonly now?: () => Date;
+    readonly dryRun?: boolean;
+    readonly onlyIssue?: string;
+    /** Test seam: skip the `terminal wait --for tui-idle` probe and assume this idleness. */
+    readonly assumeIdle?: boolean;
+    /** Wall-clock budget for this deliver run; the review deadline is capped to fit inside it. */
+    readonly budgetMs?: number;
+}
+declare const deliveryStatePath: (stateDir: string, identifier: string) => string;
+declare const readDeliveryState: (stateDir: string, identifier: string) => DeliveryState;
+/** Every issue the loop dispatched and has not finished. */
+declare const listDispatched: (stateDir: string) => readonly DispatchRecordFile[];
+declare const precheckDeliver: (stateDir: string) => {
+    readonly work: boolean;
+    readonly reason: string;
+    readonly active: number;
+};
+declare const runDeliver: (input: DeliverInput) => Promise<DeliverReport>;
+
+type LoopStage = 'tick' | 'deliver';
+declare const LOOP_STAGES: readonly LoopStage[];
+interface InstallInput {
+    readonly configPath?: string;
+    readonly loaded?: LoadedLoopConfig;
+    readonly runner: CommandRunner;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly platform?: NodeJS.Platform;
+    readonly dryRun?: boolean;
+    /** Orca agent id override for the automation provider. */
+    readonly provider?: string;
+    readonly now?: () => Date;
+}
+interface InstallAction {
+    readonly name: string;
+    readonly stage: LoopStage;
+    readonly action: 'create' | 'edit' | 'remove' | 'skip';
+    readonly id: string | null;
+    readonly argv: readonly string[];
+    readonly detail: string;
+}
+interface InstallReport {
+    readonly status: 'ok' | 'dry-run' | 'failed';
+    readonly provider: string;
+    readonly workspace: string;
+    readonly actions: readonly InstallAction[];
+    readonly notes: readonly string[];
+}
+declare const automationName: (config: LoopConfig, stage: LoopStage) => string;
+/** Quote a path for Orca's precheck shell on every platform: double quotes, no backslash doubling (cmd.exe keeps `\\` literal). */
+declare const shellQuote: (value: string) => string;
+/** The exact command Orca runs before each scheduled run. `agent` runner: exit 0 = work exists. `precheck` runner: runs the whole stage and exits 1 so no agent is launched. */
+declare const precheckCommand: (config: LoopConfig, configPath: string, stage: LoopStage) => string;
+/** Prompt the automation agent receives: run the harness stage, report, do nothing else. */
+declare const automationPrompt: (config: LoopConfig, configPath: string, stage: LoopStage) => string;
+declare const automationSpecs: (loaded: LoadedLoopConfig, provider: string) => readonly (OrcaAutomationSpec & {
+    readonly stage: LoopStage;
+})[];
+declare const installLoopAutomations: (input: InstallInput) => Promise<InstallReport>;
+declare const uninstallLoopAutomations: (input: InstallInput) => Promise<InstallReport>;
+interface AutomationStatus {
+    readonly stage: LoopStage;
+    readonly name: string;
+    readonly installed: boolean;
+    readonly enabled: boolean;
+    readonly id: string | null;
+    readonly trigger: string | null;
+    readonly provider: string | null;
+    readonly lastRun: {
+        readonly at: string | null;
+        readonly status: string | null;
+        readonly summary?: string;
+    } | null;
+    readonly runs: number;
+}
+interface LoopStatusReport {
+    readonly installed: number;
+    readonly total: number;
+    readonly automations: readonly AutomationStatus[];
+    readonly summary: string;
+}
+declare const parseAutomationRuns: (result: unknown) => readonly {
+    readonly at: string | null;
+    readonly status: string | null;
+    readonly summary?: string;
+}[];
+declare const loopStatus: (input: Pick<InstallInput, "configPath" | "loaded" | "runner">) => Promise<LoopStatusReport>;
+
+interface GuidedInstallIO {
+    /** Ask a yes/no question; `fallback` is used when the answer is empty. */
+    readonly confirm: (question: string, fallback: boolean) => Promise<boolean>;
+    readonly write: (line: string) => void;
+    /** False when prompts cannot really be answered (no TTY); the local-config wizard never writes files in that mode. */
+    readonly interactive?: boolean;
+    /** Optional richer surface; plain implementations may omit these and get text fallbacks. */
+    readonly select?: (question: string, options: readonly {
+        readonly value: string;
+        readonly label: string;
+        readonly hint?: string;
+    }[], initial?: number) => Promise<string | null>;
+    readonly text?: (question: string, fallback: string, validate?: (value: string) => string | null) => Promise<string | null>;
+    readonly checks?: (checks: readonly DoctorCheck[]) => void;
+    readonly section?: (title: string, step?: number, total?: number) => void;
+    readonly banner?: (title: string, lines: readonly string[]) => void;
+    readonly bullet?: (line: string, tone?: 'ok' | 'warn' | 'fail' | 'dim') => void;
+}
+interface GuidedInstallInput {
+    readonly configPath?: string;
+    readonly loaded?: LoadedLoopConfig;
+    readonly runner: CommandRunner;
+    readonly io: GuidedInstallIO;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly platform?: NodeJS.Platform;
+    readonly now?: () => Date;
+    /** Accept every prompt (non-interactive). */
+    readonly yes?: boolean;
+    /** Continue past failed doctor checks. */
+    readonly force?: boolean;
+    /** Skip the optional dry-run tick rehearsal. */
+    readonly skipRehearsal?: boolean;
+    /** Do not offer to create loop.config.local.yaml when it is missing. */
+    readonly skipLocalConfig?: boolean;
+    readonly provider?: string;
+    readonly dryRun?: boolean;
+}
+interface GuidedInstallReport {
+    readonly status: 'installed' | 'dry-run' | 'aborted' | 'blocked';
+    readonly reason: string;
+    readonly localConfig: {
+        readonly path: string;
+        readonly created: boolean;
+    } | null;
+    readonly doctor: Pick<LoopDoctorReport, 'status' | 'checks'> | null;
+    readonly preflight: readonly DoctorCheck[];
+    readonly rehearsal: TickReport | null;
+    readonly install: InstallReport | null;
+    readonly after: LoopStatusReport | null;
+}
+/** Environment facts the doctor does not cover but the automations depend on. */
+declare const installPreflight: (loaded: LoadedLoopConfig, runner: CommandRunner, env: NodeJS.ProcessEnv, platform: NodeJS.Platform) => Promise<readonly DoctorCheck[]>;
+declare const runGuidedInstall: (input: GuidedInstallInput) => Promise<GuidedInstallReport>;
+
+interface SelectOption {
+    readonly value: string;
+    readonly label: string;
+    readonly hint?: string;
+}
+
+interface RichIO extends GuidedInstallIO {
+    readonly interactive: boolean;
+    readonly select: (question: string, options: readonly SelectOption[], initial?: number) => Promise<string | null>;
+    readonly text: (question: string, fallback: string, validate?: (value: string) => string | null) => Promise<string | null>;
+    readonly checks: (checks: readonly DoctorCheck[]) => void;
+    readonly section: (title: string, step?: number, total?: number) => void;
+    readonly banner: (title: string, lines: readonly string[]) => void;
+    readonly bullet: (line: string, tone?: 'ok' | 'warn' | 'fail' | 'dim') => void;
+}
+/** Ink-backed IO when stdin/stdout are TTYs; plain line output otherwise, with every prompt taking its fallback. */
+declare const createRichIO: () => RichIO;
+
+interface TeamMember {
+    readonly id: string;
+    readonly displayName: string;
+}
+declare const parseTeamMembers: (result: unknown) => readonly TeamMember[];
+declare const fetchTeamMembers: (runner: CommandRunner, loaded: LoadedLoopConfig) => Promise<readonly TeamMember[]>;
+interface LocalConfigAnswers {
+    readonly person: string;
+    readonly minFreeRamGb?: number;
+    readonly ceiling?: number;
+}
+/** Serialise the per-machine overlay: only the keys the person answered, with a header explaining what it is. */
+declare const renderLocalConfig: (answers: LocalConfigAnswers, versionedPath: string) => string;
+declare const localConfigPath: (loaded: LoadedLoopConfig) => string;
+declare const writeLocalConfig: (loaded: LoadedLoopConfig, answers: LocalConfigAnswers) => {
+    readonly path: string;
+    readonly loaded: LoadedLoopConfig;
+};
+declare const hasLocalConfig: (loaded: LoadedLoopConfig) => boolean;
+interface LocalConfigPrompter {
+    readonly select: (question: string, options: readonly {
+        readonly value: string;
+        readonly label: string;
+        readonly hint?: string;
+    }[], initial?: number) => Promise<string | null>;
+    readonly text: (question: string, fallback: string, validate?: (value: string) => string | null) => Promise<string | null>;
+    readonly confirm: (question: string, fallback: boolean) => Promise<boolean>;
+    readonly write: (line: string) => void;
+}
+/** Ask who this machine works for (from the Linear team) and how much of the machine the loop may take; returns null when cancelled. */
+declare const promptLocalConfig: (runner: CommandRunner, loaded: LoadedLoopConfig, io: LocalConfigPrompter, options?: {
+    readonly currentUserHint?: string;
+}) => Promise<LocalConfigAnswers | null>;
+
+interface DebriefInput {
+    readonly configPath?: string;
+    readonly loaded?: LoadedLoopConfig;
+    readonly issue?: string;
+    readonly since?: string;
+    readonly now?: () => Date;
+}
+interface DebriefIssueRow {
+    readonly issue: string;
+    readonly url: string | null;
+    readonly phase: string;
+    readonly summary: string;
+    readonly provider: string | null;
+    readonly model: string | null;
+    readonly worktree: string | null;
+    readonly branch: string | null;
+    readonly pr: number | null;
+    readonly prUrl: string | null;
+    readonly dispatchedAt: string | null;
+    readonly ageMin: number | null;
+    readonly fixRounds: number;
+    readonly reviewStatus: string | null;
+    readonly heldFor: string | null;
+    readonly finalOutcome: string | null;
+    readonly contractIntent: string | null;
+}
+interface DebriefReport {
+    readonly generatedAt: string;
+    readonly project: string;
+    readonly person: string;
+    readonly repo: string;
+    readonly windowHours: number;
+    readonly inFlight: readonly DebriefIssueRow[];
+    readonly held: readonly DebriefIssueRow[];
+    readonly recentEscalations: readonly {
+        readonly issue: string;
+        readonly at: string;
+        readonly reason: string;
+    }[];
+    readonly cooldowns: readonly {
+        readonly provider: string;
+        readonly reason: string;
+        readonly until: string;
+    }[];
+    readonly recentEvents: readonly {
+        readonly at: string;
+        readonly type: string;
+        readonly issue: string | null;
+    }[];
+    readonly headline: string;
+}
+/** Filesystem-only human debrief of what the loop is working on right now. No Orca/gh writes. */
+declare const buildDebriefReport: (input: DebriefInput) => DebriefReport;
+declare const renderDebriefMarkdown: (report: DebriefReport) => string;
+
+type WatchEventKind = 'DONE' | 'FAILED' | 'ACTION_REQUIRED' | 'PROGRESS';
+interface WatchEvent {
+    readonly kind: WatchEventKind;
+    readonly issue: string;
+    readonly message: string;
+    readonly phase: string;
+    readonly pr: number | null;
+    readonly finalOutcome: DeliverOutcome | null;
+    readonly at: string;
+}
+interface WatchTargetSnapshot {
+    readonly issue: string;
+    readonly phase: string;
+    readonly signature: string;
+    readonly delivery: DeliveryState;
+    readonly dispatch: DispatchRecordFile | null;
+    readonly pr: PullRequestSnapshot | null;
+}
+interface WatchInput {
+    readonly configPath?: string;
+    readonly loaded?: LoadedLoopConfig;
+    readonly runner?: CommandRunner;
+    readonly issue?: string;
+    readonly intervalMs?: number;
+    readonly once?: boolean;
+    readonly timeoutMs?: number;
+    readonly livePr?: boolean;
+    readonly now?: () => Date;
+    readonly sleep?: (ms: number) => Promise<void>;
+    readonly onEvent?: (event: WatchEvent) => void;
+}
+declare const classifyWatchPhase: (delivery: DeliveryState, pr: PullRequestSnapshot | null) => string;
+declare const classifyWatchEvent: (phase: string, delivery: DeliveryState, pr: PullRequestSnapshot | null, at: string, issue: string) => WatchEvent;
+declare const snapshotWatchTargets: (input: {
+    readonly loaded: LoadedLoopConfig;
+    readonly runner?: CommandRunner;
+    readonly issue?: string;
+    readonly livePr?: boolean;
+    readonly now?: () => Date;
+}) => Promise<readonly WatchTargetSnapshot[]>;
+interface WatchReport {
+    readonly status: 'done' | 'failed' | 'waiting' | 'action-required';
+    readonly generatedAt: string;
+    readonly events: readonly WatchEvent[];
+    readonly targets: readonly WatchTargetSnapshot[];
+}
+/** Poll delivery state (and optionally live PRs). Emits DONE / FAILED / ACTION_REQUIRED / PROGRESS. Read-only. */
+declare const watchDeliveries: (input: WatchInput) => Promise<WatchReport>;
+declare const formatWatchEvent: (event: WatchEvent) => string;
+
+interface LoopEvent {
+    readonly at: string;
+    readonly type: string;
+    readonly issue?: string;
+    readonly [key: string]: unknown;
+}
+interface RetroWindow {
+    readonly since: string;
+    readonly until: string;
+    readonly days: number;
+}
+interface RetroIssueRow {
+    readonly issue: string;
+    readonly outcome: string;
+    readonly provider: string | null;
+    readonly model: string | null;
+    readonly dispatchedAt: string | null;
+    readonly finishedAt: string | null;
+    readonly leadTimeMin: number | null;
+    readonly fixRounds: number;
+    readonly nudges: number;
+    readonly reviews: number;
+    readonly pr: number | null;
+}
+/** `project`: change the target project (loop.config.yaml, issues, process). `harness`: a defect or limitation of @agentskit/harness itself, to be filed against the library. */
+type RetroTarget = 'project' | 'harness';
+interface RetroSuggestion {
+    readonly id: string;
+    readonly target: RetroTarget;
+    readonly severity: 'info' | 'tune' | 'act';
+    readonly text: string;
+    readonly evidence: string;
+    readonly knob?: string;
+}
+declare const HARNESS_REPO_URL = "https://github.com/AgentsKit-io/harness";
+interface RetroReport {
+    readonly generatedAt: string;
+    readonly window: RetroWindow;
+    readonly project: string;
+    readonly person: string;
+    readonly counts: Readonly<Record<string, number>>;
+    readonly escalations: {
+        readonly total: number;
+        readonly issues: readonly string[];
+        readonly reasons: readonly {
+            readonly reason: string;
+            readonly count: number;
+        }[];
+    };
+    readonly dispatches: {
+        readonly total: number;
+        readonly failed: number;
+        readonly byProvider: Readonly<Record<string, number>>;
+    };
+    readonly delivery: {
+        readonly merged: number;
+        readonly blocked: number;
+        readonly stuck: number;
+        readonly abandoned: number;
+        readonly inFlight: number;
+        readonly fixRounds: number;
+        readonly reviewsClean: number;
+        readonly reviewsFindings: number;
+        readonly reviewsIncomplete: number;
+        readonly medianLeadTimeMin: number | null;
+    };
+    readonly providers: {
+        readonly cooldowns: readonly {
+            readonly provider: string;
+            readonly reason: string;
+            readonly until: string;
+        }[];
+        readonly cooldownEvents: number;
+    };
+    /** Signals about the library itself, taken from events the loop only emits when its own machinery misbehaved. */
+    readonly harness: {
+        readonly relaunches: number;
+        readonly dispatchFailures: readonly string[];
+        readonly contractFailures: readonly string[];
+        readonly mergeRefusals: number;
+        readonly reviewToolErrors: number;
+    };
+    readonly orca: {
+        readonly runs: number;
+        readonly idle: number;
+        readonly work: number;
+        readonly timedOut: number;
+        readonly avgDurationSec: number | null;
+        readonly maxDurationSec: number | null;
+    } | null;
+    readonly issues: readonly RetroIssueRow[];
+    readonly suggestions: readonly RetroSuggestion[];
+    readonly digest: string;
+}
+declare const readLoopEvents: (stateDir: string) => readonly LoopEvent[];
+declare const parseSince: (value: string | undefined, now: Date) => Date;
+/** Collapse an escalation reason to its head phrase so identical shapes group together. */
+declare const normalizeReason: (reason: string) => string;
+declare const buildSuggestions: (input: {
+    readonly config: LoopConfig;
+    readonly report: Omit<RetroReport, "suggestions" | "digest">;
+}) => readonly RetroSuggestion[];
+interface RetroInput {
+    readonly configPath?: string;
+    readonly loaded?: LoadedLoopConfig;
+    readonly runner?: CommandRunner;
+    readonly since?: string;
+    readonly now?: () => Date;
+    /** Skip the Orca run summary (offline). */
+    readonly skipOrca?: boolean;
+}
+declare const buildRetroReport: (input: RetroInput) => Promise<RetroReport>;
+/** Markdown digest. Headings follow the harness retro grammar (`## What worked`, `## Problems`, `## Adjustments`) so `parseRetro` can lift learnings from it. */
+declare const renderRetroMarkdown: (report: RetroReport) => string;
+/** Learnings the harness can track; a human promotes them with `promoteLearnings`. */
+declare const retroLearnings: (report: RetroReport, markdown: string) => readonly LearningRecord[];
+
+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 AutomationStatus, 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, CONTRACT_CLOSE, CONTRACT_OPEN, CONTRACT_SCHEMA_VERSION, type CacheUsage, type CapabilityDescriptor, type CapabilityKind, type CapabilityManifest, type CapabilityManifestInput, type ChangedFile, type CheckCategory, type CheckOutcome, type CheckResult, type ChecksAssessment, type ClaimResult, type CodeReviewInput, type CodeReviewOutcome, type CodingAgentAdapter, type CodingAgentHandlerResult, type CodingAgentRequest, type CodingAgentResult, type CommandResult, type CommandRunOptions, type CommandRunner, type CompatibilityComponent, type CompatibilityComponentId, type CompatibilityManifest, type CompatibilityObservation, type CompatibilityReport, type CompatibilityStatus, type ContextProvider, type ContextQuery, type ContextReference, type ContextSnapshot, type ContractAssessment, type ContractOutcome, ContractOutcomeSchema, type ContractScope, type CooldownEntry, type CooldownState, type CoordinationIdentity, type CriterionStatus, type CycleIterationMetrics, type CycleMatrixRow, type CycleStepResult, type CycleStepStatus, type DebriefInput, type DebriefIssueRow, type DebriefReport, type DecisionPacket, type DeliverInput, type DeliverOutcome, type DeliverReport, type DeliverResult, type DeliveryState, type DetectProvidersInput, type DiscoveryAmbiguity, type DiscoveryCurrentInput, type DiscoveryCurrentResult, type DiscoveryDecisionLogEntry, type DiscoveryInput, type DiscoveryOption, type DiscoveryResult, type DispatchLease, type DispatchLedger, type DispatchRecord, type DispatchRecordFile, type Disposer, type DockerMount, type DockerRuntimeEvidence, type DockerToolDefinition, type DoctorCheck, type DoctorCheckStatus, 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, type FetchQueueInput, FileArtifactStore, FileEventStore, type FilePreflightPlan, type GateAssessment, type GateBinding, type GateCriterion, type GenerateContractInput, type GitHubCliOptions, type GuidedInstallIO, type GuidedInstallInput, type GuidedInstallReport, HARNESS_ERROR_CATALOG, HARNESS_ERROR_CODES, HARNESS_EVENT_ENVELOPE_SCHEMA_VERSION, HARNESS_EVENT_SCHEMA_VERSION, HARNESS_EVENT_TYPES, HARNESS_PLUGIN_API_VERSION, HARNESS_REPO_URL, 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, type InstallAction, type InstallInput, type InstallReport, LEARNING_STATUSES, LEGAL_TRANSITIONS, LOOP_CONFIG_FILE, LOOP_CONFIG_SCHEMA_VERSION, LOOP_LOCAL_CONFIG_FILE, LOOP_STAGES, type LearningRecord, type LearningStatus, type LinearIssueDetail, type LinearListInput, type LinearQueueFilter, type LinearWriteOptions, type LlmCache, type LlmCacheKeyInput, type LlmCacheStats, type LoadedConfig, type LoadedLoopConfig, type LocalConfigAnswers, type LocalConfigPrompter, type LoopConfig, type LoopConfigInput, LoopConfigSchema, type LoopDoctorInput, type LoopDoctorReport, type LoopEvent, type LoopIssue, type LoopProviderConfig, type LoopStage, type LoopState, type LoopStatusReport, MEMORY_SCOPES, MODEL_ROLES, type MachineMetrics, type MachineSample, type MachineThresholds, type MemoryScope, type MemoryUsage, type MetricStatus, type ModelBinding, type ModelPolicy, type ModelReference, type ModelRole, type NormalizedPhaseProfile, type OptimizationComparison, type OptimizationObservation, type OrcaAgentHookState, type OrcaAutomation, type OrcaAutomationSpec, type OrcaCliOptions, type OrcaCreatedWorktree, type OrcaDispatchInput, type OrcaDispatchPlan, type OrcaLeaseState, type OrcaLifecycleInput, type OrcaLifecycleProjection, type OrcaStatus as OrcaRuntimeStatus, type OrcaSendReceipt, type OrcaTerminal, type OrcaWorktree, PHASE_DECISIONS, PHASE_EFFECTS, PHASE_EFFECT_ACTIONS, PHASE_MODES, PR_FIELDS, 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 ProviderAuthStatus, type ProviderAvailability, type ProviderFailure, type ProviderSpec, type ProviderUsage, type PullRequestApproval, type PullRequestCheck, type PullRequestDraft, type PullRequestSnapshot, QUALITY_DIMENSIONS, type QaTransitionAssessment, type QualityDimension, type QualityDimensionScore, type QualityMatrix, REVIEW_SEVERITIES, RUN_STATES, type RankedModel, type RecoveryObservation, type RecoveryPolicy, type RecoveryResult, type RepositoryProfile, type RetroInput, type RetroIssueRow, type RetroReport, type RetroSuggestion, type RetroTarget, type RetroWindow, type ReviewFinding, type ReviewLens, type ReviewSeverity, type ReviewVerdict, type RichIO, type RoutingDecision, type RoutingSkip, type RunOutcome, type RunReconciliation, type RunState, type RuntimeConfig, type RuntimeExperimentCandidate, type RuntimeExperimentResult, STATES, SURFACE_NAMES, type SessionRecorder, type SlotAssessment, type SlotInput, type SourceSnapshot, type StateTransition, type StatusBlock, type StatusSnapshot, type StoredContract, type StructuredEvidence, type SurfaceName, type SurfaceRequirement, type TaskContract, TaskContractSchema, type TeamMember, type TickCandidateResult, type TickInput, type TickOutcome, type TickReport, type TokenUsage, type ToolDefinition, type ToolExecutionRequest, type ToolExecutionResult, type ToolRuntime, type TrackingAdapter, type TrackingConfig, type TrackingTransition, type TrustedEvidenceKey, type UsageWindow, type VerificationCheck, type VerificationConfig, type VerificationRun, WIP_STATES, type WatchEvent, type WatchEventKind, type WatchInput, type WatchReport, type WatchTargetSnapshot, type WatchdogBlocker, type WatchdogBudget, type WatchdogResult, type WipAssessment, type WipAssessmentInput, type WipEntry, type WipState, type WorkerBriefInput, type WorkflowNode, type WorkflowResult, activeCooldowns, adaptiveConcurrency, appendLoopEvent, approveRun, approvedDecision, artifactDigest, artifactFilePath, artifactIsFresh, artifactMarkdownPath, assertHuman, assessAcceptance, assessAgentEval, assessBlock, assessChecks, assessCompatibility, assessContract, assessDiscovery, assessImprovementCycle, assessIntegration, assessPilot, assessPreflight, assessProduction, assessQaTransition, assessSlots, assessWip, assessWorktreeCleanup, atLeast, authStatusFor, authorizeRun, automationName, automationPrompt, automationSpecs, availableMemoryBytes, benchmarkRuns, branchFor, buildDebriefReport, buildListIssuesArgv, buildRetroReport, buildReviewArgv, buildSuggestions, busyIssues, cancelRun, classifyFailure, classifyHarnessError, classifyProviderFailure, classifyWatchEvent, classifyWatchPhase, cleanTaskArtifacts, clearProviderCooldown, compareOptimization, compareVersions, composePullRequest, contractIsFresh, contractPath, cooldownPath, cooldownUntil, countRunningWorkers, createArtifactEnvelope, createCapabilityManifest, createCodingAgentAdapter, createCompatibilityManifest, createConfiguredToolRuntime, createDispatchLedger, createDocBridgeContextProvider, createDockerToolRuntime, createEvalManifest, createHarnessEventEnvelope, createInMemoryMemoryAdapter, createKvMemoryAdapter, createLinearTrackingAdapter, createLlmCache, createLlmCacheKey, createMachineMonitor, createModelPolicy, createOrcaDispatchPlan, createOrcaLifecycleProjection, createPhaseArtifact, createPhaseProfile, createPluginRegistry, createPluginSlot, createPolicyGate, createProcessRunner, createProcessToolRuntime, createPullRequestApproval, createQualityMatrix, createRichIO, createSessionRecorder, createStatusSnapshot, createToolRuntime, createTrackingAdapter, createTrackingTransition, deliveryStatePath, detectProviders, dispatchRecordPath, evaluateWatchdog, executePhaseProfile, exportEvidenceBundle, fetchLinearIssue, fetchLinearQueue, fetchTeamMembers, filterAndOrderQueue, findExecutable, formatWatchEvent, gatherLoopState, generateContract, githubComment, githubCommentArgv, githubCommentExists, githubMerge, githubMergeArgv, githubOpenPullRequests, githubPullRequest, githubPullRequestsForBranch, hasLocalConfig, hashContextSnapshot, hashContextSnapshots, inspectEventLogLock, installLoopAutomations, installPreflight, isDiscoveryCurrent, isWsl, launchWorkerTerminal, linearAttach, linearAttachArgv, linearCommentAdd, linearCommentAddArgv, linearLabelAdd, linearLabelArgv, linearLabelRemove, linearStatusSet, linearStatusSetArgv, listDispatched, loadBenchmarkManifest, loadConfig, loadLatestRun, loadLoopConfig, localConfigPath, loopStatus, markProviderExhausted, mergeLoopConfig, modelFor, normalizeReason, orcaAccountList, orcaAgentHooks, orcaAutomationCreateArgv, orcaAutomationEditArgv, orcaAutomationRemove, orcaAutomationRun, orcaAutomationRuns, orcaAutomationsList, orcaJson, orcaStatus, orcaTerminalCreate, orcaTerminalList, orcaTerminalScreen, orcaTerminalSend, orcaTerminalWait, orcaVersion, orcaWorktreeCreate, orcaWorktreeRemove, orcaWorktreeSet, orcaWorktreeSetArgv, orcaWorktrees, parseAutomationRuns, parseContractOutput, parseJsonEnvelope, parseLinearIssueDetail, parseLinearIssues, parseLoopConfigText, parseMemInfo, parseModelRef, parseOrcaAgentHooks, parseOrcaAutomations, parseOrcaSendReceipt, parseOrcaStatus, parseOrcaTerminals, parseOrcaVersion, parseOrcaWorktreeCreate, parseOrcaWorktrees, parseProviderUsage, parsePullRequest, parseRetro, parseReviewResult, parseSince, parseTeamMembers, parseUsageWindows, parseVmStat, planFilePreflight, planPhaseProfile, planRun, precheckCommand, precheckDeliver, precheckTick, promoteLearnings, promptLocalConfig, providerIdentity, providerSpecs, rankModels, readArtifactFile, readContextSnapshots, readCooldowns, readDeliveryState, readDispatchRecord, readEvidenceTrustStore, readLoopEvents, readStoredContract, reconcileRun, recordBenchmarkObservation, recoverEventLogLock, recoveryDelayMs, renderArtifactMarkdown, renderContractPrompt, renderDebriefMarkdown, renderFindingsForWorker, renderHeadlessArgv, renderLocalConfig, renderRetroMarkdown, renderTuiCommand, renderWorkerBrief, resolveDocContext, resumeStateFromArtifacts, retroLearnings, retryRun, routeAllRoles, runAdversarialReview, runAgentEval, runCodeReview, runDeliver, runEvalBattery, runGuidedInstall, runLoopDoctor, runTick, runWithRecovery, runWorkflow, sampleMachine, selectModel, selectRuntime, severityRank, shellQuote, snapshotWatchTargets, startRun, summarizeMachine, tiersFor, touchesProtectedPaths, transition, uninstallLoopAutomations, unknownTelemetry, untrusted, validateAdapterMetadata, validateArtifactEnvelope, validateBenchmarkManifest, validateBlockManifest, validateCacheableOperation, validateCapabilityManifest, validateCompatibilityManifest, validateConfig, validateContextSnapshot, validateContextSnapshots, validateEvalManifest, validateHarnessErrorClassification, validateHarnessEventEnvelope, validateLoopConfig, validateMemoryRecord, validateOptimizationObservation, validatePhaseTelemetry, validateSafeCommand, validateStatusSnapshot, verifyEvidenceBundle, verifyPullRequestApproval, verifyRun, watchDeliveries, worktreeNameFor, writeIdFor, writeLocalConfig, writeStoredContract };