import { DatabaseTools } from './database-tools.js';
import { ValidationTools } from './validation-tools.js';
/**
 * Orchestration tools for workflow coordination.
 * Combines Database and Validation tools for complete workflows.
 */
export declare class OrchestrationTools {
    private databaseTools;
    private validationTools;
    private workspaceRoot;
    constructor(databaseTools: DatabaseTools, validationTools: ValidationTools, workspaceRoot: string);
    private resolvePluginId;
    /**
     * Full cycle workflow: Scan → Generate → Validate → Ingest → Embeddings
     */
    fullCycle(pluginId: string): Promise<any>;
    /**
     * Generate and ingest workflow.
     */
    generateAndIngest(pluginId: string): Promise<any>;
    /**
     * Check system status.
     */
    checkStatus(pluginId?: string): Promise<any>;
    /**
     * Ensure the system is ready for onboarding and usage.
     *
     * Best-effort behavior (deterministic):
     * - Always runs check_status first
     * - If docs/ are missing/incomplete, attempts to generate docs/ (requires documentation-system-plugin compiled)
     * - If databases are missing/incomplete, attempts ingestion
     * - Embeddings are OPTIONAL and are not generated here (guidance only)
     */
    ensureReady(args: {
        pluginId?: string;
    }): Promise<any>;
    /**
     * Onboard workflow for a foreign codebase.
     *
     * Produces a deterministic, copy/paste friendly report (Markdown) plus structured JSON.
     * No AI generation: everything is tool-/database-driven.
     */
    onboard(args: {
        pluginId?: string;
        ensureReady?: boolean;
        semanticQueries?: string[];
        semanticLimit?: number;
        gapMinDependencies?: number;
        gapLimit?: number;
        summaryOnly?: boolean;
        excludeMarkdown?: boolean;
        excludeSteps?: boolean;
    }): Promise<any>;
    /**
     * Generate onboarding report (refs-first).
     *
     * @param args Arguments (pluginId, mode, reportType)
     * @returns Onboarding report (refs-first)
     */
    onboardingReport(args: {
        pluginId?: string;
        mode?: 'refs' | 'full';
        reportType?: 'summary' | 'full';
    }): Promise<any>;
    /**
     * Autonomous feature workflow (Phase 3 / Autonomy).
     *
     * This tool is intentionally deterministic and tool-driven:
     * - Collects system context via existing MCP/database tools
     * - Returns a structured plan + gathered context
     * - Does NOT modify code directly (implementation remains the AI-agent's responsibility)
     */
    autonomousFeature(args: {
        pluginId: string;
        requirement: string;
        limit?: number;
        candidateFiles?: string[];
        ensureReady?: boolean;
    }): Promise<any>;
    /**
     * Autonomous refactoring workflow (Phase 3 / Autonomy).
     *
     * Focuses on impact analysis (dependencies, ADR context, change history) and provides
     * a stepwise refactoring checklist aligned with Reality-Driven Verification.
     */
    autonomousRefactoring(args: {
        pluginId: string;
        filePath: string;
        goal?: string;
        ensureReady?: boolean;
    }): Promise<any>;
    /**
     * Autonomous documentation maintenance (Phase 3 / Autonomy).
     *
     * Identifies documentation gaps and (optionally) generates ADRs deterministically.
     */
    autonomousDocumentation(args: {
        pluginId: string;
        minDependencies?: number;
        limit?: number;
        generateAdrs?: boolean;
        dryRun?: boolean;
        verifyAdrs?: boolean;
        ensureReady?: boolean;
    }): Promise<any>;
    /**
     * Co-Partner workflow: create a structured plan + human checkpoints.
     *
     * This is intentionally lightweight and deterministic. It returns:
     * - a recommended next MCP tool call (feature/refactor/docs)
     * - explicit human approval checkpoints (evidence-based)
     * - rollback guidance (commands only; no side effects)
     */
    coPartnerPlan(args: {
        pluginId: string;
        changeType: 'feature' | 'refactor' | 'documentation';
        goal: string;
        targetFiles?: string[];
        constraints?: string[];
        ensureReady?: boolean;
        limit?: number;
    }): Promise<any>;
    /**
     * Co-Partner workflow: interpret human feedback and suggest next action.
     *
     * Deterministic heuristics only (no LLM).
     */
    coPartnerFeedback(args: {
        stage: 'analysis' | 'implementation' | 'verification' | 'review';
        feedback: string;
    }): Promise<any>;
    /**
     * Co-Partner workflow: rollback guidance (commands only; no side effects).
     */
    coPartnerRollback(args: {
        strategy: 'git' | 'docs_db';
        targetPaths?: string[];
    }): Promise<any>;
    /**
     * Check if ingestion is needed.
     */
    private checkIngestStatus;
    /**
     * Check if embeddings are needed.
     */
    private checkEmbeddingStatus;
    /**
     * Verifies plugin ID consistency between calculated value and database content.
     * Critical for foreign systems where plugin ID mismatches cause empty query results.
     */
    private verifyPluginId;
    /**
     * Generate system contract.
     *
     * @param pluginId Plugin ID (optional)
     * @returns System contract with sources
     */
    systemContract(args: {
        pluginId?: string;
        mode?: 'refs' | 'full';
        expand?: string[];
    }): Promise<any>;
    /**
     * Generate tools manifest.
     *
     * @param args Arguments (pluginId, mode, expand)
     * @returns Tools manifest (refs-first)
     */
    toolsManifest(args: {
        pluginId?: string;
        mode?: 'refs' | 'full';
        expand?: string[];
    }): Promise<any>;
    /**
     * Export system snapshot (refs-first).
     *
     * @param args Arguments (outputPath, delta, lastSnapshotHash, pluginId, mode, expand)
     * @returns Snapshot export result (refs-first)
     */
    exportSnapshot(args: {
        outputPath?: string;
        delta?: boolean;
        lastSnapshotHash?: string;
        pluginId?: string;
        mode?: 'refs' | 'full';
        expand?: string[];
    }): Promise<any>;
    /**
     * Get snapshot by artifact ID (refs-first).
     *
     * @param args Arguments (artifactId, pluginId, mode, expand)
     * @returns Snapshot (refs-first)
     */
    snapshotGet(args: {
        artifactId: string;
        pluginId?: string;
        mode?: 'refs' | 'full';
        expand?: string[];
    }): Promise<any>;
    /**
     * Import system snapshot.
     *
     * @param args Arguments (snapshotPath, delta, pluginId)
     * @returns Snapshot import result
     */
    importSnapshot(args: {
        snapshotPath: string;
        delta?: boolean;
        pluginId?: string;
    }): Promise<any>;
}
//# sourceMappingURL=orchestration-tools.d.ts.map