@agentskit/harness 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -735,8 +735,188 @@ interface DocBridgeContextProviderOptions {
     readonly root: string;
     readonly indexPath?: string;
 }
+interface DocBridgeIndexInspection {
+    readonly present: boolean;
+    readonly path: string;
+    readonly contentHash: string | null;
+    readonly mtimeMs: number | null;
+    readonly ageHours: number | null;
+    readonly error: string | null;
+}
+/** Read-only inspection for doctor freshness checks (no network, no rebuild). */
+declare const inspectDocBridgeIndex: (root: string, indexPath?: string, now?: number) => DocBridgeIndexInspection;
 declare const createDocBridgeContextProvider: ({ root, indexPath }: DocBridgeContextProviderOptions) => ContextProvider;
 
+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;
+
+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;
+type UsageMetric = 'max' | 'session' | 'weekly' | 'monthly';
+/** Remaining capacity 0–100 from usage windows, or null when unknown. `max` = most constrained window. */
+declare const remainingUsagePercent: (usage: ProviderUsage, metric?: UsageMetric) => number | null;
+/** Sort key for usage-aware ranking: higher remaining first; known before unknown when preferKnownUsage. */
+declare const usageRankTuple: (usage: ProviderUsage, metric: UsageMetric, preferKnownUsage: boolean) => readonly [number, number, number];
+/** Warn when Orca shows an integration that has no `models.providers` entry. */
+declare const undeclaredOrcaProviders: (accountList: unknown, declared: Readonly<Record<string, {
+    readonly orcaUsageKey?: string;
+}>>) => readonly string[];
+
+interface RagQueryResult {
+    readonly references: readonly ContextReference[];
+    readonly sourceHash: string;
+}
+interface RagContextProviderOptions {
+    /** Injected query function — callers wire `@agentskit/rag` (or any store) here; this package never imports it. */
+    readonly query: (query: ContextQuery) => Promise<RagQueryResult>;
+}
+interface ArgvRagContextProviderOptions {
+    readonly runner: CommandRunner;
+    /** Argv template; `{query}` and `{scope}` (JSON array) are substituted per element. */
+    readonly argv: readonly string[];
+    readonly timeoutMs?: number;
+    readonly cwd?: string;
+}
+/** Accept either a ContextSnapshot-shaped object or `{ references, sourceHash }`. Fail closed on anything else. */
+declare const parseRagQueryOutput: (value: unknown) => RagQueryResult;
+/** ContextProvider over an injected RAG query function. No static dependency on `@agentskit/rag`. */
+declare const createRagContextProvider: ({ query }: RagContextProviderOptions) => ContextProvider;
+/** ContextProvider that runs argv and parses stdout JSON as a ContextSnapshot or `{ references, sourceHash }`. */
+declare const createArgvRagContextProvider: ({ runner, argv, timeoutMs, cwd }: ArgvRagContextProviderOptions) => ContextProvider;
+
+interface PolicyRule {
+    readonly id: string;
+    readonly effect: 'allow' | 'block' | 'approve';
+    readonly toolIds: readonly string[];
+    readonly reason: string;
+}
+interface PolicyRequest {
+    readonly actionId: string;
+    readonly turnId: string;
+    readonly toolId: string;
+    readonly argumentsHash: string;
+}
+interface PolicyDecision {
+    readonly decision: 'allow' | 'block' | 'approve';
+    readonly policyId: string;
+    readonly reason: string;
+}
+interface PolicyGate {
+    evaluate(request: PolicyRequest): PolicyDecision;
+}
+declare const createPolicyGate: ({ rules }: {
+    readonly rules: readonly PolicyRule[];
+}) => PolicyGate;
+
+type McpPolicy = PolicyGate | {
+    readonly evaluate: (request: PolicyRequest) => PolicyDecision;
+};
+interface McpToolBridgeOptions {
+    readonly policy: McpPolicy;
+    readonly allowTools: readonly string[];
+    readonly call: (toolId: string, argsHash: string, args: unknown) => Promise<unknown>;
+}
+type McpToolCallResult = {
+    readonly status: 'ok';
+    readonly result: unknown;
+} | {
+    readonly status: 'blocked';
+    readonly reason: string;
+};
+interface McpToolCallInput {
+    readonly toolId: string;
+    readonly args?: unknown;
+    readonly argsHash?: string;
+    readonly actionId?: string;
+    readonly turnId?: string;
+}
+interface McpToolBridge {
+    readonly invoke: (input: McpToolCallInput) => Promise<McpToolCallResult>;
+}
+declare const hashMcpArgs: (args: unknown) => string;
+/**
+ * Adapter-only MCP tool bridge: default-deny allowlist + policy gate before any call.
+ * Not wired into loop tick/deliver in 0.6.0 (see ADR-0028).
+ */
+declare const createMcpToolBridge: ({ policy, allowTools, call }: McpToolBridgeOptions) => McpToolBridge;
+
 interface DiscoveryOption {
     readonly id: string;
     readonly summary: string;
@@ -1832,30 +2012,6 @@ declare const loadBenchmarkManifest: (path: string) => BenchmarkManifest;
 declare const recordBenchmarkObservation: (path: string, input: BenchmarkObservationInput) => BenchmarkManifest;
 declare const benchmarkRuns: (stateDir: string, manifest?: BenchmarkManifest) => BenchmarkReport;
 
-interface PolicyRule {
-    readonly id: string;
-    readonly effect: 'allow' | 'block' | 'approve';
-    readonly toolIds: readonly string[];
-    readonly reason: string;
-}
-interface PolicyRequest {
-    readonly actionId: string;
-    readonly turnId: string;
-    readonly toolId: string;
-    readonly argumentsHash: string;
-}
-interface PolicyDecision {
-    readonly decision: 'allow' | 'block' | 'approve';
-    readonly policyId: string;
-    readonly reason: string;
-}
-interface PolicyGate {
-    evaluate(request: PolicyRequest): PolicyDecision;
-}
-declare const createPolicyGate: ({ rules }: {
-    readonly rules: readonly PolicyRule[];
-}) => PolicyGate;
-
 interface AgentAdapter {
     readonly id: string;
     readonly version: string;
@@ -2195,31 +2351,6 @@ declare const verifyEvidenceBundle: (path: string, { trustedKeys }?: {
 }) => EvidenceBundleVerification;
 declare const readEvidenceTrustStore: (path: string) => readonly TrustedEvidenceKey[];
 
-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;
@@ -2359,64 +2490,6 @@ declare const orcaAutomationRemove: (runner: CommandRunner, id: string, options?
 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;
@@ -2577,6 +2650,77 @@ declare const LoopConfigSchema: z.ZodObject<{
         reviewer: z.ZodArray<z.ZodArray<z.ZodString>>;
         builder: z.ZodArray<z.ZodArray<z.ZodString>>;
         watcher: z.ZodArray<z.ZodArray<z.ZodString>>;
+        routing: z.ZodPrefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                tiers: "tiers";
+                hybrid: "hybrid";
+                dynamic: "dynamic";
+                catalog: "catalog";
+            }>>;
+            usageMetric: z.ZodDefault<z.ZodEnum<{
+                session: "session";
+                weekly: "weekly";
+                monthly: "monthly";
+                max: "max";
+            }>>;
+            preferKnownUsage: z.ZodDefault<z.ZodBoolean>;
+            excludeProviders: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            includeProviders: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            pin: z.ZodPrefault<z.ZodObject<{
+                orchestrator: z.ZodOptional<z.ZodString>;
+                reviewer: z.ZodOptional<z.ZodString>;
+                builder: z.ZodOptional<z.ZodString>;
+                watcher: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            pinStrict: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        roles: z.ZodPrefault<z.ZodObject<{
+            orchestrator: z.ZodPrefault<z.ZodObject<{
+                quality: z.ZodDefault<z.ZodEnum<{
+                    frontier: "frontier";
+                    balanced: "balanced";
+                    fast: "fast";
+                }>>;
+                preferCreators: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            reviewer: z.ZodPrefault<z.ZodObject<{
+                quality: z.ZodDefault<z.ZodEnum<{
+                    frontier: "frontier";
+                    balanced: "balanced";
+                    fast: "fast";
+                }>>;
+                preferCreators: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            builder: z.ZodPrefault<z.ZodObject<{
+                quality: z.ZodDefault<z.ZodEnum<{
+                    frontier: "frontier";
+                    balanced: "balanced";
+                    fast: "fast";
+                }>>;
+                preferCreators: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            watcher: z.ZodPrefault<z.ZodObject<{
+                quality: z.ZodDefault<z.ZodEnum<{
+                    frontier: "frontier";
+                    balanced: "balanced";
+                    fast: "fast";
+                }>>;
+                preferCreators: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        catalog: z.ZodPrefault<z.ZodObject<{
+            sources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                cli: "cli";
+                "artificial-analysis": "artificial-analysis";
+                builtin: "builtin";
+            }>>>;
+            artificialAnalysis: z.ZodPrefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                apiKeyEnv: z.ZodDefault<z.ZodString>;
+                cacheHours: z.ZodDefault<z.ZodNumber>;
+                endpoint: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
         cooldown: z.ZodPrefault<z.ZodObject<{
             initialMin: z.ZodDefault<z.ZodNumber>;
             maxMin: z.ZodDefault<z.ZodNumber>;
@@ -2636,6 +2780,10 @@ declare const LoopConfigSchema: z.ZodObject<{
             deadlineMs: z.ZodDefault<z.ZodNumber>;
             maxCalls: z.ZodDefault<z.ZodNumber>;
             post: z.ZodDefault<z.ZodBoolean>;
+            doctorProbe: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                help: "help";
+            }>>;
         }, z.core.$strip>>;
         merge: z.ZodPrefault<z.ZodObject<{
             auto: z.ZodDefault<z.ZodBoolean>;
@@ -2646,6 +2794,26 @@ declare const LoopConfigSchema: z.ZodObject<{
             }>>;
             requireChecks: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>>;
+        smoke: z.ZodPrefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            kind: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                "verify-argv": "verify-argv";
+            }>>;
+            argv: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        verify: z.ZodPrefault<z.ZodObject<{
+            runtime: z.ZodDefault<z.ZodEnum<{
+                docker: "docker";
+                process: "process";
+            }>>;
+            argv: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            docker: z.ZodPrefault<z.ZodObject<{
+                image: z.ZodDefault<z.ZodString>;
+                cwd: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
         maxFixRounds: z.ZodDefault<z.ZodNumber>;
         workerIdleTimeoutMin: z.ZodDefault<z.ZodNumber>;
         selfEditPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -2659,10 +2827,62 @@ declare const LoopConfigSchema: z.ZodObject<{
         timeoutMs: z.ZodDefault<z.ZodNumber>;
         maxContextReferences: z.ZodDefault<z.ZodNumber>;
         reuseHours: z.ZodDefault<z.ZodNumber>;
+        docBridgeMaxAgeHours: z.ZodDefault<z.ZodNumber>;
+        requireDocBridge: z.ZodDefault<z.ZodBoolean>;
+        briefScopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        maxBriefReferences: z.ZodDefault<z.ZodNumber>;
+        contextProviders: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            "doc-bridge": "doc-bridge";
+            rag: "rag";
+        }>>>;
+    }, z.core.$strip>>;
+    memory: z.ZodPrefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        backend: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            file: "file";
+        }>>;
+        storePath: z.ZodDefault<z.ZodString>;
+        maxRecall: z.ZodDefault<z.ZodNumber>;
+        maxSummaryChars: z.ZodDefault<z.ZodNumber>;
+        maxBlockChars: z.ZodDefault<z.ZodNumber>;
+        preferOverDocBridge: z.ZodDefault<z.ZodBoolean>;
+        minDocBridgeWhenMemory: z.ZodDefault<z.ZodNumber>;
+        scopes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            project: "project";
+            issue: "issue";
+            global: "global";
+        }>>>;
+        includeStale: z.ZodDefault<z.ZodBoolean>;
+        writeOnPromote: z.ZodDefault<z.ZodBoolean>;
+        categories: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            adjustment: "adjustment";
+            worked: "worked";
+            problem: "problem";
+            other: "other";
+        }>>>;
+        shrinkIssueCharsWhenMemory: z.ZodDefault<z.ZodBoolean>;
+        issueCharsWithMemory: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    agents: z.ZodPrefault<z.ZodObject<{
+        registryPath: z.ZodDefault<z.ZodString>;
+        requireRegistry: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    rag: z.ZodPrefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        queryArgv: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxReferences: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    mcp: z.ZodPrefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        allowTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     schedule: z.ZodPrefault<z.ZodObject<{
         tick: z.ZodDefault<z.ZodString>;
         deliver: z.ZodDefault<z.ZodString>;
+        retro: z.ZodOptional<z.ZodString>;
+        retroIssue: z.ZodOptional<z.ZodString>;
         precheckTimeoutSec: z.ZodDefault<z.ZodNumber>;
         harnessCommand: z.ZodDefault<z.ZodString>;
         provider: z.ZodOptional<z.ZodString>;
@@ -2708,6 +2928,42 @@ declare const renderTuiCommand: (settings: LoopProviderConfig, model: 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;
 
+declare const AGENT_REGISTRY_SCHEMA_VERSION: 1;
+declare const AgentRegistryEntrySchema: z.ZodObject<{
+    role: z.ZodOptional<z.ZodString>;
+    provider: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    tui: z.ZodOptional<z.ZodString>;
+    headless: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const AgentRegistrySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    agents: z.ZodRecord<z.ZodString, z.ZodObject<{
+        role: z.ZodOptional<z.ZodString>;
+        provider: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        tui: z.ZodOptional<z.ZodString>;
+        headless: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    roles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+type AgentRegistryEntry = z.output<typeof AgentRegistryEntrySchema>;
+type AgentRegistry = z.output<typeof AgentRegistrySchema>;
+interface ResolvedAgent {
+    readonly agentId: string;
+    readonly entry: AgentRegistryEntry;
+    readonly role: string;
+}
+/** Parse and validate an agents.registry.yaml document. Fail closed on schema drift. */
+declare const parseAgentRegistryText: (text: string, label?: string) => AgentRegistry;
+/** Load agents.registry.yaml from disk. Missing file fails closed. */
+declare const loadAgentRegistry: (path: string) => AgentRegistry;
+/**
+ * Resolve a role to a registry agent. Prefer `roles[role]` → `agents[id]`, else the first agent
+ * whose `role` field matches. Fail closed when neither mapping exists.
+ */
+declare const resolveAgentForRole: (registry: AgentRegistry, role: string) => ResolvedAgent;
+
 /** 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;
@@ -2752,25 +3008,77 @@ interface RoutingSkip {
     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;
+    readonly remainingPercent: number | null;
+    readonly reason: string;
+    readonly preferenceIndex: number;
 }
-/** 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 RoutingDecision {
+    readonly role: ModelRole;
+    readonly selected: RankedModel | null;
+    readonly skipped: readonly RoutingSkip[];
+}
+/**
+ * Walk the role's candidates according to `models.routing.mode`.
+ * - tiers: declaration order (0.6 behaviour)
+ * - hybrid: keep tier bands; within a tier pick highest remaining usage
+ * - dynamic: flatten all YAML candidates; sort by remaining usage
+ * - catalog: same as dynamic over YAML seeds for now; catalog enrichment is applied by `rankModels` callers that pass extra refs via `extraCandidates`
+ */
+declare const selectModel: (config: LoopConfig, role: ModelRole, availability: readonly ProviderAvailability[], extraCandidates?: readonly ModelReference[]) => RoutingDecision;
+declare const routeAllRoles: (config: LoopConfig, availability: readonly ProviderAvailability[], extrasByRole?: Partial<Record<ModelRole, readonly ModelReference[]>>) => Readonly<Record<ModelRole, RoutingDecision>>;
+/** Every available candidate for a role in preference / usage order. */
+declare const rankModels: (config: LoopConfig, role: ModelRole, availability: readonly ProviderAvailability[], extraCandidates?: readonly ModelReference[]) => readonly RankedModel[];
+
+type ModelQuality = 'frontier' | 'balanced' | 'fast';
+interface CatalogModel {
+    readonly id: string;
+    readonly quality: ModelQuality;
+    readonly codingScore: number;
+    readonly source: 'cli' | 'artificial-analysis' | 'builtin' | 'yaml';
+    readonly creator?: string;
+}
+interface ProviderCatalog {
+    readonly creator?: string;
+    readonly models: readonly CatalogModel[];
+}
+declare const loadBuiltinCatalog: () => Readonly<Record<string, ProviderCatalog>>;
+declare const loadAliases: () => Readonly<Record<string, Readonly<Record<string, string>>>>;
+declare const resolveAlias: (provider: string, modelId: string, aliases?: Readonly<Record<string, Readonly<Record<string, string>>>>) => string;
+/** Parse `grok models` human output into model ids. */
+declare const parseGrokModelsOutput: (stdout: string) => readonly string[];
+declare const listCliModels: (provider: string, bin: string, runner: CommandRunner, timeoutMs?: number) => Promise<readonly string[]>;
+interface ArtificialAnalysisModel {
+    readonly slug: string;
+    readonly name: string;
+    readonly creatorSlug: string;
+    readonly codingIndex: number | null;
+    readonly intelligenceIndex: number | null;
+}
+declare const parseArtificialAnalysisPayload: (payload: unknown) => readonly ArtificialAnalysisModel[];
+declare const readAaCache: (stateDir: string) => {
+    readonly fetchedAt: string;
+    readonly models: readonly ArtificialAnalysisModel[];
+} | null;
+declare const writeAaCache: (stateDir: string, models: readonly ArtificialAnalysisModel[]) => void;
+declare const fetchArtificialAnalysisModels: (input: {
+    readonly endpoint: string;
+    readonly apiKey: string;
+    readonly timeoutMs?: number;
+}) => Promise<readonly ArtificialAnalysisModel[]>;
+/** Build catalog candidates for a role from CLI + builtin + optional AA, filtered by quality band. */
+declare const resolveCatalogCandidates: (input: {
+    readonly config: LoopConfig;
+    readonly role: ModelRole;
+    readonly availableProviderIds: readonly string[];
+    readonly runner?: CommandRunner;
+    readonly stateDir?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly now?: () => Date;
+}) => Promise<readonly ModelReference[]>;
 
 interface CooldownEntry {
     readonly attempts: number;
@@ -2928,6 +3236,70 @@ declare const githubCommentExists: (runner: CommandRunner, input: {
     readonly marker: string;
 }, options?: GitHubCliOptions) => Promise<boolean>;
 
+interface MemoryPromptSelection {
+    readonly hits: readonly AgentMemoryHit[];
+    readonly block: string;
+    readonly approxChars: number;
+}
+interface MemoryContextPlan {
+    readonly hits: readonly AgentMemoryHit[];
+    readonly references: readonly ContextReference[];
+    readonly memoryBlock: string;
+    readonly issueCharBudget: number;
+    readonly approxCharsSaved: number;
+    readonly memoryDigest: string;
+    readonly docBridgeBefore: number;
+    readonly docBridgeAfter: number;
+}
+/** Atomic JSON file KV under `dir` (index + one file per record). */
+declare const createFileMemoryKvStore: (dir: string) => AgentMemoryKvStore;
+declare const createFileMemoryAdapter: (dir: string, options?: {
+    readonly id?: string;
+    readonly version?: string;
+}) => AgentMemoryAdapter;
+declare const openLoopMemory: (loaded: LoadedLoopConfig) => AgentMemoryAdapter | null;
+declare const memoryDigestOf: (hits: readonly AgentMemoryHit[]) => string;
+/** Cap, filter stale/scope, and render a bounded “Approved memory” markdown block. */
+declare const selectMemoryForPrompt: (hits: readonly AgentMemoryHit[], config: LoopConfig["memory"]) => MemoryPromptSelection;
+/** Prefer memory over Doc Bridge so adding memory reduces (not increases) prompt size. */
+declare const preferMemoryOverDocBridge: (references: readonly ContextReference[], hits: readonly AgentMemoryHit[], minKeep: number) => {
+    readonly references: readonly ContextReference[];
+    readonly dropped: number;
+};
+declare const planMemoryContext: (input: {
+    readonly adapter: AgentMemoryAdapter | null;
+    readonly config: LoopConfig;
+    readonly issueId: string;
+    readonly issueTitle: string;
+    readonly project: string;
+    readonly references: readonly ContextReference[];
+    readonly sourceRevision?: string;
+}) => Promise<MemoryContextPlan>;
+declare const learningToMemoryRecord: (learning: LearningRecord, meta: {
+    readonly project: string;
+    readonly sourceRevision: string;
+    readonly scope?: MemoryScope;
+}) => AgentMemoryRecord;
+interface LearningsLedger {
+    readonly records: readonly LearningRecord[];
+}
+declare const learningsPath: (stateDir: string) => string;
+declare const readLearningsLedger: (stateDir: string) => LearningsLedger;
+declare const writeLearningsLedger: (stateDir: string, ledger: LearningsLedger) => void;
+/** Merge proposed learnings into the ledger without changing promoted/rejected rows. */
+declare const upsertProposedLearnings: (stateDir: string, proposed: readonly LearningRecord[]) => LearningsLedger;
+declare const promoteLearningsToMemory: (input: {
+    readonly stateDir: string;
+    readonly config: LoopConfig;
+    readonly adapter: AgentMemoryAdapter | null;
+    readonly ids: readonly string[];
+    readonly actor: string;
+    readonly sourceRevision: string;
+}) => Promise<{
+    readonly ledger: LearningsLedger;
+    readonly remembered: readonly string[];
+}>;
+
 declare const CONTRACT_SCHEMA_VERSION = 1;
 declare const CONTRACT_OPEN = "<<<LOOP_CONTRACT";
 declare const CONTRACT_CLOSE = "LOOP_CONTRACT>>>";
@@ -2982,6 +3354,8 @@ interface StoredContract {
     readonly digest: string;
     readonly assessment: ContractAssessment;
     readonly source: 'llm' | 'manual';
+    /** Digest of approved memory hits frozen with this contract (invalidates reuse when memory changes). */
+    readonly memoryDigest?: string;
 }
 interface ContractAssessment {
     readonly dispatchable: boolean;
@@ -2992,17 +3366,19 @@ 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;
+/** A cached contract is fresh when the issue has not changed since, it is younger than `reuseHours`, and memory digest still matches. */
+declare const contractIsFresh: (stored: StoredContract, issue: Pick<LinearIssueDetail, "updatedAt">, reuseHours: number, now: Date, memoryDigest?: string) => 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[];
+    readonly memoryBlock?: string;
+    readonly maxIssueChars?: number;
 }) => string;
 declare const parseContractOutput: (stdout: string) => TaskContract;
-declare const resolveDocContext: (root: string, query: string, max: number) => Promise<readonly ContextReference[]>;
+declare const resolveDocContext: (root: string, query: string, max: number, scopes?: readonly string[]) => Promise<readonly ContextReference[]>;
 interface ProviderFailure {
     readonly provider: string;
     readonly model: string;
@@ -3019,8 +3395,12 @@ interface GenerateContractInput {
     readonly orchestrator?: RoutingDecision;
     readonly now?: () => Date;
     readonly references?: readonly ContextReference[];
+    /** Optional approved-memory adapter (token reduction). Fail-soft when omitted. */
+    readonly memory?: AgentMemoryAdapter | null;
     /** Called when a candidate fails for a provider-level reason (auth/quota/timeout) before the next one is tried. */
     readonly onProviderFailure?: (failure: ProviderFailure) => void;
+    /** Observability for memory/doc-bridge char budgets. */
+    readonly onMemoryPlan?: (plan: MemoryContextPlan) => void;
 }
 declare const classifyProviderFailure: (detail: string, timedOut?: boolean) => ProviderFailure["kind"];
 declare const generateContract: (input: GenerateContractInput) => Promise<StoredContract>;
@@ -3033,6 +3413,10 @@ interface WorkerBriefInput {
     readonly provider: string;
     readonly model: string;
     readonly maxIssueChars?: number;
+    /** Pre-rendered approved memory block (from `selectMemoryForPrompt`). */
+    readonly memoryBlock?: string;
+    /** Doc Bridge playbook/for-agents refs (titles/paths only). */
+    readonly guidanceRefs?: readonly ContextReference[];
 }
 /** 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;
@@ -3275,7 +3659,7 @@ declare const precheckDeliver: (stateDir: string) => {
 };
 declare const runDeliver: (input: DeliverInput) => Promise<DeliverReport>;
 
-type LoopStage = 'tick' | 'deliver';
+type LoopStage = 'tick' | 'deliver' | 'retro';
 declare const LOOP_STAGES: readonly LoopStage[];
 interface InstallInput {
     readonly configPath?: string;
@@ -3670,5 +4054,21 @@ declare const buildRetroReport: (input: RetroInput) => Promise<RetroReport>;
 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[];
+interface RetroStageReport {
+    readonly status: 'ok' | 'skipped' | 'failed' | 'dry-run';
+    readonly issue: string | null;
+    readonly digest: string | null;
+    readonly posted: boolean;
+    readonly learningsProposed: number;
+    readonly detail: string;
+}
+/** Build the weekly digest, upsert proposed learnings, and comment on `schedule.retroIssue` (idempotent write-id). */
+declare const runRetroStage: (input: {
+    readonly configPath?: string;
+    readonly loaded?: LoadedLoopConfig;
+    readonly runner: CommandRunner;
+    readonly since?: string;
+    readonly dryRun?: boolean;
+}) => Promise<RetroStageReport>;
 
-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 };
+export { AGENT_REGISTRY_SCHEMA_VERSION, 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 AgentRegistry, type AgentRegistryEntry, AgentRegistryEntrySchema, AgentRegistrySchema, type AgentSessionOptions, type AgentUsage, type ApprovedAssumption, type ArgvRagContextProviderOptions, type ArtifactBinding, type ArtifactEnvelope, type ArtifactEnvelopeInput, type ArtifactType, type ArtificialAnalysisModel, 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 CatalogModel, 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 DocBridgeIndexInspection, 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 LearningsLedger, 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 McpPolicy, type McpToolBridge, type McpToolBridgeOptions, type McpToolCallInput, type McpToolCallResult, type MemoryContextPlan, type MemoryPromptSelection, type MemoryScope, type MemoryUsage, type MetricStatus, type ModelBinding, type ModelPolicy, type ModelQuality, 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 ProviderCatalog, 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 RagContextProviderOptions, type RagQueryResult, type RankedModel, type RecoveryObservation, type RecoveryPolicy, type RecoveryResult, type RepositoryProfile, type ResolvedAgent, type RetroInput, type RetroIssueRow, type RetroReport, type RetroStageReport, 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 UsageMetric, 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, createArgvRagContextProvider, createArtifactEnvelope, createCapabilityManifest, createCodingAgentAdapter, createCompatibilityManifest, createConfiguredToolRuntime, createDispatchLedger, createDocBridgeContextProvider, createDockerToolRuntime, createEvalManifest, createFileMemoryAdapter, createFileMemoryKvStore, createHarnessEventEnvelope, createInMemoryMemoryAdapter, createKvMemoryAdapter, createLinearTrackingAdapter, createLlmCache, createLlmCacheKey, createMachineMonitor, createMcpToolBridge, createModelPolicy, createOrcaDispatchPlan, createOrcaLifecycleProjection, createPhaseArtifact, createPhaseProfile, createPluginRegistry, createPluginSlot, createPolicyGate, createProcessRunner, createProcessToolRuntime, createPullRequestApproval, createQualityMatrix, createRagContextProvider, createRichIO, createSessionRecorder, createStatusSnapshot, createToolRuntime, createTrackingAdapter, createTrackingTransition, deliveryStatePath, detectProviders, dispatchRecordPath, evaluateWatchdog, executePhaseProfile, exportEvidenceBundle, fetchArtificialAnalysisModels, fetchLinearIssue, fetchLinearQueue, fetchTeamMembers, filterAndOrderQueue, findExecutable, formatWatchEvent, gatherLoopState, generateContract, githubComment, githubCommentArgv, githubCommentExists, githubMerge, githubMergeArgv, githubOpenPullRequests, githubPullRequest, githubPullRequestsForBranch, hasLocalConfig, hashContextSnapshot, hashContextSnapshots, hashMcpArgs, inspectDocBridgeIndex, inspectEventLogLock, installLoopAutomations, installPreflight, isDiscoveryCurrent, isWsl, launchWorkerTerminal, learningToMemoryRecord, learningsPath, linearAttach, linearAttachArgv, linearCommentAdd, linearCommentAddArgv, linearLabelAdd, linearLabelArgv, linearLabelRemove, linearStatusSet, linearStatusSetArgv, listCliModels, listDispatched, loadAgentRegistry, loadAliases, loadBenchmarkManifest, loadBuiltinCatalog, loadConfig, loadLatestRun, loadLoopConfig, localConfigPath, loopStatus, markProviderExhausted, memoryDigestOf, mergeLoopConfig, modelFor, normalizeReason, openLoopMemory, orcaAccountList, orcaAgentHooks, orcaAutomationCreateArgv, orcaAutomationEditArgv, orcaAutomationRemove, orcaAutomationRun, orcaAutomationRuns, orcaAutomationsList, orcaJson, orcaStatus, orcaTerminalCreate, orcaTerminalList, orcaTerminalScreen, orcaTerminalSend, orcaTerminalWait, orcaVersion, orcaWorktreeCreate, orcaWorktreeRemove, orcaWorktreeSet, orcaWorktreeSetArgv, orcaWorktrees, parseAgentRegistryText, parseArtificialAnalysisPayload, parseAutomationRuns, parseContractOutput, parseGrokModelsOutput, parseJsonEnvelope, parseLinearIssueDetail, parseLinearIssues, parseLoopConfigText, parseMemInfo, parseModelRef, parseOrcaAgentHooks, parseOrcaAutomations, parseOrcaSendReceipt, parseOrcaStatus, parseOrcaTerminals, parseOrcaVersion, parseOrcaWorktreeCreate, parseOrcaWorktrees, parseProviderUsage, parsePullRequest, parseRagQueryOutput, parseRetro, parseReviewResult, parseSince, parseTeamMembers, parseUsageWindows, parseVmStat, planFilePreflight, planMemoryContext, planPhaseProfile, planRun, precheckCommand, precheckDeliver, precheckTick, preferMemoryOverDocBridge, promoteLearnings, promoteLearningsToMemory, promptLocalConfig, providerIdentity, providerSpecs, rankModels, readAaCache, readArtifactFile, readContextSnapshots, readCooldowns, readDeliveryState, readDispatchRecord, readEvidenceTrustStore, readLearningsLedger, readLoopEvents, readStoredContract, reconcileRun, recordBenchmarkObservation, recoverEventLogLock, recoveryDelayMs, remainingUsagePercent, renderArtifactMarkdown, renderContractPrompt, renderDebriefMarkdown, renderFindingsForWorker, renderHeadlessArgv, renderLocalConfig, renderRetroMarkdown, renderTuiCommand, renderWorkerBrief, resolveAgentForRole, resolveAlias, resolveCatalogCandidates, resolveDocContext, resumeStateFromArtifacts, retroLearnings, retryRun, routeAllRoles, runAdversarialReview, runAgentEval, runCodeReview, runDeliver, runEvalBattery, runGuidedInstall, runLoopDoctor, runRetroStage, runTick, runWithRecovery, runWorkflow, sampleMachine, selectMemoryForPrompt, selectModel, selectRuntime, severityRank, shellQuote, snapshotWatchTargets, startRun, summarizeMachine, tiersFor, touchesProtectedPaths, transition, undeclaredOrcaProviders, uninstallLoopAutomations, unknownTelemetry, untrusted, upsertProposedLearnings, usageRankTuple, validateAdapterMetadata, validateArtifactEnvelope, validateBenchmarkManifest, validateBlockManifest, validateCacheableOperation, validateCapabilityManifest, validateCompatibilityManifest, validateConfig, validateContextSnapshot, validateContextSnapshots, validateEvalManifest, validateHarnessErrorClassification, validateHarnessEventEnvelope, validateLoopConfig, validateMemoryRecord, validateOptimizationObservation, validatePhaseTelemetry, validateSafeCommand, validateStatusSnapshot, verifyEvidenceBundle, verifyPullRequestApproval, verifyRun, watchDeliveries, worktreeNameFor, writeAaCache, writeIdFor, writeLearningsLedger, writeLocalConfig, writeStoredContract };