@corbat-tech/coco 2.36.0 → 2.38.0

package/dist/index-Dp1o8c9g.d.ts

@@ -0,0 +1,2807 @@
+import { a as ToolDefinition, T as ToolRegistry } from './registry-CEpl9Jq0.js';
+import './profiles-BcyL-gQ9.js';
+
+/**
+ * Quality system types for Corbat-Coco
+ */
+/**
+ * Multi-dimensional quality scores
+ */
+interface QualityScores {
+    /**
+     * Overall weighted score (0-100)
+     */
+    overall: number;
+    /**
+     * Individual dimension scores
+     */
+    dimensions: QualityDimensions;
+    /**
+     * Metadata
+     */
+    evaluatedAt: Date;
+    evaluationDurationMs: number;
+}
+/**
+ * Quality dimensions
+ */
+interface QualityDimensions {
+    /**
+     * Does the code work correctly? (tests pass, logic correct)
+     */
+    correctness: number;
+    /**
+     * Are all requirements met?
+     */
+    completeness: number;
+    /**
+     * Are edge cases handled?
+     */
+    robustness: number;
+    /**
+     * Is the code clear and understandable?
+     */
+    readability: number;
+    /**
+     * Is the code easy to modify?
+     */
+    maintainability: number;
+    /**
+     * Cyclomatic complexity score (inverted - higher is better)
+     */
+    complexity: number;
+    /**
+     * DRY score - code duplication (inverted - higher is better)
+     */
+    duplication: number;
+    /**
+     * Line and branch coverage
+     */
+    testCoverage: number;
+    /**
+     * Test meaningfulness and quality
+     */
+    testQuality: number;
+    /**
+     * Security vulnerability score (100 = no vulnerabilities)
+     */
+    security: number;
+    /**
+     * Documentation coverage
+     */
+    documentation: number;
+    /**
+     * Linting and style compliance
+     */
+    style: number;
+}
+/**
+ * Quality thresholds
+ */
+interface QualityThresholds {
+    /**
+     * Minimum acceptable scores (must achieve to pass)
+     */
+    minimum: {
+        overall: number;
+        testCoverage: number;
+        security: number;
+    };
+    /**
+     * Target scores (excellent quality)
+     */
+    target: {
+        overall: number;
+        testCoverage: number;
+    };
+    /**
+     * Convergence threshold (max score delta to consider converged)
+     */
+    convergenceThreshold: number;
+    /**
+     * Maximum iterations before forced completion
+     */
+    maxIterations: number;
+    /**
+     * Minimum iterations before checking convergence
+     */
+    minIterations: number;
+}
+
+/**
+ * File tools for Corbat-Coco
+ * Read, write, edit, and search files
+ */
+
+/**
+ * Read file tool
+ */
+declare const readFileTool: ToolDefinition<{
+    path: string;
+    encoding?: string;
+    maxSize?: number;
+}, {
+    content: string;
+    lines: number;
+    size: number;
+    truncated: boolean;
+}>;
+/**
+ * Write file tool
+ */
+declare const writeFileTool: ToolDefinition<{
+    path: string;
+    content: string;
+    createDirs?: boolean;
+    dryRun?: boolean;
+}, {
+    path: string;
+    size: number;
+    dryRun: boolean;
+    wouldCreate: boolean;
+}>;
+/**
+ * Edit file tool (find and replace)
+ */
+declare const editFileTool: ToolDefinition<{
+    path: string;
+    oldText: string;
+    newText: string;
+    all?: boolean;
+    dryRun?: boolean;
+}, {
+    path: string;
+    replacements: number;
+    dryRun: boolean;
+    preview?: string;
+}>;
+/**
+ * Glob tool (find files by pattern)
+ */
+declare const globTool: ToolDefinition<{
+    pattern: string;
+    cwd?: string;
+    ignore?: string[];
+}, {
+    files: string[];
+    count: number;
+}>;
+/**
+ * File exists tool
+ */
+declare const fileExistsTool: ToolDefinition<{
+    path: string;
+}, {
+    exists: boolean;
+    isFile: boolean;
+    isDirectory: boolean;
+}>;
+/**
+ * List directory tool
+ */
+declare const listDirTool: ToolDefinition<{
+    path: string;
+    recursive?: boolean;
+}, {
+    entries: Array<{
+        name: string;
+        type: "file" | "directory";
+        size?: number;
+    }>;
+}>;
+/**
+ * Delete file tool
+ */
+declare const deleteFileTool: ToolDefinition<{
+    path: string;
+    recursive?: boolean;
+    confirm?: boolean;
+}, {
+    deleted: boolean;
+    path: string;
+}>;
+/**
+ * Copy file tool
+ */
+declare const copyFileTool: ToolDefinition<{
+    source: string;
+    destination: string;
+    overwrite?: boolean;
+}, {
+    source: string;
+    destination: string;
+    size: number;
+}>;
+/**
+ * Move/rename file tool
+ */
+declare const moveFileTool: ToolDefinition<{
+    source: string;
+    destination: string;
+    overwrite?: boolean;
+}, {
+    source: string;
+    destination: string;
+}>;
+declare const treeTool: ToolDefinition<{
+    path?: string;
+    depth?: number;
+    showHidden?: boolean;
+    dirsOnly?: boolean;
+}, {
+    tree: string;
+    totalFiles: number;
+    totalDirs: number;
+    truncated: boolean;
+}>;
+/**
+ * All file tools
+ */
+declare const fileTools: (ToolDefinition<{
+    path: string;
+    encoding?: string;
+    maxSize?: number;
+}, {
+    content: string;
+    lines: number;
+    size: number;
+    truncated: boolean;
+}> | ToolDefinition<{
+    path: string;
+    content: string;
+    createDirs?: boolean;
+    dryRun?: boolean;
+}, {
+    path: string;
+    size: number;
+    dryRun: boolean;
+    wouldCreate: boolean;
+}> | ToolDefinition<{
+    path: string;
+    oldText: string;
+    newText: string;
+    all?: boolean;
+    dryRun?: boolean;
+}, {
+    path: string;
+    replacements: number;
+    dryRun: boolean;
+    preview?: string;
+}> | ToolDefinition<{
+    pattern: string;
+    cwd?: string;
+    ignore?: string[];
+}, {
+    files: string[];
+    count: number;
+}> | ToolDefinition<{
+    path: string;
+}, {
+    exists: boolean;
+    isFile: boolean;
+    isDirectory: boolean;
+}> | ToolDefinition<{
+    path: string;
+    recursive?: boolean;
+}, {
+    entries: Array<{
+        name: string;
+        type: "file" | "directory";
+        size?: number;
+    }>;
+}> | ToolDefinition<{
+    path: string;
+    recursive?: boolean;
+    confirm?: boolean;
+}, {
+    deleted: boolean;
+    path: string;
+}> | ToolDefinition<{
+    source: string;
+    destination: string;
+    overwrite?: boolean;
+}, {
+    source: string;
+    destination: string;
+}> | ToolDefinition<{
+    path?: string;
+    depth?: number;
+    showHidden?: boolean;
+    dirsOnly?: boolean;
+}, {
+    tree: string;
+    totalFiles: number;
+    totalDirs: number;
+    truncated: boolean;
+}>)[];
+
+/**
+ * Bash/Shell tools for Corbat-Coco
+ * Execute shell commands with safety controls
+ */
+
+/**
+ * Execute bash command tool
+ */
+declare const bashExecTool: ToolDefinition<{
+    command: string;
+    cwd?: string;
+    timeout?: number;
+    env?: Record<string, string>;
+}, {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+}>;
+/**
+ * Execute bash command in background tool
+ */
+declare const bashBackgroundTool: ToolDefinition<{
+    command: string;
+    cwd?: string;
+    env?: Record<string, string>;
+}, {
+    pid: number;
+    command: string;
+}>;
+/**
+ * Check if command exists tool
+ */
+declare const commandExistsTool: ToolDefinition<{
+    command: string;
+}, {
+    exists: boolean;
+    path?: string;
+}>;
+/**
+ * Get environment variable tool (with security filtering)
+ */
+declare const getEnvTool: ToolDefinition<{
+    name: string;
+}, {
+    value: string | null;
+    exists: boolean;
+    blocked?: boolean;
+}>;
+/**
+ * All bash tools
+ */
+declare const bashTools: (ToolDefinition<{
+    command: string;
+    cwd?: string;
+    timeout?: number;
+    env?: Record<string, string>;
+}, {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+}> | ToolDefinition<{
+    command: string;
+    cwd?: string;
+    env?: Record<string, string>;
+}, {
+    pid: number;
+    command: string;
+}> | ToolDefinition<{
+    command: string;
+}, {
+    exists: boolean;
+    path?: string;
+}> | ToolDefinition<{
+    name: string;
+}, {
+    value: string | null;
+    exists: boolean;
+    blocked?: boolean;
+}>)[];
+
+/**
+ * Git tools for Corbat-Coco
+ * Version control operations
+ */
+
+/**
+ * Git status tool
+ */
+declare const gitStatusTool: ToolDefinition<{
+    cwd?: string;
+}, {
+    branch: string;
+    tracking?: string;
+    ahead: number;
+    behind: number;
+    staged: string[];
+    modified: string[];
+    untracked: string[];
+    conflicted: string[];
+    isClean: boolean;
+}>;
+/**
+ * Git diff tool
+ */
+declare const gitDiffTool: ToolDefinition<{
+    cwd?: string;
+    staged?: boolean;
+    files?: string[];
+}, {
+    diff: string;
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+}>;
+/**
+ * Git add tool
+ */
+declare const gitAddTool: ToolDefinition<{
+    cwd?: string;
+    files: string[];
+}, {
+    added: string[];
+}>;
+/**
+ * Git commit tool
+ */
+declare const gitCommitTool: ToolDefinition<{
+    cwd?: string;
+    message: string;
+    author?: string;
+}, {
+    hash: string;
+    summary: string;
+}>;
+/**
+ * Git log tool
+ */
+declare const gitLogTool: ToolDefinition<{
+    cwd?: string;
+    maxCount?: number;
+    file?: string;
+}, {
+    commits: Array<{
+        hash: string;
+        message: string;
+        author: string;
+        date: string;
+    }>;
+}>;
+/**
+ * Git branch tool
+ */
+declare const gitBranchTool: ToolDefinition<{
+    cwd?: string;
+    create?: string;
+    delete?: string;
+    list?: boolean;
+}, {
+    branches: string[];
+    current: string;
+}>;
+/**
+ * Git checkout tool
+ */
+declare const gitCheckoutTool: ToolDefinition<{
+    cwd?: string;
+    branch: string;
+    create?: boolean;
+}, {
+    branch: string;
+}>;
+/**
+ * Git push tool
+ */
+declare const gitPushTool: ToolDefinition<{
+    cwd?: string;
+    remote?: string;
+    branch?: string;
+    setUpstream?: boolean;
+}, {
+    pushed: boolean;
+    remote: string;
+    branch: string;
+}>;
+/**
+ * Git pull tool
+ */
+declare const gitPullTool: ToolDefinition<{
+    cwd?: string;
+    remote?: string;
+    branch?: string;
+    rebase?: boolean;
+}, {
+    updated: boolean;
+    summary: string;
+}>;
+/**
+ * Git init tool
+ */
+declare const gitInitTool: ToolDefinition<{
+    cwd?: string;
+    bare?: boolean;
+}, {
+    initialized: boolean;
+    path: string;
+}>;
+/**
+ * All git tools
+ */
+declare const gitTools: (ToolDefinition<{
+    cwd?: string;
+}, {
+    branch: string;
+    tracking?: string;
+    ahead: number;
+    behind: number;
+    staged: string[];
+    modified: string[];
+    untracked: string[];
+    conflicted: string[];
+    isClean: boolean;
+}> | ToolDefinition<{
+    cwd?: string;
+    staged?: boolean;
+    files?: string[];
+}, {
+    diff: string;
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+}> | ToolDefinition<{
+    cwd?: string;
+    files: string[];
+}, {
+    added: string[];
+}> | ToolDefinition<{
+    cwd?: string;
+    message: string;
+    author?: string;
+}, {
+    hash: string;
+    summary: string;
+}> | ToolDefinition<{
+    cwd?: string;
+    maxCount?: number;
+    file?: string;
+}, {
+    commits: Array<{
+        hash: string;
+        message: string;
+        author: string;
+        date: string;
+    }>;
+}> | ToolDefinition<{
+    cwd?: string;
+    create?: string;
+    delete?: string;
+    list?: boolean;
+}, {
+    branches: string[];
+    current: string;
+}> | ToolDefinition<{
+    cwd?: string;
+    branch: string;
+    create?: boolean;
+}, {
+    branch: string;
+}> | ToolDefinition<{
+    cwd?: string;
+    remote?: string;
+    branch?: string;
+    setUpstream?: boolean;
+}, {
+    pushed: boolean;
+    remote: string;
+    branch: string;
+}> | ToolDefinition<{
+    cwd?: string;
+    remote?: string;
+    branch?: string;
+    rebase?: boolean;
+}, {
+    updated: boolean;
+    summary: string;
+}> | ToolDefinition<{
+    cwd?: string;
+    bare?: boolean;
+}, {
+    initialized: boolean;
+    path: string;
+}>)[];
+
+/**
+ * Simple Git Auto-Commit
+ *
+ * Simplified git automation without complex bash tool integration
+ */
+/**
+ * Check if on protected branch
+ */
+declare const checkProtectedBranchTool: ToolDefinition<unknown, {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+}>;
+declare const simpleAutoCommitTool: ToolDefinition<{
+    message?: string;
+}, {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+}>;
+declare const gitSimpleTools: (ToolDefinition<unknown, {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+}> | ToolDefinition<{
+    message?: string;
+}, {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+}>)[];
+
+/**
+ * Simple Multi-Agent Tool
+ *
+ * Spawns sub-agents with specialized roles via the unified AgentManager system.
+ * Supports 12 agent types (explore, plan, test, debug, review, architect,
+ * security, tdd, refactor, e2e, docs, database) with proper tool whitelists
+ * and specialized prompts.
+ */
+/**
+ * Spawn a sub-agent with specialized role via the unified AgentManager
+ */
+declare const spawnSimpleAgentTool: ToolDefinition<unknown, {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+}>;
+/**
+ * Check agent capability
+ */
+declare const checkAgentCapabilityTool: ToolDefinition<unknown, {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+}>;
+declare const simpleAgentTools: ToolDefinition<unknown, {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+}>[];
+
+/**
+ * Test tools for Corbat-Coco
+ * Run tests and collect coverage
+ */
+
+/**
+ * Test result interface
+ */
+interface TestResult {
+    passed: number;
+    failed: number;
+    skipped: number;
+    total: number;
+    duration: number;
+    success: boolean;
+    failures: TestFailure[];
+    coverage?: CoverageResult;
+}
+/**
+ * Test failure interface
+ */
+interface TestFailure {
+    name: string;
+    file: string;
+    message: string;
+    stack?: string;
+}
+/**
+ * Coverage result interface
+ */
+interface CoverageResult {
+    lines: number;
+    branches: number;
+    functions: number;
+    statements: number;
+}
+/**
+ * Run tests tool
+ */
+declare const runTestsTool: ToolDefinition<{
+    cwd?: string;
+    pattern?: string;
+    coverage?: boolean;
+    framework?: string;
+    watch?: boolean;
+    args?: string[];
+}, TestResult>;
+/**
+ * Get coverage tool
+ */
+declare const getCoverageTool: ToolDefinition<{
+    cwd?: string;
+    format?: "summary" | "detailed";
+}, CoverageResult & {
+    report?: string;
+}>;
+/**
+ * Run single test file tool
+ */
+declare const runTestFileTool: ToolDefinition<{
+    cwd?: string;
+    file: string;
+    framework?: string;
+    args?: string[];
+}, TestResult>;
+/**
+ * All test tools
+ */
+declare const testTools: (ToolDefinition<{
+    cwd?: string;
+    pattern?: string;
+    coverage?: boolean;
+    framework?: string;
+    watch?: boolean;
+    args?: string[];
+}, TestResult> | ToolDefinition<{
+    cwd?: string;
+    format?: "summary" | "detailed";
+}, CoverageResult & {
+    report?: string;
+}> | ToolDefinition<{
+    cwd?: string;
+    file: string;
+    framework?: string;
+    args?: string[];
+}, TestResult>)[];
+
+/**
+ * Quality tools for Corbat-Coco
+ * Linting, complexity analysis, security scanning
+ */
+
+/**
+ * Lint result interface
+ */
+interface LintResult {
+    errors: number;
+    warnings: number;
+    fixable: number;
+    issues: LintIssue[];
+    score: number | null;
+    linter?: string;
+    message?: string;
+}
+/**
+ * Lint issue interface
+ */
+interface LintIssue {
+    file: string;
+    line: number;
+    column: number;
+    severity: "error" | "warning";
+    message: string;
+    rule: string;
+}
+/**
+ * Complexity result interface
+ */
+interface ComplexityResult {
+    averageComplexity: number;
+    maxComplexity: number;
+    totalFunctions: number;
+    complexFunctions: number;
+    score: number;
+    files: FileComplexity[];
+}
+/**
+ * File complexity interface
+ */
+interface FileComplexity {
+    file: string;
+    complexity: number;
+    functions: FunctionComplexity[];
+}
+/**
+ * Function complexity interface
+ */
+interface FunctionComplexity {
+    name: string;
+    complexity: number;
+    line: number;
+}
+/**
+ * Run linter tool
+ */
+declare const runLinterTool: ToolDefinition<{
+    cwd?: string;
+    files?: string[];
+    fix?: boolean;
+    linter?: string;
+}, LintResult>;
+/**
+ * Analyze complexity tool
+ */
+declare const analyzeComplexityTool: ToolDefinition<{
+    cwd?: string;
+    files?: string[];
+    threshold?: number;
+}, ComplexityResult>;
+/**
+ * Calculate full quality scores using the new QualityEvaluator
+ * This replaces hardcoded values with real measurements
+ */
+declare const calculateQualityTool: ToolDefinition<{
+    cwd?: string;
+    files?: string[];
+    useSnyk?: boolean;
+}, QualityScores>;
+/**
+ * All quality tools
+ */
+declare const qualityTools: (ToolDefinition<{
+    cwd?: string;
+    files?: string[];
+    fix?: boolean;
+    linter?: string;
+}, LintResult> | ToolDefinition<{
+    cwd?: string;
+    files?: string[];
+    threshold?: number;
+}, ComplexityResult> | ToolDefinition<{
+    cwd?: string;
+    files?: string[];
+    useSnyk?: boolean;
+}, QualityScores>)[];
+
+/**
+ * Search tools for Corbat-Coco
+ * Content search across files
+ */
+
+/**
+ * Search match interface
+ */
+interface SearchMatch {
+    file: string;
+    line: number;
+    column: number;
+    content: string;
+    contextBefore: string[];
+    contextAfter: string[];
+}
+/**
+ * Search result interface
+ */
+interface SearchResult {
+    matches: SearchMatch[];
+    totalMatches: number;
+    filesSearched: number;
+    filesWithMatches: number;
+    truncated: boolean;
+}
+/**
+ * Grep/search tool
+ */
+declare const grepTool: ToolDefinition<{
+    pattern: string;
+    path?: string;
+    include?: string;
+    exclude?: string[];
+    contextLines?: number;
+    maxResults?: number;
+    caseSensitive?: boolean;
+    wholeWord?: boolean;
+}, SearchResult>;
+/**
+ * Find in file tool (simpler single-file search)
+ */
+declare const findInFileTool: ToolDefinition<{
+    file: string;
+    pattern: string;
+    caseSensitive?: boolean;
+}, {
+    matches: Array<{
+        line: number;
+        content: string;
+    }>;
+    count: number;
+}>;
+/**
+ * All search tools
+ */
+declare const searchTools: (ToolDefinition<{
+    pattern: string;
+    path?: string;
+    include?: string;
+    exclude?: string[];
+    contextLines?: number;
+    maxResults?: number;
+    caseSensitive?: boolean;
+    wholeWord?: boolean;
+}, SearchResult> | ToolDefinition<{
+    file: string;
+    pattern: string;
+    caseSensitive?: boolean;
+}, {
+    matches: Array<{
+        line: number;
+        content: string;
+    }>;
+    count: number;
+}>)[];
+
+/**
+ * HTTP tools for Corbat-Coco
+ * Make HTTP requests to external APIs
+ */
+
+/**
+ * HTTP response interface
+ */
+interface HttpResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+    duration: number;
+    truncated: boolean;
+}
+/**
+ * HTTP fetch tool
+ */
+declare const httpFetchTool: ToolDefinition<{
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
+    headers?: Record<string, string>;
+    body?: string;
+    timeout?: number;
+    maxSize?: number;
+}, HttpResponse>;
+/**
+ * HTTP JSON fetch tool (convenience wrapper)
+ */
+declare const httpJsonTool: ToolDefinition<{
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    headers?: Record<string, string>;
+    data?: Record<string, unknown>;
+    timeout?: number;
+}, {
+    status: number;
+    data: unknown;
+    duration: number;
+}>;
+/**
+ * All HTTP tools
+ */
+declare const httpTools: (ToolDefinition<{
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
+    headers?: Record<string, string>;
+    body?: string;
+    timeout?: number;
+    maxSize?: number;
+}, HttpResponse> | ToolDefinition<{
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    headers?: Record<string, string>;
+    data?: Record<string, unknown>;
+    timeout?: number;
+}, {
+    status: number;
+    data: unknown;
+    duration: number;
+}>)[];
+
+/**
+ * Build tools for Corbat-Coco
+ * Wrappers for npm, pnpm, yarn, and make
+ */
+
+/**
+ * Package manager type
+ */
+type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
+/**
+ * Build result interface
+ */
+interface BuildResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+    packageManager?: PackageManager;
+    hint?: string;
+}
+/**
+ * Run npm/pnpm/yarn script tool
+ */
+declare const runScriptTool: ToolDefinition<{
+    script: string;
+    cwd?: string;
+    packageManager?: PackageManager;
+    args?: string[];
+    env?: Record<string, string>;
+    timeout?: number;
+}, BuildResult>;
+/**
+ * Install dependencies tool
+ */
+declare const installDepsTool: ToolDefinition<{
+    cwd?: string;
+    packageManager?: PackageManager;
+    packages?: string[];
+    dev?: boolean;
+    frozen?: boolean;
+    timeout?: number;
+}, BuildResult>;
+/**
+ * Run make target tool
+ */
+declare const makeTool: ToolDefinition<{
+    target?: string;
+    cwd?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    timeout?: number;
+}, BuildResult>;
+/**
+ * TypeScript compile tool
+ */
+declare const tscTool: ToolDefinition<{
+    cwd?: string;
+    project?: string;
+    noEmit?: boolean;
+    watch?: boolean;
+    args?: string[];
+    timeout?: number;
+}, BuildResult>;
+/**
+ * All build tools
+ */
+declare const buildTools: (ToolDefinition<{
+    script: string;
+    cwd?: string;
+    packageManager?: PackageManager;
+    args?: string[];
+    env?: Record<string, string>;
+    timeout?: number;
+}, BuildResult> | ToolDefinition<{
+    cwd?: string;
+    packageManager?: PackageManager;
+    packages?: string[];
+    dev?: boolean;
+    frozen?: boolean;
+    timeout?: number;
+}, BuildResult> | ToolDefinition<{
+    target?: string;
+    cwd?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    timeout?: number;
+}, BuildResult> | ToolDefinition<{
+    cwd?: string;
+    project?: string;
+    noEmit?: boolean;
+    watch?: boolean;
+    args?: string[];
+    timeout?: number;
+}, BuildResult> | ToolDefinition<{
+    goal: string;
+    cwd?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    timeout?: number;
+}, BuildResult> | ToolDefinition<{
+    task: string;
+    cwd?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    timeout?: number;
+}, BuildResult>)[];
+
+/**
+ * Permissions management tool
+ *
+ * Allows the LLM to modify tool permissions conversationally.
+ * The user says "block git push" or "allow npm install" in natural language,
+ * Coco invokes this tool, and the confirmation system shows the user
+ * what will change (with risk info) before applying.
+ *
+ * The tool itself only validates and returns risk info.
+ * The actual trust modification is done by agent-loop.ts after
+ * the user confirms via the standard confirmation UI.
+ *
+ * Supports two scopes:
+ * - "project" (default): per-project overrides (deny overrides global allow)
+ * - "global": affects all projects
+ */
+
+type RiskLevel = "low" | "medium" | "high" | "unknown";
+/**
+ * Assess the risk level of a permission pattern based on recommended lists.
+ */
+declare function getRiskLevel(pattern: string): RiskLevel;
+/**
+ * Get a human-readable risk description for a pattern.
+ */
+declare function getRiskDescription(pattern: string): string;
+/**
+ * Get a description of what the action will do.
+ */
+declare function getEffectDescription(action: "allow" | "deny" | "ask", pattern: string, scope?: "global" | "project"): string;
+interface ManagePermissionsInput {
+    action: "allow" | "deny" | "ask";
+    patterns: string[];
+    scope?: "global" | "project";
+    reason?: string;
+}
+interface PermissionChange {
+    pattern: string;
+    action: string;
+    risk: string;
+    effect: string;
+}
+interface ManagePermissionsOutput {
+    changes: PermissionChange[];
+    summary: string;
+}
+declare const managePermissionsTool: ToolDefinition<ManagePermissionsInput, ManagePermissionsOutput>;
+/**
+ * All permissions tools (for registry)
+ */
+declare const permissionsTools: ToolDefinition<ManagePermissionsInput, ManagePermissionsOutput>[];
+
+/**
+ * Web Fetch tool for Corbat-Coco
+ * Fetch URLs and convert HTML to clean markdown
+ */
+
+/**
+ * Web fetch result interface
+ */
+interface WebFetchOutput {
+    title: string;
+    content: string;
+    url: string;
+    contentType: string;
+    wordCount: number;
+    truncated: boolean;
+    duration: number;
+    metadata: {
+        description?: string;
+        author?: string;
+        publishedDate?: string;
+    };
+}
+/**
+ * Web fetch tool
+ */
+declare const webFetchTool: ToolDefinition<{
+    url: string;
+    extractContent?: boolean;
+    maxLength?: number;
+    timeout?: number;
+}, WebFetchOutput>;
+
+/**
+ * Web Search tool for Corbat-Coco
+ * Search the web for documentation, error solutions, and API references
+ */
+
+/**
+ * Search result interface
+ */
+interface WebSearchResultItem {
+    title: string;
+    url: string;
+    snippet: string;
+}
+interface WebSearchOutput {
+    results: WebSearchResultItem[];
+    totalResults: number;
+    engine: string;
+    duration: number;
+}
+/**
+ * Web search tool
+ */
+declare const webSearchTool: ToolDefinition<{
+    query: string;
+    maxResults?: number;
+    engine?: "duckduckgo" | "brave" | "serpapi";
+}, WebSearchOutput>;
+
+/**
+ * All web tools
+ */
+declare const webTools: (ToolDefinition<{
+    query: string;
+    maxResults?: number;
+    engine?: "duckduckgo" | "brave" | "serpapi";
+}, WebSearchOutput> | ToolDefinition<{
+    url: string;
+    extractContent?: boolean;
+    maxLength?: number;
+    timeout?: number;
+}, WebFetchOutput>)[];
+
+/**
+ * Visual diff tool for Corbat-Coco
+ *
+ * Provides visual diff rendering that the agent can invoke from chat.
+ * Supports: unstaged, staged, branch comparison, file-to-file, and arbitrary refs.
+ */
+
+/**
+ * Show diff — visual rendering of git diffs in the terminal.
+ *
+ * Modes:
+ *   1. Unstaged changes (default): no args
+ *   2. Staged changes: { staged: true }
+ *   3. Branch comparison: { base: "main" }
+ *   4. Between two refs: { base: "main", ref: "feature" }
+ *   5. Specific files: { files: ["src/app.ts"] }
+ */
+declare const showDiffTool: ToolDefinition<{
+    cwd?: string;
+    staged?: boolean;
+    base?: string;
+    ref?: string;
+    files?: string[];
+    compact?: boolean;
+}, {
+    filesChanged: number;
+    additions: number;
+    deletions: number;
+    rendered: true;
+}>;
+declare const diffTools: ToolDefinition<{
+    cwd?: string;
+    staged?: boolean;
+    base?: string;
+    ref?: string;
+    files?: string[];
+    compact?: boolean;
+}, {
+    filesChanged: number;
+    additions: number;
+    deletions: number;
+    rendered: true;
+}>[];
+
+/**
+ * Visual diff renderer for terminal
+ *
+ * Parses git unified diff format and renders with clean Codex-style formatting
+ * showing removed lines with red background (-) and added lines with green background (+).
+ */
+interface DiffStats {
+    additions: number;
+    deletions: number;
+    filesChanged: number;
+}
+interface DiffFile {
+    path: string;
+    oldPath?: string;
+    type: "modified" | "added" | "deleted" | "renamed";
+    hunks: DiffHunk[];
+    additions: number;
+    deletions: number;
+}
+interface DiffHunk {
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    heading: string;
+    lines: DiffLine[];
+}
+interface DiffLine {
+    type: "add" | "delete" | "context";
+    content: string;
+    oldLineNo?: number;
+    newLineNo?: number;
+}
+interface ParsedDiff {
+    files: DiffFile[];
+    stats: DiffStats;
+}
+
+/**
+ * Project maturity detection
+ *
+ * Heuristic-based detection of project maturity level.
+ * Used by the review tool to adjust recommendations:
+ * - empty: recommend project structure, CI, testing
+ * - new: suggest tests, documentation, standards
+ * - established: enforce existing patterns, check consistency
+ */
+type MaturityLevel = "empty" | "new" | "established";
+
+/**
+ * Code review tool for Corbat-Coco
+ *
+ * Analyzes git diffs between current branch and a base branch,
+ * runs pattern detection and optional linting, and produces
+ * structured review findings ordered by severity.
+ */
+
+type ReviewSeverity = "critical" | "major" | "minor" | "info";
+type ReviewCategory = "security" | "correctness" | "performance" | "maintainability" | "style" | "testing" | "documentation" | "best-practice";
+interface ReviewFinding {
+    file: string;
+    line?: number;
+    severity: ReviewSeverity;
+    category: ReviewCategory;
+    message: string;
+    suggestion?: {
+        old: string[];
+        new: string[];
+    };
+}
+interface ReviewSummary {
+    branch: string;
+    baseBranch: string;
+    filesChanged: number;
+    additions: number;
+    deletions: number;
+    status: "approved" | "needs_work";
+}
+interface ReviewResult {
+    summary: ReviewSummary;
+    required: ReviewFinding[];
+    suggestions: ReviewFinding[];
+    maturity: MaturityLevel;
+    diff: ParsedDiff;
+    warnings?: string[];
+}
+declare const reviewCodeTool: ToolDefinition<{
+    baseBranch?: string;
+    includeUncommitted?: boolean;
+    runLinter?: boolean;
+    cwd?: string;
+}, ReviewResult>;
+declare const reviewTools: ToolDefinition<{
+    baseBranch?: string;
+    includeUncommitted?: boolean;
+    runLinter?: boolean;
+    cwd?: string;
+}, ReviewResult>[];
+
+/**
+ * Codebase Map tool for Corbat-Coco
+ * Generate structural map of codebase: classes, functions, exports, interfaces
+ * Token-efficient overview without reading full file contents
+ */
+
+/**
+ * Definition types
+ */
+type DefinitionType = "class" | "function" | "interface" | "type" | "enum" | "const" | "variable" | "method";
+/**
+ * A single code definition
+ */
+interface CodeDefinition {
+    name: string;
+    type: DefinitionType;
+    line: number;
+    exported: boolean;
+    signature?: string;
+}
+/**
+ * File map entry
+ */
+interface FileMapEntry {
+    path: string;
+    language: string;
+    definitions: CodeDefinition[];
+    imports: string[];
+    exports: string[];
+    lineCount: number;
+}
+/**
+ * Codebase map output
+ */
+interface CodebaseMapOutput {
+    files: FileMapEntry[];
+    summary: {
+        totalFiles: number;
+        totalDefinitions: number;
+        languages: Record<string, number>;
+        exportedSymbols: number;
+    };
+    duration: number;
+}
+/**
+ * Codebase map tool
+ */
+declare const codebaseMapTool: ToolDefinition<{
+    path?: string;
+    include?: string;
+    exclude?: string[];
+    languages?: Array<"typescript" | "javascript" | "python" | "java" | "go" | "rust">;
+    maxFiles?: number;
+    depth?: "overview" | "detailed";
+    includeTests?: boolean;
+}, CodebaseMapOutput>;
+/**
+ * All codebase map tools
+ */
+declare const codebaseMapTools: ToolDefinition<{
+    path?: string;
+    include?: string;
+    exclude?: string[];
+    languages?: Array<"typescript" | "javascript" | "python" | "java" | "go" | "rust">;
+    maxFiles?: number;
+    depth?: "overview" | "detailed";
+    includeTests?: boolean;
+}, CodebaseMapOutput>[];
+
+/**
+ * Memory tools for Corbat-Coco
+ * Persist learnings and context between sessions
+ */
+
+/**
+ * Memory entry interface
+ */
+interface Memory {
+    id: string;
+    key: string;
+    value: string;
+    tags: string[];
+    scope: "global" | "project";
+    project?: string;
+    createdAt: string;
+    updatedAt: string;
+    accessCount: number;
+}
+/**
+ * Create memory tool
+ */
+declare const createMemoryTool: ToolDefinition<{
+    key: string;
+    value: string;
+    tags?: string[];
+    scope?: "global" | "project";
+}, {
+    id: string;
+    key: string;
+    scope: string;
+    created: boolean;
+}>;
+/**
+ * Recall memory tool
+ */
+declare const recallMemoryTool: ToolDefinition<{
+    query?: string;
+    tags?: string[];
+    scope?: "global" | "project" | "all";
+    limit?: number;
+}, {
+    memories: Memory[];
+    totalFound: number;
+}>;
+/**
+ * List memories tool
+ */
+declare const listMemoriesTool: ToolDefinition<{
+    scope?: "global" | "project" | "all";
+    tags?: string[];
+}, {
+    memories: Array<{
+        id: string;
+        key: string;
+        tags: string[];
+        scope: string;
+        createdAt: string;
+    }>;
+    total: number;
+}>;
+/**
+ * All memory tools
+ */
+declare const memoryTools: (ToolDefinition<{
+    key: string;
+    value: string;
+    tags?: string[];
+    scope?: "global" | "project";
+}, {
+    id: string;
+    key: string;
+    scope: string;
+    created: boolean;
+}> | ToolDefinition<{
+    query?: string;
+    tags?: string[];
+    scope?: "global" | "project" | "all";
+    limit?: number;
+}, {
+    memories: Memory[];
+    totalFound: number;
+}> | ToolDefinition<{
+    scope?: "global" | "project" | "all";
+    tags?: string[];
+}, {
+    memories: Array<{
+        id: string;
+        key: string;
+        tags: string[];
+        scope: string;
+        createdAt: string;
+    }>;
+    total: number;
+}>)[];
+
+/**
+ * Checkpoint tools for Corbat-Coco
+ * Create and restore code snapshots using git stash
+ */
+
+/**
+ * Checkpoint entry
+ */
+interface Checkpoint {
+    id: string;
+    description: string;
+    timestamp: string;
+    stashRef?: string;
+    fileCount: number;
+    files: string[];
+}
+/**
+ * Create checkpoint tool
+ */
+declare const createCheckpointTool: ToolDefinition<{
+    description: string;
+}, {
+    id: string;
+    description: string;
+    fileCount: number;
+    files: string[];
+    method: "stash" | "clean";
+}>;
+/**
+ * Restore checkpoint tool
+ */
+declare const restoreCheckpointTool: ToolDefinition<{
+    id: string;
+}, {
+    id: string;
+    description: string;
+    restored: boolean;
+    message: string;
+}>;
+/**
+ * List checkpoints tool
+ */
+declare const listCheckpointsTool: ToolDefinition<{
+    limit?: number;
+}, {
+    checkpoints: Checkpoint[];
+    total: number;
+}>;
+/**
+ * All checkpoint tools
+ */
+declare const checkpointTools: (ToolDefinition<{
+    description: string;
+}, {
+    id: string;
+    description: string;
+    fileCount: number;
+    files: string[];
+    method: "stash" | "clean";
+}> | ToolDefinition<{
+    id: string;
+}, {
+    id: string;
+    description: string;
+    restored: boolean;
+    message: string;
+}> | ToolDefinition<{
+    limit?: number;
+}, {
+    checkpoints: Checkpoint[];
+    total: number;
+}>)[];
+
+/**
+ * Semantic Search tool for Corbat-Coco
+ * Vector-based code search using local embeddings
+ */
+
+/**
+ * Semantic search result item
+ */
+interface SemanticSearchResultItem {
+    file: string;
+    line: number;
+    snippet: string;
+    score: number;
+    context: string;
+}
+/**
+ * Semantic search output
+ */
+interface SemanticSearchOutput {
+    results: SemanticSearchResultItem[];
+    totalIndexed: number;
+    indexAge: string;
+    duration: number;
+    warning?: string;
+}
+/**
+ * Semantic search tool
+ */
+declare const semanticSearchTool: ToolDefinition<{
+    query: string;
+    path?: string;
+    include?: string;
+    maxResults?: number;
+    threshold?: number;
+    reindex?: boolean;
+}, SemanticSearchOutput>;
+/**
+ * All semantic search tools
+ */
+declare const semanticSearchTools: ToolDefinition<{
+    query: string;
+    path?: string;
+    include?: string;
+    maxResults?: number;
+    threshold?: number;
+    reindex?: boolean;
+}, SemanticSearchOutput>[];
+
+/**
+ * Diagram generation tool for Corbat-Coco
+ * Generate Mermaid diagrams from code analysis or descriptions
+ */
+
+/**
+ * Diagram output
+ */
+interface DiagramOutput {
+    diagram: string;
+    format: string;
+    type: string;
+    nodeCount: number;
+    edgeCount: number;
+}
+/**
+ * Diagram generation tool
+ */
+declare const generateDiagramTool: ToolDefinition<{
+    type: "class" | "sequence" | "flowchart" | "architecture" | "er" | "mindmap";
+    description?: string;
+    path?: string;
+    include?: string;
+    format?: "mermaid" | "plantuml";
+}, DiagramOutput>;
+/**
+ * All diagram tools
+ */
+declare const diagramTools: ToolDefinition<{
+    type: "class" | "sequence" | "flowchart" | "architecture" | "er" | "mindmap";
+    description?: string;
+    path?: string;
+    include?: string;
+    format?: "mermaid" | "plantuml";
+}, DiagramOutput>[];
+
+/**
+ * PDF Reader tool for Corbat-Coco
+ * Extract text content from PDF files
+ */
+
+/**
+ * PDF read output
+ */
+interface PdfReadOutput {
+    text: string;
+    pages: number;
+    metadata: {
+        title?: string;
+        author?: string;
+        subject?: string;
+        creator?: string;
+    };
+    truncated: boolean;
+    duration: number;
+}
+/**
+ * PDF reader tool
+ */
+declare const readPdfTool: ToolDefinition<{
+    path: string;
+    pages?: string;
+    maxPages?: number;
+}, PdfReadOutput>;
+/**
+ * All document tools (PDF)
+ */
+declare const pdfTools: ToolDefinition<{
+    path: string;
+    pages?: string;
+    maxPages?: number;
+}, PdfReadOutput>[];
+
+/**
+ * Image Understanding tool for Corbat-Coco
+ * Analyze images using vision-capable LLM providers
+ */
+
+/**
+ * Image understanding output
+ */
+interface ImageReadOutput {
+    description: string;
+    provider: string;
+    model: string;
+    duration: number;
+    imageSize: number;
+    format: string;
+}
+/**
+ * Image understanding tool
+ */
+declare const readImageTool: ToolDefinition<{
+    path: string;
+    prompt?: string;
+    provider?: "anthropic" | "openai" | "gemini";
+}, ImageReadOutput>;
+/**
+ * All image tools
+ */
+declare const imageTools: ToolDefinition<{
+    path: string;
+    prompt?: string;
+    provider?: "anthropic" | "openai" | "gemini";
+}, ImageReadOutput>[];
+
+/**
+ * Database tools for Corbat-Coco
+ * SQLite query execution and schema inspection
+ */
+
+/**
+ * SQL query output
+ */
+interface SqlQueryOutput {
+    rows: Record<string, unknown>[];
+    columns: string[];
+    rowCount: number;
+    duration: number;
+    readonly: boolean;
+}
+/**
+ * Schema inspection output
+ */
+interface SchemaInspectOutput {
+    tables: Array<{
+        name: string;
+        columns: Array<{
+            name: string;
+            type: string;
+            nullable: boolean;
+            primaryKey: boolean;
+            defaultValue: string | null;
+        }>;
+        rowCount: number;
+    }>;
+    duration: number;
+}
+/**
+ * SQL query tool
+ */
+declare const sqlQueryTool: ToolDefinition<{
+    database: string;
+    query: string;
+    params?: unknown[];
+    readonly?: boolean;
+}, SqlQueryOutput>;
+/**
+ * Schema inspection tool
+ */
+declare const inspectSchemaTool: ToolDefinition<{
+    database: string;
+    table?: string;
+}, SchemaInspectOutput>;
+/**
+ * All database tools
+ */
+declare const databaseTools: (ToolDefinition<{
+    database: string;
+    query: string;
+    params?: unknown[];
+    readonly?: boolean;
+}, SqlQueryOutput> | ToolDefinition<{
+    database: string;
+    table?: string;
+}, SchemaInspectOutput>)[];
+
+interface ValidationResult {
+    valid: boolean;
+    errors: Array<{
+        line: number;
+        column: number;
+        message: string;
+    }>;
+    warnings: Array<{
+        line: number;
+        column: number;
+        message: string;
+    }>;
+    ast?: unknown;
+}
+/**
+ * Tool: Validate code syntax before applying changes
+ */
+declare const validateCodeTool: ToolDefinition<unknown, {
+    valid: boolean;
+    errors: {
+        line: number;
+        column: number;
+        message: string;
+    }[];
+    warnings: {
+        line: number;
+        column: number;
+        message: string;
+    }[];
+    hasAst: boolean;
+}>;
+/**
+ * Tool: Find missing imports in code
+ */
+declare const findMissingImportsTool: ToolDefinition<unknown, {
+    existingImports: string[];
+    missingImports: string[];
+    hasMissing: boolean;
+}>;
+declare const astValidatorTools: (ToolDefinition<unknown, {
+    valid: boolean;
+    errors: {
+        line: number;
+        column: number;
+        message: string;
+    }[];
+    warnings: {
+        line: number;
+        column: number;
+        message: string;
+    }[];
+    hasAst: boolean;
+}> | ToolDefinition<unknown, {
+    existingImports: string[];
+    missingImports: string[];
+    hasMissing: boolean;
+}>)[];
+
+interface FunctionInfo {
+    name: string;
+    line: number;
+    params: string[];
+    exported: boolean;
+    async: boolean;
+}
+interface ClassInfo {
+    name: string;
+    line: number;
+    methods: string[];
+    exported: boolean;
+}
+interface ImportInfo {
+    source: string;
+    items: string[];
+    isDefault: boolean;
+    isNamespace: boolean;
+}
+interface ExportInfo {
+    name: string;
+    type: "function" | "class" | "variable" | "type";
+}
+interface CodeAnalysisResult {
+    filePath: string;
+    language: string;
+    lines: number;
+    functions: FunctionInfo[];
+    classes: ClassInfo[];
+    imports: ImportInfo[];
+    exports: ExportInfo[];
+    complexity: {
+        cyclomatic: number;
+        functions: number;
+        classes: number;
+        avgFunctionLength: number;
+    };
+    ast?: unknown;
+}
+/**
+ * Tool: Analyze code file structure
+ */
+declare const analyzeFileTool: ToolDefinition<unknown, {
+    filePath: string;
+    language: string;
+    lines: number;
+    functionsCount: number;
+    classesCount: number;
+    importsCount: number;
+    exportsCount: number;
+    functions: FunctionInfo[];
+    classes: ClassInfo[];
+    imports: ImportInfo[];
+    exports: ExportInfo[];
+    complexity: {
+        cyclomatic: number;
+        functions: number;
+        classes: number;
+        avgFunctionLength: number;
+    };
+}>;
+/**
+ * Tool: Analyze directory structure
+ */
+declare const analyzeDirectoryTool: ToolDefinition<unknown, {
+    totalFiles: number;
+    totalLines: number;
+    filesByType: Record<string, number>;
+    largestFiles: Array<{
+        file: string;
+        lines: number;
+    }>;
+    mostComplex: Array<{
+        file: string;
+        complexity: number;
+    }>;
+}>;
+declare const codeAnalyzerTools: (ToolDefinition<unknown, {
+    filePath: string;
+    language: string;
+    lines: number;
+    functionsCount: number;
+    classesCount: number;
+    importsCount: number;
+    exportsCount: number;
+    functions: FunctionInfo[];
+    classes: ClassInfo[];
+    imports: ImportInfo[];
+    exports: ExportInfo[];
+    complexity: {
+        cyclomatic: number;
+        functions: number;
+        classes: number;
+        avgFunctionLength: number;
+    };
+}> | ToolDefinition<unknown, {
+    totalFiles: number;
+    totalLines: number;
+    filesByType: Record<string, number>;
+    largestFiles: Array<{
+        file: string;
+        lines: number;
+    }>;
+    mostComplex: Array<{
+        file: string;
+        complexity: number;
+    }>;
+}>)[];
+
+/**
+ * Optional LSP-style code intelligence tools.
+ *
+ * These tools do not require a persistent language server. When a language
+ * server is unavailable, they fall back to Coco's lightweight static parsers
+ * and repository search so the agent can still navigate code safely.
+ */
+
+interface LspStatusOutput {
+    languageServers: Array<{
+        name: string;
+        available: boolean;
+    }>;
+    fallbackMode: "static-analysis";
+}
+interface LspSymbol {
+    file: string;
+    name: string;
+    type: DefinitionType;
+    line: number;
+    exported: boolean;
+    signature?: string;
+}
+interface LspReference {
+    file: string;
+    line: number;
+    column: number;
+    content: string;
+}
+declare const lspStatusTool: ToolDefinition<Record<string, never>, LspStatusOutput>;
+declare const lspDocumentSymbolsTool: ToolDefinition<{
+    file: string;
+}, {
+    symbols: LspSymbol[];
+}>;
+declare const lspWorkspaceSymbolsTool: ToolDefinition<{
+    query: string;
+    path?: string;
+    maxFiles?: number;
+    maxResults?: number;
+}, {
+    symbols: LspSymbol[];
+    searchedFiles: number;
+    truncated: boolean;
+}>;
+declare const lspDefinitionTool: ToolDefinition<{
+    symbol: string;
+    path?: string;
+    maxFiles?: number;
+}, {
+    definition?: LspSymbol;
+    candidates: LspSymbol[];
+}>;
+declare const lspReferencesTool: ToolDefinition<{
+    symbol: string;
+    path?: string;
+    maxFiles?: number;
+    maxResults?: number;
+}, {
+    references: LspReference[];
+    searchedFiles: number;
+    truncated: boolean;
+}>;
+declare const lspTools: (ToolDefinition<Record<string, never>, LspStatusOutput> | ToolDefinition<{
+    file: string;
+}, {
+    symbols: LspSymbol[];
+}> | ToolDefinition<{
+    query: string;
+    path?: string;
+    maxFiles?: number;
+    maxResults?: number;
+}, {
+    symbols: LspSymbol[];
+    searchedFiles: number;
+    truncated: boolean;
+}> | ToolDefinition<{
+    symbol: string;
+    path?: string;
+    maxFiles?: number;
+}, {
+    definition?: LspSymbol;
+    candidates: LspSymbol[];
+}> | ToolDefinition<{
+    symbol: string;
+    path?: string;
+    maxFiles?: number;
+    maxResults?: number;
+}, {
+    references: LspReference[];
+    searchedFiles: number;
+    truncated: boolean;
+}>)[];
+
+/**
+ * Repo intelligence graph and ranked context retrieval.
+ *
+ * This builds on codebase_map and adds a lightweight, cacheable ranking layer
+ * for agent context selection.
+ */
+
+interface RepoGraphNode extends FileMapEntry {
+    inboundImports: number;
+    testRelated: boolean;
+}
+interface RepoIntelligenceGraph {
+    root: string;
+    generatedAt: string;
+    files: RepoGraphNode[];
+    summary: CodebaseMapOutput["summary"];
+}
+interface RepoContextRequest {
+    path?: string;
+    query: string;
+    budget?: number;
+    mode?: "ask" | "plan" | "build" | "debug" | "review" | "architect";
+    changedFiles?: string[];
+    refresh?: boolean;
+}
+interface RankedContextItem {
+    path: string;
+    score: number;
+    reasons: string[];
+    language: string;
+    lineCount: number;
+    definitions: FileMapEntry["definitions"];
+    imports: string[];
+    exports: string[];
+}
+interface RepoContextResult {
+    graph: {
+        root: string;
+        generatedAt: string;
+        totalFiles: number;
+        totalDefinitions: number;
+    };
+    query: string;
+    budget: number;
+    items: RankedContextItem[];
+}
+declare function getRepoContext(request: RepoContextRequest): Promise<RepoContextResult>;
+declare function repoContext(request: RepoContextRequest): Promise<RepoContextResult>;
+declare const repoContextTool: ToolDefinition<RepoContextRequest, RepoContextResult>;
+declare const repoIntelligenceTools: ToolDefinition<RepoContextRequest, RepoContextResult>[];
+
+/**
+ * Subagent types for Corbat-Coco
+ * Defines the types for specialized agents that can be spawned for different tasks
+ */
+
+/**
+ * Available agent types for specialized tasks
+ */
+type AgentType = "explore" | "plan" | "test" | "debug" | "review" | "architect" | "security" | "tdd" | "refactor" | "e2e" | "docs" | "database";
+
+/**
+ * Agent task with priority and dependencies
+ */
+interface AgentTask {
+    id: string;
+    description: string;
+    priority: "high" | "medium" | "low";
+    estimatedDuration: number;
+    dependencies: string[];
+    status: "pending" | "running" | "completed" | "failed";
+    result?: unknown;
+    error?: string;
+}
+/**
+ * Execution strategy for multiple agents
+ */
+type ExecutionStrategy = "parallel" | "sequential" | "priority-based" | "pipeline";
+/**
+ * Tool: Create agent coordination plan
+ */
+declare const createAgentPlanTool: ToolDefinition<unknown, {
+    planId: string;
+    strategy: ExecutionStrategy;
+    totalTasks: number;
+    executionOrder: string[];
+    estimatedTime: number;
+    maxParallelism: number;
+    unresolvedDependencies: {
+        taskId: string;
+        dependency: string;
+    }[];
+    tasks: {
+        id: string;
+        description: string;
+        priority: "high" | "medium" | "low";
+        dependencies: string[];
+        status: "pending" | "completed" | "failed" | "running";
+    }[];
+}>;
+/**
+ * Tool: Delegate task to specialized sub-agent via AgentManager
+ */
+declare const delegateTaskTool: ToolDefinition<unknown, {
+    agentId: string;
+    taskId: string;
+    agentType: AgentType;
+    status: string;
+    message: string;
+    success: boolean;
+    output?: undefined;
+    usage?: undefined;
+    duration?: undefined;
+} | {
+    agentId: string;
+    taskId: string;
+    agentType: AgentType;
+    status: string;
+    output: string;
+    success: boolean;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    } | undefined;
+    duration: number;
+    message?: undefined;
+}>;
+/**
+ * Tool: Aggregate results from multiple agents
+ */
+declare const aggregateResultsTool: ToolDefinition<unknown, {
+    totalResults: number;
+    completedCount: number;
+    failedCount: number;
+    strategy: string;
+    aggregatedOutput: string;
+    individualResults: {
+        agentId: string;
+        taskId: string;
+        status: "completed" | "failed";
+    }[];
+}>;
+declare const agentCoordinatorTools: (ToolDefinition<unknown, {
+    planId: string;
+    strategy: ExecutionStrategy;
+    totalTasks: number;
+    executionOrder: string[];
+    estimatedTime: number;
+    maxParallelism: number;
+    unresolvedDependencies: {
+        taskId: string;
+        dependency: string;
+    }[];
+    tasks: {
+        id: string;
+        description: string;
+        priority: "high" | "medium" | "low";
+        dependencies: string[];
+        status: "pending" | "completed" | "failed" | "running";
+    }[];
+}> | ToolDefinition<unknown, {
+    agentId: string;
+    taskId: string;
+    agentType: AgentType;
+    status: string;
+    message: string;
+    success: boolean;
+    output?: undefined;
+    usage?: undefined;
+    duration?: undefined;
+} | {
+    agentId: string;
+    taskId: string;
+    agentType: AgentType;
+    status: string;
+    output: string;
+    success: boolean;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    } | undefined;
+    duration: number;
+    message?: undefined;
+}> | ToolDefinition<unknown, {
+    totalResults: number;
+    completedCount: number;
+    failedCount: number;
+    strategy: string;
+    aggregatedOutput: string;
+    individualResults: {
+        agentId: string;
+        taskId: string;
+        status: "completed" | "failed";
+    }[];
+}>)[];
+
+interface CodeSuggestion {
+    type: "refactor" | "performance" | "security" | "readability" | "testing";
+    line: number;
+    severity: "high" | "medium" | "low";
+    message: string;
+    suggestion: string;
+    reasoning: string;
+}
+/**
+ * Tool: Get smart improvement suggestions for code
+ */
+declare const suggestImprovementsTool: ToolDefinition<unknown, {
+    filePath: string;
+    totalSuggestions: number;
+    bySeverity: {
+        high: number;
+        medium: number;
+        low: number;
+    };
+    byType: {
+        refactor: number;
+        performance: number;
+        security: number;
+        readability: number;
+        testing: number;
+    };
+    suggestions: CodeSuggestion[];
+}>;
+/**
+ * Tool: Get code quality score
+ */
+declare const calculateCodeScoreTool: ToolDefinition<unknown, {
+    filePath: string;
+    score: number;
+    grade: string;
+    lines: number;
+    nonEmptyLines: number;
+    issues: {
+        high: number;
+        medium: number;
+        low: number;
+        total: number;
+    };
+    recommendations: string[];
+}>;
+declare const smartSuggestionsTools: (ToolDefinition<unknown, {
+    filePath: string;
+    totalSuggestions: number;
+    bySeverity: {
+        high: number;
+        medium: number;
+        low: number;
+    };
+    byType: {
+        refactor: number;
+        performance: number;
+        security: number;
+        readability: number;
+        testing: number;
+    };
+    suggestions: CodeSuggestion[];
+}> | ToolDefinition<unknown, {
+    filePath: string;
+    score: number;
+    grade: string;
+    lines: number;
+    nonEmptyLines: number;
+    issues: {
+        high: number;
+        medium: number;
+        low: number;
+        total: number;
+    };
+    recommendations: string[];
+}>)[];
+
+/**
+ * Context Enhancement Tool
+ * Intelligent context loading and session-level learning
+ */
+interface ContextItem {
+    type: "file" | "conversation" | "decision" | "pattern";
+    content: string;
+    timestamp: number;
+    relevance: number;
+    tags: string[];
+}
+interface LearningEntry {
+    pattern: string;
+    userPreference: string;
+    frequency: number;
+    lastUsed: number;
+}
+/**
+ * Tool: Add context to session memory
+ */
+declare const addContextTool: ToolDefinition<unknown, {
+    contextId: string;
+    type: "decision" | "conversation" | "file" | "pattern";
+    stored: boolean;
+    message: string;
+}>;
+/**
+ * Tool: Retrieve relevant context
+ */
+declare const getRelevantContextTool: ToolDefinition<unknown, {
+    query: string;
+    resultsFound: number;
+    contexts: {
+        type: "decision" | "conversation" | "file" | "pattern";
+        content: string;
+        tags: string[];
+        timestamp: string;
+    }[];
+}>;
+/**
+ * Tool: Record user preference/learning
+ */
+declare const recordLearningTool: ToolDefinition<unknown, {
+    pattern: string;
+    preference: string;
+    frequency: number;
+    message: string;
+}>;
+/**
+ * Tool: Get learned patterns
+ */
+declare const getLearnedPatternsTool: ToolDefinition<unknown, {
+    totalPatterns: number;
+    patterns: {
+        pattern: string;
+        preference: string;
+        frequency: number;
+        lastUsed: string;
+    }[];
+}>;
+declare const contextEnhancerTools: (ToolDefinition<unknown, {
+    contextId: string;
+    type: "decision" | "conversation" | "file" | "pattern";
+    stored: boolean;
+    message: string;
+}> | ToolDefinition<unknown, {
+    query: string;
+    resultsFound: number;
+    contexts: {
+        type: "decision" | "conversation" | "file" | "pattern";
+        content: string;
+        tags: string[];
+        timestamp: string;
+    }[];
+}> | ToolDefinition<unknown, {
+    pattern: string;
+    preference: string;
+    frequency: number;
+    message: string;
+}> | ToolDefinition<unknown, {
+    totalPatterns: number;
+    patterns: {
+        pattern: string;
+        preference: string;
+        frequency: number;
+        lastUsed: string;
+    }[];
+}>)[];
+
+/**
+ * Skill Enhancement Tool
+ * Dynamic skill loading and custom tool creation
+ */
+interface SkillDefinition {
+    name: string;
+    description: string;
+    category: string;
+    handler: string;
+    parameters: Record<string, unknown>;
+}
+/**
+ * Tool: Discover available skills
+ */
+declare const discoverSkillsTool: ToolDefinition<unknown, {
+    skillsDir: string;
+    totalSkills: number;
+    skills: {
+        name: string;
+        description: string;
+        version: string;
+        dependencies: string[];
+    }[];
+}>;
+/**
+ * Tool: Validate skill definition
+ */
+declare const validateSkillTool: ToolDefinition<unknown, {
+    valid: boolean;
+    errors: string[];
+    message: string;
+}>;
+/**
+ * Tool: Create custom tool from template
+ */
+declare const createCustomToolTool: ToolDefinition<unknown, {
+    name: string;
+    template: string;
+    code: string;
+    instructions: string[];
+}>;
+declare const skillEnhancerTools: (ToolDefinition<unknown, {
+    skillsDir: string;
+    totalSkills: number;
+    skills: {
+        name: string;
+        description: string;
+        version: string;
+        dependencies: string[];
+    }[];
+}> | ToolDefinition<unknown, {
+    valid: boolean;
+    errors: string[];
+    message: string;
+}> | ToolDefinition<unknown, {
+    name: string;
+    template: string;
+    code: string;
+    instructions: string[];
+}>)[];
+
+/**
+ * Tool: Analyze repository health
+ */
+declare const analyzeRepoHealthTool: ToolDefinition<unknown, {
+    score: number;
+    grade: string;
+    issues: string[];
+    recommendations: string[];
+    message: string;
+}>;
+/**
+ * Tool: Get commit statistics
+ */
+declare const getCommitStatsTool: ToolDefinition<unknown, {
+    totalCommits: number;
+    authorCount: number;
+    authors: string[];
+    recentActivity: string;
+    active: boolean;
+}>;
+/**
+ * Tool: Smart branch recommendation
+ */
+declare const recommendBranchTool: ToolDefinition<unknown, {
+    recommendedBranch: string;
+    prefix: string;
+    exists: boolean;
+    command: string;
+    warning: string | undefined;
+}>;
+declare const gitEnhancedTools: (ToolDefinition<unknown, {
+    score: number;
+    grade: string;
+    issues: string[];
+    recommendations: string[];
+    message: string;
+}> | ToolDefinition<unknown, {
+    totalCommits: number;
+    authorCount: number;
+    authors: string[];
+    recentActivity: string;
+    active: boolean;
+}> | ToolDefinition<unknown, {
+    recommendedBranch: string;
+    prefix: string;
+    exists: boolean;
+    command: string;
+    warning: string | undefined;
+}>)[];
+
+/**
+ * GitHub CLI Tools for Corbat-Coco
+ *
+ * Wraps the `gh` CLI to provide structured access to
+ * GitHub operations: PRs, releases, checks, repo info.
+ */
+
+declare const ghCheckAuthTool: ToolDefinition<{
+    cwd?: string;
+}, {
+    authenticated: boolean;
+    user?: string;
+    error?: string;
+}>;
+declare const ghRepoInfoTool: ToolDefinition<{
+    cwd?: string;
+}, {
+    name: string;
+    fullName: string;
+    defaultBranch: string;
+    url: string;
+    private: boolean;
+}>;
+declare const ghPrCreateTool: ToolDefinition<{
+    title: string;
+    body: string;
+    base?: string;
+    draft?: boolean;
+    cwd?: string;
+}, {
+    number: number;
+    url: string;
+}>;
+declare const ghPrMergeTool: ToolDefinition<{
+    number: number;
+    method?: "squash" | "merge" | "rebase";
+    deleteBranch?: boolean;
+    subject?: string;
+    body?: string;
+    cwd?: string;
+}, {
+    merged: boolean;
+    method: string;
+}>;
+interface PRCheck {
+    name: string;
+    status: "pass" | "fail" | "pending" | "skipping";
+    conclusion: string;
+    url: string;
+}
+declare const ghPrChecksTool: ToolDefinition<{
+    number: number;
+    cwd?: string;
+}, {
+    checks: PRCheck[];
+    allPassed: boolean;
+    anyFailed: boolean;
+    anyPending: boolean;
+}>;
+declare const ghPrListTool: ToolDefinition<{
+    head?: string;
+    state?: string;
+    cwd?: string;
+}, {
+    prs: Array<{
+        number: number;
+        title: string;
+        url: string;
+        state: string;
+    }>;
+}>;
+declare const ghReleaseCreateTool: ToolDefinition<{
+    tag: string;
+    title?: string;
+    notes?: string;
+    draft?: boolean;
+    prerelease?: boolean;
+    cwd?: string;
+}, {
+    url: string;
+    tag: string;
+}>;
+declare const githubTools: (ToolDefinition<{
+    cwd?: string;
+}, {
+    authenticated: boolean;
+    user?: string;
+    error?: string;
+}> | ToolDefinition<{
+    cwd?: string;
+}, {
+    name: string;
+    fullName: string;
+    defaultBranch: string;
+    url: string;
+    private: boolean;
+}> | ToolDefinition<{
+    title: string;
+    body: string;
+    base?: string;
+    draft?: boolean;
+    cwd?: string;
+}, {
+    number: number;
+    url: string;
+}> | ToolDefinition<{
+    number: number;
+    method?: "squash" | "merge" | "rebase";
+    deleteBranch?: boolean;
+    subject?: string;
+    body?: string;
+    cwd?: string;
+}, {
+    merged: boolean;
+    method: string;
+}> | ToolDefinition<{
+    number: number;
+    cwd?: string;
+}, {
+    checks: PRCheck[];
+    allPassed: boolean;
+    anyFailed: boolean;
+    anyPending: boolean;
+}> | ToolDefinition<{
+    head?: string;
+    state?: string;
+    cwd?: string;
+}, {
+    prs: Array<{
+        number: number;
+        title: string;
+        url: string;
+        state: string;
+    }>;
+}> | ToolDefinition<{
+    tag: string;
+    title?: string;
+    notes?: string;
+    draft?: boolean;
+    prerelease?: boolean;
+    cwd?: string;
+}, {
+    url: string;
+    tag: string;
+}>)[];
+
+/**
+ * Open / Execute tool for Corbat-Coco
+ *
+ * Opens files with the system default application or executes
+ * scripts and binaries with the appropriate interpreter.
+ *
+ * Open mode: delegates to the OS (macOS `open`, Linux `xdg-open`)
+ * Exec mode: detects interpreter from extension or +x permissions
+ */
+
+interface OpenFileOutput {
+    action: "opened" | "executed";
+    path: string;
+    resolvedCommand: string;
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+    duration: number;
+}
+declare const openFileTool: ToolDefinition<{
+    path: string;
+    mode?: "open" | "exec";
+    args?: string[];
+    cwd?: string;
+    timeout?: number;
+}, OpenFileOutput>;
+declare const openTools: ToolDefinition<{
+    path: string;
+    mode?: "open" | "exec";
+    args?: string[];
+    cwd?: string;
+    timeout?: number;
+}, OpenFileOutput>[];
+
+/**
+ * MCP inspection tools
+ */
+
+interface MCPFleetServerStatus {
+    name: string;
+    transport: "stdio" | "http" | "sse";
+    enabled: boolean;
+    connected: boolean;
+    healthy: boolean;
+    toolCount: number;
+    tools?: string[];
+}
+interface MCPFleetStatus {
+    configuredCount: number;
+    connectedCount: number;
+    servers: MCPFleetServerStatus[];
+}
+interface MCPConnectServerResult {
+    requestedServer: string;
+    connected: boolean;
+    healthy: boolean;
+    toolCount: number;
+    tools?: string[];
+    authTriggered: boolean;
+    message: string;
+}
+declare const mcpListServersTool: ToolDefinition<{
+    includeDisabled?: boolean;
+    includeTools?: boolean;
+    projectPath?: string;
+}, MCPFleetStatus>;
+declare const mcpConnectServerTool: ToolDefinition<{
+    server: string;
+    includeTools?: boolean;
+    projectPath?: string;
+}, MCPConnectServerResult>;
+declare const mcpTools: (ToolDefinition<{
+    includeDisabled?: boolean;
+    includeTools?: boolean;
+    projectPath?: string;
+}, MCPFleetStatus> | ToolDefinition<{
+    server: string;
+    includeTools?: boolean;
+    projectPath?: string;
+}, MCPConnectServerResult>)[];
+
+/**
+ * Tool exports for Corbat-Coco
+ */
+
+declare function registerAllTools(registry: ToolRegistry): void;
+/**
+ * Create a registry with all tools registered
+ */
+declare function createFullToolRegistry(): ToolRegistry;
+
+export { type SearchMatch as $, type AgentTask as A, type BuildResult as B, type Checkpoint as C, type DefinitionType as D, type ExecutionStrategy as E, type FileComplexity as F, type PackageManager as G, type HttpResponse as H, type ImageReadOutput as I, type PdfReadOutput as J, type RepoContextRequest as K, type LearningEntry as L, type MCPConnectServerResult as M, type RepoContextResult as N, type OpenFileOutput as O, type PRCheck as P, type QualityScores as Q, type RankedContextItem as R, type RepoGraphNode as S, type RepoIntelligenceGraph as T, type ReviewCategory as U, type ReviewFinding as V, type ReviewResult as W, type ReviewSeverity as X, type ReviewSummary as Y, type RiskLevel as Z, type SchemaInspectOutput as _, type QualityDimensions as a, ghPrMergeTool as a$, type SearchResult as a0, type SemanticSearchOutput as a1, type SemanticSearchResultItem as a2, type SkillDefinition as a3, type SqlQueryOutput as a4, type TestFailure as a5, type TestResult as a6, type ValidationResult as a7, type WebFetchOutput as a8, type WebSearchOutput as a9, createCustomToolTool as aA, createMemoryTool as aB, databaseTools as aC, delegateTaskTool as aD, deleteFileTool as aE, diagramTools as aF, diffTools as aG, discoverSkillsTool as aH, editFileTool as aI, fileExistsTool as aJ, fileTools as aK, findInFileTool as aL, findMissingImportsTool as aM, generateDiagramTool as aN, getCommitStatsTool as aO, getCoverageTool as aP, getEffectDescription as aQ, getEnvTool as aR, getLearnedPatternsTool as aS, getRelevantContextTool as aT, getRepoContext as aU, getRiskDescription as aV, getRiskLevel as aW, ghCheckAuthTool as aX, ghPrChecksTool as aY, ghPrCreateTool as aZ, ghPrListTool as a_, type WebSearchResultItem as aa, addContextTool as ab, agentCoordinatorTools as ac, aggregateResultsTool as ad, analyzeComplexityTool as ae, analyzeDirectoryTool as af, analyzeFileTool as ag, analyzeRepoHealthTool as ah, astValidatorTools as ai, bashBackgroundTool as aj, bashExecTool as ak, bashTools as al, buildTools as am, calculateCodeScoreTool as an, calculateQualityTool as ao, checkAgentCapabilityTool as ap, checkProtectedBranchTool as aq, checkpointTools as ar, codeAnalyzerTools as as, codebaseMapTool as at, codebaseMapTools as au, commandExistsTool as av, contextEnhancerTools as aw, copyFileTool as ax, createAgentPlanTool as ay, createCheckpointTool as az, type QualityThresholds as b, semanticSearchTools as b$, ghReleaseCreateTool as b0, ghRepoInfoTool as b1, gitAddTool as b2, gitBranchTool as b3, gitCheckoutTool as b4, gitCommitTool as b5, gitDiffTool as b6, gitEnhancedTools as b7, gitInitTool as b8, gitLogTool as b9, mcpListServersTool as bA, mcpTools as bB, memoryTools as bC, moveFileTool as bD, openFileTool as bE, openTools as bF, pdfTools as bG, permissionsTools as bH, qualityTools as bI, readFileTool as bJ, readImageTool as bK, readPdfTool as bL, recallMemoryTool as bM, recommendBranchTool as bN, recordLearningTool as bO, repoContext as bP, repoContextTool as bQ, repoIntelligenceTools as bR, restoreCheckpointTool as bS, reviewCodeTool as bT, reviewTools as bU, runLinterTool as bV, runScriptTool as bW, runTestFileTool as bX, runTestsTool as bY, searchTools as bZ, semanticSearchTool as b_, gitPullTool as ba, gitPushTool as bb, gitSimpleTools as bc, gitStatusTool as bd, gitTools as be, githubTools as bf, globTool as bg, grepTool as bh, httpFetchTool as bi, httpJsonTool as bj, httpTools as bk, imageTools as bl, inspectSchemaTool as bm, installDepsTool as bn, listCheckpointsTool as bo, listDirTool as bp, listMemoriesTool as bq, lspDefinitionTool as br, lspDocumentSymbolsTool as bs, lspReferencesTool as bt, lspStatusTool as bu, lspTools as bv, lspWorkspaceSymbolsTool as bw, makeTool as bx, managePermissionsTool as by, mcpConnectServerTool as bz, createFullToolRegistry as c, showDiffTool as c0, simpleAgentTools as c1, simpleAutoCommitTool as c2, skillEnhancerTools as c3, smartSuggestionsTools as c4, spawnSimpleAgentTool as c5, sqlQueryTool as c6, suggestImprovementsTool as c7, testTools as c8, treeTool as c9, tscTool as ca, validateCodeTool as cb, validateSkillTool as cc, webFetchTool as cd, webSearchTool as ce, webTools as cf, writeFileTool as cg, type ClassInfo as d, type CodeAnalysisResult as e, type CodeDefinition as f, type CodeSuggestion as g, type CodebaseMapOutput as h, type ComplexityResult as i, type ContextItem as j, type CoverageResult as k, type DiagramOutput as l, type ExportInfo as m, type FileMapEntry as n, type FunctionComplexity as o, type FunctionInfo as p, type ImportInfo as q, registerAllTools as r, type LintIssue as s, type LintResult as t, type LspReference as u, type LspStatusOutput as v, type LspSymbol as w, type MCPFleetServerStatus as x, type MCPFleetStatus as y, type Memory as z };