cc-agent-harness 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,846 @@
+import { z } from 'zod';
+
+declare const modelTierSchema: z.ZodEnum<["low", "medium", "high"]>;
+declare const agentDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    domain: z.ZodString;
+    tier: z.ZodEnum<["low", "medium", "high"]>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    domain: string;
+    tier: "low" | "medium" | "high";
+    description?: string | undefined;
+}, {
+    name: string;
+    domain: string;
+    tier: "low" | "medium" | "high";
+    description?: string | undefined;
+}>;
+declare const providerMappingSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+declare const agentsConfigSchema: z.ZodObject<{
+    delegation_first: z.ZodDefault<z.ZodBoolean>;
+    model_routing: z.ZodDefault<z.ZodObject<{
+        low: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+        medium: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+        high: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+    }, "strip", z.ZodTypeAny, {
+        low: "low" | "medium" | "high";
+        medium: "low" | "medium" | "high";
+        high: "low" | "medium" | "high";
+    }, {
+        low?: "low" | "medium" | "high" | undefined;
+        medium?: "low" | "medium" | "high" | undefined;
+        high?: "low" | "medium" | "high" | undefined;
+    }>>;
+    providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    definitions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        domain: z.ZodString;
+        tier: z.ZodEnum<["low", "medium", "high"]>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        domain: string;
+        tier: "low" | "medium" | "high";
+        description?: string | undefined;
+    }, {
+        name: string;
+        domain: string;
+        tier: "low" | "medium" | "high";
+        description?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    delegation_first: boolean;
+    model_routing: {
+        low: "low" | "medium" | "high";
+        medium: "low" | "medium" | "high";
+        high: "low" | "medium" | "high";
+    };
+    providers: Record<string, string>;
+    definitions: {
+        name: string;
+        domain: string;
+        tier: "low" | "medium" | "high";
+        description?: string | undefined;
+    }[];
+}, {
+    delegation_first?: boolean | undefined;
+    model_routing?: {
+        low?: "low" | "medium" | "high" | undefined;
+        medium?: "low" | "medium" | "high" | undefined;
+        high?: "low" | "medium" | "high" | undefined;
+    } | undefined;
+    providers?: Record<string, string> | undefined;
+    definitions?: {
+        name: string;
+        domain: string;
+        tier: "low" | "medium" | "high";
+        description?: string | undefined;
+    }[] | undefined;
+}>;
+declare const skillsConfigSchema: z.ZodObject<{
+    directories: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    auto_detect: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    directories: string[];
+    auto_detect: boolean;
+}, {
+    directories?: string[] | undefined;
+    auto_detect?: boolean | undefined;
+}>;
+declare const verificationStageSchema: z.ZodObject<{
+    name: z.ZodString;
+    command: z.ZodOptional<z.ZodString>;
+    fail_fast: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    fail_fast: boolean;
+    command?: string | undefined;
+}, {
+    name: string;
+    command?: string | undefined;
+    fail_fast?: boolean | undefined;
+}>;
+declare const verificationConfigSchema: z.ZodObject<{
+    checks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    pipeline: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        command: z.ZodOptional<z.ZodString>;
+        fail_fast: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        fail_fast: boolean;
+        command?: string | undefined;
+    }, {
+        name: string;
+        command?: string | undefined;
+        fail_fast?: boolean | undefined;
+    }>, "many">>;
+    fail_fast: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    fail_fast: boolean;
+    checks: string[];
+    pipeline?: {
+        name: string;
+        fail_fast: boolean;
+        command?: string | undefined;
+    }[] | undefined;
+}, {
+    fail_fast?: boolean | undefined;
+    checks?: string[] | undefined;
+    pipeline?: {
+        name: string;
+        command?: string | undefined;
+        fail_fast?: boolean | undefined;
+    }[] | undefined;
+}>;
+declare const workflowsConfigSchema: z.ZodObject<{
+    commands: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    verification: z.ZodDefault<z.ZodObject<{
+        checks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        pipeline: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            command: z.ZodOptional<z.ZodString>;
+            fail_fast: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            fail_fast: boolean;
+            command?: string | undefined;
+        }, {
+            name: string;
+            command?: string | undefined;
+            fail_fast?: boolean | undefined;
+        }>, "many">>;
+        fail_fast: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        fail_fast: boolean;
+        checks: string[];
+        pipeline?: {
+            name: string;
+            fail_fast: boolean;
+            command?: string | undefined;
+        }[] | undefined;
+    }, {
+        fail_fast?: boolean | undefined;
+        checks?: string[] | undefined;
+        pipeline?: {
+            name: string;
+            command?: string | undefined;
+            fail_fast?: boolean | undefined;
+        }[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    commands: Record<string, string>;
+    verification: {
+        fail_fast: boolean;
+        checks: string[];
+        pipeline?: {
+            name: string;
+            fail_fast: boolean;
+            command?: string | undefined;
+        }[] | undefined;
+    };
+}, {
+    commands?: Record<string, string> | undefined;
+    verification?: {
+        fail_fast?: boolean | undefined;
+        checks?: string[] | undefined;
+        pipeline?: {
+            name: string;
+            command?: string | undefined;
+            fail_fast?: boolean | undefined;
+        }[] | undefined;
+    } | undefined;
+}>;
+declare const templatesConfigSchema: z.ZodObject<{
+    agents_md: z.ZodDefault<z.ZodObject<{
+        variant: z.ZodDefault<z.ZodEnum<["minimal", "standard", "full"]>>;
+        custom_rules: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        variant: "minimal" | "standard" | "full";
+        custom_rules: string[];
+    }, {
+        variant?: "minimal" | "standard" | "full" | undefined;
+        custom_rules?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    agents_md: {
+        variant: "minimal" | "standard" | "full";
+        custom_rules: string[];
+    };
+}, {
+    agents_md?: {
+        variant?: "minimal" | "standard" | "full" | undefined;
+        custom_rules?: string[] | undefined;
+    } | undefined;
+}>;
+declare const projectConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    language: z.ZodDefault<z.ZodEnum<["rust", "typescript", "python", "multi"]>>;
+    description: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    language: "rust" | "typescript" | "python" | "multi";
+}, {
+    name: string;
+    description?: string | undefined;
+    language?: "rust" | "typescript" | "python" | "multi" | undefined;
+}>;
+declare const featuresConfigSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+declare const harnessConfigSchema: z.ZodObject<{
+    project: z.ZodObject<{
+        name: z.ZodString;
+        language: z.ZodDefault<z.ZodEnum<["rust", "typescript", "python", "multi"]>>;
+        description: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        language: "rust" | "typescript" | "python" | "multi";
+    }, {
+        name: string;
+        description?: string | undefined;
+        language?: "rust" | "typescript" | "python" | "multi" | undefined;
+    }>;
+    agents: z.ZodDefault<z.ZodObject<{
+        delegation_first: z.ZodDefault<z.ZodBoolean>;
+        model_routing: z.ZodDefault<z.ZodObject<{
+            low: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+            medium: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+            high: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+        }, "strip", z.ZodTypeAny, {
+            low: "low" | "medium" | "high";
+            medium: "low" | "medium" | "high";
+            high: "low" | "medium" | "high";
+        }, {
+            low?: "low" | "medium" | "high" | undefined;
+            medium?: "low" | "medium" | "high" | undefined;
+            high?: "low" | "medium" | "high" | undefined;
+        }>>;
+        providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        definitions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            domain: z.ZodString;
+            tier: z.ZodEnum<["low", "medium", "high"]>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            domain: string;
+            tier: "low" | "medium" | "high";
+            description?: string | undefined;
+        }, {
+            name: string;
+            domain: string;
+            tier: "low" | "medium" | "high";
+            description?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        delegation_first: boolean;
+        model_routing: {
+            low: "low" | "medium" | "high";
+            medium: "low" | "medium" | "high";
+            high: "low" | "medium" | "high";
+        };
+        providers: Record<string, string>;
+        definitions: {
+            name: string;
+            domain: string;
+            tier: "low" | "medium" | "high";
+            description?: string | undefined;
+        }[];
+    }, {
+        delegation_first?: boolean | undefined;
+        model_routing?: {
+            low?: "low" | "medium" | "high" | undefined;
+            medium?: "low" | "medium" | "high" | undefined;
+            high?: "low" | "medium" | "high" | undefined;
+        } | undefined;
+        providers?: Record<string, string> | undefined;
+        definitions?: {
+            name: string;
+            domain: string;
+            tier: "low" | "medium" | "high";
+            description?: string | undefined;
+        }[] | undefined;
+    }>>;
+    skills: z.ZodDefault<z.ZodObject<{
+        directories: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        auto_detect: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        directories: string[];
+        auto_detect: boolean;
+    }, {
+        directories?: string[] | undefined;
+        auto_detect?: boolean | undefined;
+    }>>;
+    workflows: z.ZodDefault<z.ZodObject<{
+        commands: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        verification: z.ZodDefault<z.ZodObject<{
+            checks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            pipeline: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                command: z.ZodOptional<z.ZodString>;
+                fail_fast: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                fail_fast: boolean;
+                command?: string | undefined;
+            }, {
+                name: string;
+                command?: string | undefined;
+                fail_fast?: boolean | undefined;
+            }>, "many">>;
+            fail_fast: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            fail_fast: boolean;
+            checks: string[];
+            pipeline?: {
+                name: string;
+                fail_fast: boolean;
+                command?: string | undefined;
+            }[] | undefined;
+        }, {
+            fail_fast?: boolean | undefined;
+            checks?: string[] | undefined;
+            pipeline?: {
+                name: string;
+                command?: string | undefined;
+                fail_fast?: boolean | undefined;
+            }[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        commands: Record<string, string>;
+        verification: {
+            fail_fast: boolean;
+            checks: string[];
+            pipeline?: {
+                name: string;
+                fail_fast: boolean;
+                command?: string | undefined;
+            }[] | undefined;
+        };
+    }, {
+        commands?: Record<string, string> | undefined;
+        verification?: {
+            fail_fast?: boolean | undefined;
+            checks?: string[] | undefined;
+            pipeline?: {
+                name: string;
+                command?: string | undefined;
+                fail_fast?: boolean | undefined;
+            }[] | undefined;
+        } | undefined;
+    }>>;
+    templates: z.ZodDefault<z.ZodObject<{
+        agents_md: z.ZodDefault<z.ZodObject<{
+            variant: z.ZodDefault<z.ZodEnum<["minimal", "standard", "full"]>>;
+            custom_rules: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            variant: "minimal" | "standard" | "full";
+            custom_rules: string[];
+        }, {
+            variant?: "minimal" | "standard" | "full" | undefined;
+            custom_rules?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        agents_md: {
+            variant: "minimal" | "standard" | "full";
+            custom_rules: string[];
+        };
+    }, {
+        agents_md?: {
+            variant?: "minimal" | "standard" | "full" | undefined;
+            custom_rules?: string[] | undefined;
+        } | undefined;
+    }>>;
+    features: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    project: {
+        name: string;
+        description: string;
+        language: "rust" | "typescript" | "python" | "multi";
+    };
+    agents: {
+        delegation_first: boolean;
+        model_routing: {
+            low: "low" | "medium" | "high";
+            medium: "low" | "medium" | "high";
+            high: "low" | "medium" | "high";
+        };
+        providers: Record<string, string>;
+        definitions: {
+            name: string;
+            domain: string;
+            tier: "low" | "medium" | "high";
+            description?: string | undefined;
+        }[];
+    };
+    skills: {
+        directories: string[];
+        auto_detect: boolean;
+    };
+    workflows: {
+        commands: Record<string, string>;
+        verification: {
+            fail_fast: boolean;
+            checks: string[];
+            pipeline?: {
+                name: string;
+                fail_fast: boolean;
+                command?: string | undefined;
+            }[] | undefined;
+        };
+    };
+    templates: {
+        agents_md: {
+            variant: "minimal" | "standard" | "full";
+            custom_rules: string[];
+        };
+    };
+    features: Record<string, boolean>;
+}, {
+    project: {
+        name: string;
+        description?: string | undefined;
+        language?: "rust" | "typescript" | "python" | "multi" | undefined;
+    };
+    agents?: {
+        delegation_first?: boolean | undefined;
+        model_routing?: {
+            low?: "low" | "medium" | "high" | undefined;
+            medium?: "low" | "medium" | "high" | undefined;
+            high?: "low" | "medium" | "high" | undefined;
+        } | undefined;
+        providers?: Record<string, string> | undefined;
+        definitions?: {
+            name: string;
+            domain: string;
+            tier: "low" | "medium" | "high";
+            description?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    skills?: {
+        directories?: string[] | undefined;
+        auto_detect?: boolean | undefined;
+    } | undefined;
+    workflows?: {
+        commands?: Record<string, string> | undefined;
+        verification?: {
+            fail_fast?: boolean | undefined;
+            checks?: string[] | undefined;
+            pipeline?: {
+                name: string;
+                command?: string | undefined;
+                fail_fast?: boolean | undefined;
+            }[] | undefined;
+        } | undefined;
+    } | undefined;
+    templates?: {
+        agents_md?: {
+            variant?: "minimal" | "standard" | "full" | undefined;
+            custom_rules?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+    features?: Record<string, boolean> | undefined;
+}>;
+type HarnessConfig = z.infer<typeof harnessConfigSchema>;
+type AgentDefinition = z.infer<typeof agentDefinitionSchema>;
+type ModelTier = z.infer<typeof modelTierSchema>;
+
+interface ConfigLayer {
+    name: string;
+    path: string;
+    data: Record<string, unknown> | null;
+}
+interface LoadConfigOptions {
+    cwd?: string;
+    extraLayers?: ConfigLayer[];
+}
+interface LoadConfigResult {
+    config: HarnessConfig;
+    layers: ConfigLayer[];
+}
+/**
+ * Load harness configuration with N-layer merge and source tracking.
+ *
+ * Default layer order (lowest to highest priority):
+ * 1. Built-in defaults (via Zod schema defaults)
+ * 2. User-level (~/.harness/config.yaml)
+ * 3. Project-level (.harness/harness.config.yaml)
+ * 4. Extra layers (programmatic overrides)
+ */
+declare function loadConfig(opts?: LoadConfigOptions): Promise<HarnessConfig>;
+declare function loadConfigWithLayers(opts?: LoadConfigOptions): Promise<LoadConfigResult>;
+declare function configExists(cwd?: string): boolean;
+declare function projectConfigExists(cwd?: string): boolean;
+declare function userConfigExists(): boolean;
+declare function anyConfigExists(cwd?: string): boolean;
+
+declare const BUILT_IN_AGENTS: AgentDefinition[];
+declare const DEFAULT_SKILL_DIRECTORIES: string[];
+declare const DEFAULT_VERIFICATION_CHECKS: string[];
+
+declare class AgentRegistry {
+    private agents;
+    constructor(customAgents?: AgentDefinition[]);
+    get(name: string): AgentDefinition | undefined;
+    list(): AgentDefinition[];
+    listByDomain(domain: string): AgentDefinition[];
+    listByTier(tier: string): AgentDefinition[];
+    domains(): string[];
+    count(): {
+        builtin: number;
+        custom: number;
+        total: number;
+    };
+}
+
+type TaskComplexity = "low" | "medium" | "high";
+interface ModelRouting {
+    low: ModelTier;
+    medium: ModelTier;
+    high: ModelTier;
+}
+declare function routeModel(complexity: TaskComplexity, routing?: Partial<ModelRouting>): ModelTier;
+declare function inferComplexity(taskDescription: string): TaskComplexity;
+
+interface CommandDefinition {
+    name: string;
+    command: string;
+    description: string;
+}
+interface HealthCheck {
+    name: string;
+    check: () => Promise<HealthCheckResult>;
+}
+interface HealthCheckResult {
+    status: "pass" | "warn" | "fail";
+    message: string;
+}
+interface ProjectAdapter {
+    name: string;
+    detect(cwd: string): Promise<boolean>;
+    getCommands(): CommandDefinition[];
+    getHealthChecks(): HealthCheck[];
+}
+
+declare class AdapterRegistry {
+    private adapters;
+    constructor(additionalAdapters?: ProjectAdapter[]);
+    register(adapter: ProjectAdapter): void;
+    get(name: string): ProjectAdapter | undefined;
+    list(): ProjectAdapter[];
+    detect(cwd: string): Promise<ProjectAdapter | null>;
+    count(): {
+        builtin: number;
+        custom: number;
+        total: number;
+    };
+}
+
+declare function detectProjectType(cwd: string): Promise<ProjectAdapter | null>;
+declare function detectLanguage(cwd: string): "rust" | "typescript" | "python" | "multi";
+
+declare class TypeScriptAdapter implements ProjectAdapter {
+    name: string;
+    detect(cwd: string): Promise<boolean>;
+    getCommands(): CommandDefinition[];
+    getHealthChecks(): HealthCheck[];
+}
+
+declare class PythonAdapter implements ProjectAdapter {
+    name: string;
+    detect(cwd: string): Promise<boolean>;
+    getCommands(): CommandDefinition[];
+    getHealthChecks(): HealthCheck[];
+}
+
+declare class RustAdapter implements ProjectAdapter {
+    name: string;
+    detect(cwd: string): Promise<boolean>;
+    getCommands(): CommandDefinition[];
+    getHealthChecks(): HealthCheck[];
+}
+
+interface SkillInfo {
+    name: string;
+    description: string;
+    path: string;
+    valid: boolean;
+}
+declare function discoverSkills(directories: string[], cwd?: string): Promise<SkillInfo[]>;
+declare function listSkillDirectories(cwd?: string): Promise<string[]>;
+
+interface SkillValidationResult {
+    valid: boolean;
+    name: string | null;
+    description: string | null;
+    errors: string[];
+    warnings: string[];
+}
+declare function validateSkill(skillDir: string): Promise<SkillValidationResult>;
+
+interface ScaffoldOptions {
+    name: string;
+    description: string;
+    displayName: string;
+    resources?: ("scripts" | "references" | "assets")[];
+}
+declare function scaffoldSkill(targetDir: string, options: ScaffoldOptions): Promise<string>;
+
+interface HealthReport {
+    results: HealthReportEntry[];
+    summary: {
+        pass: number;
+        warn: number;
+        fail: number;
+    };
+}
+interface HealthReportEntry {
+    name: string;
+    result: HealthCheckResult;
+}
+declare function runHealthChecks(checks: HealthCheck[]): Promise<HealthReport>;
+declare function formatReport(report: HealthReport): string;
+
+interface TemplateContext {
+    [key: string]: string | boolean | string[] | undefined;
+}
+/**
+ * Lightweight template engine:
+ * - {{variable}} — interpolation
+ * - {{#if condition}}...{{/if}} — conditional block (truthy check)
+ * - {{#if condition}}...{{#else}}...{{/if}} — conditional with else
+ * - {{#each items}}...{{/each}} — array iteration (current item as {{.}})
+ */
+declare function render(template: string, context: TemplateContext): string;
+
+declare function renderFile(templatePath: string, outputPath: string, context: TemplateContext): Promise<void>;
+declare function renderDirectory(templateDir: string, outputDir: string, context: TemplateContext): Promise<string[]>;
+
+type AuditEventKind = "setup" | "update" | "doctor" | "verify" | "scaffold" | "config.loaded" | "config.changed" | "skill.discovered" | "hook.executed" | "custom";
+interface AuditEntry {
+    timestamp: string;
+    kind: AuditEventKind;
+    message: string;
+    data?: Record<string, unknown>;
+}
+
+declare class AuditLogger {
+    private logPath;
+    constructor(cwd: string, logDir?: string);
+    log(kind: AuditEventKind, message: string, data?: Record<string, unknown>): Promise<void>;
+    getLogPath(): string;
+}
+
+interface ContextBlock {
+    tag: string;
+    content: string;
+    priority: number;
+}
+type TagStyle = "xml" | "markdown" | "none";
+interface ContextBuildOptions {
+    tagStyle?: TagStyle;
+}
+interface ContextPipelineResult {
+    blocks: ContextBlock[];
+    rendered: string;
+}
+
+declare class ContextPipeline {
+    private blocks;
+    addBlock(tag: string, content: string, priority?: number): void;
+    addProjectDoc(cwd: string): Promise<void>;
+    /**
+     * Walk from projectRoot to cwd, collecting AGENTS.md files.
+     * Deeper files override shallower ones (later blocks have higher priority).
+     */
+    addHierarchicalDocs(cwd: string, projectRoot?: string): Promise<void>;
+    addSkillsSummary(config: HarnessConfig, cwd: string): Promise<void>;
+    addCustomRules(rules: string[]): void;
+    addRaw(tag: string, content: string, priority?: number): void;
+    build(options?: ContextBuildOptions): ContextPipelineResult;
+    clear(): void;
+}
+
+type HookEventName = "setup.pre" | "setup.post" | "update.pre" | "update.post" | "doctor.pre" | "doctor.post" | "verify.pre" | "verify.post" | "scaffold.pre" | "scaffold.post" | "skill.discovered" | "config.loaded";
+interface HookPayload {
+    event: HookEventName;
+    timestamp: string;
+    cwd: string;
+    data?: Record<string, unknown>;
+}
+interface HookHandler {
+    event: HookEventName;
+    command: string;
+    matcher?: string;
+}
+interface HookResult {
+    handler: HookHandler;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+}
+interface HooksConfig {
+    hooks?: HookHandler[];
+}
+
+type FeatureStage = "stable" | "experimental" | "deprecated" | "removed";
+interface FeatureSpec {
+    id: string;
+    key: string;
+    stage: FeatureStage;
+    defaultEnabled: boolean;
+    description: string;
+}
+
+interface HarnessPlugin {
+    name: string;
+    version?: string;
+    description?: string;
+    adapters?: ProjectAdapter[];
+    agents?: AgentDefinition[];
+    hooks?: HookHandler[];
+    healthChecks?: HealthCheck[];
+    features?: FeatureSpec[];
+    skillDirectories?: string[];
+}
+
+declare class PluginRegistry {
+    private plugins;
+    register(plugin: HarnessPlugin): void;
+    get(name: string): HarnessPlugin | undefined;
+    list(): HarnessPlugin[];
+    collectAdapters(): ProjectAdapter[];
+    collectAgents(): AgentDefinition[];
+    collectHooks(): HookHandler[];
+    collectHealthChecks(): HealthCheck[];
+    collectFeatures(): FeatureSpec[];
+    collectSkillDirectories(): string[];
+    count(): number;
+}
+
+declare class FeatureRegistry {
+    private specs;
+    private overrides;
+    private aliases;
+    private aliasUsages;
+    register(spec: FeatureSpec): void;
+    registerMany(specs: FeatureSpec[]): void;
+    registerAlias(legacyKey: string, featureId: string): void;
+    registerAliases(aliasMap: Record<string, string>): void;
+    applyOverrides(overrides: Record<string, boolean>): void;
+    isEnabled(id: string): boolean;
+    get(id: string): FeatureSpec | undefined;
+    list(): FeatureSpec[];
+    listByStage(stage: FeatureStage): FeatureSpec[];
+    listEnabled(): FeatureSpec[];
+    count(): {
+        total: number;
+        enabled: number;
+        disabled: number;
+    };
+    getAliasUsages(): string[];
+    private resolveAlias;
+    private findByKey;
+}
+
+declare function discoverHooks(cwd: string): Promise<HookHandler[]>;
+
+declare class HookDispatcher {
+    private handlers;
+    constructor(handlers: HookHandler[]);
+    dispatch(event: HookEventName, cwd: string, data?: Record<string, unknown>): Promise<HookResult[]>;
+    hasHandlers(event: HookEventName): boolean;
+}
+
+type RuntimeTaskSource = "adapter" | "workflow";
+interface RuntimeTask {
+    name: string;
+    command: string;
+    description: string;
+    source: RuntimeTaskSource;
+    adapterName?: string;
+}
+interface RuntimeFeatureState {
+    spec: FeatureSpec;
+    enabled: boolean;
+    configured: boolean;
+    configuredValue?: boolean;
+}
+interface CreateHarnessRuntimeOptions {
+    cwd?: string;
+    requireProjectConfig?: boolean;
+}
+interface BuildContextOptions {
+    tagStyle?: TagStyle;
+    includeSkills?: boolean;
+    includeCustomRules?: boolean;
+}
+interface WriteContextOptions extends BuildContextOptions {
+    outputPath: string;
+}
+declare class HarnessRuntime {
+    readonly cwd: string;
+    readonly hasProjectConfig: boolean;
+    readonly hasAnyConfig: boolean;
+    readonly config?: HarnessConfig;
+    readonly adapter: ProjectAdapter | null;
+    readonly agentRegistry: AgentRegistry;
+    readonly featureRegistry: FeatureRegistry;
+    private readonly hookDispatcher;
+    private readonly auditLogger;
+    private constructor();
+    static create(opts?: CreateHarnessRuntimeOptions): Promise<HarnessRuntime>;
+    listTasks(): RuntimeTask[];
+    getTask(name: string): RuntimeTask | undefined;
+    listFeatureStates(): RuntimeFeatureState[];
+    dispatchHooks(event: HookEventName, data?: Record<string, unknown>): Promise<HookResult[]>;
+    log(kind: AuditEventKind, message: string, data?: Record<string, unknown>): Promise<void>;
+    buildContext(opts?: BuildContextOptions): Promise<ContextPipelineResult>;
+    writeContext(opts: WriteContextOptions): Promise<ContextPipelineResult>;
+}
+
+export { AdapterRegistry, type AgentDefinition, AgentRegistry, type AuditEntry, type AuditEventKind, AuditLogger, BUILT_IN_AGENTS, type BuildContextOptions, type CommandDefinition, type ConfigLayer, type ContextBlock, type ContextBuildOptions, ContextPipeline, type ContextPipelineResult, type CreateHarnessRuntimeOptions, DEFAULT_SKILL_DIRECTORIES, DEFAULT_VERIFICATION_CHECKS, FeatureRegistry, type FeatureSpec, type FeatureStage, type HarnessConfig, type HarnessPlugin, HarnessRuntime, type HealthCheck, type HealthCheckResult, type HealthReport, type HealthReportEntry, HookDispatcher, type HookEventName, type HookHandler, type HookPayload, type HookResult, type HooksConfig, type LoadConfigOptions, type LoadConfigResult, type ModelRouting, type ModelTier, PluginRegistry, type ProjectAdapter, PythonAdapter, type RuntimeFeatureState, type RuntimeTask, type RuntimeTaskSource, RustAdapter, type ScaffoldOptions, type SkillInfo, type SkillValidationResult, type TagStyle, type TaskComplexity, type TemplateContext, TypeScriptAdapter, type WriteContextOptions, agentDefinitionSchema, agentsConfigSchema, anyConfigExists, configExists, detectLanguage, detectProjectType, discoverHooks, discoverSkills, featuresConfigSchema, formatReport, harnessConfigSchema, inferComplexity, listSkillDirectories, loadConfig, loadConfigWithLayers, modelTierSchema, projectConfigExists, projectConfigSchema, providerMappingSchema, render, renderDirectory, renderFile, routeModel, runHealthChecks, scaffoldSkill, skillsConfigSchema, templatesConfigSchema, userConfigExists, validateSkill, verificationConfigSchema, verificationStageSchema, workflowsConfigSchema };