@agntk/agent-harness 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,3612 @@
+import { z } from 'zod';
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { ToolSet, LanguageModel } from 'ai';
+import { ModelMessage } from '@ai-sdk/provider-utils';
+import { FSWatcher } from 'chokidar';
+import cron from 'node-cron';
+import { MCPClient } from '@ai-sdk/mcp';
+import { Hono } from 'hono';
+import { Server } from 'http';
+
+declare const FrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    created: z.ZodOptional<z.ZodString>;
+    updated: z.ZodOptional<z.ZodString>;
+    author: z.ZodDefault<z.ZodEnum<{
+        human: "human";
+        agent: "agent";
+        infrastructure: "infrastructure";
+    }>>;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+        deprecated: "deprecated";
+        draft: "draft";
+    }>>;
+    related: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    schedule: z.ZodOptional<z.ZodString>;
+    with: z.ZodOptional<z.ZodString>;
+    channel: z.ZodOptional<z.ZodString>;
+    duration_minutes: z.ZodOptional<z.ZodNumber>;
+    max_retries: z.ZodOptional<z.ZodNumber>;
+    retry_delay_ms: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type Frontmatter = z.infer<typeof FrontmatterSchema>;
+interface HarnessDocument {
+    path: string;
+    frontmatter: Frontmatter;
+    l0: string;
+    l1: string;
+    body: string;
+    raw: string;
+}
+type PrimitiveType = 'rule' | 'instinct' | 'skill' | 'playbook' | 'workflow' | 'tool' | 'agent' | 'session' | 'journal';
+declare const HarnessConfigSchema: z.ZodObject<{
+    agent: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodDefault<z.ZodString>;
+    }, z.core.$loose>;
+    model: z.ZodObject<{
+        provider: z.ZodDefault<z.ZodString>;
+        id: z.ZodString;
+        max_tokens: z.ZodDefault<z.ZodNumber>;
+        max_retries: z.ZodDefault<z.ZodNumber>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+        summary_model: z.ZodOptional<z.ZodString>;
+        fast_model: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    runtime: z.ZodObject<{
+        scratchpad_budget: z.ZodDefault<z.ZodNumber>;
+        heartbeat: z.ZodOptional<z.ZodString>;
+        daily_summary: z.ZodOptional<z.ZodString>;
+        auto_process: z.ZodDefault<z.ZodBoolean>;
+        quiet_hours: z.ZodDefault<z.ZodObject<{
+            start: z.ZodDefault<z.ZodNumber>;
+            end: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$loose>>;
+        timezone: z.ZodDefault<z.ZodString>;
+    }, z.core.$loose>;
+    memory: z.ZodObject<{
+        session_retention_days: z.ZodDefault<z.ZodNumber>;
+        journal_retention_days: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$loose>;
+    channels: z.ZodObject<{
+        primary: z.ZodDefault<z.ZodString>;
+    }, z.core.$loose>;
+    extensions: z.ZodDefault<z.ZodObject<{
+        directories: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
+    rate_limits: z.ZodDefault<z.ZodObject<{
+        per_minute: z.ZodOptional<z.ZodNumber>;
+        per_hour: z.ZodOptional<z.ZodNumber>;
+        per_day: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    budget: z.ZodDefault<z.ZodObject<{
+        daily_limit_usd: z.ZodOptional<z.ZodNumber>;
+        monthly_limit_usd: z.ZodOptional<z.ZodNumber>;
+        enforce: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    mcp: z.ZodDefault<z.ZodObject<{
+        servers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            transport: z.ZodEnum<{
+                stdio: "stdio";
+                http: "http";
+                sse: "sse";
+            }>;
+            command: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+    intelligence: z.ZodDefault<z.ZodObject<{
+        auto_journal: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+        auto_learn: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    proactive: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        max_per_hour: z.ZodDefault<z.ZodNumber>;
+        cooldown_minutes: z.ZodDefault<z.ZodNumber>;
+        quiet_hours: z.ZodOptional<z.ZodObject<{
+            start: z.ZodOptional<z.ZodNumber>;
+            end: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    registries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        token: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+type HarnessConfig = z.infer<typeof HarnessConfigSchema>;
+declare const CORE_PRIMITIVE_DIRS: readonly ["rules", "instincts", "skills", "playbooks", "workflows", "tools", "agents"];
+declare function getPrimitiveDirs(config?: HarnessConfig): string[];
+interface AgentState {
+    mode: string;
+    goals: string[];
+    active_workflows: string[];
+    last_interaction: string;
+    unfinished_business: string[];
+}
+interface ContextBudget {
+    max_tokens: number;
+    used_tokens: number;
+    remaining: number;
+    loaded_files: string[];
+}
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+interface HarnessHooks {
+    /** Called after boot completes (context loaded, state ready) */
+    onBoot?: (context: {
+        agent: HarnessAgent;
+        config: HarnessConfig;
+        state: AgentState;
+    }) => void | Promise<void>;
+    /** Called after each session completes (run or stream) */
+    onSessionEnd?: (context: {
+        agent: HarnessAgent;
+        sessionId: string;
+        prompt: string;
+        result: AgentRunResult;
+    }) => void | Promise<void>;
+    /** Called when an error occurs during run/stream */
+    onError?: (context: {
+        agent: HarnessAgent;
+        error: Error;
+        prompt?: string;
+    }) => void | Promise<void>;
+    /** Called when agent state changes (boot, shutdown, after run) */
+    onStateChange?: (context: {
+        agent: HarnessAgent;
+        previous: string;
+        current: string;
+    }) => void | Promise<void>;
+    /** Called before shutdown completes */
+    onShutdown?: (context: {
+        agent: HarnessAgent;
+        state: AgentState;
+    }) => void | Promise<void>;
+}
+interface ToolExecutorOptions {
+    /** Maximum tool calls per run (default: 5) */
+    maxToolCalls?: number;
+    /** Timeout per tool call in ms (default: 30000) */
+    toolTimeoutMs?: number;
+    /** Whether to allow HTTP tool execution (default: true) */
+    allowHttpExecution?: boolean;
+}
+interface CreateHarnessOptions {
+    dir: string;
+    /** Model ID override (e.g., "claude-sonnet-4-20250514" or "gpt-4o") */
+    model?: string;
+    /** Provider override (e.g., "anthropic", "openai", "openrouter") */
+    provider?: string;
+    apiKey?: string;
+    config?: DeepPartial<HarnessConfig>;
+    /** Lifecycle hooks for agent events */
+    hooks?: HarnessHooks;
+    /** Tool execution configuration */
+    toolExecutor?: ToolExecutorOptions;
+}
+/** Record of a single tool call made during a run */
+interface ToolCallInfo {
+    toolName: string;
+    args: Record<string, unknown>;
+    result: unknown;
+}
+interface AgentRunResult {
+    text: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    session_id: string;
+    steps: number;
+    /** Tool calls made during the run (empty array if none) */
+    toolCalls: ToolCallInfo[];
+}
+interface AgentStreamResult {
+    /** Async iterable of text chunks — consume with for-await */
+    textStream: AsyncIterable<string>;
+    /** Resolves after the stream is fully consumed with session metadata */
+    result: Promise<AgentRunResult>;
+}
+interface HarnessAgent {
+    name: string;
+    config: HarnessConfig;
+    boot(): Promise<void>;
+    run(prompt: string): Promise<AgentRunResult>;
+    stream(prompt: string): AgentStreamResult;
+    shutdown(): Promise<void>;
+    getSystemPrompt(): string;
+    getState(): AgentState;
+}
+interface IndexEntry {
+    id: string;
+    path: string;
+    tags: string[];
+    l0: string;
+    created: string;
+    status: string;
+}
+
+declare function createHarness(options: CreateHarnessOptions): HarnessAgent;
+
+declare function loadConfig(dir: string, overrides?: DeepPartial<HarnessConfig>): HarnessConfig;
+declare function writeDefaultConfig(_dir: string, agentName?: string): string;
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+interface Logger {
+    debug(msg: string, ...args: unknown[]): void;
+    info(msg: string, ...args: unknown[]): void;
+    warn(msg: string, ...args: unknown[]): void;
+    error(msg: string, ...args: unknown[]): void;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+    child(prefix: string): Logger;
+}
+declare function createLogger(prefix?: string): Logger;
+declare function setGlobalLogLevel(level: LogLevel): void;
+declare function getGlobalLogLevel(): LogLevel;
+declare const log: Logger;
+
+interface ParseError {
+    path: string;
+    error: string;
+}
+interface LoadResult {
+    docs: HarnessDocument[];
+    errors: ParseError[];
+}
+declare function parseHarnessDocument(filePath: string): HarnessDocument;
+declare function loadDirectory(dirPath: string): HarnessDocument[];
+declare function loadDirectoryWithErrors(dirPath: string): LoadResult;
+interface LoadAllResult {
+    primitives: Map<string, HarnessDocument[]>;
+    errors: ParseError[];
+}
+declare function loadAllPrimitives(harnessDir: string, extraDirs?: string[]): Map<string, HarnessDocument[]>;
+declare function loadAllPrimitivesWithErrors(harnessDir: string, extraDirs?: string[]): LoadAllResult;
+declare function estimateTokens(text: string): number;
+declare function getAtLevel(doc: HarnessDocument, level: 0 | 1 | 2): string;
+
+interface LoadedContext {
+    systemPrompt: string;
+    budget: ContextBudget;
+    parseErrors: ParseError[];
+    warnings: string[];
+}
+declare function buildSystemPrompt(harnessDir: string, config: HarnessConfig): LoadedContext;
+
+declare function loadState(harnessDir: string): AgentState;
+declare function saveState(harnessDir: string, state: AgentState): void;
+
+interface ToolAuth {
+    envVar: string;
+    present: boolean;
+}
+interface ToolOperation {
+    name: string;
+    method: string;
+    endpoint: string;
+}
+interface ToolDefinition {
+    id: string;
+    doc: HarnessDocument;
+    tags: string[];
+    status: string;
+    auth: ToolAuth[];
+    operations: ToolOperation[];
+    rateLimits: string[];
+    gotchas: string[];
+}
+interface ToolSummary {
+    id: string;
+    l0: string;
+    tags: string[];
+    status: string;
+    authReady: boolean;
+    operationCount: number;
+}
+/**
+ * Parse a tool document into a structured ToolDefinition.
+ */
+declare function parseToolDefinition(doc: HarnessDocument): ToolDefinition;
+/**
+ * Load all tool definitions from the tools/ directory.
+ */
+declare function loadTools(harnessDir: string): ToolDefinition[];
+/**
+ * Get a specific tool definition by ID.
+ */
+declare function getToolById(harnessDir: string, toolId: string): ToolDefinition | null;
+/**
+ * List tools with summary info (without full document content).
+ */
+declare function listToolSummaries(harnessDir: string): ToolSummary[];
+/**
+ * Check auth status for a specific tool or all tools.
+ */
+declare function checkToolAuth(harnessDir: string, toolId?: string): Array<{
+    tool: string;
+    auth: ToolAuth[];
+}>;
+
+/** Result of a single tool execution */
+interface ToolCallResult {
+    toolName: string;
+    input: Record<string, unknown>;
+    output: unknown;
+    durationMs: number;
+    error: string | null;
+}
+/** Record of all tool calls in a run (for session recording) */
+interface ToolCallRecord {
+    calls: ToolCallResult[];
+    totalDurationMs: number;
+}
+/** A programmatic tool definition (not from markdown) */
+interface ProgrammaticTool {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType;
+    execute: (input: Record<string, unknown>) => Promise<unknown>;
+}
+/** Configuration for tool execution */
+interface ToolExecutorConfig {
+    /** Maximum tool calls per run (default: 10) */
+    maxToolCalls?: number;
+    /** Timeout per tool call in ms (default: 30000) */
+    toolTimeoutMs?: number;
+    /** Whether to allow HTTP tool execution (default: true) */
+    allowHttpExecution?: boolean;
+    /** Additional programmatic tools */
+    tools?: ProgrammaticTool[];
+}
+/** AI SDK ToolSet — record of named tool definitions */
+type AIToolSet = ToolSet;
+/**
+ * Resolve a URL template by replacing `{param}` placeholders with input values.
+ * E.g., `/repos/{owner}/{repo}/pulls` with { owner: 'a', repo: 'b' } → `/repos/a/b/pulls`
+ */
+declare function resolveEndpoint(endpoint: string, input: Record<string, unknown>): string;
+/**
+ * Build a JSON Schema object for a tool operation's URL parameters.
+ * Extracts `{param}` patterns from the endpoint URL and creates string properties for each.
+ */
+declare function buildOperationSchema(operation: ToolOperation): Record<string, unknown>;
+/**
+ * Execute an HTTP tool operation.
+ * Resolves URL parameters, attaches auth headers, and makes the HTTP request.
+ */
+declare function executeHttpOperation(operation: ToolOperation, baseUrl: string, authHeaders: Record<string, string>, input: Record<string, unknown>, timeoutMs: number): Promise<unknown>;
+/**
+ * Build auth headers from a tool's auth configuration.
+ * Maps known env var patterns to standard header formats.
+ */
+declare function buildAuthHeaders(toolDef: ToolDefinition): Record<string, string>;
+/**
+ * Convert a single ToolDefinition (from markdown) into AI SDK tools.
+ * Each operation becomes a separate tool entry.
+ */
+declare function convertToolDefinition(toolDef: ToolDefinition, config: ToolExecutorConfig): AIToolSet;
+/**
+ * Load all tools from the harness directory and convert them to AI SDK format.
+ * Includes markdown-defined tools, programmatic tools from config, and MCP tools.
+ *
+ * Returns an empty object if no tools are configured.
+ *
+ * @param harnessDir - Path to the harness directory
+ * @param config - Tool executor configuration
+ * @param mcpTools - Pre-loaded MCP tools to merge (from McpManager.getTools())
+ */
+declare function buildToolSet(harnessDir: string, config?: ToolExecutorConfig, mcpTools?: AIToolSet): AIToolSet;
+/**
+ * Create a ToolCallRecord tracker for recording tool calls in a run.
+ */
+declare function createToolCallTracker(): {
+    record: (result: ToolCallResult) => void;
+    getRecord: () => ToolCallRecord;
+};
+/**
+ * Get a human-readable summary of tools available in the harness.
+ */
+declare function getToolSetSummary(tools: AIToolSet): string[];
+
+/** Supported provider names for config.model.provider */
+type ProviderName = 'openrouter' | 'anthropic' | 'openai';
+/**
+ * Get the OpenRouter provider (backward-compatible).
+ * @deprecated Use getModel() with config.model.provider instead.
+ */
+declare function getProvider(apiKey?: string): ReturnType<typeof createOpenRouter>;
+declare function resetProvider(): void;
+/**
+ * Get a LanguageModel from config. Supports openrouter, anthropic, and openai providers.
+ *
+ * Provider is selected from config.model.provider (defaults to 'openrouter').
+ * Model ID format depends on provider:
+ *   - openrouter: "anthropic/claude-sonnet-4" (vendor/model)
+ *   - anthropic: "claude-sonnet-4-20250514" (native model ID)
+ *   - openai: "gpt-4o" (native model ID)
+ */
+declare function getModel(config: HarnessConfig, apiKey?: string): LanguageModel;
+/**
+ * Get the summary model for cheap auto-generation tasks (L0/L1 summaries, tags, frontmatter).
+ * Falls back to the primary model if summary_model is not configured.
+ *
+ * Usage: set `model.summary_model` in config.yaml, e.g.:
+ *   summary_model: "google/gemini-flash-1.5"
+ */
+declare function getSummaryModel(config: HarnessConfig, apiKey?: string): LanguageModel;
+/**
+ * Get the fast model for validation, checks, and quick decisions.
+ * Falls back to summary_model, then primary model.
+ *
+ * Usage: set `model.fast_model` in config.yaml, e.g.:
+ *   fast_model: "google/gemini-flash-1.5"
+ */
+declare function getFastModel(config: HarnessConfig, apiKey?: string): LanguageModel;
+interface CallOptions {
+    maxRetries?: number;
+    timeoutMs?: number;
+    abortSignal?: AbortSignal;
+}
+interface GenerateOptions extends CallOptions {
+    model: LanguageModel;
+    system: string;
+    prompt: string;
+    maxOutputTokens?: number;
+    /** AI SDK tools to make available for the LLM */
+    tools?: AIToolSet;
+    /** Max tool-use roundtrips (default: 1 if tools provided, 0 otherwise) */
+    maxToolSteps?: number;
+}
+interface GenerateWithMessagesOptions extends CallOptions {
+    model: LanguageModel;
+    system: string;
+    messages: ModelMessage[];
+    maxOutputTokens?: number;
+    /** AI SDK tools to make available for the LLM */
+    tools?: AIToolSet;
+    /** Max tool-use roundtrips (default: 1 if tools provided, 0 otherwise) */
+    maxToolSteps?: number;
+}
+interface GenerateResult {
+    text: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    /** Tool calls made during generation (empty if no tools used) */
+    toolCalls: ToolCallInfo[];
+    /** Number of steps taken (1 = no tool calls, >1 = tool roundtrips) */
+    steps: number;
+}
+declare function generate(opts: GenerateOptions): Promise<GenerateResult>;
+declare function generateWithMessages(opts: GenerateWithMessagesOptions): Promise<GenerateResult>;
+interface StreamWithMessagesResult {
+    textStream: AsyncIterable<string>;
+    usage: Promise<GenerateResult['usage']>;
+    /** Tool calls made across all steps (resolves after stream completes) */
+    toolCalls: Promise<ToolCallInfo[]>;
+    /** Number of steps (resolves after stream completes) */
+    steps: Promise<number>;
+}
+declare function streamWithMessages(opts: GenerateWithMessagesOptions): StreamWithMessagesResult;
+interface StreamGenerateResult {
+    textStream: AsyncIterable<string>;
+    usage: Promise<GenerateResult['usage']>;
+    toolCalls: Promise<ToolCallInfo[]>;
+    steps: Promise<number>;
+}
+declare function streamGenerateWithDetails(opts: GenerateOptions): StreamGenerateResult;
+
+interface ScaffoldOptions {
+    template?: string;
+    /** Custom CORE.md content — overrides template */
+    coreContent?: string;
+    /** Agent purpose description (stored as comment in CORE.md when no LLM generation) */
+    purpose?: string;
+}
+declare function scaffoldHarness(targetDir: string, agentName: string, options?: ScaffoldOptions): void;
+/**
+ * Generate SYSTEM.md content from the actual directory structure of a harness.
+ * Scans for primitives and reflects the real structure.
+ */
+declare function generateSystemMd(harnessDir: string, agentName: string): string;
+/**
+ * Generate a rich CORE.md using an LLM, given an agent name and purpose description.
+ * Returns the generated markdown content, or throws on failure.
+ */
+declare function generateCoreMd(agentName: string, purpose: string, options: {
+    provider?: string;
+    modelId?: string;
+    apiKey?: string;
+}): Promise<string>;
+/**
+ * List available templates.
+ */
+declare function listTemplates(): string[];
+
+declare function buildIndex(harnessDir: string, directory: string): IndexEntry[];
+interface IndexOptions {
+    /** Max characters for L0 summary in index table. Defaults to 120. */
+    summaryMaxLength?: number;
+}
+declare function writeIndexFile(harnessDir: string, directory: string, options?: IndexOptions): void;
+declare function rebuildAllIndexes(harnessDir: string, extraDirs?: string[]): void;
+
+/** Result of auto-processing a file */
+interface AutoProcessResult {
+    /** Path that was processed */
+    path: string;
+    /** Whether any changes were made */
+    modified: boolean;
+    /** List of fixes applied */
+    fixes: string[];
+    /** Errors encountered */
+    errors: string[];
+}
+/** Options for auto-processing */
+interface AutoProcessOptions {
+    /** Harness directory (for inferring primitive type from path) */
+    harnessDir: string;
+    /** Whether to generate frontmatter (default: true) */
+    generateFrontmatter?: boolean;
+    /** Whether to generate L0/L1 summaries (default: true) */
+    generateSummaries?: boolean;
+}
+/**
+ * Auto-process a markdown primitive file:
+ * 1. Generate frontmatter if missing (id from filename, created, status, tags, author)
+ * 2. Generate L0 summary if missing (from heading or first line)
+ * 3. Generate L1 summary if missing (from first paragraph)
+ *
+ * This is designed to run on file save (via watcher) to ensure
+ * all primitives have valid structure without user intervention.
+ */
+declare function autoProcessFile(filePath: string, options: AutoProcessOptions): AutoProcessResult;
+/**
+ * Auto-process all primitives in a harness directory.
+ * Useful for batch processing after init or on first dev startup.
+ */
+declare function autoProcessAll(harnessDir: string, options?: {
+    generateFrontmatter?: boolean;
+    generateSummaries?: boolean;
+}): AutoProcessResult[];
+
+interface WatcherOptions {
+    harnessDir: string;
+    extraDirs?: string[];
+    onChange?: (path: string, event: string) => void;
+    onIndexRebuild?: (directory: string) => void;
+    onError?: (error: Error) => void;
+    /** Also watch config.yaml for changes */
+    watchConfig?: boolean;
+    onConfigChange?: () => void;
+    /** Enable auto-processing of primitives on save (default: false) */
+    autoProcess?: boolean;
+    /** Called after auto-processing a file */
+    onAutoProcess?: (result: AutoProcessResult) => void;
+}
+declare function createWatcher(options: WatcherOptions): FSWatcher;
+
+/**
+ * Check if the current time falls within quiet hours.
+ * Quiet hours wrap around midnight (e.g. start: 23, end: 6 means 23:00–05:59).
+ * Returns true if the agent should be quiet (no scheduled workflows).
+ */
+declare function isQuietHours(config: HarnessConfig, now?: Date): boolean;
+interface ScheduledWorkflow {
+    doc: HarnessDocument;
+    cronExpression: string;
+    task: ReturnType<typeof cron.schedule> | null;
+}
+interface SchedulerOptions {
+    harnessDir: string;
+    apiKey?: string;
+    /** Enable daily auto-archival of expired sessions/journals (default: true) */
+    autoArchival?: boolean;
+    /** Cron expression for auto-archival (default: "0 23 * * *" = daily at 23:00) */
+    archivalCron?: string;
+    /** Enable auto-journal synthesis (cron string or true for default "0 22 * * *") */
+    autoJournal?: boolean | string;
+    /** Enable auto-learn after journal synthesis (default: false) */
+    autoLearn?: boolean;
+    onRun?: (workflowId: string, result: string) => void;
+    onError?: (workflowId: string, error: Error) => void;
+    onSchedule?: (workflowId: string, cron: string) => void;
+    onSkipQuietHours?: (workflowId: string) => void;
+    onArchival?: (sessionsArchived: number, journalsArchived: number) => void;
+    onRetry?: (workflowId: string, attempt: number, maxRetries: number, error: Error) => void;
+    onJournal?: (date: string, sessionsCount: number) => void;
+    onLearn?: (installed: number, skipped: number) => void;
+}
+declare class Scheduler {
+    private workflows;
+    private harnessDir;
+    private apiKey?;
+    private autoArchival;
+    private archivalCron;
+    private archivalTask;
+    private autoJournal;
+    private autoLearn;
+    private journalTask;
+    /** Tracks proactive executions: workflowId → timestamps of recent runs */
+    private proactiveHistory;
+    private onRun?;
+    private onError?;
+    private onSchedule?;
+    private onSkipQuietHours?;
+    private onArchival?;
+    private onRetry?;
+    private onJournal?;
+    private onLearn?;
+    private running;
+    constructor(options: SchedulerOptions);
+    start(): void;
+    stop(): void;
+    executeWorkflow(doc: HarnessDocument): Promise<string>;
+    runOnce(workflowId: string): Promise<string>;
+    listScheduled(): Array<{
+        id: string;
+        cron: string;
+        path: string;
+    }>;
+    /** Run archival of expired sessions/journals based on config retention policy. */
+    runArchival(): void;
+    /**
+     * Synthesize today's journal from unjournaled sessions.
+     * Optionally runs instinct learning after synthesis if auto_learn is enabled.
+     */
+    runJournalSynthesis(): Promise<void>;
+    /**
+     * Check if a proactive workflow is allowed to run based on rate limits and cooldown.
+     * Returns true if the workflow should proceed, false if it should be skipped.
+     */
+    checkProactiveCooldown(workflowId: string, config: HarnessConfig): boolean;
+    isRunning(): boolean;
+}
+
+interface JournalSynthesis {
+    summary: string;
+    insights: string[];
+    instinct_candidates: string[];
+    knowledge_updates: string[];
+}
+interface JournalEntry {
+    date: string;
+    sessions: HarnessDocument[];
+    synthesis: string;
+    structured: JournalSynthesis;
+    instinct_candidates: string[];
+    tokens_used: number;
+}
+declare function synthesizeJournal(harnessDir: string, date?: string, apiKey?: string): Promise<JournalEntry>;
+/**
+ * Parse a journal synthesis response into structured sections.
+ * Resilient to missing sections — returns empty arrays/strings for missing parts.
+ */
+declare function parseJournalSynthesis(text: string): JournalSynthesis;
+/**
+ * Synthesize journals for a date range.
+ * Processes each date that has sessions, skipping dates already journaled unless force is set.
+ */
+declare function synthesizeJournalRange(harnessDir: string, options: {
+    from?: string;
+    to?: string;
+    all?: boolean;
+    force?: boolean;
+    apiKey?: string;
+}): Promise<JournalEntry[]>;
+/**
+ * List dates that have sessions but no journal entry.
+ */
+declare function listUnjournaled(harnessDir: string): string[];
+declare function listJournals(harnessDir: string): string[];
+interface WeekSummary {
+    weekStart: string;
+    weekEnd: string;
+    journalDates: string[];
+    summary: string;
+    allInsights: string[];
+    allInstinctCandidates: string[];
+    allKnowledgeUpdates: string[];
+    filePath: string;
+}
+/**
+ * Compress daily journals into weekly roll-up summaries.
+ * Groups journals by ISO week, aggregates structured sections, writes
+ * weekly summary files to memory/journal/weekly/. Pure file-based — no LLM calls.
+ *
+ * Returns only weeks that were newly created (skips existing unless force=true).
+ */
+declare function compressJournals(harnessDir: string, options?: {
+    force?: boolean;
+}): WeekSummary[];
+
+interface InstinctCandidate {
+    id: string;
+    behavior: string;
+    provenance: string;
+    confidence: number;
+}
+interface LearnResult {
+    candidates: InstinctCandidate[];
+    installed: string[];
+    skipped: string[];
+}
+declare function proposeInstincts(harnessDir: string, fromJournalDate?: string, apiKey?: string): Promise<InstinctCandidate[]>;
+declare function installInstinct(harnessDir: string, candidate: InstinctCandidate): string;
+declare function learnFromSessions(harnessDir: string, autoInstall?: boolean, apiKey?: string): Promise<LearnResult>;
+interface HarvestResult {
+    candidates: InstinctCandidate[];
+    installed: string[];
+    skipped: string[];
+    journalsScanned: number;
+}
+/**
+ * Harvest instinct candidates from journal entries.
+ * Scans all journals (or journals within a date range) for instinct candidate
+ * sections, deduplicates against existing instincts, and optionally installs them.
+ *
+ * Unlike learnFromSessions which uses LLM calls, harvestInstincts is pure file-based —
+ * it extracts already-identified candidates from journal synthesis output.
+ */
+declare function harvestInstincts(harnessDir: string, options?: {
+    from?: string;
+    to?: string;
+    install?: boolean;
+}): HarvestResult;
+
+interface EvalResult {
+    valid: boolean;
+    type: string | null;
+    errors: string[];
+    warnings: string[];
+    fixes_applied: string[];
+}
+/**
+ * Auto-fix common issues in a capability file.
+ * Reads the file, applies fixes, writes back, returns what was fixed.
+ * Does NOT fix unfixable issues (e.g., empty body, unparseable YAML).
+ */
+declare function fixCapability(filePath: string): EvalResult;
+/**
+ * Evaluate a capability file. If harnessDir is provided, also checks
+ * dependency resolution (related: references, with: agent references).
+ */
+declare function evaluateCapability(filePath: string, harnessDir?: string): EvalResult;
+declare function installCapability(harnessDir: string, filePath: string): {
+    installed: boolean;
+    destination: string;
+    evalResult: EvalResult;
+};
+declare function processIntake(harnessDir: string): Array<{
+    file: string;
+    result: ReturnType<typeof installCapability>;
+}>;
+interface DownloadResult {
+    downloaded: boolean;
+    localPath: string;
+    error?: string;
+}
+/**
+ * Download a capability file from a URL to a temporary file.
+ * Validates the URL (must be HTTPS) and content type (must look like markdown).
+ * Returns a local temp path suitable for passing to installCapability().
+ */
+declare function downloadCapability(url: string): Promise<DownloadResult>;
+
+interface ValidationResult {
+    ok: string[];
+    warnings: string[];
+    errors: string[];
+    parseErrors: ParseError[];
+    primitiveCounts: Map<string, number>;
+    totalPrimitives: number;
+}
+/**
+ * Comprehensive harness validation:
+ * - Required/optional files
+ * - Config validation
+ * - State validation
+ * - Primitive loading with parse error collection
+ * - Cross-reference integrity (related: fields)
+ * - Context budget check with warnings
+ * - Memory directory structure
+ * - API key presence
+ */
+declare function validateHarness(dir: string): ValidationResult;
+interface DoctorResult extends ValidationResult {
+    fixes: string[];
+    directoriesCreated: string[];
+}
+/**
+ * Run validation then auto-fix all fixable issues:
+ * - Fix primitives with missing id/status/L0/L1/tags
+ * - Create missing memory directories
+ */
+declare function doctorHarness(dir: string): DoctorResult;
+
+interface SessionRecord {
+    id: string;
+    started: string;
+    ended: string;
+    prompt: string;
+    summary: string;
+    tokens_used: number;
+    steps: number;
+    model_id?: string;
+    delegated_to?: string;
+    /** Tool calls executed during this session */
+    tool_calls?: ToolCallInfo[];
+}
+declare function createSessionId(): string;
+declare function writeSession(harnessDir: string, session: SessionRecord): string;
+interface CleanupResult {
+    sessionsRemoved: number;
+    journalsRemoved: number;
+    sessionFiles: string[];
+    journalFiles: string[];
+}
+interface ArchiveResult {
+    sessionsArchived: number;
+    journalsArchived: number;
+    sessionFiles: string[];
+    journalFiles: string[];
+}
+/**
+ * Archive sessions and journals older than their configured retention periods.
+ * Moves files to archive/YYYY-MM/ subdirectories instead of deleting them.
+ * Archived files remain on disk for audit/query but aren't loaded by default.
+ */
+declare function archiveOldFiles(harnessDir: string, sessionRetentionDays: number, journalRetentionDays: number): ArchiveResult;
+/**
+ * Remove sessions and journals older than their configured retention periods.
+ * @deprecated Use archiveOldFiles() instead — it preserves files in archive/.
+ * This function deletes files permanently.
+ */
+declare function cleanupOldFiles(harnessDir: string, sessionRetentionDays: number, journalRetentionDays: number): CleanupResult;
+/** List all session files with their dates */
+declare function listSessions(harnessDir: string): Array<{
+    id: string;
+    date: string;
+    path: string;
+}>;
+/** List files that would be removed by cleanup (dry run — doesn't delete) */
+declare function listExpiredFiles(harnessDir: string, sessionRetentionDays: number, journalRetentionDays: number): {
+    sessionFiles: string[];
+    journalFiles: string[];
+};
+
+interface Message {
+    role: 'user' | 'assistant';
+    content: string;
+    tokens: number;
+}
+interface ConversationOptions {
+    recordSessions?: boolean;
+    /** AI SDK tools available during conversation */
+    tools?: AIToolSet;
+    /** Maximum tool-use roundtrips per message (default: 5) */
+    maxToolSteps?: number;
+}
+interface ConversationSendResult {
+    text: string;
+    usage: {
+        totalTokens: number;
+    };
+    steps: number;
+    toolCalls: ToolCallInfo[];
+}
+interface ConversationStreamResult {
+    /** Async iterable of text chunks — consume with for-await */
+    textStream: AsyncIterable<string>;
+    /** Resolves after the stream is fully consumed with turn metadata */
+    result: Promise<{
+        text: string;
+        usage: {
+            totalTokens: number;
+        };
+        steps: number;
+        toolCalls: ToolCallInfo[];
+    }>;
+}
+declare class Conversation {
+    private messages;
+    private harnessDir;
+    private apiKey?;
+    private systemPrompt;
+    private systemPromptTokens;
+    private maxContextTokens;
+    private modelOverride?;
+    private providerOverride?;
+    private recordSessions;
+    private tools;
+    private maxToolSteps;
+    constructor(harnessDir: string, apiKey?: string, options?: ConversationOptions);
+    /** Update the tool set (e.g., after MCP servers connect) */
+    setTools(tools: AIToolSet): void;
+    setModelOverride(modelId: string): void;
+    setProviderOverride(provider: string): void;
+    init(): Promise<void>;
+    private getConfig;
+    /**
+     * Token budget available for conversation messages.
+     * Allocates CONVERSATION_BUDGET_RATIO of (max_tokens - system_prompt) to messages.
+     */
+    private getMessageBudget;
+    /**
+     * Trim oldest messages until token budget is satisfied.
+     * Always retains at least MIN_MESSAGES.
+     */
+    private trimToTokenBudget;
+    private toModelMessages;
+    send(userMessage: string): Promise<ConversationSendResult>;
+    sendStream(userMessage: string): ConversationStreamResult;
+    save(): void;
+    clear(): void;
+    private writeSessionRecord;
+    getHistory(): Array<{
+        role: string;
+        content: string;
+    }>;
+    /** Token usage stats for the conversation window */
+    getTokenStats(): {
+        messageTokens: number;
+        budget: number;
+        messageCount: number;
+    };
+}
+/**
+ * Parse JSON-lines context format.
+ * Each line is a JSON object: { role, content }
+ */
+declare function parseJsonlContext(raw: string): Message[];
+/**
+ * Parse legacy context.md format (### User / ### Assistant sections).
+ * Kept for backward compatibility — auto-migrates on first load.
+ */
+declare function parseLegacyContext(raw: string): Message[];
+
+interface DelegationResult {
+    agentId: string;
+    text: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    sessionId: string;
+}
+interface AgentInfo {
+    id: string;
+    l0: string;
+    l1: string;
+    path: string;
+    tags: string[];
+    status: string;
+}
+/**
+ * Load all agent documents from the agents/ directory.
+ */
+declare function loadAgentDocs(harnessDir: string): HarnessDocument[];
+/**
+ * Find an agent document by its frontmatter id.
+ * Falls back to filename match if id doesn't match.
+ */
+declare function findAgent(harnessDir: string, agentId: string): HarnessDocument | undefined;
+/**
+ * List all available agents with summary info.
+ */
+declare function listAgents(harnessDir: string): AgentInfo[];
+/**
+ * Build a minimal system prompt for a delegated agent.
+ * Sub-agents are stateless — they get:
+ * 1. The agent's own body (L2) as primary instructions
+ * 2. CORE.md identity (so they know who they serve)
+ * 3. Active rules (at L1 level — compressed for efficiency)
+ */
+declare function buildAgentPrompt(harnessDir: string, agentDoc: HarnessDocument, config: HarnessConfig): string;
+interface DelegateOptions {
+    harnessDir: string;
+    agentId: string;
+    prompt: string;
+    apiKey?: string;
+    modelOverride?: string;
+}
+/**
+ * Delegate a prompt to a sub-agent.
+ * Sub-agents are stateless single-turn executors. They:
+ * - Receive their own body as system prompt + rules + CORE.md
+ * - Execute a single prompt
+ * - Record a session (tagged with the agent id)
+ * - Return the result
+ *
+ * They do NOT have persistent state, memory, or learning.
+ */
+declare function delegateTo(opts: DelegateOptions): Promise<DelegationResult>;
+interface DelegateStreamResult {
+    agentId: string;
+    sessionId: string;
+    textStream: AsyncIterable<string>;
+}
+/**
+ * Stream-delegate a prompt to a sub-agent.
+ * Returns an async iterable of text chunks. Session is recorded after
+ * the stream is fully consumed.
+ */
+declare function delegateStream(opts: DelegateOptions): DelegateStreamResult;
+
+interface SearchOptions {
+    /** Filter by tag (case-insensitive) */
+    tag?: string;
+    /** Filter by primitive type directory (e.g., "rules", "skills") */
+    type?: string;
+    /** Filter by status (e.g., "active", "draft") */
+    status?: string;
+    /** Filter by author (e.g., "human", "agent") */
+    author?: string;
+}
+interface SearchResult {
+    doc: HarnessDocument;
+    directory: string;
+    matchReason: string;
+}
+/**
+ * Search primitives across all directories by query text and/or filters.
+ * Query matches against: id, tags, L0 summary, L1 summary, body content.
+ */
+declare function searchPrimitives(harnessDir: string, query?: string, options?: SearchOptions, config?: HarnessConfig): SearchResult[];
+
+interface WorkflowRun {
+    workflow_id: string;
+    started: string;
+    ended: string;
+    duration_ms: number;
+    success: boolean;
+    error?: string;
+    tokens_used?: number;
+    attempt: number;
+    max_retries: number;
+}
+interface MetricsStore {
+    runs: WorkflowRun[];
+    updated: string;
+}
+interface WorkflowStats {
+    workflow_id: string;
+    total_runs: number;
+    successes: number;
+    failures: number;
+    success_rate: number;
+    avg_duration_ms: number;
+    total_tokens: number;
+    last_run: string;
+    last_success: string | null;
+    last_failure: string | null;
+}
+/**
+ * Load metrics from the metrics store file.
+ * Returns an empty store if the file doesn't exist.
+ */
+declare function loadMetrics(harnessDir: string): MetricsStore;
+/**
+ * Save metrics to the store file. Trims to MAX_RUNS most recent entries.
+ */
+declare function saveMetrics(harnessDir: string, store: MetricsStore): void;
+/**
+ * Record a workflow run in the metrics store.
+ */
+declare function recordRun(harnessDir: string, run: WorkflowRun): void;
+/**
+ * Get aggregated stats for a specific workflow.
+ */
+declare function getWorkflowStats(harnessDir: string, workflowId: string): WorkflowStats | null;
+/**
+ * Get aggregated stats for all workflows that have been run.
+ */
+declare function getAllWorkflowStats(harnessDir: string): WorkflowStats[];
+/**
+ * Clear all metrics for a specific workflow, or all workflows if no ID given.
+ */
+declare function clearMetrics(harnessDir: string, workflowId?: string): number;
+
+interface ExportEntry {
+    path: string;
+    content: string;
+}
+interface HarnessBundle {
+    version: string;
+    exported_at: string;
+    agent_name: string;
+    entries: ExportEntry[];
+    metadata: {
+        primitives: number;
+        sessions: number;
+        journals: number;
+    };
+}
+interface ImportResult {
+    imported: number;
+    skipped: number;
+    errors: string[];
+    files: string[];
+}
+interface ExportOptions {
+    /** Include session files (default: true) */
+    sessions?: boolean;
+    /** Include journal files (default: true) */
+    journals?: boolean;
+    /** Include memory/metrics.json (default: true) */
+    metrics?: boolean;
+    /** Include state.md and scratch.md (default: true) */
+    state?: boolean;
+}
+/**
+ * Export a harness to a portable JSON bundle.
+ */
+declare function exportHarness(harnessDir: string, options?: ExportOptions): HarnessBundle;
+/**
+ * Write an export bundle to a JSON file.
+ */
+declare function writeBundle(bundle: HarnessBundle, outputPath: string): void;
+/**
+ * Read a bundle from a JSON file.
+ */
+declare function readBundle(bundlePath: string): HarnessBundle;
+/**
+ * Import a bundle into a harness directory.
+ * Only writes files that don't already exist (no overwrites by default).
+ */
+declare function importBundle(harnessDir: string, bundle: HarnessBundle, options?: {
+    overwrite?: boolean;
+}): ImportResult;
+
+interface GraphNode {
+    id: string;
+    directory: string;
+    path: string;
+    tags: string[];
+    status: string;
+    l0: string;
+}
+interface GraphEdge {
+    from: string;
+    to: string;
+    type: 'related' | 'with';
+}
+interface DependencyGraph {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    orphans: string[];
+    clusters: string[][];
+}
+interface GraphStats {
+    totalNodes: number;
+    totalEdges: number;
+    orphanCount: number;
+    clusterCount: number;
+    mostConnected: Array<{
+        id: string;
+        connections: number;
+    }>;
+    brokenRefs: Array<{
+        from: string;
+        ref: string;
+    }>;
+}
+/**
+ * Build a dependency graph from all primitives in the harness.
+ * Analyzes `related:` and `with:` frontmatter fields to create edges.
+ */
+declare function buildDependencyGraph(harnessDir: string, config?: HarnessConfig): DependencyGraph;
+/**
+ * Get statistics about the dependency graph.
+ */
+declare function getGraphStats(harnessDir: string, config?: HarnessConfig): GraphStats;
+
+interface SessionData {
+    id: string;
+    date: string;
+    started: string;
+    ended: string;
+    tokens: number;
+    steps: number;
+    durationMinutes: number;
+    model?: string;
+    delegatedTo?: string;
+}
+interface SessionAnalytics {
+    totalSessions: number;
+    totalTokens: number;
+    totalDurationMinutes: number;
+    avgTokensPerSession: number;
+    avgDurationMinutes: number;
+    sessionsPerDay: Map<string, number>;
+    tokensPerDay: Map<string, number>;
+    modelUsage: Map<string, number>;
+    delegationCount: number;
+    dateRange: {
+        earliest: string;
+        latest: string;
+    } | null;
+    topDays: Array<{
+        date: string;
+        sessions: number;
+        tokens: number;
+    }>;
+}
+/**
+ * Load all sessions and compute analytics.
+ */
+declare function getSessionAnalytics(harnessDir: string): SessionAnalytics;
+/**
+ * Load raw session data for a date range.
+ */
+declare function getSessionsInRange(harnessDir: string, from?: string, to?: string): SessionData[];
+
+/** A recorded event in the sliding window */
+interface RateEvent {
+    key: string;
+    timestamp: number;
+}
+/** Rate limit rule: max requests per window_ms */
+interface RateLimit {
+    key: string;
+    max_requests: number;
+    window_ms: number;
+}
+/** Result of a rate limit check */
+interface RateLimitCheck {
+    allowed: boolean;
+    key: string;
+    current: number;
+    max: number;
+    window_ms: number;
+    /** ms until oldest event expires (0 if allowed) */
+    retry_after_ms: number;
+}
+/** Persisted rate limit state */
+interface RateLimitStore {
+    events: RateEvent[];
+    updated: string;
+}
+/**
+ * Load rate limit events from disk.
+ * Returns empty store if file doesn't exist or is corrupt.
+ */
+declare function loadRateLimits(harnessDir: string): RateLimitStore;
+/**
+ * Save rate limit events to disk. Trims to MAX_EVENTS.
+ */
+declare function saveRateLimits(harnessDir: string, store: RateLimitStore): void;
+/**
+ * Check if a request is allowed under the given rate limit.
+ * Does NOT record the event — call recordEvent() separately on success.
+ */
+declare function checkRateLimit(harnessDir: string, limit: RateLimit, now?: number): RateLimitCheck;
+/**
+ * Record a rate limit event for a key.
+ */
+declare function recordEvent(harnessDir: string, key: string, now?: number): void;
+/**
+ * Check rate limit AND record the event if allowed.
+ * Returns the check result. If not allowed, does NOT record.
+ */
+declare function tryAcquire(harnessDir: string, limit: RateLimit, now?: number): RateLimitCheck;
+/**
+ * Get current usage for a key within a window.
+ */
+declare function getUsage(harnessDir: string, key: string, windowMs: number, now?: number): {
+    count: number;
+    oldest: number | null;
+    newest: number | null;
+};
+/**
+ * Clear all rate limit events for a key, or all keys.
+ */
+declare function clearRateLimits(harnessDir: string, key?: string): number;
+
+/** Cost per 1M tokens for a model (input and output separately) */
+interface ModelPricing {
+    model_pattern: string;
+    input_per_million: number;
+    output_per_million: number;
+}
+/** A recorded cost event */
+interface CostEntry {
+    timestamp: string;
+    model_id: string;
+    provider: string;
+    input_tokens: number;
+    output_tokens: number;
+    cost_usd: number;
+    source: string;
+}
+/** Budget configuration */
+interface BudgetConfig {
+    daily_limit_usd?: number;
+    monthly_limit_usd?: number;
+    alert_threshold_pct?: number;
+}
+/** Budget status check result */
+interface BudgetStatus {
+    daily_spent_usd: number;
+    daily_limit_usd: number | null;
+    daily_remaining_usd: number | null;
+    daily_pct: number | null;
+    monthly_spent_usd: number;
+    monthly_limit_usd: number | null;
+    monthly_remaining_usd: number | null;
+    monthly_pct: number | null;
+    alerts: string[];
+}
+/** Spending summary for a time period */
+interface SpendingSummary {
+    total_cost_usd: number;
+    total_input_tokens: number;
+    total_output_tokens: number;
+    entries: number;
+    by_model: Record<string, {
+        cost_usd: number;
+        input_tokens: number;
+        output_tokens: number;
+        count: number;
+    }>;
+    by_provider: Record<string, {
+        cost_usd: number;
+        count: number;
+    }>;
+}
+/** Persisted cost store */
+interface CostStore {
+    entries: CostEntry[];
+    updated: string;
+}
+/**
+ * Load cost entries from disk.
+ */
+declare function loadCosts(harnessDir: string): CostStore;
+/**
+ * Save cost entries to disk. Trims to MAX_ENTRIES.
+ */
+declare function saveCosts(harnessDir: string, store: CostStore): void;
+/**
+ * Find pricing for a model ID. Uses prefix matching against DEFAULT_PRICING.
+ * Custom pricing can be passed to override defaults.
+ */
+declare function findPricing(modelId: string, customPricing?: ModelPricing[]): ModelPricing | null;
+/**
+ * Calculate cost in USD for a given usage.
+ */
+declare function calculateCost(modelId: string, inputTokens: number, outputTokens: number, customPricing?: ModelPricing[]): number;
+/**
+ * Record a cost entry.
+ */
+declare function recordCost(harnessDir: string, entry: Omit<CostEntry, 'timestamp' | 'cost_usd'> & {
+    cost_usd?: number;
+}, customPricing?: ModelPricing[]): CostEntry;
+/**
+ * Get spending summary for a date range.
+ * Defaults to today if no range specified.
+ */
+declare function getSpending(harnessDir: string, from?: string, to?: string): SpendingSummary;
+/**
+ * Check budget status against configured limits.
+ */
+declare function checkBudget(harnessDir: string, budget: BudgetConfig): BudgetStatus;
+/**
+ * Clear all cost entries, or entries for a specific model.
+ */
+declare function clearCosts(harnessDir: string, modelId?: string): number;
+
+interface LockInfo {
+    pid: number;
+    acquired: string;
+    file: string;
+}
+interface LockOptions {
+    /** Stale lock timeout in ms (default: 30000 = 30s) */
+    staleMs?: number;
+    /** How often to retry in ms (default: 50) */
+    retryIntervalMs?: number;
+    /** Max time to wait for lock in ms (default: 5000 = 5s) */
+    waitMs?: number;
+}
+/**
+ * Try to acquire a file lock. Non-blocking — returns immediately.
+ * Returns true if lock was acquired, false if already held.
+ */
+declare function tryLock(harnessDir: string, filePath: string, options?: LockOptions): boolean;
+/**
+ * Release a file lock. Safe to call even if we don't hold it.
+ */
+declare function releaseLock(harnessDir: string, filePath: string): void;
+/**
+ * Wait to acquire a file lock with timeout.
+ * Polls at retryIntervalMs until lock is acquired or waitMs expires.
+ */
+declare function acquireLock(harnessDir: string, filePath: string, options?: LockOptions): Promise<boolean>;
+/**
+ * Execute a function while holding a file lock.
+ * Acquires lock, runs fn, releases lock (even on error).
+ * If lock cannot be acquired within waitMs, runs fn anyway (fail-open).
+ */
+declare function withFileLock<T>(harnessDir: string, filePath: string, fn: () => T | Promise<T>, options?: LockOptions): Promise<T>;
+/**
+ * Synchronous version of withFileLock for use in sync code paths.
+ * Tries lock once — if fails, proceeds anyway (fail-open).
+ */
+declare function withFileLockSync<T>(harnessDir: string, filePath: string, fn: () => T, options?: LockOptions): T;
+/**
+ * Check if a file is currently locked (by any process).
+ */
+declare function isLocked(harnessDir: string, filePath: string, options?: LockOptions): boolean;
+/**
+ * Force-remove a lock regardless of who owns it.
+ * Use only for manual cleanup via CLI.
+ */
+declare function breakLock(harnessDir: string, filePath: string): boolean;
+
+/** Individual health check result */
+interface HealthCheck {
+    name: string;
+    status: 'pass' | 'warn' | 'fail';
+    message: string;
+}
+/** Persisted health metrics */
+interface HealthMetrics {
+    lastSuccessfulRun: string | null;
+    lastFailedRun: string | null;
+    lastError: string | null;
+    consecutiveFailures: number;
+    totalRuns: number;
+    totalSuccesses: number;
+    totalFailures: number;
+    bootedAt: string | null;
+    updatedAt: string;
+}
+/** Overall health status */
+interface HealthStatus {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    checks: HealthCheck[];
+    metrics: HealthMetrics;
+    costToday: number;
+    costThisMonth: number;
+}
+/**
+ * Load health metrics from disk.
+ */
+declare function loadHealth(harnessDir: string): HealthMetrics;
+/**
+ * Save health metrics to disk.
+ */
+declare function saveHealth(harnessDir: string, metrics: HealthMetrics): void;
+/**
+ * Record a successful run.
+ */
+declare function recordSuccess(harnessDir: string): void;
+/**
+ * Record a failed run.
+ */
+declare function recordFailure(harnessDir: string, error?: string): void;
+/**
+ * Record boot time.
+ */
+declare function recordBoot(harnessDir: string): void;
+/**
+ * Run all health checks and return overall status.
+ */
+declare function getHealthStatus(harnessDir: string): HealthStatus;
+/**
+ * Reset health metrics (for testing or fresh start).
+ */
+declare function resetHealth(harnessDir: string): void;
+
+/** A point-in-time snapshot of all system telemetry. */
+interface TelemetrySnapshot {
+    timestamp: string;
+    agent: {
+        name: string;
+        version: string;
+        mode: AgentState['mode'];
+        lastInteraction: string;
+    };
+    health: HealthStatus;
+    spending: {
+        today: SpendingSummary;
+        thisMonth: SpendingSummary;
+        allTime: SpendingSummary;
+    };
+    sessions: {
+        total: number;
+        totalTokens: number;
+        avgTokensPerSession: number;
+        delegationCount: number;
+    };
+    workflows: {
+        totalRuns: number;
+        totalSuccesses: number;
+        totalFailures: number;
+        overallSuccessRate: number;
+        stats: WorkflowStats[];
+    };
+    storage: {
+        sessionCount: number;
+        journalCount: number;
+        weeklyCount: number;
+        primitiveCount: number;
+    };
+    mcp: {
+        serverCount: number;
+        enabledCount: number;
+        servers: Array<{
+            name: string;
+            transport: string;
+            enabled: boolean;
+            valid: boolean;
+            error?: string;
+        }>;
+    };
+}
+/** Options for snapshot collection. */
+interface TelemetryOptions {
+    /** Skip health checks (default: false) */
+    skipHealth?: boolean;
+    /** Skip session analytics parsing (default: false) */
+    skipSessions?: boolean;
+    /** Skip workflow metrics (default: false) */
+    skipWorkflows?: boolean;
+    /** Skip spending data (default: false) */
+    skipSpending?: boolean;
+}
+/**
+ * Collect a full telemetry snapshot from all system modules.
+ * Each section can be skipped via options for performance.
+ */
+declare function collectSnapshot(harnessDir: string, options?: TelemetryOptions): TelemetrySnapshot;
+/**
+ * Format a telemetry snapshot as a human-readable dashboard string.
+ */
+declare function formatDashboard(snapshot: TelemetrySnapshot): string;
+
+/** Result of a guardrail check before an LLM call. */
+interface GuardrailResult {
+    allowed: boolean;
+    reason: string | null;
+    rateLimitCheck: RateLimitCheck | null;
+    budgetStatus: BudgetStatus | null;
+    /** Suggested wait time in ms if rate-limited (0 otherwise) */
+    retryAfterMs: number;
+}
+/**
+ * Build rate limit rules from config.
+ * Returns an array of limits to check (per-minute, per-hour, per-day).
+ */
+declare function buildRateLimits(config: HarnessConfig): RateLimit[];
+/**
+ * Check all guardrails (rate limits + budget) before an LLM call.
+ *
+ * Rate limits: Checks all configured limits. If any limit is exceeded,
+ * the call is blocked with `retry_after_ms` from the first violated limit.
+ *
+ * Budget: Checks daily and monthly spending limits. If `budget.enforce` is true
+ * and any limit is exceeded, the call is blocked.
+ *
+ * Returns { allowed: true } if all checks pass.
+ */
+declare function checkGuardrails(harnessDir: string, config: HarnessConfig): GuardrailResult;
+
+/** Single MCP server configuration (mirrors config schema) */
+interface McpServerConfig {
+    transport: 'stdio' | 'http' | 'sse';
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    url?: string;
+    headers?: Record<string, string>;
+    enabled?: boolean;
+}
+/** Result of connecting to an MCP server */
+interface McpServerConnection {
+    name: string;
+    client: MCPClient;
+    toolCount: number;
+    tools: ToolSet;
+}
+/** Summary of an MCP server for display */
+interface McpServerSummary {
+    name: string;
+    transport: string;
+    enabled: boolean;
+    connected: boolean;
+    toolCount: number;
+    toolNames: string[];
+    error?: string;
+}
+/** Manages all MCP server connections for a harness */
+interface McpManager {
+    /** Connect to all enabled MCP servers and load their tools */
+    connect(): Promise<void>;
+    /** Get merged tool set from all connected servers */
+    getTools(): ToolSet;
+    /** Get summary of all configured servers */
+    getSummaries(): McpServerSummary[];
+    /** Close all connected clients */
+    close(): Promise<void>;
+    /** Check if any servers are configured */
+    hasServers(): boolean;
+}
+/**
+ * Create an MCP manager from harness config.
+ * Manages lifecycle of all MCP server connections.
+ */
+declare function createMcpManager(config: HarnessConfig): McpManager;
+/**
+ * Load MCP tools from all enabled servers in config.
+ * Convenience function for one-shot usage (connects, loads, returns tools + close fn).
+ */
+declare function loadMcpTools(config: HarnessConfig): Promise<{
+    tools: ToolSet;
+    summaries: McpServerSummary[];
+    close: () => Promise<void>;
+}>;
+/**
+ * Validate MCP server configurations without connecting.
+ * Returns validation errors for each server.
+ */
+declare function validateMcpConfig(config: HarnessConfig): Array<{
+    server: string;
+    error: string;
+}>;
+
+/** A discovered MCP server from an external tool's config */
+interface DiscoveredMcpServer {
+    /** Server name (key from the source config) */
+    name: string;
+    /** Transport type inferred from config */
+    transport: 'stdio' | 'http' | 'sse';
+    /** Command for stdio transport */
+    command?: string;
+    /** Args for stdio transport */
+    args?: string[];
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Working directory */
+    cwd?: string;
+    /** URL for http/sse transport */
+    url?: string;
+    /** Headers for http/sse transport */
+    headers?: Record<string, string>;
+}
+/** Result of scanning a single tool's config */
+interface DiscoverySource {
+    /** Tool name (e.g. "Claude Desktop", "Cursor") */
+    tool: string;
+    /** Config file path that was scanned */
+    configPath: string;
+    /** Whether the config file exists */
+    found: boolean;
+    /** Servers discovered from this tool */
+    servers: DiscoveredMcpServer[];
+    /** Error encountered while reading/parsing */
+    error?: string;
+}
+/** Aggregated discovery results */
+interface DiscoveryResult {
+    /** All sources scanned */
+    sources: DiscoverySource[];
+    /** Deduplicated servers (by name, preferring first seen) */
+    servers: DiscoveredMcpServer[];
+    /** Total sources that had config files */
+    sourcesFound: number;
+    /** Total unique servers discovered */
+    totalServers: number;
+}
+/** Options for discovery — primarily used for testing */
+interface DiscoveryOptions {
+    /** Override home directory (default: os.homedir()) */
+    homeDir?: string;
+    /** Override platform detection (default: os.platform() === 'darwin') */
+    isMac?: boolean;
+}
+/**
+ * Scan all known tool config locations for MCP servers.
+ * Returns deduplicated results with source tracking.
+ */
+declare function discoverMcpServers(options?: DiscoveryOptions): DiscoveryResult;
+/**
+ * Convert discovered servers to the harness config YAML format.
+ * Returns a string that can be appended to config.yaml.
+ *
+ * Normalizes absolute paths to well-known binaries (npx/node/python) to bare
+ * names so the YAML is portable across machines. When the command is normalized,
+ * any PATH env var entry is dropped — it was only needed to find the absolute
+ * binary location.
+ */
+declare function discoveredServersToYaml(servers: DiscoveredMcpServer[]): string;
+/** Get the list of tools that are scanned (for display purposes) */
+declare function getScannedTools(): string[];
+
+/** Environment variable from registry server entry */
+interface RegistryEnvVar {
+    name: string;
+    description?: string;
+    isRequired?: boolean;
+    format?: string;
+}
+/** Package entry from registry server */
+interface RegistryPackage {
+    registryType: 'npm' | 'pypi' | 'oci' | 'nuget' | 'mcpb';
+    identifier: string;
+    version: string;
+    transport: {
+        type: 'stdio' | 'streamable-http' | 'sse';
+    };
+    environmentVariables?: RegistryEnvVar[];
+    runtimeHint?: 'npx' | 'uvx' | 'docker' | 'dnx';
+    packageArguments?: unknown[];
+    runtimeArguments?: unknown[];
+}
+/** Remote endpoint from registry server */
+interface RegistryRemote {
+    transportType: 'streamable-http' | 'sse';
+    url: string;
+    headers?: Record<string, string>;
+}
+/** A single server entry from the MCP registry API */
+interface RegistryServer {
+    $schema?: string;
+    name: string;
+    description?: string;
+    title?: string;
+    version: string;
+    repository?: {
+        url: string;
+        source?: string;
+        subfolder?: string;
+    };
+    websiteUrl?: string;
+    packages?: RegistryPackage[];
+    remotes?: RegistryRemote[];
+}
+/** A server result from the registry search API */
+interface RegistrySearchResult {
+    server: RegistryServer;
+    _meta?: Record<string, unknown>;
+}
+/** Full search response from the registry */
+interface RegistrySearchResponse {
+    servers: RegistrySearchResult[];
+    metadata?: {
+        nextCursor?: string;
+        count?: number;
+    };
+}
+/** Resolved server config ready for installation */
+interface ResolvedServer {
+    /** Display name for the server */
+    name: string;
+    /** Server description from registry */
+    description?: string;
+    /** Registry name (e.g. "io.github.foo/bar") */
+    registryName: string;
+    /** Source package info */
+    package?: RegistryPackage;
+    /** Source remote info */
+    remote?: RegistryRemote;
+    /** Generated harness config */
+    config: McpServerConfig;
+    /** Environment variables that need to be set */
+    requiredEnv: RegistryEnvVar[];
+    /** All environment variables (required + optional) */
+    allEnv: RegistryEnvVar[];
+}
+/**
+ * Search the MCP registry for servers matching a query.
+ */
+declare function searchRegistry(query: string, options?: {
+    limit?: number;
+    cursor?: string;
+}): Promise<RegistrySearchResponse>;
+/**
+ * Get a specific server by its registry name and version.
+ * Name must be URL-encoded (e.g. "io.github.foo/bar" -> "io.github.foo%2Fbar").
+ */
+declare function getRegistryServer(name: string, version?: string): Promise<RegistryServer>;
+/**
+ * Derive a short config name from a registry server name.
+ * "io.github.foo/bar-server" -> "bar-server"
+ * "io.github.foo/mcp-something" -> "mcp-something"
+ */
+declare function deriveConfigName(registryName: string): string;
+/**
+ * Resolve a registry server entry into a harness McpServerConfig.
+ * Prefers npm stdio packages, falls back to pypi, then remotes.
+ */
+declare function resolveServerConfig(server: RegistryServer): ResolvedServer;
+/**
+ * Search the registry and return the best match for a query.
+ * If the query looks like a registry name (contains "/" or "."), try exact lookup first.
+ * Otherwise, search and return the first result.
+ */
+declare function findServer(query: string): Promise<ResolvedServer | null>;
+/**
+ * Search the registry and return all matches for display.
+ */
+declare function searchServers(query: string, options?: {
+    limit?: number;
+}): Promise<ResolvedServer[]>;
+
+/** Result of installing an MCP server */
+interface McpInstallResult {
+    /** Whether installation succeeded */
+    installed: boolean;
+    /** Server config name in config.yaml */
+    name: string;
+    /** The resolved server details */
+    server?: ResolvedServer;
+    /** Connection test results */
+    connectionTest?: {
+        connected: boolean;
+        toolCount: number;
+        toolNames: string[];
+        error?: string;
+    };
+    /** Generated tool doc paths */
+    generatedDocs: string[];
+    /** Env vars that need user configuration */
+    pendingEnvVars: RegistryEnvVar[];
+    /** Error message if installation failed */
+    error?: string;
+}
+/** Options for the install command */
+interface McpInstallOptions {
+    /** Harness directory */
+    dir: string;
+    /** Skip connection testing */
+    skipTest?: boolean;
+    /** Skip tool doc generation */
+    skipDocs?: boolean;
+    /** Force overwrite if server already exists */
+    force?: boolean;
+    /** Custom name override for the server in config */
+    name?: string;
+}
+/**
+ * Add or update an MCP server entry in the config file.
+ * Preserves existing config structure and comments where possible.
+ */
+declare function updateConfigWithServer(dir: string, serverName: string, serverConfig: McpServerConfig): void;
+/**
+ * Generate a tools/*.md knowledge doc from a connected MCP server's tools.
+ * Creates one file per MCP server with descriptions of all available tools.
+ */
+declare function generateToolDocs(dir: string, serverName: string, toolNames: string[], description?: string): string[];
+/**
+ * Install an MCP server by name or search query.
+ *
+ * Flow:
+ * 1. Search the MCP registry for the server
+ * 2. Resolve the best package/transport configuration
+ * 3. Add/update the server entry in config.yaml
+ * 4. Optionally test the connection
+ * 5. Optionally generate tools/*.md knowledge docs
+ */
+declare function installMcpServer(query: string, options: McpInstallOptions): Promise<McpInstallResult>;
+/**
+ * List available servers from the registry for a given query.
+ */
+declare function listRegistryServers(query: string, options?: {
+    limit?: number;
+}): Promise<ResolvedServer[]>;
+/**
+ * Format a registry search result for CLI display.
+ */
+declare function formatRegistryServer(entry: {
+    server: RegistryServer;
+}): string;
+
+/** A detected API key from environment files */
+interface DetectedApiKey {
+    /** Environment variable name */
+    name: string;
+    /** Which file it was found in */
+    source: string;
+    /** Whether the value looks like an actual key (not a placeholder) */
+    hasValue: boolean;
+    /** Suggested MCP server or service this key is for */
+    suggestion?: string;
+}
+/** Result of scanning environment for API keys */
+interface EnvDiscoveryResult {
+    /** All detected API keys */
+    keys: DetectedApiKey[];
+    /** Files that were scanned */
+    filesScanned: string[];
+    /** Suggested MCP servers based on detected keys */
+    suggestions: EnvSuggestion[];
+}
+/** Suggested MCP server based on detected environment */
+interface EnvSuggestion {
+    /** Human-readable suggestion */
+    message: string;
+    /** MCP server registry name or package */
+    serverQuery: string;
+    /** Which env var triggered this suggestion */
+    triggeredBy: string;
+}
+/**
+ * Parse a .env file and extract variable names and whether they have real values.
+ * Handles comments, empty values, and quoted values.
+ */
+declare function parseEnvFile(content: string): Array<{
+    name: string;
+    hasValue: boolean;
+}>;
+/** Options for environment discovery */
+interface EnvDiscoveryOptions {
+    /** Directory to scan (defaults to cwd) */
+    dir?: string;
+    /** Additional directories to scan for .env files */
+    extraDirs?: string[];
+}
+/**
+ * Scan for .env files and detect API keys with suggestions.
+ */
+declare function discoverEnvKeys(options?: EnvDiscoveryOptions): EnvDiscoveryResult;
+
+/** A detected project characteristic */
+interface ProjectSignal {
+    /** What was detected (e.g. "TypeScript", "React", "Docker") */
+    name: string;
+    /** Category of signal */
+    category: 'language' | 'framework' | 'tool' | 'runtime' | 'database' | 'cloud' | 'testing';
+    /** Source file that triggered the detection */
+    source: string;
+    /** Additional details */
+    details?: string;
+}
+/** Suggested rule, skill, or MCP server */
+interface ProjectSuggestion {
+    /** What type of thing to add */
+    type: 'rule' | 'skill' | 'mcp-server';
+    /** Human-readable suggestion */
+    message: string;
+    /** File to create (for rules/skills) or server query (for MCP) */
+    target: string;
+    /** Triggered by these signals */
+    signals: string[];
+}
+/** Full project discovery result */
+interface ProjectDiscoveryResult {
+    /** Detected project signals */
+    signals: ProjectSignal[];
+    /** Files that were examined */
+    filesExamined: string[];
+    /** Suggestions based on signals */
+    suggestions: ProjectSuggestion[];
+}
+/** Options for project discovery */
+interface ProjectDiscoveryOptions {
+    /** Project directory to scan */
+    dir?: string;
+}
+/**
+ * Scan a project directory to detect its technology stack and suggest
+ * rules, skills, and MCP servers.
+ */
+declare function discoverProjectContext(options?: ProjectDiscoveryOptions): ProjectDiscoveryResult;
+
+interface WebServerOptions {
+    harnessDir: string;
+    port?: number;
+    /** API key for LLM calls (chat) */
+    apiKey?: string;
+    /** Callback when server starts */
+    onStart?: (port: number) => void;
+}
+interface ServerSentEvent {
+    type: string;
+    data: unknown;
+    timestamp: string;
+}
+declare class SSEBroadcaster {
+    private clients;
+    private nextId;
+    addClient(controller: ReadableStreamDefaultController): string;
+    removeClient(id: string): void;
+    broadcast(event: ServerSentEvent): void;
+    get clientCount(): number;
+}
+interface CreateWebAppOptions {
+    apiKey?: string;
+}
+declare function createWebApp(harnessDir: string, options?: CreateWebAppOptions): {
+    app: Hono;
+    broadcaster: SSEBroadcaster;
+};
+declare function startWebServer(options: WebServerOptions): Promise<{
+    server: Server;
+    broadcaster: SSEBroadcaster;
+}>;
+
+interface BundleManifest {
+    /** Manifest format version */
+    version: string;
+    /** Bundle name (e.g., "code-review-rules") */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Author identifier */
+    author: string;
+    /** Semantic version (e.g., "1.0.0") */
+    bundle_version: string;
+    /** When this bundle was created */
+    created: string;
+    /** Primitive type(s) contained (e.g., ["rules", "instincts"]) */
+    types: string[];
+    /** Tags for search/discovery */
+    tags: string[];
+    /** Files included in this bundle (relative paths) */
+    files: BundleFileEntry[];
+    /** Optional dependencies (other bundle names) */
+    dependencies?: string[];
+    /** Optional registry URL this was published to */
+    registry?: string;
+    /** Optional license identifier */
+    license?: string;
+}
+interface BundleFileEntry {
+    path: string;
+    type: string;
+    id: string;
+    l0: string;
+}
+interface RegistryConfig {
+    /** Registry URL (HTTPS) */
+    url: string;
+    /** Optional auth token */
+    token?: string;
+    /** Optional name for display */
+    name?: string;
+}
+interface BundleSearchResult {
+    name: string;
+    description: string;
+    author: string;
+    version: string;
+    types: string[];
+    tags: string[];
+    download_url: string;
+}
+interface BundleSearchResponse {
+    results: BundleSearchResult[];
+    total: number;
+}
+interface PrimitiveInstallResult {
+    installed: boolean;
+    name: string;
+    files: string[];
+    skipped: string[];
+    errors: string[];
+    manifest?: BundleManifest;
+}
+interface PrimitiveUninstallResult {
+    uninstalled: boolean;
+    name: string;
+    archived: string[];
+    dependents: string[];
+    errors: string[];
+}
+interface PrimitiveUpdateResult {
+    updated: boolean;
+    name: string;
+    added: string[];
+    modified: string[];
+    removed: string[];
+    errors: string[];
+    oldVersion?: string;
+    newVersion?: string;
+}
+/**
+ * Create a manifest.yaml for a set of primitive files.
+ */
+declare function createManifest(harnessDir: string, options: {
+    name: string;
+    description: string;
+    author?: string;
+    version?: string;
+    files: string[];
+    tags?: string[];
+    license?: string;
+}): BundleManifest;
+/**
+ * Write a manifest to a YAML file.
+ */
+declare function writeManifest(manifest: BundleManifest, outputPath: string): void;
+/**
+ * Read and validate a manifest from a YAML file.
+ */
+declare function readManifest(manifestPath: string): BundleManifest;
+interface PackedBundle {
+    manifest: BundleManifest;
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+}
+/**
+ * Pack a set of primitives into a bundle (manifest + file contents).
+ */
+declare function packBundle(harnessDir: string, options: {
+    name: string;
+    description: string;
+    author?: string;
+    version?: string;
+    files?: string[];
+    types?: string[];
+    tags?: string[];
+    license?: string;
+}): PackedBundle;
+/**
+ * Write a packed bundle to a directory (manifest.yaml + files).
+ */
+declare function writeBundleDir(bundle: PackedBundle, outputDir: string): void;
+/**
+ * Read a packed bundle from a directory containing manifest.yaml.
+ */
+declare function readBundleDir(bundleDir: string): PackedBundle;
+/**
+ * Install primitives from a packed bundle into a harness directory.
+ */
+declare function installBundle(harnessDir: string, bundle: PackedBundle, options?: {
+    overwrite?: boolean;
+    force?: boolean;
+}): PrimitiveInstallResult;
+/**
+ * Uninstall (soft-delete) a previously installed bundle.
+ * Moves files to archive/ instead of deleting.
+ */
+declare function uninstallBundle(harnessDir: string, bundleName: string, options?: {
+    hard?: boolean;
+}): PrimitiveUninstallResult;
+/**
+ * Compare an installed bundle against a new version and produce a diff.
+ */
+declare function diffBundle(harnessDir: string, newBundle: PackedBundle): {
+    added: string[];
+    modified: string[];
+    removed: string[];
+    unchanged: string[];
+};
+/**
+ * Update an installed bundle to a new version.
+ */
+declare function updateBundle(harnessDir: string, newBundle: PackedBundle, options?: {
+    removeDeleted?: boolean;
+}): PrimitiveUpdateResult;
+/**
+ * Read all installed bundle manifests.
+ */
+declare function readInstalledManifests(harnessDir: string): BundleManifest[];
+/**
+ * List all installed bundles with summary info.
+ */
+declare function listInstalledBundles(harnessDir: string): Array<{
+    name: string;
+    version: string;
+    types: string[];
+    fileCount: number;
+    description: string;
+}>;
+/**
+ * Fetch a bundle from a remote registry URL.
+ */
+declare function fetchRemoteBundle(url: string): Promise<PackedBundle>;
+/**
+ * Search a remote registry for bundles.
+ */
+declare function searchBundleRegistry(registryUrl: string, query: string, options?: {
+    limit?: number;
+    token?: string;
+}): Promise<BundleSearchResponse>;
+/**
+ * Fetch a bundle from a registry by name.
+ */
+declare function fetchFromRegistry(registryUrl: string, bundleName: string, options?: {
+    version?: string;
+    token?: string;
+}): Promise<PackedBundle>;
+interface BundleSearchHit extends BundleSearchResult {
+    /** Which registry URL this result came from */
+    registryUrl: string;
+    /** Display name of the registry */
+    registryName: string;
+}
+interface MultiBundleSearchResponse {
+    results: BundleSearchHit[];
+    total: number;
+    registriesSearched: number;
+    errors: Array<{
+        registry: string;
+        error: string;
+    }>;
+}
+/**
+ * Search all configured registries for bundles.
+ * Merges results, deduplicating by name (first registry wins).
+ */
+declare function searchConfiguredRegistries(registries: Array<{
+    url: string;
+    name?: string;
+    token?: string;
+}>, query: string, options?: {
+    limit?: number;
+}): Promise<MultiBundleSearchResponse>;
+/**
+ * Install a bundle from configured registries by name.
+ * Searches each registry in order, installs from the first match.
+ */
+declare function installFromRegistry(harnessDir: string, registries: Array<{
+    url: string;
+    name?: string;
+    token?: string;
+}>, bundleName: string, options?: {
+    version?: string;
+    overwrite?: boolean;
+    force?: boolean;
+}): Promise<PrimitiveInstallResult & {
+    registryUrl?: string;
+}>;
+
+/**
+ * Builtin starter packs — installable bundles of primitives (workflows,
+ * rules, instincts, skills) that users can customize after installation.
+ *
+ * Install via: `harness install pack:<name>`
+ * List available: `harness install pack:list`
+ */
+
+interface StarterPack {
+    name: string;
+    description: string;
+    tags: string[];
+    files: Array<{
+        path: string;
+        content: string;
+        id: string;
+        l0: string;
+    }>;
+}
+/**
+ * Get a builtin starter pack by name.
+ * Returns null if the pack doesn't exist.
+ */
+declare function getStarterPack(name: string): PackedBundle | null;
+/**
+ * List all available builtin starter packs.
+ */
+declare function listStarterPacks(): Array<{
+    name: string;
+    description: string;
+    fileCount: number;
+    tags: string[];
+}>;
+/**
+ * Check if a source string is a pack reference (starts with "pack:").
+ */
+declare function isPackReference(source: string): boolean;
+/**
+ * Parse the pack name from a "pack:<name>" reference.
+ */
+declare function parsePackName(source: string): string;
+
+interface PatternOccurrence {
+    behavior: string;
+    journalDates: string[];
+    count: number;
+}
+interface AutoPromoteResult {
+    patterns: PatternOccurrence[];
+    promoted: string[];
+    skipped: string[];
+    journalsScanned: number;
+}
+/**
+ * Scan all journals for instinct candidates that appear 3+ times.
+ * These repeated patterns suggest strong behavioral signals worth auto-promoting.
+ *
+ * The function:
+ * 1. Reads all journal files
+ * 2. Extracts "## Instinct Candidates" sections
+ * 3. Normalizes behavior text for fuzzy matching
+ * 4. Groups by similar behavior (normalized string comparison)
+ * 5. Returns patterns with 3+ occurrences across different journal dates
+ * 6. Optionally auto-installs promoted instincts
+ */
+declare function autoPromoteInstincts(harnessDir: string, options?: {
+    threshold?: number;
+    install?: boolean;
+}): AutoPromoteResult;
+interface DeadPrimitive {
+    id: string;
+    path: string;
+    directory: string;
+    lastModified: string;
+    daysSinceModified: number;
+    reason: string;
+}
+interface DeadPrimitiveResult {
+    dead: DeadPrimitive[];
+    totalScanned: number;
+    thresholdDays: number;
+}
+/**
+ * Detect "dead" primitives — files that are:
+ * 1. Orphaned (no incoming or outgoing references via related:/with:)
+ * 2. Not modified in the last N days (default 30)
+ *
+ * Excludes session and journal directories (memory files).
+ * Does NOT flag recently created primitives even if orphaned.
+ */
+declare function detectDeadPrimitives(harnessDir: string, config?: HarnessConfig, options?: {
+    thresholdDays?: number;
+}): DeadPrimitiveResult;
+interface Contradiction {
+    primitiveA: {
+        id: string;
+        path: string;
+        type: string;
+        text: string;
+    };
+    primitiveB: {
+        id: string;
+        path: string;
+        type: string;
+        text: string;
+    };
+    reason: string;
+    severity: 'low' | 'medium' | 'high';
+}
+interface ContradictionResult {
+    contradictions: Contradiction[];
+    rulesChecked: number;
+    instinctsChecked: number;
+}
+/**
+ * Detect contradictions between rules and instincts.
+ *
+ * Checks for:
+ * 1. Direct negation patterns ("always X" vs "never X", "do X" vs "don't X")
+ * 2. Conflicting tag overlap with opposing behavioral signals
+ * 3. Same topic with contradictory directives
+ *
+ * This is a heuristic-based detector (no LLM needed).
+ * Returns candidate contradictions for human review.
+ */
+declare function detectContradictions(harnessDir: string): ContradictionResult;
+interface SessionEnrichment {
+    sessionId: string;
+    topics: string[];
+    tokenCount: number;
+    stepCount: number;
+    model: string;
+    toolsUsed: string[];
+    primitivesReferenced: string[];
+    duration: string;
+}
+interface EnrichmentResult {
+    enriched: SessionEnrichment[];
+    sessionsScanned: number;
+}
+/**
+ * Enrich sessions with extracted metadata.
+ *
+ * Scans session files and extracts:
+ * - Topics (from prompt text, frequent nouns, matched primitive IDs)
+ * - Token/step counts (from frontmatter or markdown body)
+ * - Model used
+ * - Tools used (from tool call sections)
+ * - Referenced primitives (IDs mentioned in session text)
+ * - Duration
+ */
+declare function enrichSessions(harnessDir: string, config?: HarnessConfig, options?: {
+    from?: string;
+    to?: string;
+}): EnrichmentResult;
+interface CapabilitySuggestion {
+    topic: string;
+    frequency: number;
+    sessionDates: string[];
+    suggestion: string;
+    suggestedType: 'skill' | 'playbook';
+}
+interface CapabilitySuggestionResult {
+    suggestions: CapabilitySuggestion[];
+    topicsAnalyzed: number;
+    sessionsScanned: number;
+}
+/**
+ * Suggest capabilities (skills/playbooks) for frequent session topics
+ * that don't have existing coverage.
+ *
+ * Scans sessions for recurring topics, cross-references against existing
+ * skills/playbooks, and suggests new ones for uncovered topics.
+ */
+declare function suggestCapabilities(harnessDir: string, config?: HarnessConfig, options?: {
+    minFrequency?: number;
+}): CapabilitySuggestionResult;
+/**
+ * Named failure modes with recovery strategies.
+ * Based on common agent failure patterns (context overflow, tool errors,
+ * budget exhaustion, hallucination, stale primitives, circular delegation).
+ */
+type FailureMode = 'context_overflow' | 'tool_execution_error' | 'budget_exhausted' | 'rate_limited' | 'llm_timeout' | 'llm_error' | 'hallucination_detected' | 'stale_primitive' | 'circular_delegation' | 'missing_dependency' | 'parse_error' | 'config_invalid' | 'mcp_connection_failed' | 'state_corruption' | 'unknown';
+interface FailureRecord {
+    mode: FailureMode;
+    timestamp: string;
+    sessionId?: string;
+    message: string;
+    context?: Record<string, unknown>;
+    recoveryAttempted?: string;
+    recovered: boolean;
+}
+interface FailureTaxonomy {
+    modes: Record<FailureMode, {
+        description: string;
+        severity: 'low' | 'medium' | 'high' | 'critical';
+        recoveryStrategies: string[];
+        autoRecoverable: boolean;
+    }>;
+}
+/**
+ * The canonical failure taxonomy for agent-harness.
+ * Each mode has a description, severity level, recovery strategies,
+ * and whether automatic recovery is possible.
+ */
+declare const FAILURE_TAXONOMY: FailureTaxonomy;
+interface FailureAnalysis {
+    recentFailures: FailureRecord[];
+    modeFrequency: Record<string, number>;
+    mostCommonMode: FailureMode | null;
+    suggestedRecovery: string[];
+    healthImplication: 'healthy' | 'degraded' | 'unhealthy';
+}
+/**
+ * Classify an error into a failure mode.
+ */
+declare function classifyFailure(error: Error | string, context?: Record<string, unknown>): FailureMode;
+/**
+ * Get recovery strategies for a failure mode.
+ */
+declare function getRecoveryStrategies(mode: FailureMode): string[];
+/**
+ * Analyze failure patterns from session history and health data.
+ * Returns frequency analysis and recovery suggestions.
+ */
+declare function analyzeFailures(harnessDir: string, options?: {
+    days?: number;
+}): FailureAnalysis;
+type GateStatus = 'pass' | 'fail' | 'warn' | 'skip';
+interface GateCheck {
+    name: string;
+    description: string;
+    status: GateStatus;
+    message: string;
+    details?: Record<string, unknown>;
+}
+interface VerificationGateResult {
+    gateName: string;
+    passed: boolean;
+    checks: GateCheck[];
+    summary: string;
+}
+/**
+ * Run a verification gate by name.
+ * Returns all check results and an overall pass/fail status.
+ */
+declare function runGate(gateName: string, harnessDir: string, config?: HarnessConfig): VerificationGateResult;
+/**
+ * Run all built-in verification gates.
+ */
+declare function runAllGates(harnessDir: string, config?: HarnessConfig): VerificationGateResult[];
+/**
+ * List available gate names and descriptions.
+ */
+declare function listGates(): Array<{
+    name: string;
+    description: string;
+}>;
+
+/**
+ * Fluent builder for defining agents with a clean, declarative API.
+ *
+ * Usage:
+ * ```ts
+ * const agent = defineAgent('/path/to/harness')
+ *   .model('anthropic/claude-sonnet-4')
+ *   .provider('openrouter')
+ *   .onBoot(({ config }) => console.log(`Booted ${config.agent.name}`))
+ *   .onSessionEnd(({ sessionId }) => console.log(`Session ${sessionId} done`))
+ *   .onError(({ error }) => console.error(error))
+ *   .maxToolCalls(10)
+ *   .build();
+ *
+ * await agent.boot();
+ * const result = await agent.run('Hello');
+ * await agent.shutdown();
+ * ```
+ */
+interface AgentBuilder {
+    /** Override the model ID (e.g., "anthropic/claude-sonnet-4") */
+    model(id: string): AgentBuilder;
+    /** Override the provider (e.g., "openrouter", "anthropic", "openai") */
+    provider(name: string): AgentBuilder;
+    /** Set the API key for LLM calls */
+    apiKey(key: string): AgentBuilder;
+    /** Merge partial config overrides */
+    configure(overrides: DeepPartial<HarnessConfig>): AgentBuilder;
+    /** Register a boot lifecycle hook */
+    onBoot(fn: NonNullable<HarnessHooks['onBoot']>): AgentBuilder;
+    /** Register a session-end lifecycle hook */
+    onSessionEnd(fn: NonNullable<HarnessHooks['onSessionEnd']>): AgentBuilder;
+    /** Register an error lifecycle hook */
+    onError(fn: NonNullable<HarnessHooks['onError']>): AgentBuilder;
+    /** Register a state-change lifecycle hook */
+    onStateChange(fn: NonNullable<HarnessHooks['onStateChange']>): AgentBuilder;
+    /** Register a shutdown lifecycle hook */
+    onShutdown(fn: NonNullable<HarnessHooks['onShutdown']>): AgentBuilder;
+    /** Set maximum tool calls per run */
+    maxToolCalls(n: number): AgentBuilder;
+    /** Set per-tool timeout in ms */
+    toolTimeout(ms: number): AgentBuilder;
+    /** Enable/disable HTTP tool execution */
+    allowHttp(enabled: boolean): AgentBuilder;
+    /** Build and return the HarnessAgent (does NOT auto-boot) */
+    build(): HarnessAgent;
+}
+/**
+ * Create a fluent builder for defining a HarnessAgent.
+ * This is the recommended entry point for programmatic agent creation.
+ *
+ * @param dir - Path to the harness directory
+ * @returns A builder with chainable methods
+ */
+declare function defineAgent(dir: string): AgentBuilder;
+
+type RuleAction = 'allow' | 'deny' | 'warn' | 'require_approval';
+interface ParsedRule {
+    /** Source rule document ID */
+    ruleId: string;
+    /** What this rule regulates */
+    subject: string;
+    /** Whether it permits or blocks */
+    action: RuleAction;
+    /** Original directive text (for messages) */
+    directive: string;
+    /** Tags from the source document (for scoping) */
+    tags: string[];
+}
+interface RuleCheckInput {
+    /** The action being attempted (e.g., "run", "tool_call", "delegate") */
+    action: string;
+    /** Free-text description of what's being attempted */
+    description?: string;
+    /** Relevant tags or topics for the check */
+    tags?: string[];
+    /** Tool name if this is a tool call */
+    toolName?: string;
+}
+interface RuleViolation {
+    ruleId: string;
+    directive: string;
+    severity: 'deny' | 'warn' | 'require_approval';
+    reason: string;
+}
+interface RuleCheckResult {
+    allowed: boolean;
+    violations: RuleViolation[];
+    warnings: RuleViolation[];
+    requiresApproval: boolean;
+    /** Human-readable summary */
+    summary: string;
+}
+/**
+ * Extract enforceable rules from a harness document.
+ * Parses "never", "must not", "do not", "always", "require" directives
+ * and converts them into structured rule objects.
+ */
+declare function parseRulesFromDoc(doc: HarnessDocument): ParsedRule[];
+/**
+ * Load and parse all enforceable rules from a harness directory.
+ * Loads all documents from the rules/ directory and extracts structured rules.
+ */
+declare function loadRules(harnessDir: string): ParsedRule[];
+/**
+ * Check whether an action violates any loaded rules.
+ * Uses keyword overlap between the action description/tags and rule subjects.
+ *
+ * @param rules - Parsed rules from loadRules()
+ * @param input - Description of the action being attempted
+ * @returns Check result with violations, warnings, and approval requirements
+ */
+declare function checkRules(rules: ParsedRule[], input: RuleCheckInput): RuleCheckResult;
+/**
+ * Convenience: load rules from disk and check an action in one call.
+ */
+declare function enforceRules(harnessDir: string, input: RuleCheckInput): RuleCheckResult;
+
+interface VerificationCriterion {
+    /** Human-readable criterion description */
+    description: string;
+    /** Whether this criterion must be manually checked (vs auto-checkable) */
+    manual: boolean;
+    /** Optional command to run for automated verification */
+    command?: string;
+    /** Optional expected output pattern (regex) for automated verification */
+    expectedPattern?: string;
+}
+interface VerificationGate {
+    /** Gate ID derived from playbook/workflow stage */
+    id: string;
+    /** Stage name this gate guards (e.g., "Build", "Verify") */
+    stage: string;
+    /** Source playbook/workflow ID */
+    sourceId: string;
+    /** Acceptance criteria that must pass before proceeding */
+    criteria: VerificationCriterion[];
+}
+interface GateCheckResult {
+    gateId: string;
+    stage: string;
+    passed: boolean;
+    /** Individual criterion results */
+    results: Array<{
+        criterion: string;
+        passed: boolean;
+        detail?: string;
+    }>;
+    /** Criteria that need manual verification */
+    pendingManual: string[];
+}
+interface GateExtractResult {
+    gates: VerificationGate[];
+    /** Source playbook/workflow IDs that had gates */
+    sources: string[];
+}
+/**
+ * Extract verification gates from a playbook or workflow document.
+ *
+ * Gates are detected from:
+ * 1. `## Gate:` or `## Verification:` sections in the document body
+ * 2. Acceptance criteria blocks (`### Acceptance Criteria` or `### Gate`)
+ * 3. Inline gate markers: `<!-- gate: description -->` in the markdown
+ * 4. Numbered steps with `[x]` checkbox markers (treated as manual criteria)
+ */
+declare function extractGates(doc: HarnessDocument): VerificationGate[];
+/**
+ * Load all verification gates from playbooks and workflows in the harness.
+ */
+declare function loadGates(harnessDir: string): GateExtractResult;
+/**
+ * Find gates for a specific playbook/workflow by ID.
+ */
+declare function getGatesForPlaybook(harnessDir: string, playbookId: string): VerificationGate[];
+/**
+ * Check a verification gate against provided results.
+ * For manual criteria, checks against the `manualResults` map.
+ * For automated criteria, checks if the command output matches the expected pattern.
+ *
+ * @param gate - The gate to check
+ * @param manualResults - Map of criterion description → pass/fail
+ * @param commandOutputs - Map of command → actual output (for automated checks)
+ */
+declare function checkGate(gate: VerificationGate, manualResults?: Map<string, boolean>, commandOutputs?: Map<string, string>): GateCheckResult;
+/**
+ * Check all gates for a playbook/workflow. Returns individual gate results.
+ */
+declare function checkAllGates(harnessDir: string, playbookId: string, manualResults?: Map<string, boolean>, commandOutputs?: Map<string, string>): GateCheckResult[];
+
+interface AgentDefinition {
+    /** Agent name (used for logging and config resolution) */
+    name: string;
+    /** Harness directory path */
+    dir: string;
+    /** Model override */
+    model?: string;
+    /** Provider override */
+    provider?: string;
+    /** API key override */
+    apiKey?: string;
+    /** Config overrides */
+    config?: DeepPartial<HarnessConfig>;
+    /** Lifecycle hooks  called at various points in the agent lifecycle */
+    hooks?: AgentLifecycleHooks;
+    /** Pre-action rule enforcement configuration */
+    guardrails?: GuardrailEnforcementConfig;
+    /** Human-in-the-loop gate configuration */
+    approval?: ApprovalGateConfig;
+    /** Middleware functions that wrap each run/stream call */
+    middleware?: AgentMiddleware[];
+}
+interface AgentLifecycleHooks extends HarnessHooks {
+    /** Called before each run/stream  can modify prompt or reject */
+    beforeRun?: (ctx: BeforeRunContext) => Promise<BeforeRunResult | void>;
+    /** Called after each run/stream  can transform result */
+    afterRun?: (ctx: AfterRunContext) => Promise<AgentRunResult | void>;
+    /** Called periodically for health checks */
+    onHealthCheck?: (ctx: {
+        agent: DefinedAgent;
+    }) => Promise<void>;
+}
+interface BeforeRunContext {
+    agent: DefinedAgent;
+    prompt: string;
+    isStream: boolean;
+}
+interface BeforeRunResult {
+    /** Modified prompt (if changed) */
+    prompt?: string;
+    /** Set to true to reject the run */
+    reject?: boolean;
+    /** Reason for rejection */
+    reason?: string;
+}
+interface AfterRunContext {
+    agent: DefinedAgent;
+    prompt: string;
+    result: AgentRunResult;
+}
+type AgentMiddleware = (ctx: {
+    agent: DefinedAgent;
+    prompt: string;
+    isStream: boolean;
+}, next: () => Promise<AgentRunResult>) => Promise<AgentRunResult>;
+/**
+ * A defined agent wraps a HarnessAgent with additional capabilities:
+ * - Middleware pipeline
+ * - Pre-action guardrails
+ * - Human-in-the-loop gates
+ * - Extended lifecycle hooks
+ */
+interface DefinedAgent {
+    name: string;
+    config: HarnessConfig;
+    /** The underlying harness agent */
+    harness: HarnessAgent;
+    /** Boot the agent */
+    boot(): Promise<void>;
+    /** Run with middleware, guardrails, and approval gates */
+    run(prompt: string): Promise<AgentRunResult>;
+    /** Stream with middleware, guardrails, and approval gates */
+    stream(prompt: string): AgentStreamResult;
+    /** Shutdown cleanly */
+    shutdown(): Promise<void>;
+    /** Get agent state */
+    getState(): AgentState;
+    /** Get system prompt */
+    getSystemPrompt(): string;
+    /** Check if agent is booted */
+    isBooted(): boolean;
+    /** Access the definition */
+    definition: AgentDefinition;
+}
+/**
+ * Define an agent with declarative configuration.
+ *
+ * This is the high-level API for creating agents with:
+ * - Lifecycle hooks (beforeRun, afterRun, onBoot, onSessionEnd, onError, onShutdown)
+ * - Middleware pipeline (wrap each run with custom logic)
+ * - Guardrail enforcement (check rules before actions)
+ * - Human-in-the-loop gates (require approval for certain prompts)
+ *
+ * Usage:
+ * ```typescript
+ * const agent = createAgent({
+ *   name: 'my-agent',
+ *   dir: './my-harness',
+ *   hooks: {
+ *     beforeRun: async ({ prompt }) => {
+ *       if (prompt.includes('delete')) return { reject: true, reason: 'Destructive action' };
+ *     },
+ *     onBoot: async () => console.log('Agent booted!'),
+ *   },
+ *   guardrails: { enforceRules: true },
+ *   approval: { requireApproval: (prompt) => prompt.includes('deploy') },
+ * });
+ *
+ * await agent.boot();
+ * const result = await agent.run('Hello world');
+ * ```
+ */
+declare function createAgent(definition: AgentDefinition): DefinedAgent;
+interface GuardrailEnforcementConfig {
+    /** Enable rule-based pre-action checking (default: false) */
+    enforceRules?: boolean;
+    /** Custom check function (in addition to rule scanning) */
+    customCheck?: (prompt: string) => string | null;
+    /** Tags to filter rules (only check rules with these tags) */
+    ruleTags?: string[];
+}
+interface AgentRuleViolation {
+    ruleId: string;
+    rulePath: string;
+    violatedDirective: string;
+    prompt: string;
+}
+/**
+ * Check if a prompt violates any rules in the harness.
+ *
+ * Rules are scanned for "never" / "don't" / "must not" / "avoid" directives.
+ * If the prompt contains keywords that match a forbidden action,
+ * a violation is returned.
+ *
+ * This is a heuristic check  not a semantic understanding of the prompt.
+ * Returns null if no violation found, or a string describing the violation.
+ */
+declare function checkRuleViolation(harnessDir: string, prompt: string, options?: {
+    ruleTags?: string[];
+}): string | null;
+interface ApprovalGateConfig {
+    /**
+     * Function that decides if a prompt requires human approval.
+     * Return true to require approval, false to proceed.
+     */
+    requireApproval?: (prompt: string) => boolean;
+    /**
+     * Called when approval is needed.
+     * Should return true if approved, false if rejected.
+     * For CLI: prompt user with readline.
+     * For API: send webhook and await response.
+     */
+    onApprovalNeeded?: (prompt: string) => Promise<boolean>;
+    /**
+     * Timeout in ms for approval (default: 300000 = 5 minutes).
+     * If timeout is reached, the run is rejected.
+     */
+    timeoutMs?: number;
+}
+/**
+ * Create a simple CLI-based approval handler.
+ * Prompts the user on stdin for approval.
+ *
+ * Usage:
+ * ```typescript
+ * createAgent({
+ *   ...
+ *   approval: {
+ *     requireApproval: (prompt) => prompt.includes('deploy'),
+ *     onApprovalNeeded: createCliApproval(),
+ *   },
+ * });
+ * ```
+ */
+declare function createCliApproval(options?: {
+    timeoutMs?: number;
+}): (prompt: string) => Promise<boolean>;
+/**
+ * Create a webhook-based approval handler.
+ * Sends a POST to the webhook URL and awaits response.
+ */
+declare function createWebhookApproval(options: {
+    url: string;
+    timeoutMs?: number;
+    headers?: Record<string, string>;
+}): (prompt: string) => Promise<boolean>;
+/**
+ * Check if a specific action is allowed by the harness rules.
+ * Returns { allowed: true } or { allowed: false, reason: string }.
+ *
+ * This is a lightweight version of checkRuleViolation for use outside defineAgent.
+ */
+declare function checkAction(harnessDir: string, action: string, options?: {
+    ruleTags?: string[];
+}): {
+    allowed: boolean;
+    reason: string | null;
+};
+
+type StateOwner = 'human' | 'agent' | 'infrastructure';
+/** Tracks which entity last modified each field of the state. */
+interface StateOwnership {
+    mode: StateOwner;
+    goals: StateOwner;
+    active_workflows: StateOwner;
+    last_interaction: StateOwner;
+    unfinished_business: StateOwner;
+}
+/** A state change with ownership metadata. */
+interface OwnedStateChange {
+    /** Who is making this change */
+    author: StateOwner;
+    /** Partial state to merge — only provided fields are updated */
+    changes: Partial<AgentState>;
+    /** Timestamp of the change (ISO string) */
+    timestamp?: string;
+}
+/** Strategy for resolving conflicting state changes. */
+type MergeStrategy = 'human-wins' | 'agent-wins' | 'latest-wins' | 'union';
+interface MergeResult {
+    /** The merged state */
+    state: AgentState;
+    /** Updated ownership */
+    ownership: StateOwnership;
+    /** Fields that had conflicts */
+    conflicts: StateConflict[];
+    /** Whether any conflicts were resolved */
+    hadConflicts: boolean;
+}
+interface StateConflict {
+    field: keyof AgentState;
+    humanValue: unknown;
+    agentValue: unknown;
+    resolvedTo: StateOwner;
+    resolvedValue: unknown;
+}
+/** Load ownership metadata from the harness directory. */
+declare function loadOwnership(harnessDir: string): StateOwnership;
+/** Save ownership metadata to the harness directory. */
+declare function saveOwnership(harnessDir: string, ownership: StateOwnership): void;
+/**
+ * Merge a state change into the current state, respecting ownership.
+ *
+ * Rules:
+ * - `human-wins`: If a human-owned field is being changed by an agent, the human value is kept.
+ * - `agent-wins`: If an agent-owned field is being changed by a human, the agent value is kept.
+ * - `latest-wins`: The most recent change always wins (default).
+ * - `union`: For array fields (goals, active_workflows, unfinished_business), merge by union.
+ *            For scalar fields, latest-wins.
+ *
+ * @param harnessDir - Harness directory path
+ * @param change - The state change to apply
+ * @param strategy - Merge strategy (default: 'human-wins')
+ */
+declare function mergeState(harnessDir: string, change: OwnedStateChange, strategy?: MergeStrategy): MergeResult;
+/**
+ * Apply a state change without ownership — direct write.
+ * Use this when ownership tracking is not needed.
+ */
+declare function applyStateChange(harnessDir: string, changes: Partial<AgentState>): AgentState;
+
+/**
+ * Emotional valence dimensions for agent self-assessment.
+ * These are not human emotions — they represent operational disposition signals
+ * that influence context loading, risk tolerance, and communication style.
+ */
+interface EmotionalState {
+    /** Confidence in current task (0-100). Low → more cautious, more verification. */
+    confidence: number;
+    /** Engagement/focus level (0-100). Low → may need re-orientation. */
+    engagement: number;
+    /** Frustration/difficulty signal (0-100). High → may need escalation or approach change. */
+    frustration: number;
+    /** Curiosity/exploration drive (0-100). High → more likely to explore tangents. */
+    curiosity: number;
+    /** Urgency/time-pressure (0-100). High → skip verification, prioritize speed. */
+    urgency: number;
+    /** Last updated timestamp */
+    updatedAt: string;
+    /** Optional notes about the emotional state */
+    notes?: string;
+}
+interface EmotionalSignal {
+    dimension: keyof Omit<EmotionalState, 'updatedAt' | 'notes'>;
+    delta: number;
+    reason?: string;
+}
+interface EmotionalSnapshot {
+    state: EmotionalState;
+    signals: EmotionalSignal[];
+    timestamp: string;
+}
+interface EmotionalTrend {
+    dimension: keyof Omit<EmotionalState, 'updatedAt' | 'notes'>;
+    values: Array<{
+        value: number;
+        timestamp: string;
+    }>;
+    trend: 'rising' | 'falling' | 'stable';
+    average: number;
+}
+/** Load the current emotional state from the harness memory directory. */
+declare function loadEmotionalState(harnessDir: string): EmotionalState;
+/** Save the emotional state to the harness memory directory. */
+declare function saveEmotionalState(harnessDir: string, state: EmotionalState): void;
+/**
+ * Apply emotional signals to the current state.
+ * Signals are additive deltas (e.g., { dimension: 'confidence', delta: +10 }).
+ * Values are clamped to 0-100.
+ *
+ * Also appends to the history file for trend analysis.
+ */
+declare function applySignals(harnessDir: string, signals: EmotionalSignal[]): EmotionalState;
+/**
+ * Derive emotional signals from session outcomes.
+ *
+ * Heuristic rules:
+ * - Successful run → confidence +5, frustration -5
+ * - Long run (many steps) → engagement +3, urgency +2
+ * - Error → frustration +10, confidence -5
+ * - Tool calls → curiosity +2
+ * - Budget close to limit → urgency +10
+ */
+declare function deriveSignals(outcome: {
+    success: boolean;
+    steps: number;
+    toolCalls: number;
+    error?: boolean;
+    budgetPercent?: number;
+}): EmotionalSignal[];
+/**
+ * Generate a natural-language summary of the emotional state for context injection.
+ * This can be injected into the system prompt to inform the agent of its disposition.
+ */
+declare function summarizeEmotionalState(state: EmotionalState): string;
+/**
+ * Reset all emotional dimensions to defaults.
+ */
+declare function resetEmotionalState(harnessDir: string): EmotionalState;
+/**
+ * Load emotional history and compute trends.
+ *
+ * @param harnessDir - Harness directory
+ * @param options.days - Number of days to look back (default: 7)
+ */
+declare function getEmotionalTrends(harnessDir: string, options?: {
+    days?: number;
+}): EmotionalTrend[];
+
+/** A stored embedding for a single primitive document. */
+interface EmbeddingRecord {
+    /** Document ID from frontmatter */
+    id: string;
+    /** Path to the source markdown file */
+    path: string;
+    /** Primitive directory (rules, skills, etc.) */
+    directory: string;
+    /** Text that was embedded (L0 + L1 + tags) */
+    embeddedText: string;
+    /** The embedding vector */
+    vector: number[];
+    /** File modification time (to detect stale embeddings) */
+    mtime: string;
+    /** When the embedding was generated */
+    createdAt: string;
+}
+/** Embedding store format — persisted as JSON. */
+interface EmbeddingStore {
+    /** Model ID used for embeddings (invalidate cache if changed) */
+    modelId: string;
+    /** Embedding vector dimension */
+    dimensions: number;
+    /** Map of document ID → embedding record */
+    records: Record<string, EmbeddingRecord>;
+    /** Last full index time */
+    lastIndexedAt: string;
+}
+/** Result of a semantic search query. */
+interface SemanticSearchResult {
+    doc: HarnessDocument;
+    directory: string;
+    /** Cosine similarity score (0-1, higher is more relevant) */
+    score: number;
+    /** The embedded text that matched */
+    embeddedText: string;
+}
+/** Function signature for embedding text → vector. */
+type EmbedFunction = (texts: string[]) => Promise<number[][]>;
+/** Configuration for the semantic search module. */
+interface SemanticSearchConfig {
+    /** Function to embed text (wraps Vercel AI SDK embed/embedMany) */
+    embed: EmbedFunction;
+    /** Embedding model identifier (for cache invalidation) */
+    modelId: string;
+    /** Maximum results to return (default: 10) */
+    maxResults?: number;
+    /** Minimum similarity threshold (default: 0.3) */
+    minScore?: number;
+}
+/** Load the embedding store from disk. Returns null if not found or invalid. */
+declare function loadEmbeddingStore(harnessDir: string): EmbeddingStore | null;
+/** Save the embedding store to disk. */
+declare function saveEmbeddingStore(harnessDir: string, store: EmbeddingStore): void;
+/**
+ * Extract embeddable text from a document.
+ * Combines: tags, L0 summary, L1 summary, and first 500 chars of body.
+ * This gives a compact representation for embedding.
+ */
+declare function extractEmbeddableText(doc: HarnessDocument): string;
+/**
+ * Detect which primitives need re-embedding.
+ * A primitive is stale if:
+ * - It doesn't exist in the store
+ * - Its file mtime has changed since last embedding
+ * - The embedding model has changed
+ */
+declare function detectStalePrimitives(harnessDir: string, store: EmbeddingStore | null, modelId: string, config?: HarnessConfig): Array<{
+    doc: HarnessDocument;
+    directory: string;
+}>;
+/**
+ * Index (or re-index) all primitives that need embeddings.
+ * Incrementally updates the store — only re-embeds stale documents.
+ *
+ * @param harnessDir - Harness directory path
+ * @param config - Semantic search configuration with embed function
+ * @param harnessConfig - Optional harness config for extension directories
+ * @returns Updated embedding store
+ */
+declare function indexPrimitives(harnessDir: string, searchConfig: SemanticSearchConfig, harnessConfig?: HarnessConfig): Promise<EmbeddingStore>;
+/**
+ * Compute cosine similarity between two vectors.
+ * Returns a value between -1 and 1 (1 = identical, 0 = orthogonal).
+ */
+declare function cosineSimilarity(a: number[], b: number[]): number;
+/**
+ * Perform semantic search over indexed primitives.
+ *
+ * @param harnessDir - Harness directory path
+ * @param query - Natural language query
+ * @param searchConfig - Search configuration with embed function
+ * @param harnessConfig - Optional harness config
+ * @returns Ranked search results by cosine similarity
+ */
+declare function semanticSearch(harnessDir: string, query: string, searchConfig: SemanticSearchConfig, harnessConfig?: HarnessConfig): Promise<SemanticSearchResult[]>;
+/**
+ * Get embedding stats for the harness.
+ */
+declare function getEmbeddingStats(harnessDir: string): {
+    indexed: number;
+    modelId: string | null;
+    dimensions: number;
+    lastIndexedAt: string | null;
+    storeSize: number;
+};
+
+interface ServeOptions {
+    harnessDir: string;
+    port?: number;
+    apiKey?: string;
+    /** Secret for authenticating incoming webhooks */
+    webhookSecret?: string;
+    /** Enable CORS for all origins (default: true) */
+    corsEnabled?: boolean;
+}
+interface WebhookRegistration {
+    /** Unique webhook ID */
+    id: string;
+    /** URL to send events to */
+    url: string;
+    /** Events to subscribe to (e.g., ['session_end', 'state_change']) */
+    events: string[];
+    /** Optional secret for signing payloads */
+    secret?: string;
+    /** Whether this webhook is active */
+    active: boolean;
+    /** Created timestamp */
+    createdAt: string;
+}
+interface WebhookPayload {
+    event: string;
+    timestamp: string;
+    data: unknown;
+    webhookId: string;
+}
+interface WebhookStore {
+    webhooks: WebhookRegistration[];
+}
+interface ServeResult {
+    server: Server;
+    port: number;
+    /** Function to fire a webhook event */
+    fireEvent: (event: string, data: unknown) => Promise<void>;
+    /** Function to stop the server */
+    stop: () => void;
+}
+/**
+ * Create and start the harness API server.
+ *
+ * Includes:
+ * - All dashboard endpoints from web-server.ts
+ * - Webhook registration and management API
+ * - Prompt execution endpoint (POST /api/run)
+ * - Health check endpoint (GET /api/health)
+ * - Version information endpoint (GET /api/info)
+ *
+ * Usage:
+ * ```typescript
+ * const result = startServe({
+ *   harnessDir: './my-harness',
+ *   port: 8080,
+ *   webhookSecret: 'my-secret',
+ * });
+ *
+ * // Fire events to registered webhooks
+ * await result.fireEvent('custom_event', { key: 'value' });
+ *
+ * // Stop the server
+ * result.stop();
+ * ```
+ */
+declare function startServe(options: ServeOptions): ServeResult;
+
+type SourceType = 'github' | 'registry' | 'api';
+type ContentType = 'skills' | 'agents' | 'rules' | 'playbooks' | 'hooks' | 'templates' | 'mcp' | 'plugins';
+interface Source {
+    /** Display name */
+    name: string;
+    /** URL — GitHub repo, registry API, or endpoint */
+    url: string;
+    /** Source type */
+    type: SourceType;
+    /** Content types provided */
+    content: ContentType[];
+    /** Searchable tags */
+    tags: string[];
+    /** Description of the source */
+    description?: string;
+    /** Optional stats (e.g., { skills: 31, agents: 19 }) */
+    stats?: Record<string, number>;
+}
+interface SourcesFile {
+    version: string;
+    sources: Source[];
+}
+interface SourceDiscoveryResult {
+    /** Source the item came from */
+    source: Source;
+    /** Item name/title */
+    name: string;
+    /** Item description */
+    description: string;
+    /** Item type (skill, agent, rule, etc.) */
+    type: ContentType;
+    /** URL to the item (file or page) */
+    url: string;
+    /** Match relevance score (0-1) */
+    score: number;
+}
+interface SourceDiscoveryOptions {
+    /** Filter by content type */
+    type?: ContentType;
+    /** Maximum results */
+    maxResults?: number;
+    /** Only search these sources (by name) */
+    sourceNames?: string[];
+}
+/**
+ * Load the shipped sources.yaml from the package root.
+ */
+declare function loadShippedSources(): Source[];
+/**
+ * Load user-added sources from the harness memory directory.
+ */
+declare function loadUserSources(harnessDir: string): Source[];
+/**
+ * Save user sources to the harness memory directory.
+ */
+declare function saveUserSources(harnessDir: string, sources: Source[]): void;
+/**
+ * Load all sources: shipped + user-added, deduplicated by name.
+ */
+declare function loadAllSources(harnessDir: string): Source[];
+/**
+ * Add a new source to the user's sources list.
+ * Returns the added source, or null if it already exists.
+ */
+declare function addSource(harnessDir: string, source: Omit<Source, 'tags'> & {
+    tags?: string[];
+}): Source | null;
+/**
+ * Remove a source by name from the user's sources list.
+ * Returns true if removed, false if not found.
+ */
+declare function removeSource(harnessDir: string, name: string): boolean;
+/**
+ * Search all sources for content matching a query.
+ *
+ * This performs local matching against source metadata (name, description,
+ * tags, content types). For deeper search, each source type has its own
+ * fetcher (GitHub API, registry API, etc.).
+ *
+ * @param harnessDir - Harness directory
+ * @param query - Search query (text or content type)
+ * @param options - Discovery options
+ * @returns Ranked results from all matching sources
+ */
+declare function discoverSources(harnessDir: string, query: string, options?: SourceDiscoveryOptions): SourceDiscoveryResult[];
+/**
+ * Get all sources that provide a specific content type.
+ */
+declare function getSourcesForType(harnessDir: string, type: ContentType): Source[];
+/**
+ * Get a summary of all known sources grouped by content type.
+ */
+declare function getSourcesSummary(harnessDir: string): Record<ContentType, Source[]>;
+/**
+ * Fetch content listing from a GitHub source via the Contents API.
+ *
+ * Uses `GET /repos/{owner}/{repo}/contents/{path}` which works without
+ * authentication (60 req/hr limit). Recurses one level into `plugins/*`
+ * to discover wshobson-style nested layouts.
+ *
+ * Falls back to the legacy Code Search API only if `GITHUB_TOKEN` is set
+ * AND `HARNESS_DISCOVER_USE_CODE_SEARCH=1` is opted in via env. Code Search
+ * always requires auth (returns 401 unauthenticated as of 2023).
+ *
+ * @param source - GitHub source definition
+ * @param query - Search query (case-insensitive substring match)
+ * @param options - Discovery options
+ * @returns Discovery results from the GitHub repo
+ */
+declare function fetchGitHubSource(source: Source, query: string, options?: SourceDiscoveryOptions, budget?: CallBudget): Promise<SourceDiscoveryResult[]>;
+/**
+ * A budget for Contents API calls. Shared across a single discoverRemote
+ * invocation so multiple sources can't collectively exhaust the rate limit.
+ */
+interface CallBudget {
+    remaining: number;
+}
+/**
+ * Perform a full remote discovery across all sources.
+ * Searches GitHub repos and registries in parallel.
+ *
+ * @param harnessDir - Harness directory
+ * @param query - Search query
+ * @param options - Discovery options
+ * @returns All discovery results, merged and ranked
+ */
+declare function discoverRemote(harnessDir: string, query: string, options?: SourceDiscoveryOptions): Promise<SourceDiscoveryResult[]>;
+
+/** Detected source format of a file to be installed. */
+type SourceFormat = 'harness' | 'claude-skill' | 'faf-yaml' | 'raw-markdown' | 'bash-hook' | 'mcp-config' | 'unknown';
+/** Result of format detection. */
+interface FormatDetection {
+    /** Detected format */
+    format: SourceFormat;
+    /** Inferred primitive type (skill, agent, rule, etc.) */
+    primitiveType: string | null;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Reasons for the detection */
+    reasons: string[];
+}
+/** Result of a universal install operation. */
+interface UniversalInstallResult {
+    /** Whether installation succeeded */
+    installed: boolean;
+    /** Source reference that was resolved */
+    source: string;
+    /** Detected format */
+    format: FormatDetection;
+    /** Path where the file was installed */
+    destination: string;
+    /** Fixes applied during normalization */
+    fixes: string[];
+    /** Errors encountered */
+    errors: string[];
+    /** Suggested dependencies to install */
+    suggestedDependencies: string[];
+}
+/** Options for the universal installer. */
+interface UniversalInstallOptions {
+    /** Override the detected primitive type (skill, rule, agent, etc.) */
+    type?: string;
+    /** Override the generated ID */
+    id?: string;
+    /** Force install even if validation has warnings */
+    force?: boolean;
+    /** Skip auto-fix (frontmatter, L0/L1 generation) */
+    skipFix?: boolean;
+    /** Additional tags to add */
+    tags?: string[];
+}
+/**
+ * Detect the format of a file based on its content and extension.
+ *
+ * Detection heuristics:
+ * - Has `---` frontmatter with `id:` + `status:` → harness convention
+ * - Has `---` frontmatter but missing harness fields → raw-markdown
+ * - `.faf` or `.yaml`/`.yml` with `type:` + `content:` keys → faf-yaml
+ * - `.sh`/`.bash` or starts with `#!/` → bash-hook
+ * - JSON/YAML with `mcpServers` or `servers` → mcp-config
+ * - Plain markdown with no frontmatter → claude-skill or raw-markdown
+ */
+declare function detectFormat(content: string, filename: string): FormatDetection;
+/**
+ * Normalize content from any detected format to harness convention.
+ * Returns the normalized markdown content ready for writing.
+ */
+declare function normalizeToHarness(content: string, filename: string, detection: FormatDetection, options?: UniversalInstallOptions): {
+    content: string;
+    filename: string;
+    fixes: string[];
+};
+/**
+ * Resolve a source reference to a local file path.
+ *
+ * Supports:
+ * - Local file paths (absolute or relative)
+ * - HTTPS URLs (GitHub raw, any markdown URL)
+ * - Source query (searches registered sources)
+ *
+ * @returns Path to a local file (downloaded if remote)
+ */
+declare function resolveSource(source: string, harnessDir: string): Promise<{
+    localPath: string;
+    originalSource: string;
+    error?: string;
+}>;
+/**
+ * Universal install: resolve → detect → normalize → fix → install.
+ *
+ * Accepts a local path, URL, or search query. Detects the format,
+ * normalizes to harness convention, applies auto-fixes, and installs
+ * to the correct directory.
+ *
+ * @param harnessDir - Harness directory
+ * @param source - File path, URL, or name to install
+ * @param options - Installation options
+ * @returns Install result with status, fixes, errors, dependency hints
+ */
+declare function universalInstall(harnessDir: string, source: string, options?: UniversalInstallOptions): Promise<UniversalInstallResult>;
+/**
+ * Install from a URL (convenience wrapper).
+ */
+declare function installFromUrl(harnessDir: string, url: string, options?: UniversalInstallOptions): Promise<UniversalInstallResult>;
+/**
+ * Install from a local file path (convenience wrapper).
+ */
+declare function installFromFile(harnessDir: string, filePath: string, options?: UniversalInstallOptions): Promise<UniversalInstallResult>;
+/**
+ * Convert a GitHub URL to its raw content URL.
+ *
+ * Handles:
+ * - github.com/owner/repo/blob/branch/path → raw.githubusercontent.com/owner/repo/branch/path
+ * - Already raw.githubusercontent.com URLs → pass through
+ * - Other URLs → pass through
+ */
+declare function convertToRawUrl(url: string): string;
+
+interface VersionEntry {
+    /** Git commit hash (short) */
+    hash: string;
+    /** Full commit hash */
+    fullHash: string;
+    /** Commit message */
+    message: string;
+    /** Timestamp (ISO string) */
+    timestamp: string;
+    /** Files changed in this version */
+    filesChanged: string[];
+    /** Author name */
+    author: string;
+    /** Tag if one was applied */
+    tag?: string;
+}
+interface VersionLog {
+    /** Ordered list of versions (newest first) */
+    entries: VersionEntry[];
+    /** Current HEAD hash */
+    currentHash: string;
+    /** Current tag if any */
+    currentTag?: string;
+}
+interface RollbackResult {
+    success: boolean;
+    /** Hash we rolled back to */
+    targetHash: string;
+    /** Files that were restored */
+    restoredFiles: string[];
+    /** Error message if failed */
+    error?: string;
+}
+interface SnapshotResult {
+    success: boolean;
+    /** New commit hash */
+    hash: string;
+    /** Files included in snapshot */
+    files: string[];
+    /** Error if failed */
+    error?: string;
+}
+interface DiffEntry {
+    file: string;
+    status: 'added' | 'modified' | 'deleted' | 'renamed';
+    /** Lines added */
+    additions?: number;
+    /** Lines deleted */
+    deletions?: number;
+}
+interface VersionDiff {
+    from: string;
+    to: string;
+    entries: DiffEntry[];
+    summary: string;
+}
+/**
+ * Check if the harness directory is a git repository.
+ */
+declare function isGitRepo(harnessDir: string): boolean;
+/**
+ * Initialize a git repository in the harness directory.
+ * If already initialized, this is a no-op.
+ */
+declare function initVersioning(harnessDir: string): boolean;
+/**
+ * Take a versioned snapshot of the current harness state.
+ * Stages all changes and creates a git commit.
+ *
+ * @param harnessDir - Harness directory path
+ * @param message - Commit message describing the change
+ * @param options.tag - Optional tag to apply to this version
+ */
+declare function snapshot(harnessDir: string, message: string, options?: {
+    tag?: string;
+}): SnapshotResult;
+/**
+ * Get the version history of the harness.
+ *
+ * @param harnessDir - Harness directory path
+ * @param options.limit - Maximum entries to return (default: 50)
+ * @param options.file - Filter to a specific file path
+ */
+declare function getVersionLog(harnessDir: string, options?: {
+    limit?: number;
+    file?: string;
+}): VersionLog;
+/**
+ * Get the diff between two versions (or between a version and HEAD).
+ */
+declare function getVersionDiff(harnessDir: string, from: string, to?: string): VersionDiff;
+/**
+ * Roll back the harness to a previous version.
+ *
+ * Creates a new commit that restores files to the state at `targetHash`,
+ * preserving full history (no destructive rewrite).
+ *
+ * @param harnessDir - Harness directory path
+ * @param targetHash - Commit hash or tag to roll back to
+ */
+declare function rollback(harnessDir: string, targetHash: string): RollbackResult;
+/**
+ * List all version tags.
+ */
+declare function listTags(harnessDir: string): Array<{
+    tag: string;
+    hash: string;
+    message: string;
+}>;
+/**
+ * Tag the current version.
+ */
+declare function tagVersion(harnessDir: string, tag: string, message?: string): boolean;
+/**
+ * Get uncommitted changes in the harness.
+ */
+declare function getPendingChanges(harnessDir: string): DiffEntry[];
+/**
+ * Get the version history for a specific file.
+ */
+declare function getFileHistory(harnessDir: string, filePath: string, options?: {
+    limit?: number;
+}): VersionEntry[];
+/**
+ * Get the content of a file at a specific version.
+ */
+declare function getFileAtVersion(harnessDir: string, filePath: string, hash: string): string | null;
+
+export { type AIToolSet, type AfterRunContext, type AgentBuilder, type AgentDefinition, type AgentInfo, type AgentLifecycleHooks, type AgentMiddleware, type AgentRuleViolation, type AgentRunResult, type AgentState, type AgentStreamResult, type ApprovalGateConfig, type ArchiveResult, type AutoProcessOptions, type AutoProcessResult, type AutoPromoteResult, type BeforeRunContext, type BeforeRunResult, type BudgetConfig, type BudgetStatus, type BundleFileEntry, type BundleManifest, type BundleSearchHit, type BundleSearchResponse, type BundleSearchResult, CORE_PRIMITIVE_DIRS, type CallOptions, type CapabilitySuggestion, type CapabilitySuggestionResult, type CleanupResult, type ContentType, type ContextBudget, type Contradiction, type ContradictionResult, Conversation, type ConversationOptions, type ConversationSendResult, type ConversationStreamResult, type CostEntry, type CostStore, type CreateHarnessOptions, type CreateWebAppOptions, type DeadPrimitive, type DeadPrimitiveResult, type DeepPartial, type DefinedAgent, type DelegateOptions, type DelegateStreamResult, type DelegationResult, type DependencyGraph, type DetectedApiKey, type DiffEntry, type DiscoveredMcpServer, type DiscoveryOptions, type DiscoveryResult, type DiscoverySource, type DoctorResult, type DownloadResult, type EmbedFunction, type EmbeddingRecord, type EmbeddingStore, type EmotionalSignal, type EmotionalSnapshot, type EmotionalState, type EmotionalTrend, type EnrichmentResult, type EnvDiscoveryOptions, type EnvDiscoveryResult, type EnvSuggestion, type ExportEntry, type ExportOptions, FAILURE_TAXONOMY, type FailureAnalysis, type FailureMode, type FailureRecord, type FailureTaxonomy, type FormatDetection, type Frontmatter, FrontmatterSchema, type GateCheck, type GateCheckResult, type GateExtractResult, type GateStatus, type GenerateOptions, type GenerateResult, type GenerateWithMessagesOptions, type GraphEdge, type GraphNode, type GraphStats, type GuardrailEnforcementConfig, type GuardrailResult, type HarnessAgent, type HarnessBundle, type HarnessConfig, HarnessConfigSchema, type HarnessDocument, type HarnessHooks, type HarvestResult, type HealthCheck, type HealthMetrics, type HealthStatus, type ImportResult, type IndexEntry, type IndexOptions, type InstinctCandidate, type JournalEntry, type JournalSynthesis, type LearnResult, type LoadAllResult, type LoadResult, type LoadedContext, type LockInfo, type LockOptions, type LogLevel, type Logger, type McpInstallOptions, type McpInstallResult, type McpManager, type McpServerConfig, type McpServerConnection, type McpServerSummary, type MergeResult, type MergeStrategy, type MetricsStore, type ModelPricing, type MultiBundleSearchResponse, type OwnedStateChange, type PackedBundle, type ParseError, type ParsedRule, type PatternOccurrence, type PrimitiveInstallResult, type PrimitiveType, type PrimitiveUninstallResult, type PrimitiveUpdateResult, type ProgrammaticTool, type ProjectDiscoveryOptions, type ProjectDiscoveryResult, type ProjectSignal, type ProjectSuggestion, type ProviderName, type RateEvent, type RateLimit, type RateLimitCheck, type RateLimitStore, type RegistryConfig, type RegistryEnvVar, type RegistryPackage, type RegistryRemote, type RegistrySearchResponse, type RegistrySearchResult, type RegistryServer, type ResolvedServer, type RollbackResult, type RuleAction, type RuleCheckInput, type RuleCheckResult, type RuleViolation, type ScaffoldOptions, type ScheduledWorkflow, Scheduler, type SchedulerOptions, type SearchOptions, type SearchResult, type SemanticSearchConfig, type SemanticSearchResult, type ServeOptions, type ServeResult, type ServerSentEvent, type SessionAnalytics, type SessionData, type SessionEnrichment, type SessionRecord, type SnapshotResult, type Source, type SourceDiscoveryOptions, type SourceDiscoveryResult, type SourceFormat, type SourceType, type SourcesFile, type SpendingSummary, type StarterPack, type StateConflict, type StateOwner, type StateOwnership, type StreamGenerateResult, type StreamWithMessagesResult, type TelemetryOptions, type TelemetrySnapshot, type ToolAuth, type ToolCallInfo, type ToolCallRecord, type ToolCallResult, type ToolDefinition, type ToolExecutorConfig, type ToolExecutorOptions, type ToolOperation, type ToolSummary, type UniversalInstallOptions, type UniversalInstallResult, type ValidationResult, type VerificationCriterion, type VerificationGate, type VerificationGateResult, type VersionDiff, type VersionEntry, type VersionLog, type WatcherOptions, type WebServerOptions, type WebhookPayload, type WebhookRegistration, type WebhookStore, type WeekSummary, type WorkflowRun, type WorkflowStats, acquireLock, addSource, analyzeFailures, applySignals, applyStateChange, archiveOldFiles, autoProcessAll, autoProcessFile, autoPromoteInstincts, breakLock, buildAgentPrompt, buildAuthHeaders, buildDependencyGraph, buildIndex, buildOperationSchema, buildRateLimits, buildSystemPrompt, buildToolSet, calculateCost, checkAction, checkAllGates, checkBudget, checkGate, checkGuardrails, checkRateLimit, checkRuleViolation, checkRules, checkToolAuth, classifyFailure, cleanupOldFiles, clearCosts, clearMetrics, clearRateLimits, collectSnapshot, compressJournals, convertToRawUrl, convertToolDefinition, cosineSimilarity, createAgent, createCliApproval, createHarness, createLogger, createManifest, createMcpManager, createSessionId, createToolCallTracker, createWatcher, createWebApp, createWebhookApproval, defineAgent, delegateStream, delegateTo, deriveConfigName, deriveSignals, detectContradictions, detectDeadPrimitives, detectFormat, detectStalePrimitives, diffBundle, discoverEnvKeys, discoverMcpServers, discoverProjectContext, discoverRemote, discoverSources, discoveredServersToYaml, doctorHarness, downloadCapability, enforceRules, enrichSessions, estimateTokens, evaluateCapability, executeHttpOperation, exportHarness, extractEmbeddableText, extractGates, fetchFromRegistry, fetchGitHubSource, fetchRemoteBundle, findAgent, findPricing, findServer, fixCapability, formatDashboard, formatRegistryServer, generate, generateCoreMd, generateSystemMd, generateToolDocs, generateWithMessages, getAllWorkflowStats, getAtLevel, getEmbeddingStats, getEmotionalTrends, getFastModel, getFileAtVersion, getFileHistory, getGatesForPlaybook, getGlobalLogLevel, getGraphStats, getHealthStatus, getModel, getPendingChanges, getPrimitiveDirs, getProvider, getRecoveryStrategies, getRegistryServer, getScannedTools, getSessionAnalytics, getSessionsInRange, getSourcesForType, getSourcesSummary, getSpending, getStarterPack, getSummaryModel, getToolById, getToolSetSummary, getUsage, getVersionDiff, getVersionLog, getWorkflowStats, harvestInstincts, importBundle, indexPrimitives, initVersioning, installBundle, installCapability, installFromFile, installFromRegistry, installFromUrl, installInstinct, installMcpServer, isGitRepo, isLocked, isPackReference, isQuietHours, learnFromSessions, listAgents, listExpiredFiles, listGates, listInstalledBundles, listJournals, listRegistryServers, listSessions, listStarterPacks, listTags, listTemplates, listToolSummaries, listUnjournaled, loadAgentDocs, loadAllPrimitives, loadAllPrimitivesWithErrors, loadAllSources, loadConfig, loadCosts, loadDirectory, loadDirectoryWithErrors, loadEmbeddingStore, loadEmotionalState, loadGates, loadHealth, loadMcpTools, loadMetrics, loadOwnership, loadRateLimits, loadRules, loadShippedSources, loadState, loadTools, loadUserSources, log, mergeState, normalizeToHarness, packBundle, parseEnvFile, parseHarnessDocument, parseJournalSynthesis, parseJsonlContext, parseLegacyContext, parsePackName, parseRulesFromDoc, parseToolDefinition, processIntake, proposeInstincts, readBundle, readBundleDir, readInstalledManifests, readManifest, rebuildAllIndexes, recordBoot, recordCost, recordEvent, recordFailure, recordRun, recordSuccess, releaseLock, removeSource, resetEmotionalState, resetHealth, resetProvider, resolveEndpoint, resolveServerConfig, resolveSource, rollback, runAllGates, runGate, saveCosts, saveEmbeddingStore, saveEmotionalState, saveHealth, saveMetrics, saveOwnership, saveRateLimits, saveState, saveUserSources, scaffoldHarness, searchBundleRegistry, searchConfiguredRegistries, searchPrimitives, searchRegistry, searchServers, semanticSearch, setGlobalLogLevel, snapshot, startServe, startWebServer, streamGenerateWithDetails, streamWithMessages, suggestCapabilities, summarizeEmotionalState, synthesizeJournal, synthesizeJournalRange, tagVersion, tryAcquire, tryLock, uninstallBundle, universalInstall, updateBundle, updateConfigWithServer, validateHarness, validateMcpConfig, withFileLock, withFileLockSync, writeBundle, writeBundleDir, writeDefaultConfig, writeIndexFile, writeManifest, writeSession };