agentix-cli 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,2105 @@
+import { z } from 'zod';
+import { PackageJson } from 'type-fest';
+
+interface GenerationMessage {
+    role: "user" | "assistant" | "system";
+    content: string;
+}
+interface GenerationResult {
+    content: string;
+    files: GeneratedFile[];
+    followUp?: string;
+    tokensUsed?: number;
+}
+interface GeneratedFile {
+    path: string;
+    content: string;
+    language?: string;
+    description?: string;
+}
+interface ProviderOptions {
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    apiKey?: string;
+}
+type StreamEvent = {
+    type: "text_delta";
+    text: string;
+} | {
+    type: "tool_use_start";
+    name: string;
+    id: string;
+} | {
+    type: "tool_use_delta";
+    json: string;
+} | {
+    type: "tool_use_end";
+    name: string;
+} | {
+    type: "done";
+    result: GenerationResult;
+} | {
+    type: "error";
+    error: string;
+};
+interface AnthropicMessage {
+    role: "user" | "assistant";
+    content: string | ContentBlock[];
+}
+type ContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+};
+interface RawGenerationResult {
+    content: ContentBlock[];
+    stop_reason: "end_turn" | "tool_use" | "max_tokens" | "stop_sequence";
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+interface AgentProvider {
+    name: string;
+    generate(messages: GenerationMessage[], options?: ProviderOptions): Promise<GenerationResult>;
+    stream?(messages: GenerationMessage[], options?: ProviderOptions): AsyncIterable<StreamEvent>;
+    /** Low-level method returning raw content blocks for the agentic tool_result loop */
+    generateRaw?(messages: AnthropicMessage[], systemPrompt: string, tools: Array<{
+        name: string;
+        description: string;
+        input_schema: Record<string, unknown>;
+    }>, options?: ProviderOptions): Promise<RawGenerationResult>;
+}
+declare const agentConfigSchema$1: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<["claude-code", "claude", "openai", "ollama", "custom"]>>;
+    model: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    output: z.ZodDefault<z.ZodObject<{
+        dir: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        dir: string;
+    }, {
+        dir?: string | undefined;
+    }>>;
+    context7: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        apiKey: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        apiKey?: string | undefined;
+    }, {
+        apiKey?: string | undefined;
+        enabled?: boolean | undefined;
+    }>>;
+    agentic: z.ZodDefault<z.ZodObject<{
+        maxIterations: z.ZodDefault<z.ZodNumber>;
+        enabledTools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        disabledTools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        maxIterations: number;
+        enabledTools: string[];
+        disabledTools: string[];
+    }, {
+        maxIterations?: number | undefined;
+        enabledTools?: string[] | undefined;
+        disabledTools?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    provider: "claude-code" | "claude" | "openai" | "ollama" | "custom";
+    skills: string[];
+    output: {
+        dir: string;
+    };
+    context7: {
+        enabled: boolean;
+        apiKey?: string | undefined;
+    };
+    agentic: {
+        maxIterations: number;
+        enabledTools: string[];
+        disabledTools: string[];
+    };
+    model?: string | undefined;
+    apiKey?: string | undefined;
+}, {
+    provider?: "claude-code" | "claude" | "openai" | "ollama" | "custom" | undefined;
+    model?: string | undefined;
+    apiKey?: string | undefined;
+    skills?: string[] | undefined;
+    output?: {
+        dir?: string | undefined;
+    } | undefined;
+    context7?: {
+        apiKey?: string | undefined;
+        enabled?: boolean | undefined;
+    } | undefined;
+    agentic?: {
+        maxIterations?: number | undefined;
+        enabledTools?: string[] | undefined;
+        disabledTools?: string[] | undefined;
+    } | undefined;
+}>;
+type AgentConfig = z.infer<typeof agentConfigSchema$1>;
+declare const OUTPUT_TYPES: readonly ["component", "page", "api", "website", "document", "script", "config", "skill", "media", "report", "test", "workflow", "schema", "email", "diagram", "auto"];
+type OutputType = (typeof OUTPUT_TYPES)[number];
+declare const outputTypeDescriptions: Record<OutputType, string>;
+
+declare class ClaudeProvider implements AgentProvider {
+    name: string;
+    private apiKey;
+    private authType;
+    constructor(apiKey?: string);
+    generate(messages: GenerationMessage[], options?: ProviderOptions): Promise<GenerationResult>;
+    generateRaw(messages: AnthropicMessage[], systemPrompt: string, tools: Array<{
+        name: string;
+        description: string;
+        input_schema: Record<string, unknown>;
+    }>, options?: ProviderOptions): Promise<RawGenerationResult>;
+    stream(messages: GenerationMessage[], options?: ProviderOptions): AsyncIterable<StreamEvent>;
+    private buildHeaders;
+    private callApi;
+    private parseResponse;
+}
+
+declare class ClaudeCodeProvider implements AgentProvider {
+    name: string;
+    private credential;
+    constructor();
+    generate(messages: GenerationMessage[], options?: ProviderOptions): Promise<GenerationResult>;
+    /**
+     * generateRaw() for the agentic tool_result loop.
+     * Only available for API key auth — the CLI binary has its own agent loop.
+     */
+    generateRaw(messages: AnthropicMessage[], systemPrompt: string, tools: Array<{
+        name: string;
+        description: string;
+        input_schema: Record<string, unknown>;
+    }>, options?: ProviderOptions): Promise<RawGenerationResult>;
+    /**
+     * Returns true if this provider can use the agentic tool loop.
+     * Only available for API key auth (CLI mode falls back to legacy loop).
+     */
+    get supportsAgenticLoop(): boolean;
+    /**
+     * Generate via the `claude` CLI binary.
+     * This is how subscription billing works — the CLI handles auth internally.
+     */
+    private generateViaCli;
+    /**
+     * Generate via direct Anthropic API call (for API key auth).
+     */
+    private generateViaApi;
+    /**
+     * Stream responses. For OAuth, uses CLI with --output-format stream-json.
+     * For API keys, uses SSE streaming.
+     */
+    stream(messages: GenerationMessage[], options?: ProviderOptions): AsyncIterable<StreamEvent>;
+    private streamViaCli;
+    private streamViaApi;
+    /**
+     * Parse JSON output from the `claude` CLI.
+     */
+    private parseCliOutput;
+    /**
+     * Extract file blocks from CLI text output.
+     * Looks for patterns like: ```path/to/file.ts ... ```
+     */
+    private extractFilesFromText;
+    /**
+     * Claude CLI (OAuth/subscription) doesn't always emit structured ask_user tool blocks.
+     * When it's obviously asking for clarification, infer a follow-up question from the tail.
+     */
+    private inferFollowUpFromText;
+    /**
+     * Parse Anthropic API response (tool-use format).
+     */
+    private parseApiResponse;
+}
+
+type ProviderName = "claude-code" | "claude" | "openai" | "ollama" | "custom";
+declare function createProvider(name?: ProviderName, apiKey?: string): AgentProvider;
+
+interface MemoryEntry {
+    id: string;
+    timestamp: number;
+    type: "generation" | "evolution" | "heal" | "skill" | "feedback" | "pattern";
+    task: string;
+    outputType?: string;
+    files: string[];
+    success: boolean;
+    error?: string;
+    userFeedback?: "positive" | "negative" | "neutral";
+    context: {
+        techStack?: string[];
+        frameworks?: string[];
+        skillsUsed?: string[];
+    };
+    metadata?: Record<string, unknown>;
+}
+interface LearnedPattern {
+    id: string;
+    description: string;
+    frequency: number;
+    lastUsed: number;
+    techStack: string[];
+    example?: string;
+}
+interface UserPreference {
+    key: string;
+    value: string;
+    confidence: number;
+    source: string;
+}
+interface MemoryStore {
+    version: number;
+    entries: MemoryEntry[];
+    patterns: LearnedPattern[];
+    preferences: UserPreference[];
+    stats: {
+        totalGenerations: number;
+        successRate: number;
+        totalHeals: number;
+        skillsGenerated: number;
+    };
+}
+declare class Memory {
+    private cwd;
+    private store;
+    private memoryPath;
+    private dirty;
+    constructor(cwd: string);
+    load(): Promise<void>;
+    save(): Promise<void>;
+    recordGeneration(entry: Omit<MemoryEntry, "id" | "timestamp" | "type"> & {
+        type?: MemoryEntry["type"];
+    }): Promise<string>;
+    recordHeal(originalEntryId: string, error: string, fixed: boolean, fixFiles: string[]): Promise<void>;
+    recordFeedback(entryId: string, feedback: "positive" | "negative" | "neutral"): Promise<void>;
+    learnPreference(key: string, value: string, source: string): Promise<void>;
+    getRecentGenerations(limit?: number): MemoryEntry[];
+    getFailedGenerations(limit?: number): MemoryEntry[];
+    getSimilarTasks(task: string, limit?: number): MemoryEntry[];
+    getPatterns(): LearnedPattern[];
+    getPreferences(): UserPreference[];
+    getStats(): MemoryStore["stats"];
+    buildMemoryContext(task: string): string;
+    private extractPattern;
+    private updateSuccessRate;
+    private trimEntries;
+}
+
+interface HealConfig {
+    enabled: boolean;
+    testCommand?: string;
+    buildCommand?: string;
+    lintCommand?: string;
+    maxAttempts: number;
+    provider: ProviderName;
+    model?: string;
+    apiKey?: string;
+}
+interface HealResult {
+    healed: boolean;
+    attempts: number;
+    error: string;
+    fix?: string;
+    filesChanged: string[];
+}
+declare class HealEngine {
+    private cwd;
+    private config;
+    private memory;
+    constructor(cwd: string, config?: Partial<HealConfig>, memory?: Memory);
+    detectAndHeal(generatedFiles: string[], originalTask: string, entryId?: string): Promise<HealResult>;
+    private runVerification;
+    private detectCommands;
+    private generateFix;
+}
+
+interface TechStack {
+    languages: Language[];
+    frameworks: Framework[];
+    packageManager?: string;
+    databases: string[];
+    styling: string[];
+    testing: string[];
+    deployment: string[];
+    monorepo: boolean;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    scripts: Record<string, string>;
+    projectRoot: string;
+    srcDir: string | null;
+    configFiles: string[];
+}
+interface Language {
+    name: string;
+    version?: string;
+    configFile?: string;
+}
+interface Framework {
+    name: string;
+    version?: string;
+    type: "frontend" | "backend" | "fullstack" | "mobile" | "cli" | "library";
+}
+declare function detectTechStack(cwd: string): Promise<TechStack>;
+declare function formatTechStack(stack: TechStack): string;
+
+interface ProjectSchemas {
+    database?: DatabaseSchema;
+    api?: ApiSchema;
+    env?: EnvSchema;
+    models?: ModelFile[];
+}
+interface DatabaseSchema {
+    type: string;
+    content: string;
+    tables?: string[];
+}
+interface ApiSchema {
+    type: string;
+    content: string;
+    endpoints?: string[];
+}
+interface EnvSchema {
+    variables: {
+        key: string;
+        description?: string;
+        required: boolean;
+    }[];
+}
+interface ModelFile {
+    path: string;
+    content: string;
+    type: string;
+}
+declare function detectSchemas(cwd: string): Promise<ProjectSchemas>;
+declare function formatSchemas(schemas: ProjectSchemas): string;
+
+interface WriteResult {
+    written: string[];
+    skipped: string[];
+    errors: string[];
+}
+
+declare const skillFrontmatterSchema: 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">>;
+    globs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        pattern: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        pattern: string;
+        description?: string | undefined;
+    }, {
+        pattern: string;
+        description?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    version?: string | undefined;
+    author?: string | undefined;
+    tags?: string[] | undefined;
+    globs?: string[] | undefined;
+    triggers?: {
+        pattern: string;
+        description?: string | undefined;
+    }[] | undefined;
+}, {
+    name: string;
+    description: string;
+    version?: string | undefined;
+    author?: string | undefined;
+    tags?: string[] | undefined;
+    globs?: string[] | undefined;
+    triggers?: {
+        pattern: string;
+        description?: string | undefined;
+    }[] | undefined;
+}>;
+type SkillFrontmatter = z.infer<typeof skillFrontmatterSchema>;
+interface Skill {
+    frontmatter: SkillFrontmatter;
+    instructions: string;
+    source: "local" | "remote" | "generated";
+    path?: string;
+    packageId?: string;
+}
+interface SkillMatch {
+    skill: Skill;
+    relevance: number;
+    matchReason: string;
+}
+
+interface AgentContext {
+    techStack: TechStack;
+    schemas: ProjectSchemas;
+    skills: Skill[];
+    docs: string;
+    config: AgentConfig;
+    memoryContext: string;
+    projectInstructions: string;
+}
+interface GenerateOptions {
+    task: string;
+    outputType?: OutputType;
+    outputDir?: string;
+    overwrite?: boolean;
+    dryRun?: boolean;
+    provider?: ProviderName;
+    model?: string;
+    apiKey?: string;
+    cwd: string;
+    context7?: boolean;
+    interactive?: boolean;
+    skills?: string[];
+    maxSteps?: number;
+    sessionMessages?: GenerationMessage[];
+    heal?: boolean;
+    healConfig?: {
+        testCommand?: string;
+        buildCommand?: string;
+        lintCommand?: string;
+        maxAttempts?: number;
+    };
+}
+interface GenerateResult {
+    files: WriteResult;
+    content: string;
+    outputType: OutputType;
+    followUp?: string;
+    tokensUsed?: number;
+    healResult?: HealResult;
+}
+declare function createAgentContext(cwd: string, task: string, config?: Partial<AgentConfig>): Promise<AgentContext>;
+declare function generate(options: GenerateOptions): Promise<GenerateResult>;
+type GenerateStreamEvent = StreamEvent | {
+    type: "context_ready";
+    outputType: OutputType;
+} | {
+    type: "step_complete";
+    step: number;
+    filesCount: number;
+} | {
+    type: "tool_call";
+    name: string;
+    id: string;
+} | {
+    type: "tool_result";
+    name: string;
+    id: string;
+    is_error?: boolean;
+} | {
+    type: "iteration";
+    iteration: number;
+} | {
+    type: "generate_result";
+    result: GenerateResult;
+};
+declare function generateStream(options: GenerateOptions): AsyncGenerator<GenerateStreamEvent>;
+
+declare function gatherContext7Docs(stack: TechStack, topic: string, apiKey?: string): Promise<string>;
+
+declare function loadLocalSkills(cwd: string): Promise<Skill[]>;
+declare function parseSkillFile(filePath: string): Promise<Skill | null>;
+declare function parseSkillContent(content: string): Skill | null;
+declare function matchSkillsToTask(skills: Skill[], taskDescription: string, outputType?: string): SkillMatch[];
+
+declare function installSkillPackage(packageId: string, cwd: string): Promise<Skill[]>;
+declare function generateSkillMd(name: string, description: string, instructions: string, tags?: string[], globs?: string[]): Promise<string>;
+declare function listInstalledSkills(cwd: string): Promise<Skill[]>;
+
+declare function generateSkill(provider: AgentProvider, name: string, description: string, techStack: TechStack, options?: {
+    tags?: string[];
+    outputType?: string;
+}): Promise<{
+    skill: Skill;
+    content: string;
+}>;
+
+interface OutputConfig {
+    type: OutputType;
+    baseDir: string;
+    filePatterns: string[];
+    description: string;
+}
+declare const OUTPUT_CONFIGS: Record<string, OutputConfig>;
+declare function resolveOutputType(userHint: string | undefined, taskDescription: string): OutputType;
+
+/**
+ * Get all tool definitions in Anthropic API format (for generateRaw()).
+ * Optionally filter by enabled tool names.
+ */
+declare function getAnthropicTools(enabledTools?: string[]): Array<{
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}>;
+/**
+ * Get the legacy tools (create_files + ask_user) for backward compatibility.
+ */
+declare function getLegacyTools(): Array<{
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}>;
+/**
+ * Format tool descriptions for inclusion in a system prompt.
+ * Used when the `claude` CLI binary handles its own tools —
+ * we describe our additional tools as text so the binary's built-in
+ * capabilities (read, write, bash) handle them natively.
+ */
+declare function formatToolsForSystemPrompt(): string;
+declare const ALL_TOOL_NAMES: string[];
+
+interface ToolCallInput {
+    name: string;
+    id: string;
+    input: Record<string, unknown>;
+}
+interface ToolResult {
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+    /** Files collected from create_files calls */
+    files?: GeneratedFile[];
+    /** Question from ask_user calls */
+    followUp?: string;
+}
+interface ToolExecutorOptions {
+    interactive?: boolean;
+    overwrite?: boolean;
+    dryRun?: boolean;
+}
+declare class ToolExecutor {
+    private cwd;
+    private options;
+    constructor(cwd: string, options?: ToolExecutorOptions);
+    execute(call: ToolCallInput): Promise<ToolResult>;
+    private readFile;
+    private searchFiles;
+    private listDirectory;
+    private runCommand;
+    private editFile;
+    private createFiles;
+    private askUser;
+}
+
+interface EnhanceConfig {
+    enabled: boolean;
+    autoSkills: boolean;
+    minFrequency: number;
+    provider: ProviderName;
+    model?: string;
+    apiKey?: string;
+}
+interface EnhanceResult {
+    skillsCreated: string[];
+    skillsUpdated: string[];
+    insights: string[];
+}
+declare class EnhanceEngine {
+    private cwd;
+    private memory;
+    private config;
+    constructor(cwd: string, memory: Memory, config?: Partial<EnhanceConfig>);
+    enhance(): Promise<EnhanceResult>;
+    private createSkillsFromPatterns;
+    private generateSkillFromPattern;
+    private analyzeFailures;
+    private analyzePreferences;
+}
+
+interface PipelineRequest {
+    id: string;
+    task: string;
+    outputType?: string;
+    outputDir?: string;
+    provider?: string;
+    model?: string;
+    apiKey?: string;
+    cwd: string;
+    overwrite?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface PipelineResponse {
+    id: string;
+    success: boolean;
+    files: {
+        path: string;
+        content?: string;
+    }[];
+    content: string;
+    outputType: string;
+    error?: string;
+    healed?: boolean;
+    healAttempts?: number;
+    tokensUsed?: number;
+    memoryEntryId?: string;
+    insights?: string[];
+    duration: number;
+}
+type MiddlewareFn = (req: PipelineRequest, res: PipelineResponse, context: PipelineContext, next: () => Promise<void>) => Promise<void>;
+interface PipelineContext {
+    agentContext?: AgentContext;
+    memory?: Memory;
+    startTime: number;
+    [key: string]: unknown;
+}
+declare class Pipeline {
+    private middleware;
+    use(name: string, fn: MiddlewareFn): Pipeline;
+    execute(req: PipelineRequest): Promise<PipelineResponse>;
+    getMiddlewareNames(): string[];
+}
+
+interface RuntimeConfig {
+    port: number;
+    host: string;
+    provider: ProviderName;
+    model?: string;
+    apiKey?: string;
+    cwd: string;
+    memory: {
+        enabled: boolean;
+    };
+    heal: {
+        enabled: boolean;
+        testCommand?: string;
+        buildCommand?: string;
+    };
+    enhance: {
+        enabled: boolean;
+        autoSkills: boolean;
+    };
+    cors: boolean;
+}
+declare class AgentXRuntime {
+    private config;
+    private memory;
+    private healEngine;
+    private enhanceEngine;
+    private pipeline;
+    private requestCount;
+    private log;
+    constructor(config?: Partial<RuntimeConfig>);
+    private buildPipeline;
+    start(): Promise<void>;
+    private handleRequest;
+    private handleGenerate;
+    private handleEvolve;
+    private handleInspect;
+    private handleMemory;
+    private handleFeedback;
+    private handleEnhance;
+    private memoryMiddleware;
+    private contextMiddleware;
+    private generateMiddleware;
+    private healMiddleware;
+    private recordMiddleware;
+    private enhanceMiddleware;
+    private sendJson;
+}
+
+declare function startMcpServer(): Promise<void>;
+
+declare class MemoryHierarchy {
+    private cwd;
+    private userMemory;
+    private projectMemory;
+    constructor(cwd: string);
+    load(): Promise<void>;
+    save(): Promise<void>;
+    /**
+     * Build merged memory context for the agent. Project overrides user.
+     */
+    buildMemoryContext(task: string): string;
+    /**
+     * Learn a preference at user level (global).
+     */
+    learnPreference(key: string, value: string, source: string): Promise<void>;
+    /**
+     * Record a generation at project level (task-specific).
+     */
+    recordGeneration(entry: Omit<MemoryEntry, "id" | "timestamp" | "type"> & {
+        type?: MemoryEntry["type"];
+    }): Promise<string>;
+    /**
+     * Get combined preferences (project overrides user for same keys).
+     */
+    getPreferences(): UserPreference[];
+    /**
+     * Get combined patterns from both levels.
+     */
+    getPatterns(): LearnedPattern[];
+    /**
+     * Get stats from both levels.
+     */
+    getStats(): {
+        user: MemoryStore["stats"];
+        project: MemoryStore["stats"];
+    };
+    /**
+     * Get recent generations from project level.
+     */
+    getRecentGenerations(limit?: number): MemoryEntry[];
+}
+
+/**
+ * Resolve @-imports in content: replace @path/to/file with file contents.
+ */
+declare function resolveAtImports(content: string, basedir: string): string;
+/**
+ * Load project instructions from SHADXN.md or CLAUDE.md.
+ */
+declare function loadProjectInstructions(cwd: string): string;
+declare class ContextBuilder {
+    private sections;
+    addSection(label: string, content: string, priority?: number): void;
+    /**
+     * Build final context, trimming lowest-relevance sections if over budget.
+     */
+    buildContext(task: string, maxTokens?: number): string;
+}
+
+interface StepUsage {
+    step: number;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cost: number;
+    timestamp: number;
+}
+interface ModelUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cost: number;
+    steps: number;
+}
+interface UsageSummary {
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalTokens: number;
+    totalCost: number;
+    steps: StepUsage[];
+    models: Record<string, ModelUsage>;
+}
+declare class UsageTracker {
+    private steps;
+    private models;
+    recordStep(step: number, model: string, inputTokens: number, outputTokens: number): void;
+    getSummary(): UsageSummary;
+    reset(): void;
+}
+declare const globalTracker: UsageTracker;
+
+declare function setDebug(enabled: boolean): void;
+declare function isDebug(): boolean;
+declare const debug: {
+    log(...args: unknown[]): void;
+    step(step: number, message: string): void;
+    hook(name: string, duration: number, result: string): void;
+    api(method: string, model: string, tokens?: number): void;
+    tokens(input: number, output: number, cost: number): void;
+    context(label: string, detail: string): void;
+};
+
+interface Session {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    cwd: string;
+    messages: GenerationMessage[];
+    tokensUsed: number;
+    filesGenerated: string[];
+}
+/**
+ * Create a new session.
+ */
+declare function createSession(cwd: string): Session;
+/**
+ * Save a session to disk.
+ */
+declare function saveSession(session: Session): void;
+/**
+ * Load a session from disk.
+ */
+declare function loadSession(id: string): Session | null;
+/**
+ * Load the most recent session.
+ */
+declare function loadLatestSession(): Session | null;
+/**
+ * List all saved sessions.
+ */
+declare function listSessions(): Session[];
+
+declare function exportSession(session: Session, usage?: UsageSummary): string;
+
+declare const PERMISSION_MODES: readonly ["default", "acceptEdits", "plan", "yolo"];
+type PermissionMode = (typeof PERMISSION_MODES)[number];
+declare const permissionModeSchema: z.ZodEnum<["default", "acceptEdits", "plan", "yolo"]>;
+interface PermissionRule {
+    pattern: string;
+    action: "allow" | "deny" | "confirm";
+}
+declare const permissionConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<["default", "acceptEdits", "plan", "yolo"]>>;
+    allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    deny: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    confirm: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    confirm: string[];
+    allow: string[];
+    deny: string[];
+    mode: "default" | "acceptEdits" | "plan" | "yolo";
+}, {
+    confirm?: string[] | undefined;
+    allow?: string[] | undefined;
+    deny?: string[] | undefined;
+    mode?: "default" | "acceptEdits" | "plan" | "yolo" | undefined;
+}>;
+type PermissionConfig = z.infer<typeof permissionConfigSchema>;
+
+type PermissionAction = "allow" | "deny" | "skip";
+declare class PermissionManager {
+    private mode;
+    private allowPatterns;
+    private denyPatterns;
+    private confirmPatterns;
+    private autoAllowAll;
+    constructor(config?: Partial<PermissionConfig>);
+    getMode(): PermissionMode;
+    setMode(mode: PermissionMode): void;
+    /**
+     * Check whether a file write should proceed.
+     */
+    checkFileWrite(filePath: string): Promise<PermissionAction>;
+    /**
+     * Check whether a command should proceed (for pre:command hook).
+     */
+    checkCommand(command: string): Promise<"allow" | "deny">;
+    private matchesAny;
+    private promptUser;
+}
+declare const globalPermissions: PermissionManager;
+
+declare const HOOK_EVENTS: readonly ["pre:generate", "post:generate", "pre:file-write", "post:file-write", "pre:prompt", "post:response", "pre:command", "on:error", "pre:tool-call", "post:tool-call", "pre:channel-message", "post:channel-message", "pre:a2a-task", "pre:cron-run", "post:cron-run"];
+type HookEvent = (typeof HOOK_EVENTS)[number];
+declare const BLOCKING_EVENTS: HookEvent[];
+declare const hookDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<["command", "prompt", "script"]>;
+    command: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodEnum<["claude-code", "claude", "openai", "ollama", "custom"]>>;
+    model: z.ZodOptional<z.ZodString>;
+    script: z.ZodOptional<z.ZodString>;
+    priority: z.ZodDefault<z.ZodNumber>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "script" | "command" | "prompt";
+    enabled: boolean;
+    name: string;
+    priority: number;
+    provider?: "claude-code" | "claude" | "openai" | "ollama" | "custom" | undefined;
+    model?: string | undefined;
+    script?: string | undefined;
+    command?: string | undefined;
+    prompt?: string | undefined;
+}, {
+    type: "script" | "command" | "prompt";
+    name: string;
+    provider?: "claude-code" | "claude" | "openai" | "ollama" | "custom" | undefined;
+    model?: string | undefined;
+    enabled?: boolean | undefined;
+    script?: string | undefined;
+    command?: string | undefined;
+    prompt?: string | undefined;
+    priority?: number | undefined;
+}>;
+type HookDefinition = z.infer<typeof hookDefinitionSchema>;
+interface HookContext {
+    event: HookEvent;
+    task?: string;
+    file?: string;
+    fileContent?: string;
+    content?: string;
+    command?: string;
+    error?: Error;
+    cwd?: string;
+    [key: string]: unknown;
+}
+interface HookResult {
+    blocked?: boolean;
+    message?: string;
+    modified?: Record<string, unknown>;
+}
+type HookHandler = (context: HookContext) => Promise<HookResult>;
+
+declare class HookRegistry {
+    private hooks;
+    /**
+     * Register a hook for an event.
+     */
+    register(event: HookEvent, definition: HookDefinition): void;
+    /**
+     * Execute all hooks for an event. Returns combined result.
+     * For blocking events, stops at the first hook that returns { blocked: true }.
+     */
+    execute(event: HookEvent, context: HookContext): Promise<HookResult>;
+    /**
+     * Check if any hooks are registered for an event.
+     */
+    has(event: HookEvent): boolean;
+    /**
+     * Clear all hooks (useful for testing).
+     */
+    clear(): void;
+    /**
+     * Create a HookHandler from a HookDefinition.
+     */
+    private createHandler;
+    /**
+     * Command hook: runs a shell command with {{variable}} interpolation.
+     * Exit code 0 = success, non-zero = blocked (for blocking events).
+     */
+    private createCommandHandler;
+    /**
+     * Script hook: imports and runs a JS/TS module that exports a handler function.
+     */
+    private createScriptHandler;
+    /**
+     * Prompt hook: single-turn LLM call that can block or modify the operation.
+     * The prompt template supports {{variable}} interpolation from hook context.
+     * The LLM must respond with JSON: { "action": "allow"|"block", "message": "...", "modified": {...} }
+     */
+    private createPromptHandler;
+}
+
+/**
+ * Load hooks from agentx.config.json and .agentx/hooks/ directory.
+ */
+declare function loadHooks(cwd: string, registry: HookRegistry): void;
+
+declare const globalHooks: HookRegistry;
+
+interface GitStatus {
+    staged: string[];
+    modified: string[];
+    untracked: string[];
+    deleted: string[];
+    branch: string;
+    isClean: boolean;
+}
+interface GitLogEntry {
+    hash: string;
+    shortHash: string;
+    message: string;
+    author: string;
+    date: string;
+}
+interface GitDiffFile {
+    path: string;
+    status: "added" | "modified" | "deleted" | "renamed";
+    additions: number;
+    deletions: number;
+}
+interface GitCommitResult {
+    hash: string;
+    message: string;
+    filesChanged: number;
+}
+
+declare class GitManager {
+    private cwd;
+    constructor(cwd: string);
+    /**
+     * Check if the current directory is a git repository.
+     */
+    isRepo(): Promise<boolean>;
+    /**
+     * Get current git status.
+     */
+    status(): Promise<GitStatus>;
+    /**
+     * Get git diff (staged or unstaged).
+     */
+    diff(staged?: boolean): Promise<string>;
+    /**
+     * Get diff summary with file-level stats.
+     */
+    diffStat(staged?: boolean): Promise<GitDiffFile[]>;
+    /**
+     * Get recent git log entries.
+     */
+    log(count?: number): Promise<GitLogEntry[]>;
+    /**
+     * Stage files.
+     */
+    add(files: string[]): Promise<void>;
+    /**
+     * Stage all changes.
+     */
+    addAll(): Promise<void>;
+    /**
+     * Commit with a message.
+     */
+    commit(message: string): Promise<GitCommitResult>;
+    /**
+     * Get current branch name.
+     */
+    currentBranch(): Promise<string>;
+    /**
+     * Create and switch to a new branch.
+     */
+    createBranch(name: string): Promise<void>;
+    /**
+     * Switch to an existing branch.
+     */
+    checkout(name: string): Promise<void>;
+    /**
+     * Stash current changes.
+     */
+    stash(message?: string): Promise<void>;
+    /**
+     * Pop the latest stash.
+     */
+    stashPop(): Promise<void>;
+    /**
+     * Generate an AI commit message from staged changes.
+     * Returns a conventional commit message based on the diff.
+     */
+    generateCommitMessage(provider?: {
+        generate: (messages: any[], options?: any) => Promise<any>;
+    }): Promise<string>;
+    private fallbackCommitMessage;
+}
+
+interface ReplOptions {
+    cwd: string;
+    provider?: string;
+    model?: string;
+    apiKey?: string;
+    resume?: boolean;
+    sessionId?: string;
+    version: string;
+}
+declare class ReplEngine {
+    private rl;
+    private session;
+    private options;
+    private running;
+    constructor(options: ReplOptions);
+    /**
+     * Start the REPL loop.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the REPL and save session.
+     */
+    private stop;
+    /**
+     * Handle a slash command.
+     */
+    private handleCommand;
+    /**
+     * Handle a natural language generation prompt.
+     * Uses streaming to render text in real-time instead of blocking with a spinner.
+     */
+    private handleGeneration;
+}
+
+interface CommandContext {
+    session: Session;
+    cwd: string;
+    onSessionChange: (session: Session) => void;
+}
+type SlashCommandHandler = (args: string, ctx: CommandContext) => Promise<boolean>;
+declare function registerCommand(name: string, handler: SlashCommandHandler): void;
+declare function getCommand(name: string): SlashCommandHandler | undefined;
+declare function isCommand(input: string): boolean;
+declare function parseCommand(input: string): {
+    name: string;
+    args: string;
+};
+
+interface A2AServerConfig {
+    port: number;
+    host: string;
+    provider: ProviderName;
+    model?: string;
+    apiKey?: string;
+    cwd: string;
+    cors: boolean;
+}
+declare class A2AServer {
+    private config;
+    private tasks;
+    private activeCancellations;
+    private log;
+    constructor(config?: Partial<A2AServerConfig>);
+    start(): Promise<void>;
+    private getAgentCard;
+    private handleRequest;
+    private handleJsonRpc;
+    private handleTaskSend;
+    private handleTaskSendSubscribe;
+    private handleTaskGet;
+    private handleTaskCancel;
+    private sendJson;
+    private sendJsonRpc;
+}
+
+interface AgentCard {
+    name: string;
+    description: string;
+    url: string;
+    version: string;
+    capabilities: {
+        streaming: boolean;
+        pushNotifications: boolean;
+        stateTransitionHistory: boolean;
+    };
+    skills: AgentSkill[];
+    defaultInputModes: string[];
+    defaultOutputModes: string[];
+}
+interface AgentSkill {
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    examples?: string[];
+}
+type TaskState = "submitted" | "working" | "input-required" | "completed" | "failed" | "canceled";
+interface Task {
+    id: string;
+    state: TaskState;
+    messages: TaskMessage[];
+    artifacts: TaskArtifact[];
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface TaskMessage {
+    role: "user" | "agent";
+    parts: MessagePart[];
+}
+type MessagePart = TextPart | FilePart | DataPart;
+interface TextPart {
+    type: "text";
+    text: string;
+}
+interface FilePart {
+    type: "file";
+    file: {
+        name: string;
+        mimeType?: string;
+        bytes?: string;
+        uri?: string;
+    };
+}
+interface DataPart {
+    type: "data";
+    data: Record<string, unknown>;
+}
+interface TaskArtifact {
+    name: string;
+    description?: string;
+    parts: MessagePart[];
+    index: number;
+}
+interface TaskStatusUpdate {
+    id: string;
+    state: TaskState;
+    message?: TaskMessage;
+    artifact?: TaskArtifact;
+    final: boolean;
+    metadata?: Record<string, unknown>;
+}
+
+declare class A2AClient {
+    private baseUrl;
+    private token?;
+    constructor(baseUrl: string, token?: string);
+    /**
+     * Fetch the remote agent's card.
+     */
+    getAgentCard(): Promise<AgentCard>;
+    /**
+     * Send a task synchronously and wait for completion.
+     */
+    sendTask(text: string, metadata?: Record<string, unknown>): Promise<Task>;
+    /**
+     * Send a task with SSE streaming.
+     */
+    sendTaskStream(text: string, metadata?: Record<string, unknown>): AsyncIterable<{
+        state: string;
+        message?: string;
+        final: boolean;
+    }>;
+    /**
+     * Get task status by ID.
+     */
+    getTask(taskId: string): Promise<Task>;
+    /**
+     * Cancel a running task.
+     */
+    cancelTask(taskId: string): Promise<Task>;
+    private rpc;
+    private headers;
+}
+
+declare const agentConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    workspace: z.ZodString;
+    tier: z.ZodDefault<z.ZodEnum<["claude-code", "sdk", "orchestrator"]>>;
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    mentions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    maxConcurrent: z.ZodDefault<z.ZodNumber>;
+    permissionMode: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    workspace: string;
+    tier: "claude-code" | "sdk" | "orchestrator";
+    mentions: string[];
+    maxConcurrent: number;
+    permissionMode: string;
+    provider?: string | undefined;
+    model?: string | undefined;
+    systemPrompt?: string | undefined;
+}, {
+    name: string;
+    workspace: string;
+    provider?: string | undefined;
+    model?: string | undefined;
+    systemPrompt?: string | undefined;
+    tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
+    mentions?: string[] | undefined;
+    maxConcurrent?: number | undefined;
+    permissionMode?: string | undefined;
+}>;
+declare const cronJobSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    schedule: z.ZodString;
+    timezone: z.ZodDefault<z.ZodString>;
+    agent: z.ZodString;
+    prompt: z.ZodString;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    model: z.ZodOptional<z.ZodString>;
+    onError: z.ZodDefault<z.ZodEnum<["log", "notify", "disable"]>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    agent: string;
+    timeout: number;
+    prompt: string;
+    schedule: string;
+    timezone: string;
+    onError: "log" | "notify" | "disable";
+    model?: string | undefined;
+}, {
+    agent: string;
+    prompt: string;
+    schedule: string;
+    model?: string | undefined;
+    enabled?: boolean | undefined;
+    timeout?: number | undefined;
+    timezone?: string | undefined;
+    onError?: "log" | "notify" | "disable" | undefined;
+}>;
+declare const meshPeerSchema: z.ZodObject<{
+    url: z.ZodString;
+    name: z.ZodString;
+    token: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    url: string;
+    token?: string | undefined;
+}, {
+    name: string;
+    url: string;
+    token?: string | undefined;
+}>;
+declare const daemonConfigSchema: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        bind: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        bind: string;
+    }, {
+        id: string;
+        name: string;
+        bind?: string | undefined;
+    }>;
+    providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        apiKey: z.ZodOptional<z.ZodString>;
+        defaultModel: z.ZodOptional<z.ZodString>;
+        baseUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        apiKey?: string | undefined;
+        defaultModel?: string | undefined;
+        baseUrl?: string | undefined;
+    }, {
+        apiKey?: string | undefined;
+        defaultModel?: string | undefined;
+        baseUrl?: string | undefined;
+    }>>>;
+    agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        workspace: z.ZodString;
+        tier: z.ZodDefault<z.ZodEnum<["claude-code", "sdk", "orchestrator"]>>;
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        mentions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        maxConcurrent: z.ZodDefault<z.ZodNumber>;
+        permissionMode: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        workspace: string;
+        tier: "claude-code" | "sdk" | "orchestrator";
+        mentions: string[];
+        maxConcurrent: number;
+        permissionMode: string;
+        provider?: string | undefined;
+        model?: string | undefined;
+        systemPrompt?: string | undefined;
+    }, {
+        name: string;
+        workspace: string;
+        provider?: string | undefined;
+        model?: string | undefined;
+        systemPrompt?: string | undefined;
+        tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
+        mentions?: string[] | undefined;
+        maxConcurrent?: number | undefined;
+        permissionMode?: string | undefined;
+    }>>>;
+    channels: z.ZodDefault<z.ZodObject<{
+        telegram: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            accounts: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                token: z.ZodString;
+                agentBinding: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                token: string;
+                agentBinding: string;
+            }, {
+                token: string;
+                agentBinding: string;
+            }>>>;
+            policy: z.ZodDefault<z.ZodObject<{
+                dm: z.ZodDefault<z.ZodEnum<["pair", "block"]>>;
+                group: z.ZodDefault<z.ZodEnum<["mention-required", "all"]>>;
+            }, "strip", z.ZodTypeAny, {
+                dm: "block" | "pair";
+                group: "all" | "mention-required";
+            }, {
+                dm?: "block" | "pair" | undefined;
+                group?: "all" | "mention-required" | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            accounts: Record<string, {
+                token: string;
+                agentBinding: string;
+            }>;
+            policy: {
+                dm: "block" | "pair";
+                group: "all" | "mention-required";
+            };
+        }, {
+            enabled?: boolean | undefined;
+            accounts?: Record<string, {
+                token: string;
+                agentBinding: string;
+            }> | undefined;
+            policy?: {
+                dm?: "block" | "pair" | undefined;
+                group?: "all" | "mention-required" | undefined;
+            } | undefined;
+        }>>;
+        whatsapp: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            sessionDir: z.ZodDefault<z.ZodString>;
+            agentBinding: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            sessionDir: string;
+            agentBinding?: string | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            agentBinding?: string | undefined;
+            sessionDir?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        telegram: {
+            enabled: boolean;
+            accounts: Record<string, {
+                token: string;
+                agentBinding: string;
+            }>;
+            policy: {
+                dm: "block" | "pair";
+                group: "all" | "mention-required";
+            };
+        };
+        whatsapp: {
+            enabled: boolean;
+            sessionDir: string;
+            agentBinding?: string | undefined;
+        };
+    }, {
+        telegram?: {
+            enabled?: boolean | undefined;
+            accounts?: Record<string, {
+                token: string;
+                agentBinding: string;
+            }> | undefined;
+            policy?: {
+                dm?: "block" | "pair" | undefined;
+                group?: "all" | "mention-required" | undefined;
+            } | undefined;
+        } | undefined;
+        whatsapp?: {
+            enabled?: boolean | undefined;
+            agentBinding?: string | undefined;
+            sessionDir?: string | undefined;
+        } | undefined;
+    }>>;
+    crons: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        schedule: z.ZodString;
+        timezone: z.ZodDefault<z.ZodString>;
+        agent: z.ZodString;
+        prompt: z.ZodString;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodString>;
+        onError: z.ZodDefault<z.ZodEnum<["log", "notify", "disable"]>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        agent: string;
+        timeout: number;
+        prompt: string;
+        schedule: string;
+        timezone: string;
+        onError: "log" | "notify" | "disable";
+        model?: string | undefined;
+    }, {
+        agent: string;
+        prompt: string;
+        schedule: string;
+        model?: string | undefined;
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+        timezone?: string | undefined;
+        onError?: "log" | "notify" | "disable" | undefined;
+    }>>>;
+    mesh: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        peers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            name: z.ZodString;
+            token: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }, {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }>, "many">>;
+        discovery: z.ZodDefault<z.ZodEnum<["static", "mdns"]>>;
+        healthCheck: z.ZodDefault<z.ZodObject<{
+            interval: z.ZodDefault<z.ZodNumber>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            timeout: number;
+            interval: number;
+        }, {
+            timeout?: number | undefined;
+            interval?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        peers: {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }[];
+        discovery: "static" | "mdns";
+        healthCheck: {
+            timeout: number;
+            interval: number;
+        };
+    }, {
+        enabled?: boolean | undefined;
+        peers?: {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }[] | undefined;
+        discovery?: "static" | "mdns" | undefined;
+        healthCheck?: {
+            timeout?: number | undefined;
+            interval?: number | undefined;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    agents: Record<string, {
+        name: string;
+        workspace: string;
+        tier: "claude-code" | "sdk" | "orchestrator";
+        mentions: string[];
+        maxConcurrent: number;
+        permissionMode: string;
+        provider?: string | undefined;
+        model?: string | undefined;
+        systemPrompt?: string | undefined;
+    }>;
+    node: {
+        id: string;
+        name: string;
+        bind: string;
+    };
+    providers: Record<string, {
+        apiKey?: string | undefined;
+        defaultModel?: string | undefined;
+        baseUrl?: string | undefined;
+    }>;
+    channels: {
+        telegram: {
+            enabled: boolean;
+            accounts: Record<string, {
+                token: string;
+                agentBinding: string;
+            }>;
+            policy: {
+                dm: "block" | "pair";
+                group: "all" | "mention-required";
+            };
+        };
+        whatsapp: {
+            enabled: boolean;
+            sessionDir: string;
+            agentBinding?: string | undefined;
+        };
+    };
+    crons: Record<string, {
+        enabled: boolean;
+        agent: string;
+        timeout: number;
+        prompt: string;
+        schedule: string;
+        timezone: string;
+        onError: "log" | "notify" | "disable";
+        model?: string | undefined;
+    }>;
+    mesh: {
+        enabled: boolean;
+        peers: {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }[];
+        discovery: "static" | "mdns";
+        healthCheck: {
+            timeout: number;
+            interval: number;
+        };
+    };
+}, {
+    node: {
+        id: string;
+        name: string;
+        bind?: string | undefined;
+    };
+    agents?: Record<string, {
+        name: string;
+        workspace: string;
+        provider?: string | undefined;
+        model?: string | undefined;
+        systemPrompt?: string | undefined;
+        tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
+        mentions?: string[] | undefined;
+        maxConcurrent?: number | undefined;
+        permissionMode?: string | undefined;
+    }> | undefined;
+    providers?: Record<string, {
+        apiKey?: string | undefined;
+        defaultModel?: string | undefined;
+        baseUrl?: string | undefined;
+    }> | undefined;
+    channels?: {
+        telegram?: {
+            enabled?: boolean | undefined;
+            accounts?: Record<string, {
+                token: string;
+                agentBinding: string;
+            }> | undefined;
+            policy?: {
+                dm?: "block" | "pair" | undefined;
+                group?: "all" | "mention-required" | undefined;
+            } | undefined;
+        } | undefined;
+        whatsapp?: {
+            enabled?: boolean | undefined;
+            agentBinding?: string | undefined;
+            sessionDir?: string | undefined;
+        } | undefined;
+    } | undefined;
+    crons?: Record<string, {
+        agent: string;
+        prompt: string;
+        schedule: string;
+        model?: string | undefined;
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+        timezone?: string | undefined;
+        onError?: "log" | "notify" | "disable" | undefined;
+    }> | undefined;
+    mesh?: {
+        enabled?: boolean | undefined;
+        peers?: {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }[] | undefined;
+        discovery?: "static" | "mdns" | undefined;
+        healthCheck?: {
+            timeout?: number | undefined;
+            interval?: number | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+type DaemonConfig = z.infer<typeof daemonConfigSchema>;
+type AgentDef = z.infer<typeof agentConfigSchema>;
+type CronJobDef = z.infer<typeof cronJobSchema>;
+type MeshPeer = z.infer<typeof meshPeerSchema>;
+/**
+ * Load daemon config from agentx.json, with env var expansion and validation.
+ */
+declare function loadDaemonConfig(configPath?: string): DaemonConfig;
+/**
+ * Validate agent workspace directories exist and have .claude/ setup.
+ */
+declare function validateWorkspaces(config: DaemonConfig): string[];
+
+interface PeerState {
+    peer: MeshPeer;
+    client: A2AClient;
+    healthy: boolean;
+    lastCheck?: Date;
+    agentCard?: AgentCard;
+    agents: AgentSkill[];
+}
+declare class A2AMesh {
+    private peers;
+    private healthTimer?;
+    private config;
+    private log;
+    constructor(config: DaemonConfig, log?: (...args: unknown[]) => void);
+    /**
+     * Start the mesh: discover peers and begin health checks.
+     */
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Discover agent cards from all peers.
+     */
+    discoverAll(): Promise<void>;
+    private discoverPeer;
+    /**
+     * Send a task to a remote peer by name.
+     * Uses the peer's /task HTTP endpoint (agentx daemon API).
+     * If no agent specified, uses the first available agent on the peer.
+     */
+    sendTask(peerName: string, text: string, agentId?: string): Promise<string>;
+    /**
+     * Find a peer that has a specific skill.
+     */
+    findPeerWithSkill(skillId: string): PeerState | undefined;
+    /**
+     * Get the combined agent directory across all healthy peers.
+     */
+    directory(): Array<{
+        peer: string;
+        peerUrl: string;
+        healthy: boolean;
+        skills: AgentSkill[];
+        lastCheck?: Date;
+    }>;
+}
+
+declare class AgentXDaemon {
+    private config;
+    private registry;
+    private router;
+    private cron;
+    private mesh?;
+    private hooks;
+    private httpServer?;
+    private log;
+    constructor(configPath?: string);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private startChannels;
+    private startHttpApi;
+    private handleHttp;
+    private json;
+}
+
+interface AgentPeer {
+    id: string;
+    name: string;
+    handle?: string;
+    role?: string;
+}
+interface AgentTask {
+    message: string;
+    agentId: string;
+    context?: {
+        channel?: string;
+        sender?: string;
+        group?: string;
+        conversationHistory?: Array<{
+            role: string;
+            content: string;
+        }>;
+        /** This agent's own handle on the current channel */
+        myHandle?: string;
+        /** Other available agents and their handles */
+        peers?: AgentPeer[];
+    };
+}
+interface AgentResponse {
+    content: string;
+    error?: string;
+    tokensUsed?: number;
+    duration?: number;
+    claudeSessionId?: string;
+}
+/** Callback for streaming text deltas */
+type StreamCallback = (delta: string, fullText: string) => void;
+/**
+ * Execute a task using the Claude Code CLI (tier: "claude-code").
+ * Non-streaming — waits for full response.
+ */
+declare function executeClaudeCode(agent: AgentDef, task: AgentTask, historyContext?: string, resumeSessionId?: string): Promise<AgentResponse>;
+/**
+ * Execute a task using the Claude Agent SDK (tier: "sdk").
+ */
+declare function executeSdk(agent: AgentDef, task: AgentTask, apiKey: string): Promise<AgentResponse>;
+/**
+ * Execute a task using agentx's own orchestrator (tier: "orchestrator").
+ */
+declare function executeOrchestrator(agent: AgentDef, task: AgentTask, apiKey?: string): Promise<AgentResponse>;
+/**
+ * Route a task to the correct execution tier.
+ */
+declare function executeTask(agent: AgentDef, task: AgentTask, providers: Record<string, {
+    apiKey?: string;
+}>, onDelta?: StreamCallback, historyContext?: string, resumeSessionId?: string): Promise<AgentResponse>;
+
+declare class AgentRegistry {
+    private agents;
+    private config;
+    private providers;
+    private sessions;
+    private log;
+    constructor(config: DaemonConfig, log?: (...args: unknown[]) => void);
+    /**
+     * Get agent definition by ID.
+     */
+    getAgent(id: string): AgentDef | undefined;
+    /**
+     * Find agent by mention pattern (e.g., "@nadia" -> "marketing-agent").
+     * Returns the agent with the longest (most specific) mention match.
+     */
+    findByMention(text: string): string | undefined;
+    /**
+     * Find ALL agents mentioned in text (for bot-to-bot detection).
+     */
+    findAllMentioned(text: string): string[];
+    /**
+     * Get the primary channel handle for an agent (e.g. "@noqta_devops_bot" on telegram).
+     */
+    private getChannelHandle;
+    /**
+     * Enrich the task context with peer roster and channel handles.
+     */
+    private enrichTaskContext;
+    /**
+     * Execute a task on an agent. Respects maxConcurrent limit.
+     */
+    execute(task: AgentTask, onDelta?: StreamCallback): Promise<AgentResponse>;
+    /**
+     * List all agents and their status.
+     */
+    list(): Array<{
+        id: string;
+        name: string;
+        tier: string;
+        workspace: string;
+        active: number;
+        total: number;
+        errors: number;
+        lastActive?: Date;
+    }>;
+}
+
+interface IncomingMessage {
+    id: string;
+    channel: string;
+    accountId: string;
+    sender: {
+        id: string;
+        name: string;
+        username?: string;
+    };
+    group?: {
+        id: string;
+        name: string;
+    };
+    text: string;
+    replyTo?: string;
+    timestamp: Date;
+    raw?: unknown;
+}
+interface OutgoingMessage {
+    channel: string;
+    chatId: string;
+    text: string;
+    replyTo?: string;
+    parseMode?: "markdown" | "html" | "plain";
+}
+interface ChannelAdapter {
+    readonly name: string;
+    /** Start polling or webhook listener */
+    start(): Promise<void>;
+    /** Stop the adapter gracefully */
+    stop(): Promise<void>;
+    /** Send a message back to a chat */
+    send(msg: OutgoingMessage): Promise<string | void>;
+    /** Edit an existing message (returns false if not supported) */
+    editMessage?(chatId: string, messageId: string, text: string, parseMode?: string): Promise<boolean>;
+    /** Send typing/action indicator */
+    sendTyping?(chatId: string): Promise<void>;
+    /** React to a message with an emoji (e.g., 👀 for seen) */
+    react?(chatId: string, messageId: string, emoji?: string): Promise<void>;
+    /** Register handler for incoming messages */
+    onMessage(handler: (msg: IncomingMessage) => Promise<void>): void;
+}
+
+declare class MessageRouter {
+    private registry;
+    private config;
+    private channels;
+    private hooks?;
+    private log;
+    constructor(registry: AgentRegistry, config: DaemonConfig, hooks?: HookRegistry, log?: (...args: unknown[]) => void);
+    addChannel(adapter: ChannelAdapter): void;
+    startAll(): Promise<void>;
+    stopAll(): Promise<void>;
+    private handleMessage;
+    /**
+     * Check if an agent's response mentions another agent.
+     * If so, route the response as a new task to that agent.
+     */
+    private handleBotToBotMentions;
+    private adapterSend;
+    private adapterEdit;
+    private adapterReact;
+    private startTypingLoop;
+    private getAccountForAgent;
+    private resolveAgent;
+}
+
+interface TelegramAccountConfig {
+    token: string;
+    agentBinding: string;
+}
+declare class TelegramAdapter implements ChannelAdapter {
+    readonly name = "telegram";
+    private accounts;
+    private offsets;
+    private handler?;
+    private polling;
+    private log;
+    constructor(accounts: Record<string, TelegramAccountConfig>, log?: (...args: unknown[]) => void);
+    onMessage(handler: (msg: IncomingMessage) => Promise<void>): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Get token for a specific account ID. Used by router to send from correct bot.
+     */
+    getTokenForAccount(accountId: string): string | undefined;
+    /**
+     * Get the default (first) account token as fallback.
+     */
+    private getDefaultToken;
+    /**
+     * Resolve which token to use: prefer accountId, fall back to chatAccountMap, then default.
+     */
+    private resolveToken;
+    /** Track which account a chat was last seen on (for DMs) */
+    private chatAccountMap;
+    /**
+     * Send a message. Returns the sent message ID.
+     * Pass accountId to send from a specific bot account.
+     */
+    send(msg: OutgoingMessage & {
+        accountId?: string;
+    }): Promise<string>;
+    /**
+     * Edit an existing message (for streaming updates).
+     */
+    editMessage(chatId: string, messageId: string, text: string, parseMode?: string, accountId?: string): Promise<boolean>;
+    /**
+     * React to a message with an emoji.
+     */
+    react(chatId: string, messageId: string, emoji?: string, accountId?: string): Promise<void>;
+    /**
+     * Send typing indicator.
+     */
+    sendTyping(chatId: string, accountId?: string): Promise<void>;
+    private pollLoop;
+    private apiCall;
+}
+
+declare class WhatsAppAdapter implements ChannelAdapter {
+    readonly name = "whatsapp";
+    private sessionDir;
+    private agentBinding?;
+    private handler?;
+    private log;
+    constructor(config: {
+        sessionDir: string;
+        agentBinding?: string;
+    }, log?: (...args: unknown[]) => void);
+    onMessage(handler: (msg: IncomingMessage) => Promise<void>): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(msg: OutgoingMessage): Promise<void>;
+}
+
+interface CronJobState {
+    id: string;
+    enabled: boolean;
+    schedule: string;
+    timezone: string;
+    agent: string;
+    prompt: string;
+    timeout: number;
+    model?: string;
+    onError: "log" | "notify" | "disable";
+    lastRun?: Date;
+    nextRun?: Date;
+    consecutiveErrors: number;
+    totalRuns: number;
+}
+interface CronRunResult {
+    jobId: string;
+    startedAt: Date;
+    completedAt: Date;
+    success: boolean;
+    response?: string;
+    error?: string;
+    duration: number;
+}
+
+declare class CronScheduler {
+    private jobs;
+    private timers;
+    private registry;
+    private hooks?;
+    private runsDir;
+    private running;
+    private log;
+    constructor(config: DaemonConfig, registry: AgentRegistry, hooks?: HookRegistry, log?: (...args: unknown[]) => void);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private scheduleNext;
+    private executeJob;
+    private logRun;
+    /**
+     * List all jobs and their status.
+     */
+    list(): CronJobState[];
+}
+
+interface ProviderCapabilities {
+    streaming: boolean;
+    tools: boolean;
+    vision: boolean;
+    thinking: boolean;
+    maxContext: number;
+}
+declare const PROVIDER_CAPABILITIES: Record<string, ProviderCapabilities>;
+/**
+ * Check provider capabilities and return warnings for missing features.
+ */
+declare function checkCapabilities(providerName: string, requiredFeatures?: string[]): string[];
+
+interface AuthConfig {
+    provider: "claude" | "claude-code";
+    authType: "api-key" | "oauth";
+    token: string;
+    model: string;
+}
+declare function loadAuthConfig(): AuthConfig | null;
+declare function saveAuthConfig(config: AuthConfig): void;
+/**
+ * Resolve a token for the Anthropic API.
+ * Priority: (1) explicit token, (2) env vars, (3) ~/.agentx/auth.json, (4) OpenClaw auth stores
+ */
+declare function resolveToken(explicitKey?: string): {
+    token: string;
+    authType: "api-key" | "oauth";
+} | null;
+/**
+ * Reusable interactive setup flow. Returns the saved config, or null if the user cancelled.
+ */
+declare function runModelSetup(): Promise<AuthConfig | null>;
+/**
+ * Ensure credentials are available. If not, auto-prompt the interactive setup.
+ * Returns true if credentials are ready, false if user cancelled.
+ */
+declare function ensureCredentials(explicitKey?: string): Promise<boolean>;
+
+declare const logger: {
+    error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    success(...args: unknown[]): void;
+    break(): void;
+};
+
+declare function handleError(error: unknown): void;
+
+declare function getPackageInfo(): PackageJson;
+
+export { A2AClient, A2AMesh, A2AServer, A2AServerConfig, ALL_TOOL_NAMES, AgentCard, AgentConfig, AgentContext, AgentDef, AgentProvider, AgentRegistry, AgentResponse, AgentTask, AgentXDaemon, AgentXRuntime, AnthropicMessage, AuthConfig, BLOCKING_EVENTS, ChannelAdapter, ClaudeCodeProvider, ClaudeProvider, ContentBlock, ContextBuilder, CronJobDef, CronJobState, CronRunResult, CronScheduler, DaemonConfig, EnhanceConfig, EnhanceEngine, EnhanceResult, GenerateOptions, GenerateResult, GenerateStreamEvent, GeneratedFile, GenerationMessage, GenerationResult, GitCommitResult, GitDiffFile, GitLogEntry, GitManager, GitStatus, HOOK_EVENTS, HealConfig, HealEngine, HealResult, HookContext, HookDefinition, HookEvent, HookHandler, HookRegistry, HookResult, IncomingMessage, Memory, MemoryEntry, MemoryHierarchy, MemoryStore, MeshPeer, MessageRouter, MiddlewareFn, ModelUsage, OUTPUT_CONFIGS, OUTPUT_TYPES, OutgoingMessage, OutputConfig, OutputType, PERMISSION_MODES, PROVIDER_CAPABILITIES, PermissionAction, PermissionConfig, PermissionManager, PermissionMode, PermissionRule, Pipeline, PipelineRequest, PipelineResponse, ProjectSchemas, ProviderCapabilities, ProviderName, ProviderOptions, RawGenerationResult, ReplEngine, ReplOptions, RuntimeConfig, Session, StepUsage, StreamEvent, Task, TaskArtifact, TaskMessage, TaskState, TaskStatusUpdate, TechStack, TelegramAdapter, ToolCallInput, ToolExecutor, ToolExecutorOptions, ToolResult, UsageSummary, UsageTracker, WhatsAppAdapter, agentConfigSchema$1 as agentConfigSchema, checkCapabilities, createAgentContext, createProvider, createSession, daemonConfigSchema, debug, detectSchemas, detectTechStack, ensureCredentials, executeClaudeCode, executeOrchestrator, executeSdk, executeTask, exportSession, formatSchemas, formatTechStack, formatToolsForSystemPrompt, gatherContext7Docs, generate, generateSkill, generateSkillMd, generateStream, getAnthropicTools, getCommand, getLegacyTools, getPackageInfo, globalHooks, globalPermissions, globalTracker, handleError, installSkillPackage, isCommand, isDebug, listInstalledSkills, listSessions, loadAuthConfig, loadDaemonConfig, loadHooks, loadLatestSession, loadLocalSkills, loadProjectInstructions, loadSession, logger, matchSkillsToTask, outputTypeDescriptions, parseCommand, parseSkillContent, parseSkillFile, permissionConfigSchema, permissionModeSchema, registerCommand, resolveAtImports, resolveOutputType, resolveToken, runModelSetup, saveAuthConfig, saveSession, setDebug, startMcpServer, validateWorkspaces };