@lydia-agent/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3434 @@
+import * as zod from 'zod';
+import { z } from 'zod';
+import { EventEmitter } from 'node:events';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+
+declare const RoleSchema: z.ZodEnum<["system", "user", "assistant", "tool"]>;
+type Role = z.infer<typeof RoleSchema>;
+declare const TextContentSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "text";
+    text: string;
+}, {
+    type: "text";
+    text: string;
+}>;
+type TextContent = z.infer<typeof TextContentSchema>;
+declare const ImageContentSchema: z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    source: z.ZodObject<{
+        type: z.ZodLiteral<"base64">;
+        media_type: z.ZodString;
+        data: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "base64";
+        media_type: string;
+        data: string;
+    }, {
+        type: "base64";
+        media_type: string;
+        data: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "image";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+}, {
+    type: "image";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+}>;
+type ImageContent = z.infer<typeof ImageContentSchema>;
+declare const ToolUseContentSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tool_use">;
+    id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}, {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}>;
+type ToolUseContent = z.infer<typeof ToolUseContentSchema>;
+declare const ToolResultContentSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    tool_use_id: z.ZodString;
+    content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        source: z.ZodObject<{
+            type: z.ZodLiteral<"base64">;
+            media_type: z.ZodString;
+            data: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "base64";
+            media_type: string;
+            data: string;
+        }, {
+            type: "base64";
+            media_type: string;
+            data: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    }, {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    }>]>, "many">]>;
+    is_error: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    })[];
+    is_error?: boolean | undefined;
+}, {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    })[];
+    is_error?: boolean | undefined;
+}>;
+type ToolResultContent = z.infer<typeof ToolResultContentSchema>;
+declare const ThinkingContentSchema: z.ZodObject<{
+    type: z.ZodLiteral<"thinking">;
+    thinking: z.ZodString;
+    signature: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "thinking";
+    thinking: string;
+    signature?: string | undefined;
+}, {
+    type: "thinking";
+    thinking: string;
+    signature?: string | undefined;
+}>;
+type ThinkingContent = z.infer<typeof ThinkingContentSchema>;
+declare const ContentBlockSchema: z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "text";
+    text: string;
+}, {
+    type: "text";
+    text: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    source: z.ZodObject<{
+        type: z.ZodLiteral<"base64">;
+        media_type: z.ZodString;
+        data: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "base64";
+        media_type: string;
+        data: string;
+    }, {
+        type: "base64";
+        media_type: string;
+        data: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "image";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+}, {
+    type: "image";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_use">;
+    id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}, {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    tool_use_id: z.ZodString;
+    content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        source: z.ZodObject<{
+            type: z.ZodLiteral<"base64">;
+            media_type: z.ZodString;
+            data: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "base64";
+            media_type: string;
+            data: string;
+        }, {
+            type: "base64";
+            media_type: string;
+            data: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    }, {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    }>]>, "many">]>;
+    is_error: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    })[];
+    is_error?: boolean | undefined;
+}, {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    })[];
+    is_error?: boolean | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"thinking">;
+    thinking: z.ZodString;
+    signature: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "thinking";
+    thinking: string;
+    signature?: string | undefined;
+}, {
+    type: "thinking";
+    thinking: string;
+    signature?: string | undefined;
+}>]>;
+type ContentBlock = z.infer<typeof ContentBlockSchema>;
+declare const MessageSchema: z.ZodObject<{
+    role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
+    content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        source: z.ZodObject<{
+            type: z.ZodLiteral<"base64">;
+            media_type: z.ZodString;
+            data: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "base64";
+            media_type: string;
+            data: string;
+        }, {
+            type: "base64";
+            media_type: string;
+            data: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    }, {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    }, {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_result">;
+        tool_use_id: z.ZodString;
+        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+            text: string;
+        }, {
+            type: "text";
+            text: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            source: z.ZodObject<{
+                type: z.ZodLiteral<"base64">;
+                media_type: z.ZodString;
+                data: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "base64";
+                media_type: string;
+                data: string;
+            }, {
+                type: "base64";
+                media_type: string;
+                data: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        }, {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        }>]>, "many">]>;
+        is_error: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "tool_result";
+        tool_use_id: string;
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        })[];
+        is_error?: boolean | undefined;
+    }, {
+        type: "tool_result";
+        tool_use_id: string;
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        })[];
+        is_error?: boolean | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"thinking">;
+        thinking: z.ZodString;
+        signature: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "thinking";
+        thinking: string;
+        signature?: string | undefined;
+    }, {
+        type: "thinking";
+        thinking: string;
+        signature?: string | undefined;
+    }>]>, "many">]>;
+    name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    content: string | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    } | {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    } | {
+        type: "tool_result";
+        tool_use_id: string;
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        })[];
+        is_error?: boolean | undefined;
+    } | {
+        type: "thinking";
+        thinking: string;
+        signature?: string | undefined;
+    })[];
+    role: "system" | "user" | "assistant" | "tool";
+    name?: string | undefined;
+}, {
+    content: string | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    } | {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    } | {
+        type: "tool_result";
+        tool_use_id: string;
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        })[];
+        is_error?: boolean | undefined;
+    } | {
+        type: "thinking";
+        thinking: string;
+        signature?: string | undefined;
+    })[];
+    role: "system" | "user" | "assistant" | "tool";
+    name?: string | undefined;
+}>;
+type Message = z.infer<typeof MessageSchema>;
+declare const TokenUsageSchema: z.ZodObject<{
+    input_tokens: z.ZodNumber;
+    output_tokens: z.ZodNumber;
+    total_tokens: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    input_tokens: number;
+    output_tokens: number;
+    total_tokens: number;
+}, {
+    input_tokens: number;
+    output_tokens: number;
+    total_tokens: number;
+}>;
+type TokenUsage = z.infer<typeof TokenUsageSchema>;
+declare const LLMResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        source: z.ZodObject<{
+            type: z.ZodLiteral<"base64">;
+            media_type: z.ZodString;
+            data: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "base64";
+            media_type: string;
+            data: string;
+        }, {
+            type: "base64";
+            media_type: string;
+            data: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    }, {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    }, {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_result">;
+        tool_use_id: z.ZodString;
+        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+            text: string;
+        }, {
+            type: "text";
+            text: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            source: z.ZodObject<{
+                type: z.ZodLiteral<"base64">;
+                media_type: z.ZodString;
+                data: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "base64";
+                media_type: string;
+                data: string;
+            }, {
+                type: "base64";
+                media_type: string;
+                data: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        }, {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        }>]>, "many">]>;
+        is_error: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "tool_result";
+        tool_use_id: string;
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        })[];
+        is_error?: boolean | undefined;
+    }, {
+        type: "tool_result";
+        tool_use_id: string;
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        })[];
+        is_error?: boolean | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"thinking">;
+        thinking: z.ZodString;
+        signature: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "thinking";
+        thinking: string;
+        signature?: string | undefined;
+    }, {
+        type: "thinking";
+        thinking: string;
+        signature?: string | undefined;
+    }>]>, "many">;
+    role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
+    model: z.ZodString;
+    stop_reason: z.ZodNullable<z.ZodEnum<["end_turn", "max_tokens", "stop_sequence", "tool_use", "error", "pause_turn"]>>;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+        total_tokens: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+    }, {
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    content: ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    } | {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    } | {
+        type: "tool_result";
+        tool_use_id: string;
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        })[];
+        is_error?: boolean | undefined;
+    } | {
+        type: "thinking";
+        thinking: string;
+        signature?: string | undefined;
+    })[];
+    role: "system" | "user" | "assistant" | "tool";
+    model: string;
+    stop_reason: "tool_use" | "end_turn" | "max_tokens" | "stop_sequence" | "error" | "pause_turn" | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+    };
+}, {
+    id: string;
+    content: ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        source: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    } | {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    } | {
+        type: "tool_result";
+        tool_use_id: string;
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        })[];
+        is_error?: boolean | undefined;
+    } | {
+        type: "thinking";
+        thinking: string;
+        signature?: string | undefined;
+    })[];
+    role: "system" | "user" | "assistant" | "tool";
+    model: string;
+    stop_reason: "tool_use" | "end_turn" | "max_tokens" | "stop_sequence" | "error" | "pause_turn" | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+    };
+}>;
+type LLMResponse = z.infer<typeof LLMResponseSchema>;
+declare const ToolDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}, {
+    name: string;
+    inputSchema: Record<string, unknown>;
+    description?: string | undefined;
+}>;
+type ToolDefinition = z.infer<typeof ToolDefinitionSchema>;
+type StreamChunk = {
+    type: 'text_delta';
+    text: string;
+} | {
+    type: 'thinking_delta';
+    thinking: string;
+} | {
+    type: 'tool_use_start';
+    id: string;
+    name: string;
+} | {
+    type: 'tool_use_delta';
+    id: string;
+    input_json: string;
+} | {
+    type: 'tool_use_end';
+    id: string;
+} | {
+    type: 'message_stop';
+    response: LLMResponse;
+} | {
+    type: 'error';
+    error: string;
+};
+declare const LLMRequestSchema: z.ZodObject<{
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
+        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+            text: string;
+        }, {
+            type: "text";
+            text: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            source: z.ZodObject<{
+                type: z.ZodLiteral<"base64">;
+                media_type: z.ZodString;
+                data: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "base64";
+                media_type: string;
+                data: string;
+            }, {
+                type: "base64";
+                media_type: string;
+                data: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        }, {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_use">;
+            id: z.ZodString;
+            name: z.ZodString;
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        }, {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_result">;
+            tool_use_id: z.ZodString;
+            content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "text";
+                text: string;
+            }, {
+                type: "text";
+                text: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                source: z.ZodObject<{
+                    type: z.ZodLiteral<"base64">;
+                    media_type: z.ZodString;
+                    data: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    type: "base64";
+                    media_type: string;
+                    data: string;
+                }, {
+                    type: "base64";
+                    media_type: string;
+                    data: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                type: "image";
+                source: {
+                    type: "base64";
+                    media_type: string;
+                    data: string;
+                };
+            }, {
+                type: "image";
+                source: {
+                    type: "base64";
+                    media_type: string;
+                    data: string;
+                };
+            }>]>, "many">]>;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | ({
+                type: "text";
+                text: string;
+            } | {
+                type: "image";
+                source: {
+                    type: "base64";
+                    media_type: string;
+                    data: string;
+                };
+            })[];
+            is_error?: boolean | undefined;
+        }, {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | ({
+                type: "text";
+                text: string;
+            } | {
+                type: "image";
+                source: {
+                    type: "base64";
+                    media_type: string;
+                    data: string;
+                };
+            })[];
+            is_error?: boolean | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"thinking">;
+            thinking: z.ZodString;
+            signature: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "thinking";
+            thinking: string;
+            signature?: string | undefined;
+        }, {
+            type: "thinking";
+            thinking: string;
+            signature?: string | undefined;
+        }>]>, "many">]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | ({
+                type: "text";
+                text: string;
+            } | {
+                type: "image";
+                source: {
+                    type: "base64";
+                    media_type: string;
+                    data: string;
+                };
+            })[];
+            is_error?: boolean | undefined;
+        } | {
+            type: "thinking";
+            thinking: string;
+            signature?: string | undefined;
+        })[];
+        role: "system" | "user" | "assistant" | "tool";
+        name?: string | undefined;
+    }, {
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | ({
+                type: "text";
+                text: string;
+            } | {
+                type: "image";
+                source: {
+                    type: "base64";
+                    media_type: string;
+                    data: string;
+                };
+            })[];
+            is_error?: boolean | undefined;
+        } | {
+            type: "thinking";
+            thinking: string;
+            signature?: string | undefined;
+        })[];
+        role: "system" | "user" | "assistant" | "tool";
+        name?: string | undefined;
+    }>, "many">;
+    model: z.ZodOptional<z.ZodString>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodDefault<z.ZodString>;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+    }, {
+        name: string;
+        inputSchema: Record<string, unknown>;
+        description?: string | undefined;
+    }>, "many">>;
+    system: z.ZodOptional<z.ZodString>;
+    stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    messages: {
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | ({
+                type: "text";
+                text: string;
+            } | {
+                type: "image";
+                source: {
+                    type: "base64";
+                    media_type: string;
+                    data: string;
+                };
+            })[];
+            is_error?: boolean | undefined;
+        } | {
+            type: "thinking";
+            thinking: string;
+            signature?: string | undefined;
+        })[];
+        role: "system" | "user" | "assistant" | "tool";
+        name?: string | undefined;
+    }[];
+    system?: string | undefined;
+    model?: string | undefined;
+    max_tokens?: number | undefined;
+    temperature?: number | undefined;
+    tools?: {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+    }[] | undefined;
+    stop?: string[] | undefined;
+}, {
+    messages: {
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: "base64";
+                media_type: string;
+                data: string;
+            };
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content: string | ({
+                type: "text";
+                text: string;
+            } | {
+                type: "image";
+                source: {
+                    type: "base64";
+                    media_type: string;
+                    data: string;
+                };
+            })[];
+            is_error?: boolean | undefined;
+        } | {
+            type: "thinking";
+            thinking: string;
+            signature?: string | undefined;
+        })[];
+        role: "system" | "user" | "assistant" | "tool";
+        name?: string | undefined;
+    }[];
+    system?: string | undefined;
+    model?: string | undefined;
+    max_tokens?: number | undefined;
+    temperature?: number | undefined;
+    tools?: {
+        name: string;
+        inputSchema: Record<string, unknown>;
+        description?: string | undefined;
+    }[] | undefined;
+    stop?: string[] | undefined;
+}>;
+type LLMRequest = z.infer<typeof LLMRequestSchema>;
+
+type ComputerUseDomain = 'browser' | 'desktop';
+interface CanonicalComputerUseAction {
+    domain: ComputerUseDomain;
+    toolName: string;
+    requiredArgs: string[];
+    description: string;
+    aliases: string[];
+}
+declare function listCanonicalComputerUseActions(): CanonicalComputerUseAction[];
+declare function resolveCanonicalComputerUseToolName(toolName: string): string | undefined;
+declare function isCanonicalComputerUseTool(toolName: string): boolean;
+
+declare const COMPUTER_USE_ERROR_CODES: readonly ["ARG_INVALID", "CAPABILITY_UNAVAILABLE", "POLICY_DENIED", "EXECUTION_FAILED", "OBSERVATION_MISSING"];
+type ComputerUseErrorCode = (typeof COMPUTER_USE_ERROR_CODES)[number];
+type ComputerUseRiskLevel = 'low' | 'medium' | 'high';
+type ObservationArtifactKind = 'download' | 'upload' | 'log';
+interface ComputerUseActionEnvelope {
+    sessionId: string;
+    actionId: string;
+    domain: ComputerUseDomain;
+    canonicalAction: string;
+    args: Record<string, unknown>;
+    riskLevel: ComputerUseRiskLevel;
+    requestedAt: number;
+}
+type ObservationBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    mediaType: string;
+    dataRef: string;
+} | {
+    type: 'artifact_ref';
+    kind: ObservationArtifactKind;
+    path: string;
+} | {
+    type: 'structured_json';
+    payload: Record<string, unknown>;
+};
+interface ObservationFrame {
+    sessionId: string;
+    actionId: string;
+    frameId: string;
+    blocks: ObservationBlock[];
+    createdAt: number;
+}
+interface ComputerUseCheckpoint {
+    sessionId: string;
+    taskId: string;
+    lastActionId?: string;
+    latestFrameIds: string[];
+    verificationFailures: number;
+    updatedAt: number;
+}
+interface ComputerUseError {
+    code: ComputerUseErrorCode;
+    message: string;
+    retryable: boolean;
+    details?: Record<string, unknown>;
+}
+declare function isComputerUseErrorCode(value: string): value is ComputerUseErrorCode;
+
+interface Fact {
+    id?: number;
+    key?: string;
+    content: string;
+    tags?: string[];
+    created_at: number;
+}
+interface Episode {
+    id?: number;
+    task_id?: string;
+    input: string;
+    plan: string;
+    result: string;
+    strategy_id?: string;
+    strategy_version?: string;
+    created_at: number;
+}
+interface StrategyEpisodeSummary {
+    strategy_id: string;
+    strategy_version: string;
+    total: number;
+    success: number;
+    failure: number;
+    avg_duration_ms: number;
+}
+interface Trace {
+    id?: number;
+    episode_id?: number;
+    step_index: number;
+    tool_name: string;
+    tool_args: string;
+    tool_output: string;
+    duration: number;
+    status: 'success' | 'failed';
+}
+interface StrategyProposal {
+    id?: number;
+    strategy_path: string;
+    status: 'pending_human' | 'approved' | 'rejected' | 'invalid';
+    reason?: string;
+    evaluation_json?: string;
+    created_at: number;
+    decided_at?: number;
+}
+interface TaskReportRecord {
+    id?: number;
+    task_id: string;
+    report_json: string;
+    created_at: number;
+}
+interface TaskFeedbackRecord {
+    id?: number;
+    task_id: string;
+    feedback_json: string;
+    created_at: number;
+}
+interface ObservationFrameRecord {
+    id?: number;
+    task_id: string;
+    session_id: string;
+    action_id: string;
+    frame_id: string;
+    frame_json: string;
+    created_at: number;
+}
+interface ComputerUseSessionSummaryRecord {
+    id?: number;
+    session_id: string;
+    task_id: string;
+    last_action_id?: string;
+    latest_frame_ids_json: string;
+    verification_failures: number;
+    status: 'active' | 'ended';
+    started_at: number;
+    ended_at?: number;
+    updated_at: number;
+}
+interface ComputerUseSessionSummary {
+    sessionId: string;
+    taskId: string;
+    lastActionId?: string;
+    latestFrameIds: string[];
+    verificationFailures: number;
+    status: 'active' | 'ended';
+    startedAt: number;
+    endedAt?: number;
+    updatedAt: number;
+}
+interface UpsertComputerUseSessionSummaryInput {
+    sessionId: string;
+    taskId: string;
+    lastActionId?: string;
+    latestFrameIds: string[];
+    verificationFailures: number;
+    status: 'active' | 'ended';
+    startedAt?: number;
+    endedAt?: number;
+    updatedAt?: number;
+}
+/**
+ * Checkpoint captures the full execution state of an agentic loop iteration,
+ * allowing interrupted tasks to be resumed from the last successful checkpoint.
+ */
+interface Checkpoint {
+    taskId: string;
+    runId: string;
+    input: string;
+    iteration: number;
+    messagesJson: string;
+    tracesJson: string;
+    systemPrompt: string;
+    toolsJson: string;
+    computerUseSessionId?: string;
+    computerUseLastActionId?: string;
+    computerUseLatestFrameIdsJson?: string;
+    computerUseVerificationFailures?: number;
+    taskCreatedAt: number;
+    updatedAt: number;
+}
+interface MemoryManagerOptions {
+    checkpointTtlMs?: number;
+    observationFrameTtlMs?: number;
+}
+declare class MemoryManager extends EventEmitter {
+    private db;
+    private checkpointTtlMs;
+    private observationFrameTtlMs;
+    constructor(dbPath: string, options?: MemoryManagerOptions);
+    private init;
+    /**
+     * Remember a fact. If key is provided and exists, it updates the fact.
+     */
+    rememberFact(content: string, key?: string, tags?: string[]): void;
+    /**
+     * Search for facts using Full-Text Search
+     */
+    searchFacts(query: string, limit?: number): Fact[];
+    getAllFacts(limit?: number): Fact[];
+    getFactsByTag(tag: string, limit?: number): Fact[];
+    getFactByKey(key: string): Fact | undefined;
+    deleteFactById(id: number): boolean;
+    deleteFactByKey(key: string): boolean;
+    /**
+     * Record a completed task execution and return its ID
+     */
+    recordEpisode(episode: Episode): number;
+    getEpisode(id: number): Episode | undefined;
+    listEpisodes(limit?: number): Episode[];
+    listEpisodesByStrategy(strategyId: string, strategyVersion: string, options?: {
+        limit?: number;
+        sinceMs?: number;
+    }): Episode[];
+    summarizeEpisodesByStrategy(strategyId: string, strategyVersion: string, options?: {
+        limit?: number;
+        sinceMs?: number;
+    }): StrategyEpisodeSummary;
+    recordStrategyProposal(proposal: StrategyProposal): number;
+    updateStrategyProposal(id: number, status: StrategyProposal['status'], reason?: string, evaluation_json?: string): boolean;
+    getStrategyProposal(id: number): StrategyProposal | undefined;
+    listStrategyProposals(limit?: number): StrategyProposal[];
+    recordTaskReport(taskId: string, report: unknown): number;
+    listTaskReports(limit?: number): TaskReportRecord[];
+    recordTaskFeedback(taskId: string, feedback: unknown): number;
+    listTaskFeedback(limit?: number): TaskFeedbackRecord[];
+    /**
+     * Find relevant past episodes
+     */
+    recallEpisodes(query: string, limit?: number): Episode[];
+    /**
+     * Record execution traces for an episode
+     */
+    recordTraces(episodeId: number, traces: Trace[]): void;
+    getTraces(episodeId: number): Trace[];
+    recordObservationFrame(taskId: string, frame: ObservationFrame): number;
+    listObservationFramesByTask(taskId: string, limit?: number): ObservationFrame[];
+    listObservationFramesBySession(sessionId: string, limit?: number): ObservationFrame[];
+    upsertComputerUseSessionSummary(input: UpsertComputerUseSessionSummaryInput): void;
+    getComputerUseSessionSummary(sessionId: string): ComputerUseSessionSummary | null;
+    private parseFrameIdsJson;
+    /**
+     * Save or update a checkpoint. Uses UPSERT (INSERT OR REPLACE) so each
+     * task has at most one checkpoint row, updated in-place every iteration.
+     */
+    saveCheckpoint(checkpoint: Checkpoint): void;
+    /**
+     * Load a checkpoint by task ID. Returns null if not found.
+     */
+    loadCheckpoint(taskId: string): Checkpoint | null;
+    /**
+     * Delete a checkpoint after task completion or failure.
+     */
+    deleteCheckpoint(taskId: string): boolean;
+    /**
+     * List all checkpoints that can be resumed (for UI and CLI).
+     */
+    listCheckpoints(): Checkpoint[];
+    /**
+     * Remove checkpoints older than the TTL (default: 24 hours).
+     */
+    cleanupStaleCheckpoints(ttlMs?: number): number;
+    /**
+     * Remove observation frames older than the TTL (default: 7 days).
+     */
+    cleanupStaleObservationFrames(ttlMs?: number): number;
+    getPerformanceMetrics(limit?: number): {
+        total: number;
+        success: number;
+        failure: number;
+    };
+}
+
+declare const TaskStatusSchema: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+type TaskStatus = z.infer<typeof TaskStatusSchema>;
+declare const TaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    createdAt: z.ZodNumber;
+    status: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+    result: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    status: "failed" | "pending" | "running" | "completed" | "cancelled";
+    id: string;
+    description: string;
+    createdAt: number;
+    result?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    status: "failed" | "pending" | "running" | "completed" | "cancelled";
+    id: string;
+    description: string;
+    createdAt: number;
+    result?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+type Task = z.infer<typeof TaskSchema>;
+declare const StepTypeSchema: z.ZodEnum<["thought", "action", "system"]>;
+type StepType = z.infer<typeof StepTypeSchema>;
+declare const StepStatusSchema: z.ZodEnum<["pending", "running", "completed", "failed", "skipped"]>;
+type StepStatus = z.infer<typeof StepStatusSchema>;
+declare const StepSchema: z.ZodObject<{
+    id: z.ZodString;
+    taskId: z.ZodString;
+    type: z.ZodEnum<["thought", "action", "system"]>;
+    description: z.ZodString;
+    status: z.ZodEnum<["pending", "running", "completed", "failed", "skipped"]>;
+    tool: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodNumber>;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    riskLevel: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    requiresConfirmation: z.ZodOptional<z.ZodBoolean>;
+    verification: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "system" | "thought" | "action";
+    status: "failed" | "pending" | "running" | "completed" | "skipped";
+    id: string;
+    description: string;
+    taskId: string;
+    tool?: string | undefined;
+    error?: string | undefined;
+    startedAt?: number | undefined;
+    result?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    args?: Record<string, unknown> | undefined;
+    completedAt?: number | undefined;
+    dependsOn?: string[] | undefined;
+    riskLevel?: "low" | "medium" | "high" | undefined;
+    requiresConfirmation?: boolean | undefined;
+    verification?: string[] | undefined;
+}, {
+    type: "system" | "thought" | "action";
+    status: "failed" | "pending" | "running" | "completed" | "skipped";
+    id: string;
+    description: string;
+    taskId: string;
+    tool?: string | undefined;
+    error?: string | undefined;
+    startedAt?: number | undefined;
+    result?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    args?: Record<string, unknown> | undefined;
+    completedAt?: number | undefined;
+    dependsOn?: string[] | undefined;
+    riskLevel?: "low" | "medium" | "high" | undefined;
+    requiresConfirmation?: boolean | undefined;
+    verification?: string[] | undefined;
+}>;
+type Step = z.infer<typeof StepSchema>;
+interface AgentContext {
+    taskId: string;
+    history: Message[];
+    state: Record<string, unknown>;
+    taskContext?: TaskContext;
+}
+interface TaskContext {
+    cwd: string;
+    tools: string[];
+    toolDefinitions?: Array<{
+        name: string;
+        description?: string;
+        inputSchema?: Record<string, unknown>;
+    }>;
+    strategyId: string;
+    strategyVersion: string;
+    facts: Fact[];
+    episodes: Episode[];
+    riskPolicy: {
+        requiresConfirmation: string[];
+        deniedTools: string[];
+    };
+}
+interface IStrategy {
+    id: string;
+    name: string;
+    description: string;
+    /**
+     * Initialize a task, potentially creating the first set of steps
+     */
+    init(task: Task, context: AgentContext): Promise<Step[]>;
+    /**
+     * Update the plan based on the result of the last step
+     */
+    next(task: Task, context: AgentContext, lastStep?: Step): Promise<Step | null>;
+}
+
+interface ILLMProvider {
+    /**
+     * The unique identifier of the provider (e.g., "anthropic", "openai")
+     */
+    id: string;
+    /**
+     * Generate a completion for the given messages
+     */
+    generate(request: LLMRequest): Promise<LLMResponse>;
+    /**
+     * Generate a stream of completion chunks
+     */
+    generateStream(request: LLMRequest): AsyncGenerator<StreamChunk, void, unknown>;
+}
+
+interface CreateLLMOptions {
+    /** Override provider choice (default: from config or 'auto') */
+    provider?: string;
+    /** Override default model */
+    model?: string;
+    /** Override config-backed llm settings for draft/testing scenarios */
+    llmOverrides?: {
+        provider?: string;
+        defaultModel?: string;
+        fallbackOrder?: string[];
+        openaiApiKey?: string;
+        anthropicApiKey?: string;
+        openaiBaseUrl?: string;
+        anthropicBaseUrl?: string;
+        ollamaBaseUrl?: string;
+    };
+}
+/**
+ * Create an LLM provider based on Lydia's config.
+ *
+ * Reads `~/.lydia/config.json` for provider settings, API keys come from
+ * environment variables. Returns a single provider or a FallbackProvider
+ * when `provider` is 'auto'.
+ *
+ * This is the single source of truth for provider initialization —
+ * used by both the Server (dashboard) and CLI.
+ */
+declare function createLLMFromConfig(options?: CreateLLMOptions): Promise<ILLMProvider>;
+
+declare class AnthropicProvider implements ILLMProvider {
+    readonly id = "anthropic";
+    private client;
+    private defaultModel;
+    constructor(options?: {
+        apiKey?: string;
+        baseURL?: string;
+        defaultModel?: string;
+    });
+    generate(request: LLMRequest): Promise<LLMResponse>;
+    generateStream(request: LLMRequest): AsyncGenerator<StreamChunk, void, unknown>;
+    private convertMessages;
+    private convertContentBlock;
+    private convertResponse;
+}
+
+declare class OllamaProvider implements ILLMProvider {
+    readonly id = "ollama";
+    private baseURL;
+    private defaultModel;
+    constructor(options?: {
+        baseURL?: string;
+        defaultModel?: string;
+    });
+    generate(request: LLMRequest): Promise<LLMResponse>;
+    generateStream(request: LLMRequest): AsyncGenerator<StreamChunk, void, unknown>;
+    private mapOptions;
+    private convertMessages;
+    private normalizeToolResult;
+    private convertResponse;
+    private mapStopReason;
+}
+
+declare class FallbackProvider implements ILLMProvider {
+    readonly id = "fallback";
+    private providers;
+    constructor(providers: ILLMProvider[]);
+    generate(request: LLMRequest): Promise<LLMResponse>;
+    generateStream(request: LLMRequest): AsyncGenerator<StreamChunk, void, unknown>;
+}
+
+declare class OpenAIProvider implements ILLMProvider {
+    readonly id = "openai";
+    private client;
+    private defaultModel;
+    constructor(options?: {
+        apiKey?: string;
+        baseURL?: string;
+        defaultModel?: string;
+    });
+    generate(request: LLMRequest): Promise<LLMResponse>;
+    generateStream(request: LLMRequest): AsyncGenerator<StreamChunk, void, unknown>;
+    private convertMessages;
+    private convertMessageContent;
+    private extractToolResult;
+    private normalizeToolResultContent;
+    private convertResponse;
+    private mapStopReason;
+}
+
+declare class MockProvider implements ILLMProvider {
+    readonly id = "mock";
+    requests: LLMRequest[];
+    private responseQueue;
+    /**
+     * Queue a mock response to be returned by the next generate call
+     */
+    enqueueResponse(response: Partial<LLMResponse> & {
+        text?: string;
+    }): void;
+    generate(request: LLMRequest): Promise<LLMResponse>;
+    generateStream(request: LLMRequest): AsyncGenerator<StreamChunk, void, unknown>;
+    /**
+     * Clear recorded requests and response queue
+     */
+    clear(): void;
+}
+
+declare const IntentSchema: z.ZodObject<{
+    category: z.ZodEnum<["query", "action", "script", "unknown"]>;
+    summary: z.ZodString;
+    entities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    complexity: z.ZodEnum<["simple", "medium", "complex"]>;
+}, "strip", z.ZodTypeAny, {
+    category: "unknown" | "action" | "query" | "script";
+    summary: string;
+    complexity: "medium" | "simple" | "complex";
+    entities?: string[] | undefined;
+}, {
+    category: "unknown" | "action" | "query" | "script";
+    summary: string;
+    complexity: "medium" | "simple" | "complex";
+    entities?: string[] | undefined;
+}>;
+type Intent = z.infer<typeof IntentSchema>;
+declare const IntentProfileSchema: z.ZodObject<{
+    category: z.ZodEnum<["query", "action", "script", "unknown"]>;
+    summary: z.ZodString;
+    entities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    complexity: z.ZodEnum<["simple", "medium", "complex"]>;
+} & {
+    goal: z.ZodDefault<z.ZodString>;
+    deliverables: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    successCriteria: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    assumptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    requiredTools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    category: "unknown" | "action" | "query" | "script";
+    summary: string;
+    complexity: "medium" | "simple" | "complex";
+    goal: string;
+    deliverables: string[];
+    constraints: string[];
+    successCriteria: string[];
+    assumptions: string[];
+    requiredTools: string[];
+    entities?: string[] | undefined;
+}, {
+    category: "unknown" | "action" | "query" | "script";
+    summary: string;
+    complexity: "medium" | "simple" | "complex";
+    entities?: string[] | undefined;
+    goal?: string | undefined;
+    deliverables?: string[] | undefined;
+    constraints?: string[] | undefined;
+    successCriteria?: string[] | undefined;
+    assumptions?: string[] | undefined;
+    requiredTools?: string[] | undefined;
+}>;
+type IntentProfile = z.infer<typeof IntentProfileSchema>;
+declare class IntentAnalyzer {
+    private llm;
+    constructor(llm: ILLMProvider);
+    analyze(userInput: string): Promise<IntentProfile>;
+}
+
+declare const SkillMetaSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodEnum<["main", "fork"]>>>;
+    path: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodEnum<["main", "fork"]>>>;
+    path: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodEnum<["main", "fork"]>>>;
+    path: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+type SkillMeta = z.infer<typeof SkillMetaSchema>;
+declare const StaticSkillSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodEnum<["main", "fork"]>>>;
+    path: z.ZodOptional<z.ZodString>;
+} & {
+    content: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodEnum<["main", "fork"]>>>;
+    path: z.ZodOptional<z.ZodString>;
+} & {
+    content: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodEnum<["main", "fork"]>>>;
+    path: z.ZodOptional<z.ZodString>;
+} & {
+    content: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+type StaticSkill = z.infer<typeof StaticSkillSchema>;
+/** @deprecated Use StaticSkillSchema instead */
+declare const SkillSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodEnum<["main", "fork"]>>>;
+    path: z.ZodOptional<z.ZodString>;
+} & {
+    content: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodEnum<["main", "fork"]>>>;
+    path: z.ZodOptional<z.ZodString>;
+} & {
+    content: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodEnum<["main", "fork"]>>>;
+    path: z.ZodOptional<z.ZodString>;
+} & {
+    content: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+type SkillContext = {
+    agentId?: string;
+    taskId?: string;
+};
+interface DynamicSkill {
+    name: string;
+    description: string;
+    version: string;
+    author?: string;
+    tags?: string[];
+    tools?: {
+        name: string;
+        description: string;
+        inputSchema: any;
+    }[];
+    execute(toolName: string, args: any, context: SkillContext): Promise<string>;
+    content?: string;
+    path?: string;
+    allowedTools?: string[];
+}
+type Skill = StaticSkill | DynamicSkill;
+/** Type guard: check if a skill is a DynamicSkill */
+declare function isDynamicSkill(skill: Skill | SkillMeta): skill is DynamicSkill;
+/** Type guard: check if a skill has content loaded */
+declare function hasContent(skill: Skill | SkillMeta): skill is StaticSkill | (DynamicSkill & {
+    content: string;
+});
+/** Extract content from a skill safely */
+declare function getSkillContent(skill: Skill | SkillMeta): string;
+
+declare const StrategyMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    inheritFrom: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    version: string;
+    description?: string | undefined;
+    author?: string | undefined;
+    inheritFrom?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    version: string;
+    description?: string | undefined;
+    author?: string | undefined;
+    inheritFrom?: string | undefined;
+}>;
+declare const StrategySystemSchema: z.ZodObject<{
+    role: z.ZodString;
+    personality: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    goals: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    role: string;
+    constraints: string[];
+    goals: string[];
+    personality?: string | undefined;
+}, {
+    role: string;
+    constraints?: string[] | undefined;
+    personality?: string | undefined;
+    goals?: string[] | undefined;
+}>;
+declare const StrategyPromptsSchema: z.ZodObject<{
+    planning: z.ZodOptional<z.ZodString>;
+    reflection: z.ZodOptional<z.ZodString>;
+    intent: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    planning?: string | undefined;
+    reflection?: string | undefined;
+    intent?: string | undefined;
+}, {
+    planning?: string | undefined;
+    reflection?: string | undefined;
+    intent?: string | undefined;
+}>;
+declare const StrategyPlanningSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxSteps: z.ZodDefault<z.ZodNumber>;
+    thinkingProcess: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    temperature: number;
+    maxSteps: number;
+    thinkingProcess: boolean;
+    model?: string | undefined;
+}, {
+    model?: string | undefined;
+    temperature?: number | undefined;
+    maxSteps?: number | undefined;
+    thinkingProcess?: boolean | undefined;
+}>;
+declare const StrategyExecutionSchema: z.ZodObject<{
+    riskTolerance: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+    requiresConfirmation: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    autoRetry: z.ZodDefault<z.ZodBoolean>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    requiresConfirmation: string[];
+    maxRetries: number;
+    riskTolerance: "low" | "medium" | "high";
+    autoRetry: boolean;
+}, {
+    requiresConfirmation?: string[] | undefined;
+    maxRetries?: number | undefined;
+    riskTolerance?: "low" | "medium" | "high" | undefined;
+    autoRetry?: boolean | undefined;
+}>;
+declare const StrategyPreferencesSchema: z.ZodObject<{
+    riskTolerance: z.ZodDefault<z.ZodNumber>;
+    userConfirmation: z.ZodDefault<z.ZodNumber>;
+    autonomyLevel: z.ZodDefault<z.ZodEnum<["manual", "assisted", "autonomous"]>>;
+    responseSpeed: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    riskTolerance: number;
+    userConfirmation: number;
+    autonomyLevel: "manual" | "assisted" | "autonomous";
+    responseSpeed: number;
+}, {
+    riskTolerance?: number | undefined;
+    userConfirmation?: number | undefined;
+    autonomyLevel?: "manual" | "assisted" | "autonomous" | undefined;
+    responseSpeed?: number | undefined;
+}>;
+declare const StrategyConstraintsSchema: z.ZodObject<{
+    mustConfirmBefore: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    neverSkipReviewFor: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    deniedTools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    mustConfirmBefore: string[];
+    neverSkipReviewFor: string[];
+    deniedTools: string[];
+}, {
+    mustConfirmBefore?: string[] | undefined;
+    neverSkipReviewFor?: string[] | undefined;
+    deniedTools?: string[] | undefined;
+}>;
+declare const StrategyEvolutionLimitsSchema: z.ZodObject<{
+    maxAutonomyIncrease: z.ZodDefault<z.ZodNumber>;
+    cooldownPeriod: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    maxAutonomyIncrease: number;
+    cooldownPeriod: string;
+}, {
+    maxAutonomyIncrease?: number | undefined;
+    cooldownPeriod?: string | undefined;
+}>;
+declare const StrategySchema: z.ZodObject<{
+    metadata: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        inheritFrom: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        version: string;
+        description?: string | undefined;
+        author?: string | undefined;
+        inheritFrom?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        version: string;
+        description?: string | undefined;
+        author?: string | undefined;
+        inheritFrom?: string | undefined;
+    }>;
+    system: z.ZodObject<{
+        role: z.ZodString;
+        personality: z.ZodOptional<z.ZodString>;
+        constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        goals: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        role: string;
+        constraints: string[];
+        goals: string[];
+        personality?: string | undefined;
+    }, {
+        role: string;
+        constraints?: string[] | undefined;
+        personality?: string | undefined;
+        goals?: string[] | undefined;
+    }>;
+    prompts: z.ZodOptional<z.ZodObject<{
+        planning: z.ZodOptional<z.ZodString>;
+        reflection: z.ZodOptional<z.ZodString>;
+        intent: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        planning?: string | undefined;
+        reflection?: string | undefined;
+        intent?: string | undefined;
+    }, {
+        planning?: string | undefined;
+        reflection?: string | undefined;
+        intent?: string | undefined;
+    }>>;
+    planning: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodDefault<z.ZodNumber>;
+        maxSteps: z.ZodDefault<z.ZodNumber>;
+        thinkingProcess: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        temperature: number;
+        maxSteps: number;
+        thinkingProcess: boolean;
+        model?: string | undefined;
+    }, {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        maxSteps?: number | undefined;
+        thinkingProcess?: boolean | undefined;
+    }>>;
+    execution: z.ZodOptional<z.ZodObject<{
+        riskTolerance: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+        requiresConfirmation: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        autoRetry: z.ZodDefault<z.ZodBoolean>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        requiresConfirmation: string[];
+        maxRetries: number;
+        riskTolerance: "low" | "medium" | "high";
+        autoRetry: boolean;
+    }, {
+        requiresConfirmation?: string[] | undefined;
+        maxRetries?: number | undefined;
+        riskTolerance?: "low" | "medium" | "high" | undefined;
+        autoRetry?: boolean | undefined;
+    }>>;
+    preferences: z.ZodOptional<z.ZodObject<{
+        riskTolerance: z.ZodDefault<z.ZodNumber>;
+        userConfirmation: z.ZodDefault<z.ZodNumber>;
+        autonomyLevel: z.ZodDefault<z.ZodEnum<["manual", "assisted", "autonomous"]>>;
+        responseSpeed: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        riskTolerance: number;
+        userConfirmation: number;
+        autonomyLevel: "manual" | "assisted" | "autonomous";
+        responseSpeed: number;
+    }, {
+        riskTolerance?: number | undefined;
+        userConfirmation?: number | undefined;
+        autonomyLevel?: "manual" | "assisted" | "autonomous" | undefined;
+        responseSpeed?: number | undefined;
+    }>>;
+    constraints: z.ZodOptional<z.ZodObject<{
+        mustConfirmBefore: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        neverSkipReviewFor: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        deniedTools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        mustConfirmBefore: string[];
+        neverSkipReviewFor: string[];
+        deniedTools: string[];
+    }, {
+        mustConfirmBefore?: string[] | undefined;
+        neverSkipReviewFor?: string[] | undefined;
+        deniedTools?: string[] | undefined;
+    }>>;
+    evolution_limits: z.ZodOptional<z.ZodObject<{
+        maxAutonomyIncrease: z.ZodDefault<z.ZodNumber>;
+        cooldownPeriod: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        maxAutonomyIncrease: number;
+        cooldownPeriod: string;
+    }, {
+        maxAutonomyIncrease?: number | undefined;
+        cooldownPeriod?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    system: {
+        role: string;
+        constraints: string[];
+        goals: string[];
+        personality?: string | undefined;
+    };
+    metadata: {
+        id: string;
+        name: string;
+        version: string;
+        description?: string | undefined;
+        author?: string | undefined;
+        inheritFrom?: string | undefined;
+    };
+    constraints?: {
+        mustConfirmBefore: string[];
+        neverSkipReviewFor: string[];
+        deniedTools: string[];
+    } | undefined;
+    planning?: {
+        temperature: number;
+        maxSteps: number;
+        thinkingProcess: boolean;
+        model?: string | undefined;
+    } | undefined;
+    prompts?: {
+        planning?: string | undefined;
+        reflection?: string | undefined;
+        intent?: string | undefined;
+    } | undefined;
+    execution?: {
+        requiresConfirmation: string[];
+        maxRetries: number;
+        riskTolerance: "low" | "medium" | "high";
+        autoRetry: boolean;
+    } | undefined;
+    preferences?: {
+        riskTolerance: number;
+        userConfirmation: number;
+        autonomyLevel: "manual" | "assisted" | "autonomous";
+        responseSpeed: number;
+    } | undefined;
+    evolution_limits?: {
+        maxAutonomyIncrease: number;
+        cooldownPeriod: string;
+    } | undefined;
+}, {
+    system: {
+        role: string;
+        constraints?: string[] | undefined;
+        personality?: string | undefined;
+        goals?: string[] | undefined;
+    };
+    metadata: {
+        id: string;
+        name: string;
+        version: string;
+        description?: string | undefined;
+        author?: string | undefined;
+        inheritFrom?: string | undefined;
+    };
+    constraints?: {
+        mustConfirmBefore?: string[] | undefined;
+        neverSkipReviewFor?: string[] | undefined;
+        deniedTools?: string[] | undefined;
+    } | undefined;
+    planning?: {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        maxSteps?: number | undefined;
+        thinkingProcess?: boolean | undefined;
+    } | undefined;
+    prompts?: {
+        planning?: string | undefined;
+        reflection?: string | undefined;
+        intent?: string | undefined;
+    } | undefined;
+    execution?: {
+        requiresConfirmation?: string[] | undefined;
+        maxRetries?: number | undefined;
+        riskTolerance?: "low" | "medium" | "high" | undefined;
+        autoRetry?: boolean | undefined;
+    } | undefined;
+    preferences?: {
+        riskTolerance?: number | undefined;
+        userConfirmation?: number | undefined;
+        autonomyLevel?: "manual" | "assisted" | "autonomous" | undefined;
+        responseSpeed?: number | undefined;
+    } | undefined;
+    evolution_limits?: {
+        maxAutonomyIncrease?: number | undefined;
+        cooldownPeriod?: string | undefined;
+    } | undefined;
+}>;
+type Strategy = z.infer<typeof StrategySchema>;
+type StrategyConfig = Strategy;
+
+declare class SimplePlanner {
+    private llm;
+    private config;
+    constructor(llm: ILLMProvider, config: StrategyConfig);
+    private fillTemplate;
+    private formatToolList;
+    private formatToolArgs;
+    createPlan(task: Task, intent: IntentProfile, context: AgentContext, skills?: Skill[], memories?: {
+        facts: Fact[];
+        episodes: Episode[];
+    }): Promise<Step[]>;
+}
+
+declare class StrategyRegistry {
+    private strategies;
+    private activeId;
+    loadDefault(): Promise<Strategy>;
+    listFromDirectory(dirPath: string): Promise<Strategy[]>;
+    loadFromFile(filePath: string): Promise<Strategy>;
+    saveToFile(strategy: Strategy, filePath: string): Promise<void>;
+    setActive(id: string): void;
+    getActive(): Strategy;
+}
+
+declare const McpServerSchema: z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    args: string[];
+    command: string;
+    env?: Record<string, string> | undefined;
+}, {
+    command: string;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+}>;
+declare const ConfigSchema: z.ZodObject<{
+    llm: z.ZodDefault<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<["anthropic", "openai", "ollama", "mock", "auto"]>>;
+        defaultModel: z.ZodDefault<z.ZodString>;
+        fallbackOrder: z.ZodDefault<z.ZodArray<z.ZodEnum<["ollama", "openai", "anthropic", "mock"]>, "many">>;
+        openaiApiKey: z.ZodDefault<z.ZodString>;
+        anthropicApiKey: z.ZodDefault<z.ZodString>;
+        openaiBaseUrl: z.ZodDefault<z.ZodString>;
+        anthropicBaseUrl: z.ZodDefault<z.ZodString>;
+        ollamaBaseUrl: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "anthropic" | "openai" | "ollama" | "mock" | "auto";
+        defaultModel: string;
+        fallbackOrder: ("anthropic" | "openai" | "ollama" | "mock")[];
+        openaiApiKey: string;
+        anthropicApiKey: string;
+        openaiBaseUrl: string;
+        anthropicBaseUrl: string;
+        ollamaBaseUrl: string;
+    }, {
+        provider?: "anthropic" | "openai" | "ollama" | "mock" | "auto" | undefined;
+        defaultModel?: string | undefined;
+        fallbackOrder?: ("anthropic" | "openai" | "ollama" | "mock")[] | undefined;
+        openaiApiKey?: string | undefined;
+        anthropicApiKey?: string | undefined;
+        openaiBaseUrl?: string | undefined;
+        anthropicBaseUrl?: string | undefined;
+        ollamaBaseUrl?: string | undefined;
+    }>>;
+    mcpServers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        args: string[];
+        command: string;
+        env?: Record<string, string> | undefined;
+    }, {
+        command: string;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+    }>>>;
+    strategy: z.ZodDefault<z.ZodObject<{
+        activePath: z.ZodDefault<z.ZodString>;
+        approvalCooldownDays: z.ZodDefault<z.ZodNumber>;
+        approvalDailyLimit: z.ZodDefault<z.ZodNumber>;
+        replayEpisodes: z.ZodDefault<z.ZodNumber>;
+        shadowModeEnabled: z.ZodDefault<z.ZodBoolean>;
+        shadowRolloutMode: z.ZodDefault<z.ZodEnum<["shadow", "canary"]>>;
+        shadowTrafficRatio: z.ZodDefault<z.ZodNumber>;
+        shadowCandidatePaths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        autoPromoteEnabled: z.ZodDefault<z.ZodBoolean>;
+        autoPromoteMinTasks: z.ZodDefault<z.ZodNumber>;
+        autoPromoteEvalInterval: z.ZodDefault<z.ZodNumber>;
+        autoPromoteMinImprovement: z.ZodDefault<z.ZodNumber>;
+        autoPromoteConfidence: z.ZodDefault<z.ZodNumber>;
+        shadowWindowDays: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        activePath: string;
+        approvalCooldownDays: number;
+        approvalDailyLimit: number;
+        replayEpisodes: number;
+        shadowModeEnabled: boolean;
+        shadowRolloutMode: "shadow" | "canary";
+        shadowTrafficRatio: number;
+        shadowCandidatePaths: string[];
+        autoPromoteEnabled: boolean;
+        autoPromoteMinTasks: number;
+        autoPromoteEvalInterval: number;
+        autoPromoteMinImprovement: number;
+        autoPromoteConfidence: number;
+        shadowWindowDays: number;
+    }, {
+        activePath?: string | undefined;
+        approvalCooldownDays?: number | undefined;
+        approvalDailyLimit?: number | undefined;
+        replayEpisodes?: number | undefined;
+        shadowModeEnabled?: boolean | undefined;
+        shadowRolloutMode?: "shadow" | "canary" | undefined;
+        shadowTrafficRatio?: number | undefined;
+        shadowCandidatePaths?: string[] | undefined;
+        autoPromoteEnabled?: boolean | undefined;
+        autoPromoteMinTasks?: number | undefined;
+        autoPromoteEvalInterval?: number | undefined;
+        autoPromoteMinImprovement?: number | undefined;
+        autoPromoteConfidence?: number | undefined;
+        shadowWindowDays?: number | undefined;
+    }>>;
+    safety: z.ZodDefault<z.ZodObject<{
+        userDataDirs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        systemDirs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        allowPaths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        denyPaths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        rememberApprovals: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        userDataDirs: string[];
+        systemDirs: string[];
+        allowPaths: string[];
+        denyPaths: string[];
+        rememberApprovals: boolean;
+    }, {
+        userDataDirs?: string[] | undefined;
+        systemDirs?: string[] | undefined;
+        allowPaths?: string[] | undefined;
+        denyPaths?: string[] | undefined;
+        rememberApprovals?: boolean | undefined;
+    }>>;
+    agent: z.ZodDefault<z.ZodObject<{
+        maxIterations: z.ZodDefault<z.ZodNumber>;
+        intentAnalysis: z.ZodDefault<z.ZodBoolean>;
+        failureReplan: z.ZodDefault<z.ZodBoolean>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        retryDelayMs: z.ZodDefault<z.ZodNumber>;
+        streaming: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        maxIterations: number;
+        intentAnalysis: boolean;
+        failureReplan: boolean;
+        maxRetries: number;
+        retryDelayMs: number;
+        streaming: boolean;
+    }, {
+        maxIterations?: number | undefined;
+        intentAnalysis?: boolean | undefined;
+        failureReplan?: boolean | undefined;
+        maxRetries?: number | undefined;
+        retryDelayMs?: number | undefined;
+        streaming?: boolean | undefined;
+    }>>;
+    server: z.ZodDefault<z.ZodObject<{
+        apiToken: z.ZodDefault<z.ZodString>;
+        sessionTtlHours: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        apiToken: string;
+        sessionTtlHours: number;
+    }, {
+        apiToken?: string | undefined;
+        sessionTtlHours?: number | undefined;
+    }>>;
+    memory: z.ZodDefault<z.ZodObject<{
+        checkpointTtlHours: z.ZodDefault<z.ZodNumber>;
+        observationFrameTtlHours: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        checkpointTtlHours: number;
+        observationFrameTtlHours: number;
+    }, {
+        checkpointTtlHours?: number | undefined;
+        observationFrameTtlHours?: number | undefined;
+    }>>;
+    skills: z.ZodDefault<z.ZodObject<{
+        /** Maximum number of skills whose full content is injected into the prompt (default: 3) */
+        matchTopK: z.ZodDefault<z.ZodNumber>;
+        /** Enable file system watching for hot-reload of skills (default: true) */
+        hotReload: z.ZodDefault<z.ZodBoolean>;
+        /** Additional directories to scan for skills */
+        extraDirs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        matchTopK: number;
+        hotReload: boolean;
+        extraDirs: string[];
+    }, {
+        matchTopK?: number | undefined;
+        hotReload?: boolean | undefined;
+        extraDirs?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    llm: {
+        provider: "anthropic" | "openai" | "ollama" | "mock" | "auto";
+        defaultModel: string;
+        fallbackOrder: ("anthropic" | "openai" | "ollama" | "mock")[];
+        openaiApiKey: string;
+        anthropicApiKey: string;
+        openaiBaseUrl: string;
+        anthropicBaseUrl: string;
+        ollamaBaseUrl: string;
+    };
+    mcpServers: Record<string, {
+        args: string[];
+        command: string;
+        env?: Record<string, string> | undefined;
+    }>;
+    strategy: {
+        activePath: string;
+        approvalCooldownDays: number;
+        approvalDailyLimit: number;
+        replayEpisodes: number;
+        shadowModeEnabled: boolean;
+        shadowRolloutMode: "shadow" | "canary";
+        shadowTrafficRatio: number;
+        shadowCandidatePaths: string[];
+        autoPromoteEnabled: boolean;
+        autoPromoteMinTasks: number;
+        autoPromoteEvalInterval: number;
+        autoPromoteMinImprovement: number;
+        autoPromoteConfidence: number;
+        shadowWindowDays: number;
+    };
+    safety: {
+        userDataDirs: string[];
+        systemDirs: string[];
+        allowPaths: string[];
+        denyPaths: string[];
+        rememberApprovals: boolean;
+    };
+    agent: {
+        maxIterations: number;
+        intentAnalysis: boolean;
+        failureReplan: boolean;
+        maxRetries: number;
+        retryDelayMs: number;
+        streaming: boolean;
+    };
+    server: {
+        apiToken: string;
+        sessionTtlHours: number;
+    };
+    memory: {
+        checkpointTtlHours: number;
+        observationFrameTtlHours: number;
+    };
+    skills: {
+        matchTopK: number;
+        hotReload: boolean;
+        extraDirs: string[];
+    };
+}, {
+    llm?: {
+        provider?: "anthropic" | "openai" | "ollama" | "mock" | "auto" | undefined;
+        defaultModel?: string | undefined;
+        fallbackOrder?: ("anthropic" | "openai" | "ollama" | "mock")[] | undefined;
+        openaiApiKey?: string | undefined;
+        anthropicApiKey?: string | undefined;
+        openaiBaseUrl?: string | undefined;
+        anthropicBaseUrl?: string | undefined;
+        ollamaBaseUrl?: string | undefined;
+    } | undefined;
+    mcpServers?: Record<string, {
+        command: string;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+    }> | undefined;
+    strategy?: {
+        activePath?: string | undefined;
+        approvalCooldownDays?: number | undefined;
+        approvalDailyLimit?: number | undefined;
+        replayEpisodes?: number | undefined;
+        shadowModeEnabled?: boolean | undefined;
+        shadowRolloutMode?: "shadow" | "canary" | undefined;
+        shadowTrafficRatio?: number | undefined;
+        shadowCandidatePaths?: string[] | undefined;
+        autoPromoteEnabled?: boolean | undefined;
+        autoPromoteMinTasks?: number | undefined;
+        autoPromoteEvalInterval?: number | undefined;
+        autoPromoteMinImprovement?: number | undefined;
+        autoPromoteConfidence?: number | undefined;
+        shadowWindowDays?: number | undefined;
+    } | undefined;
+    safety?: {
+        userDataDirs?: string[] | undefined;
+        systemDirs?: string[] | undefined;
+        allowPaths?: string[] | undefined;
+        denyPaths?: string[] | undefined;
+        rememberApprovals?: boolean | undefined;
+    } | undefined;
+    agent?: {
+        maxIterations?: number | undefined;
+        intentAnalysis?: boolean | undefined;
+        failureReplan?: boolean | undefined;
+        maxRetries?: number | undefined;
+        retryDelayMs?: number | undefined;
+        streaming?: boolean | undefined;
+    } | undefined;
+    server?: {
+        apiToken?: string | undefined;
+        sessionTtlHours?: number | undefined;
+    } | undefined;
+    memory?: {
+        checkpointTtlHours?: number | undefined;
+        observationFrameTtlHours?: number | undefined;
+    } | undefined;
+    skills?: {
+        matchTopK?: number | undefined;
+        hotReload?: boolean | undefined;
+        extraDirs?: string[] | undefined;
+    } | undefined;
+}>;
+type LydiaConfig = z.infer<typeof ConfigSchema>;
+
+declare class ConfigLoader {
+    private configPath;
+    constructor();
+    load(): Promise<LydiaConfig>;
+    update(partial: Partial<LydiaConfig>): Promise<LydiaConfig>;
+    private save;
+}
+
+declare class StrategyApprovalService {
+    private memory;
+    private configLoader;
+    constructor(memoryManager?: MemoryManager, configLoader?: ConfigLoader);
+    approveProposal(proposalId: number): Promise<{
+        proposal: StrategyProposal;
+        activePath: string;
+    }>;
+    rejectProposal(proposalId: number, reason?: string): Promise<{
+        proposal: StrategyProposal;
+    }>;
+    private getPendingProposal;
+}
+
+interface RoutedStrategy {
+    role: 'baseline' | 'candidate';
+    path?: string;
+    strategyId: string;
+    strategyVersion: string;
+    reason: string;
+}
+interface ShadowPromotionDecision {
+    candidatePath: string;
+    candidateId: string;
+    candidateVersion: string;
+    baselineId: string;
+    baselineVersion: string;
+    candidateSummary: StrategyEpisodeSummary;
+    baselineSummary: StrategyEpisodeSummary;
+    successImprovement: number;
+    pValue: number;
+}
+declare class ShadowRouter {
+    private memory;
+    private registry;
+    private random;
+    constructor(memoryManager?: MemoryManager, strategyRegistry?: StrategyRegistry, random?: () => number);
+    selectStrategy(config: LydiaConfig): Promise<RoutedStrategy>;
+    evaluateAutoPromotion(config: LydiaConfig): Promise<ShadowPromotionDecision | null>;
+    private loadBaseline;
+    private loadCandidates;
+    private computeUcbScore;
+    private safeRate;
+    private twoProportionPValue;
+    private normalCdf;
+}
+
+interface GateResult {
+    ok: boolean;
+    reason?: string;
+}
+declare class BasicStrategyGate {
+    /**
+     * Minimal automatic validation rules for strategy proposals.
+     * Rejects obvious unsafe or ambiguous configurations.
+     */
+    static validate(strategy: Strategy): GateResult;
+}
+
+interface ReviewFinding {
+    tool: string;
+    total: number;
+    failed: number;
+    failureRate: number;
+    recommendation: string;
+}
+interface ReviewSummary {
+    episodes: number;
+    traces: number;
+    findings: ReviewFinding[];
+    suggestedConfirmations: string[];
+}
+interface ReviewOptions {
+    episodeLimit?: number;
+    minFailures?: number;
+    minFailureRate?: number;
+}
+declare class StrategyReviewer {
+    private memory;
+    constructor(memory: MemoryManager);
+    review(strategy: Strategy, options?: ReviewOptions): ReviewSummary;
+}
+
+interface StrategyBranch {
+    name: string;
+    version: string;
+    path: string;
+    parent?: string;
+    createdAt: number;
+}
+declare class StrategyBranchManager {
+    private baseDir;
+    constructor(baseDir?: string);
+    init(): Promise<void>;
+    listBranches(): Promise<StrategyBranch[]>;
+    createBranch(sourceStrategy: Strategy, newBranchName: string, modifications: Partial<Strategy>): Promise<Strategy>;
+    getBranch(branchName: string): Promise<Strategy | null>;
+    mergeBranch(branchName: string): Promise<void>;
+    archiveBranch(branchName: string): Promise<void>;
+}
+
+interface AgentOptions {
+    strategyPathOverride?: string;
+}
+declare class Agent extends EventEmitter {
+    private llm;
+    private intentAnalyzer;
+    private mcpClientManager;
+    private skillRegistry;
+    private skillLoader;
+    private strategyRegistry;
+    private activeStrategy?;
+    private configLoader;
+    private memoryManager;
+    private interactionServer?;
+    private config?;
+    private isInitialized;
+    private traces;
+    private stepResults;
+    private taskApprovals;
+    private planner?;
+    private currentPlan;
+    private executedPlanStepIds;
+    private skippedPlanStepIds;
+    private replannedFailures;
+    private verificationFailureCount;
+    private computerUseSessionId?;
+    private computerUseCheckpoint?;
+    private computerUseActionCounter;
+    private branchManager;
+    private reviewManager;
+    private updateGate;
+    private reporter;
+    private feedbackCollector;
+    private sessionMessages;
+    private sessionSystemPrompt;
+    private sessionTools;
+    private sessionInitialized;
+    private skillToolMap;
+    private skillWatcher?;
+    private currentTaskId?;
+    private currentRunId?;
+    private currentInput?;
+    private currentTaskCreatedAt?;
+    private builtinServerSpecs;
+    private options;
+    private computerUseAdapter;
+    private computerUseOrchestrator;
+    constructor(llm: ILLMProvider, options?: AgentOptions);
+    private bindComputerUseEvents;
+    init(): Promise<void>;
+    private registerSkillTools;
+    private isDynamicSkillCheck;
+    private connectInMemoryServer;
+    private connectBuiltinServers;
+    private connectExternalMcpServers;
+    private getAllToolDefinitions;
+    /**
+     * Collect allowedTools from matched skills and return a Set for filtering.
+     * Returns null if no skill restricts tools (all tools are allowed).
+     */
+    private getActiveAllowedTools;
+    chat(userMessage: string): Promise<string>;
+    resetSession(): void;
+    run(userInput: string, runId?: string): Promise<Task>;
+    /**
+     * Resume an interrupted task from a persisted checkpoint.
+     * Restores the conversation history, traces, and iteration counter,
+     * then continues the agentic loop from where it left off.
+     */
+    resume(taskId: string): Promise<Task>;
+    private agenticLoop;
+    private buildFallbackIntentProfile;
+    private buildTaskContext;
+    private createExecutionPlan;
+    private buildPlanGuidance;
+    private selectPlannedStepForTool;
+    private markPlanStepExecuted;
+    private recordStepResult;
+    private markDownstreamStepsSkipped;
+    private enqueueFailureReplan;
+    private recordFailedStep;
+    private evaluateStepVerification;
+    private evaluateVerificationCriterion;
+    private extractQuotedFragments;
+    private containsPathLikeText;
+    private looksLikeJson;
+    private containsFailureSignals;
+    private containsMissingSignals;
+    private isLikelySuccessfulOutput;
+    private buildVerificationFailureMessage;
+    private truncateText;
+    private parseCheckpointFrameIds;
+    private executeToolWithComputerUseOrchestration;
+    private resolveCanonicalComputerUseAction;
+    private inferComputerUseDomain;
+    private formatComputerUseFailure;
+    private toDisplayText;
+    private normalizeMcpResultForLoop;
+    private extractMcpRichBlocks;
+    private escalateRiskByVerificationState;
+    private rehydrateStepResultsFromTraces;
+    private persistReportAndFeedback;
+    private callLLMWithRetry;
+    private callLLM;
+    private isRetryableError;
+    private sleep;
+    resolveInteraction(id: string, response: string): boolean;
+    /**
+     * Build the system prompt with progressive skill disclosure:
+     * - Layer 1: Lightweight catalog of ALL registered skills (name + description)
+     * - Layer 2: Full content of only the top-K matched skills
+     */
+    private buildSystemPrompt;
+    /**
+     * Lazy-load content for matched skills that don't have content in memory yet.
+     */
+    private ensureSkillContent;
+    private buildApprovalKey;
+    private getApprovalRecord;
+    private recordApprovalPersistent;
+    private recordApprovalHistory;
+    private confirmRisk;
+}
+
+declare class ShellServer {
+    server: Server;
+    constructor();
+    private setupHandlers;
+}
+
+declare class FileSystemServer {
+    server: Server;
+    private allowedRootDir;
+    constructor(allowedRootDir?: string);
+    private validatePath;
+    private setupHandlers;
+    private ensureDestWritable;
+    private moveFile;
+    private searchByName;
+    private buildMatcher;
+    private createArchiveBundle;
+    private parseArchiveBundle;
+    private extractArchiveBundle;
+    private decodeArchiveEntry;
+    private prepareOutputDirectory;
+}
+
+declare class GitServer {
+    server: Server;
+    private git;
+    constructor(baseDir?: string);
+    private setupHandlers;
+}
+
+declare class MemoryServer {
+    server: Server;
+    private memoryManager;
+    constructor(memoryManager: MemoryManager);
+    private setupHandlers;
+}
+
+interface InteractionRequest {
+    id: string;
+    type: 'text' | 'confirm';
+    prompt: string;
+}
+declare class InteractionServer extends EventEmitter {
+    server: Server;
+    private pendingInteractions;
+    constructor();
+    private setupHandlers;
+    resolve(id: string, response: string): boolean;
+}
+
+interface McpServerConfig {
+    id: string;
+    type: 'stdio' | 'in-memory';
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    transport?: InMemoryTransport;
+}
+declare class McpClientManager {
+    private clients;
+    private tools;
+    private nameMap;
+    connect(config: McpServerConfig): Promise<Client<{
+        method: string;
+        params?: zod.objectOutputType<{
+            _meta: zod.ZodOptional<zod.ZodObject<{
+                progressToken: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>>;
+            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+                progressToken: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>>;
+            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+                progressToken: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodNumber]>>;
+            }, zod.ZodTypeAny, "passthrough">>>;
+        }, zod.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        method: string;
+        params?: zod.objectOutputType<{
+            _meta: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
+        }, zod.ZodTypeAny, "passthrough"> | undefined;
+    }, zod.objectOutputType<{
+        _meta: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
+    }, zod.ZodTypeAny, "passthrough">>>;
+    refreshTools(serverId: string): Promise<void>;
+    getTools(): Tool[];
+    /**
+     * Get tool definitions in LLM-provider-agnostic format.
+     * Converts MCP Tool schemas to ToolDefinition for use with LLM function calling.
+     * Returns de-conflicted names (prefixed where necessary).
+     */
+    getToolDefinitions(): ToolDefinition[];
+    getToolInfo(name: string): {
+        serverId: string;
+        tool: Tool;
+    } | undefined;
+    isToolExternal(name: string): boolean;
+    callTool(name: string, args: any): Promise<zod.objectOutputType<{
+        _meta: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
+    } & {
+        content: zod.ZodArray<zod.ZodUnion<[zod.ZodObject<{
+            type: zod.ZodLiteral<"text">;
+            text: zod.ZodString;
+        }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+            type: zod.ZodLiteral<"text">;
+            text: zod.ZodString;
+        }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+            type: zod.ZodLiteral<"text">;
+            text: zod.ZodString;
+        }, zod.ZodTypeAny, "passthrough">>, zod.ZodObject<{
+            type: zod.ZodLiteral<"image">;
+            data: zod.ZodString;
+            mimeType: zod.ZodString;
+        }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+            type: zod.ZodLiteral<"image">;
+            data: zod.ZodString;
+            mimeType: zod.ZodString;
+        }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+            type: zod.ZodLiteral<"image">;
+            data: zod.ZodString;
+            mimeType: zod.ZodString;
+        }, zod.ZodTypeAny, "passthrough">>, zod.ZodObject<{
+            type: zod.ZodLiteral<"resource">;
+            resource: zod.ZodUnion<[zod.ZodObject<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                text: zod.ZodString;
+            }>, "passthrough", zod.ZodTypeAny, zod.objectOutputType<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                text: zod.ZodString;
+            }>, zod.ZodTypeAny, "passthrough">, zod.objectInputType<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                text: zod.ZodString;
+            }>, zod.ZodTypeAny, "passthrough">>, zod.ZodObject<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                blob: zod.ZodString;
+            }>, "passthrough", zod.ZodTypeAny, zod.objectOutputType<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                blob: zod.ZodString;
+            }>, zod.ZodTypeAny, "passthrough">, zod.objectInputType<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                blob: zod.ZodString;
+            }>, zod.ZodTypeAny, "passthrough">>]>;
+        }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
+            type: zod.ZodLiteral<"resource">;
+            resource: zod.ZodUnion<[zod.ZodObject<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                text: zod.ZodString;
+            }>, "passthrough", zod.ZodTypeAny, zod.objectOutputType<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                text: zod.ZodString;
+            }>, zod.ZodTypeAny, "passthrough">, zod.objectInputType<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                text: zod.ZodString;
+            }>, zod.ZodTypeAny, "passthrough">>, zod.ZodObject<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                blob: zod.ZodString;
+            }>, "passthrough", zod.ZodTypeAny, zod.objectOutputType<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                blob: zod.ZodString;
+            }>, zod.ZodTypeAny, "passthrough">, zod.objectInputType<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                blob: zod.ZodString;
+            }>, zod.ZodTypeAny, "passthrough">>]>;
+        }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
+            type: zod.ZodLiteral<"resource">;
+            resource: zod.ZodUnion<[zod.ZodObject<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                text: zod.ZodString;
+            }>, "passthrough", zod.ZodTypeAny, zod.objectOutputType<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                text: zod.ZodString;
+            }>, zod.ZodTypeAny, "passthrough">, zod.objectInputType<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                text: zod.ZodString;
+            }>, zod.ZodTypeAny, "passthrough">>, zod.ZodObject<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                blob: zod.ZodString;
+            }>, "passthrough", zod.ZodTypeAny, zod.objectOutputType<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                blob: zod.ZodString;
+            }>, zod.ZodTypeAny, "passthrough">, zod.objectInputType<zod.objectUtil.extendShape<{
+                uri: zod.ZodString;
+                mimeType: zod.ZodOptional<zod.ZodString>;
+            }, {
+                blob: zod.ZodString;
+            }>, zod.ZodTypeAny, "passthrough">>]>;
+        }, zod.ZodTypeAny, "passthrough">>]>, "many">;
+        isError: zod.ZodOptional<zod.ZodDefault<zod.ZodBoolean>>;
+    }, zod.ZodTypeAny, "passthrough"> | zod.objectOutputType<{
+        _meta: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
+    } & {
+        toolResult: zod.ZodUnknown;
+    }, zod.ZodTypeAny, "passthrough">>;
+    closeAll(): Promise<void>;
+    private registerToolName;
+}
+
+type RiskLevel = 'low' | 'high';
+interface RiskAssessment {
+    level: RiskLevel;
+    reason?: string;
+    signature?: string;
+    details?: string;
+}
+declare function assessRisk(toolName: string, args: Record<string, unknown> | undefined, mcp: McpClientManager, config?: LydiaConfig): RiskAssessment;
+
+interface EvaluationMetrics {
+    duration: number;
+    steps: number;
+    cost?: number;
+    driftDetected: boolean;
+    riskEvents: number;
+    humanInterrupts: number;
+    observationFrames: number;
+    multimodalFrames: number;
+}
+interface EvaluationResult {
+    taskId: string;
+    success: boolean;
+    score: number;
+    metrics: EvaluationMetrics;
+    details?: string;
+}
+interface EvaluationSummary {
+    tasks: number;
+    successRate: number;
+    averageScore: number;
+    averageDuration: number;
+    averageCost: number;
+    driftRate: number;
+    averageRiskEvents: number;
+    averageHumanInterrupts: number;
+    averageObservationFrames: number;
+    averageMultimodalFrames: number;
+}
+interface StrategyComparison {
+    baselineId: string;
+    candidateId: string;
+    tasksEvaluated: number;
+    baselineScore: number;
+    candidateScore: number;
+    improvement: number;
+    details: EvaluationResult[];
+    baselineSummary: EvaluationSummary;
+    candidateSummary: EvaluationSummary;
+    delta: {
+        successRate: number;
+        averageScore: number;
+        averageDuration: number;
+        averageCost: number;
+        driftRate: number;
+        averageRiskEvents: number;
+        averageHumanInterrupts: number;
+        averageObservationFrames: number;
+        averageMultimodalFrames: number;
+    };
+}
+declare class StrategyEvaluator {
+    evaluateTask(task: Task, originalResult: string | undefined, runtimeMetrics?: Partial<EvaluationMetrics>): EvaluationResult;
+    compareResults(baseline: EvaluationResult[], candidate: EvaluationResult[]): StrategyComparison;
+    private calculateAverageScore;
+    summarize(results: EvaluationResult[]): EvaluationSummary;
+    private computeScore;
+    private computeTextSimilarity;
+    private tokenize;
+    private lowerIsBetter;
+    private clamp01;
+}
+
+interface ValidationResult {
+    status: 'PASS' | 'REJECT' | 'NEEDS_HUMAN';
+    reason?: string;
+    details?: any;
+}
+interface GateValidator {
+    name: string;
+    validate(candidate: Strategy, branch: StrategyBranch, evaluations?: EvaluationResult[], baseline?: Strategy): Promise<ValidationResult>;
+}
+declare class SyntaxValidator implements GateValidator {
+    name: string;
+    validate(candidate: Strategy): Promise<ValidationResult>;
+}
+declare class EvolutionLimitValidator implements GateValidator {
+    name: string;
+    validate(candidate: Strategy, _branch: StrategyBranch, _evaluations?: EvaluationResult[], baseline?: Strategy): Promise<ValidationResult>;
+}
+declare class ReplayPerformanceValidator implements GateValidator {
+    name: string;
+    validate(_candidate: Strategy, _branch: StrategyBranch, evaluations?: EvaluationResult[]): Promise<ValidationResult>;
+}
+declare class RiskSafetyValidator implements GateValidator {
+    name: string;
+    validate(candidate: Strategy, _branch: StrategyBranch, _evaluations?: EvaluationResult[], baseline?: Strategy): Promise<ValidationResult>;
+}
+
+declare class StrategyUpdateGate {
+    private validators;
+    private readonly enableLogs;
+    constructor();
+    process(candidate: Strategy, branch: StrategyBranch, evaluations?: EvaluationResult[], baseline?: Strategy): Promise<ValidationResult>;
+}
+
+interface ReviewRequest {
+    id: number;
+    source: string;
+    timestamp: number;
+    branchName: string;
+    strategyId: string;
+    strategyPath: string;
+    diffSummary: string;
+    validationResult: ValidationResult;
+    analysis?: string;
+    description?: string;
+    status: 'pending' | 'approved' | 'rejected';
+}
+declare class ReviewManager {
+    private memory;
+    constructor(memoryManager?: MemoryManager);
+    init(): Promise<void>;
+    addRequest(request: Omit<ReviewRequest, 'id' | 'timestamp' | 'status'>): Promise<number>;
+    listPending(): Promise<ReviewRequest[]>;
+    getRequest(id: number): Promise<ReviewRequest | undefined>;
+    updateStatus(id: number, status: 'approved' | 'rejected'): Promise<void>;
+    private parseEvaluation;
+    private mapStatus;
+    private toReviewRequest;
+}
+
+interface ReplayDeterminismMismatch {
+    run: number;
+    signature: string;
+}
+interface ReplayDeterminismResult {
+    episodeId: number;
+    runs: number;
+    consistentRuns: number;
+    consistencyRate: number;
+    ok: boolean;
+    baselineSignature: string;
+    mismatches: ReplayDeterminismMismatch[];
+}
+declare class ReplayManager {
+    private memoryManager;
+    private evaluator;
+    constructor(memoryManager?: MemoryManager);
+    replay(episodeId: number, customStrategy?: Strategy): Promise<EvaluationResult>;
+    replayDeterminism(episodeId: number, options?: {
+        runs?: number;
+        minConsistencyRate?: number;
+        strategy?: Strategy;
+    }): Promise<ReplayDeterminismResult>;
+    replayBatch(episodeIds: number[], strategy?: Strategy): Promise<EvaluationResult[]>;
+    replayCompare(episodeIds: number[], baseline: Strategy, candidate: Strategy): Promise<StrategyComparison>;
+    private buildDeterminismSignature;
+}
+
+declare class ReplayLLMProvider implements ILLMProvider {
+    readonly id = "replay";
+    private originalPlan;
+    private callCount;
+    constructor(originalPlan: string);
+    generate(request: LLMRequest): Promise<LLMResponse>;
+    generateStream(request: LLMRequest): AsyncGenerator<StreamChunk, void, unknown>;
+    private normalizePlan;
+}
+
+type ReplayToolResult = {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+};
+declare class ReplayMcpClientManager extends McpClientManager {
+    private traces;
+    private callIndex;
+    drifts: Array<{
+        index: number;
+        expected: string;
+        actual: string;
+        type: 'tool' | 'args';
+    }>;
+    private readonly virtualRoot;
+    private virtualFiles;
+    private gitHeadFiles;
+    private gitStagedFiles;
+    private gitCommits;
+    private invocationCount;
+    private riskEventCount;
+    private humanInterruptCount;
+    private readonly highRiskTools;
+    constructor(traces: Trace[]);
+    connect(config: any): Promise<any>;
+    callTool(name: string, args: any): Promise<ReplayToolResult>;
+    getInvocationCount(): number;
+    getRiskEventCount(): number;
+    getHumanInterruptCount(): number;
+    private isFsTool;
+    private isGitTool;
+    private recordInvocation;
+    private executeFsTool;
+    private executeShellTool;
+    private mapShellGitCommand;
+    private executeGitTool;
+    private consumeTrace;
+    private consumeTraceAt;
+    private findTraceIndex;
+    private recordToolDrift;
+    private recordArgsDrift;
+    private seedVirtualFileState;
+    private initializeGitState;
+    private computeGitChanges;
+    private sortedArray;
+    private normalizeFsPath;
+    private listDirectoryEntries;
+    private stableStringify;
+    private safeParseJson;
+    private normalizeToolOutput;
+}
+
+declare class SkillParser {
+    /**
+     * Parse a SKILL.md file content into a full StaticSkill object (metadata + content).
+     */
+    static parse(fileContent: string, filePath?: string): StaticSkill;
+    /**
+     * Parse only the YAML frontmatter of a SKILL.md file into lightweight SkillMeta.
+     * This avoids loading the full content body, saving memory for large skill sets.
+     */
+    static parseMeta(fileContent: string, filePath?: string): SkillMeta;
+    /**
+     * Extract YAML frontmatter from markdown content
+     */
+    static extractFrontmatter(content: string): {
+        frontmatter: string | null;
+        body: string;
+    };
+}
+
+declare class SkillRegistry {
+    private skills;
+    private relevanceThreshold;
+    register(skill: Skill | SkillMeta): void;
+    unregister(name: string): boolean;
+    get(name: string): Skill | SkillMeta | undefined;
+    list(): (Skill | SkillMeta)[];
+    /**
+     * Find relevant skills using TF-IDF weighted scoring.
+     * - name match: weight 3.0
+     * - tags match: weight 2.5
+     * - description match: weight 2.0
+     * - content match: weight 1.0 (only if content is in memory)
+     *
+     * @param intent - The user's intent/query to match against
+     * @param topK - Maximum number of results to return (default: 3)
+     * @returns Sorted array of matched skills, limited to topK
+     */
+    match(intent: string, topK?: number): (Skill | SkillMeta)[];
+    private tokenize;
+    private getSkillTokens;
+}
+
+declare class SkillLoader {
+    private registry;
+    /** Ordered list of directories to scan for skills */
+    private directories;
+    constructor(registry: SkillRegistry);
+    /**
+     * Get the list of skill directories in priority order.
+     * Later directories override earlier ones (Project > User > Built-in).
+     */
+    getDirectories(extraDirs?: string[]): string[];
+    /**
+     * Phase 1: Scan all skill directories and load ONLY frontmatter metadata.
+     * Skill content bodies are NOT loaded into memory — they will be
+     * lazy-loaded on demand when matched.
+     */
+    loadAll(extraDirs?: string[]): Promise<void>;
+    /**
+     * Recursively scan a directory and register skill metadata (frontmatter only).
+     */
+    loadMetadataFromDirectory(dirPath: string): Promise<void>;
+    /**
+     * Load only the frontmatter metadata from a skill file.
+     * The markdown body content is NOT read into memory.
+     */
+    private loadSkillMeta;
+    /**
+     * Phase 2: On-demand content loading.
+     * Reads the full file content for a registered skill and returns
+     * the parsed StaticSkill with the markdown body.
+     *
+     * @param name - The skill name to load content for
+     * @returns The full skill content string, or null if not found
+     */
+    loadContent(name: string): Promise<string | null>;
+    /**
+     * Load and return the full StaticSkill object for a given skill name.
+     * This reads the file and parses both metadata and content.
+     */
+    loadFull(name: string): Promise<StaticSkill | null>;
+    /**
+     * Reload a single skill file's metadata into the registry.
+     * Used by the hot-reload watcher on file change.
+     */
+    reloadSkillMeta(filePath: string): Promise<SkillMeta | null>;
+}
+
+declare class SkillWatcher extends EventEmitter {
+    private directories;
+    private registry;
+    private loader;
+    private watchers;
+    private debounceTimers;
+    private debounceMs;
+    /** Map of file path -> skill name for tracking deletions */
+    private pathToName;
+    private running;
+    constructor(directories: string[], registry: SkillRegistry, loader: SkillLoader, options?: {
+        debounceMs?: number;
+    });
+    /**
+     * Start watching all skill directories for changes.
+     */
+    start(): void;
+    /**
+     * Stop all file watchers and clean up timers.
+     */
+    stop(): void;
+    private watchDirectory;
+    private handleFileChange;
+    private processFileChange;
+}
+
+interface StepResult {
+    stepId: string;
+    status: 'completed' | 'failed' | 'skipped';
+    output?: string;
+    error?: string;
+    durationMs?: number;
+    verificationStatus?: 'pending' | 'passed' | 'failed';
+}
+interface ExecutionSummary {
+    taskId: string;
+    stepsTotal: number;
+    stepsCompleted: number;
+    stepsFailed: number;
+    outputs: string[];
+    failures: Array<{
+        stepId: string;
+        reason: string;
+    }>;
+    artifacts: Array<{
+        path: string;
+        description?: string;
+    }>;
+}
+interface TaskReport {
+    taskId: string;
+    intentSummary: string;
+    success: boolean;
+    summary: string;
+    outputs: string[];
+    followUps: string[];
+    steps: StepResult[];
+    verificationNotes?: string[];
+    createdAt: number;
+}
+declare class TaskReporter {
+    buildSummary(taskId: string, results: StepResult[]): ExecutionSummary;
+    generateReport(task: Task, intent: IntentProfile, results: StepResult[]): TaskReport;
+}
+
+interface TaskFeedback {
+    taskId: string;
+    rating?: 'positive' | 'neutral' | 'negative';
+    comment?: string;
+    corrections?: string[];
+    createdAt: number;
+}
+declare class FeedbackCollector {
+    collect(task: Task, report: TaskReport, askUser?: (prompt: string) => Promise<string>): Promise<TaskFeedback | null>;
+}
+
+interface ComputerUseAdapterContext {
+    toolName: string;
+    invokeTool: (toolName: string, args: Record<string, unknown>) => Promise<any>;
+    createFrameId?: () => string;
+}
+interface ComputerUseAdapterResult {
+    toolResult: any;
+    frame: ObservationFrame;
+}
+interface ComputerUseCapabilityAdapter {
+    id: string;
+    execute(action: ComputerUseActionEnvelope, context: ComputerUseAdapterContext): Promise<ComputerUseAdapterResult>;
+}
+declare class McpCanonicalCapabilityAdapter implements ComputerUseCapabilityAdapter {
+    readonly id = "mcp-canonical-adapter";
+    private readonly maxInlineImageBase64Length;
+    execute(action: ComputerUseActionEnvelope, context: ComputerUseAdapterContext): Promise<ComputerUseAdapterResult>;
+    private validateActionArgs;
+    private extractObservationBlocks;
+}
+declare function normalizeComputerUseError(error: unknown): ComputerUseError;
+
+interface SessionState {
+    sessionId: string;
+    taskId: string;
+    latestFrameIds: string[];
+    lastActionId?: string;
+    verificationFailures: number;
+}
+interface DispatchCanonicalActionRequest {
+    taskId: string;
+    action: ComputerUseActionEnvelope;
+    adapter: ComputerUseCapabilityAdapter;
+    toolName: string;
+    invokeTool: (toolName: string, args: Record<string, unknown>) => Promise<any>;
+}
+interface DispatchCanonicalActionResult {
+    sessionId: string;
+    toolResult: any;
+    frame: ObservationFrame;
+    frameId: string;
+    checkpoint: ComputerUseCheckpoint;
+}
+declare class ComputerUseSessionOrchestrator extends EventEmitter {
+    private sessions;
+    startSession(taskId: string, sessionId?: string): SessionState;
+    dispatchCanonicalAction(request: DispatchCanonicalActionRequest): Promise<DispatchCanonicalActionResult>;
+    endSession(sessionId: string): ComputerUseCheckpoint | undefined;
+    getCheckpoint(sessionId: string): ComputerUseCheckpoint | undefined;
+    restoreCheckpoint(checkpoint: ComputerUseCheckpoint): void;
+    private buildCheckpoint;
+    private normalizeError;
+}
+
+export { Agent, type AgentContext, type AgentOptions, AnthropicProvider, BasicStrategyGate, COMPUTER_USE_ERROR_CODES, type CanonicalComputerUseAction, type Checkpoint, type ComputerUseActionEnvelope, type ComputerUseAdapterContext, type ComputerUseAdapterResult, type ComputerUseCapabilityAdapter, type ComputerUseCheckpoint, type ComputerUseDomain, type ComputerUseError, type ComputerUseErrorCode, type ComputerUseRiskLevel, ComputerUseSessionOrchestrator, type ComputerUseSessionSummary, type ComputerUseSessionSummaryRecord, ConfigLoader, ConfigSchema, type ContentBlock, ContentBlockSchema, type CreateLLMOptions, type DispatchCanonicalActionRequest, type DispatchCanonicalActionResult, type DynamicSkill, type Episode, type EvaluationMetrics, type EvaluationResult, type EvaluationSummary, EvolutionLimitValidator, type ExecutionSummary, type Fact, FallbackProvider, FeedbackCollector, FileSystemServer, type GateResult, type GateValidator, GitServer, type ILLMProvider, type IStrategy, type ImageContent, ImageContentSchema, type Intent, IntentAnalyzer, type IntentProfile, IntentProfileSchema, IntentSchema, type InteractionRequest, InteractionServer, type LLMRequest, LLMRequestSchema, type LLMResponse, LLMResponseSchema, type LydiaConfig, McpCanonicalCapabilityAdapter, McpClientManager, type McpServerConfig, McpServerSchema, MemoryManager, type MemoryManagerOptions, MemoryServer, type Message, MessageSchema, MockProvider, type ObservationArtifactKind, type ObservationBlock, type ObservationFrame, type ObservationFrameRecord, OllamaProvider, OpenAIProvider, type ReplayDeterminismMismatch, type ReplayDeterminismResult, ReplayLLMProvider, ReplayManager, ReplayMcpClientManager, ReplayPerformanceValidator, type ReviewFinding, ReviewManager, type ReviewOptions, type ReviewRequest, type ReviewSummary, type RiskAssessment, type RiskLevel, RiskSafetyValidator, type Role, RoleSchema, type RoutedStrategy, type ShadowPromotionDecision, ShadowRouter, ShellServer, SimplePlanner, type Skill, type SkillContext, SkillLoader, type SkillMeta, SkillMetaSchema, SkillParser, SkillRegistry, SkillSchema, SkillWatcher, type StaticSkill, StaticSkillSchema, type Step, type StepResult, StepSchema, type StepStatus, StepStatusSchema, type StepType, StepTypeSchema, type Strategy, StrategyApprovalService, type StrategyBranch, StrategyBranchManager, type StrategyComparison, type StrategyConfig, StrategyConstraintsSchema, type StrategyEpisodeSummary, StrategyEvaluator, StrategyEvolutionLimitsSchema, StrategyExecutionSchema, StrategyMetadataSchema, StrategyPlanningSchema, StrategyPreferencesSchema, StrategyPromptsSchema, type StrategyProposal, StrategyRegistry, StrategyReviewer, StrategySchema, StrategySystemSchema, StrategyUpdateGate, type StreamChunk, SyntaxValidator, type Task, type TaskContext, type TaskFeedback, type TaskFeedbackRecord, type TaskReport, type TaskReportRecord, TaskReporter, TaskSchema, type TaskStatus, TaskStatusSchema, type TextContent, TextContentSchema, type ThinkingContent, ThinkingContentSchema, type TokenUsage, TokenUsageSchema, type ToolDefinition, ToolDefinitionSchema, type ToolResultContent, ToolResultContentSchema, type ToolUseContent, ToolUseContentSchema, type Trace, type UpsertComputerUseSessionSummaryInput, type ValidationResult, assessRisk, createLLMFromConfig, getSkillContent, hasContent, isCanonicalComputerUseTool, isComputerUseErrorCode, isDynamicSkill, listCanonicalComputerUseActions, normalizeComputerUseError, resolveCanonicalComputerUseToolName };