import * as sdk from "../sdk/index.js";
import type { CapabilityRegistry } from "../types/index.js";
import { ExecutionArtifactAdapter } from "./artifact-adapter.js";
import { CanonicalLanguageAuditor } from "./language-auditor.js";
import { RepositoryHealth } from "./repository-health.js";
import { SemanticVerifier } from "./semantic-verifier.js";
import type { StateReader, HealthStatus } from "./types.js";
export type EnvironmentCheck = {
    name: string;
    status: "PASS" | "WARN" | "FAIL";
    detail: string;
};
export type EnvironmentReport = {
    status: "READY" | "DEGRADED" | "BLOCKED";
    platform: string;
    runtime: {
        name: string;
        version: string;
        ok: boolean;
    };
    checks: EnvironmentCheck[];
    summary: {
        pass: number;
        warn: number;
        fail: number;
    };
};
export type WorkspaceDescriptor = {
    version: string;
    generatedAt: string;
    identity: {
        system: string;
        version: string;
        description: string;
        layers: string[];
    };
    environment: EnvironmentReport;
    architecture: Awaited<ReturnType<WorkspaceCognitionEnvironment["verifyArchitecture"]>>;
    language: Awaited<ReturnType<WorkspaceCognitionEnvironment["verifyLanguage"]>>;
    semantic: Awaited<ReturnType<WorkspaceCognitionEnvironment["verifySemantics"]>>;
    health: Awaited<ReturnType<WorkspaceCognitionEnvironment["getHealth"]>>;
    engineeringContext: {
        missionCount: number;
        expeditionCount: number;
        objectiveCount: number;
        discoveryCount: number;
        decisionCount: number;
        workItemCount: number;
        eventCount: number;
    };
    suggestedActions: {
        action: string;
        context: string;
        priority: string;
    }[];
};
export declare class WorkspaceCognitionEnvironment {
    private reader;
    private capabilityRegistry;
    languageAuditor: CanonicalLanguageAuditor;
    semanticVerifier: SemanticVerifier;
    health: RepositoryHealth;
    artifactAdapter: ExecutionArtifactAdapter;
    private orientationCount;
    private lastOrientationAt;
    private phaseLog;
    private blocks;
    constructor(reader: StateReader, capabilityRegistry: CapabilityRegistry);
    getIdentity(): {
        system: string;
        version: string;
        description: string;
        layers: string[];
    };
    getEnvironment(): Promise<EnvironmentReport>;
    getArchitecture(): {
        ubiquitousLanguage: import("./language-auditor.js").LanguageReport;
        invariants: {
            id: string;
            text: string;
            status: string;
        }[];
    };
    verifyArchitecture(): Promise<{
        checks: {
            name: string;
            category: string;
            status: HealthStatus;
            path: string;
        }[];
        invariants: {
            id: string;
            text: string;
            status: string;
        }[];
    }>;
    verifyLanguage(): Promise<{
        source: string;
        loaded: boolean;
        layers: Record<string, {
            term: string;
            definition: string;
        }[]>;
        forbidden: {
            term: string;
            replacement: string;
        }[];
        sourceAudit: {
            passed: boolean;
            issues: Array<{
                message: string;
            }>;
        };
    }>;
    verifySemantics(): Promise<import("./semantic-verifier.js").SemanticVerificationResult>;
    getHealth(): Promise<import("./repository-health.js").RepositoryHealthResult>;
    getEngineeringContext(): Promise<{
        missions: import("../types/state.js").Mission[];
        expeditions: import("../types/state.js").Expedition[];
        objectives: import("../types/state.js").Objective[];
        discoveries: import("../types/state.js").Discovery[];
        decisions: import("../types/state.js").Decision[];
        workItems: import("../types/state.js").WorkItem[];
        eventCount: number;
    }>;
    getSuggestedActions(context: {
        expeditions?: Array<{
            status: string;
            name: string;
        }>;
        discoveries?: unknown[];
    }): {
        action: string;
        context: string;
        priority: string;
    }[];
    canProceed(): Promise<{
        canProceed: boolean;
        blockReason: string;
        warnings: string[];
    } | {
        canProceed: boolean;
        blockReason: null;
        warnings: string[];
    }>;
    generateWorkspaceDescriptor(): Promise<WorkspaceDescriptor>;
    render(): Promise<string>;
    writeDescriptors(): Promise<{
        written: number;
        files: string[];
        directory: typeof sdk.paths.synthDir;
    }>;
}