declare const MEM_PALACE_OPERATIONS: readonly ["install", "initialize", "mcp-configure", "model-download", "mining", "hooks", "read", "write", "coordination-write", "logstream-write", "delete"];
export type MemPalaceOperation = typeof MEM_PALACE_OPERATIONS[number];
export type MemPalaceReadinessStatus = "compatible" | "missing" | "incompatible" | "invalid";
export type MemPalaceMcpPlanStatus = "requires-approval" | "already-configured" | "unavailable" | "unsupported";
export type MemPalaceCommandRunner = (command: string, args: string[]) => Promise<MemPalaceCommandResult>;
export interface MemPalaceCommandResult {
    code: number | null;
    stdout: string;
    detail: string;
}
export interface MemPalaceManifest {
    schemaVersion: 1;
    name: "mempalace";
    package: "mempalace";
    version: "3.6.0";
    packageSpec: "mempalace==3.6.0";
    python: ">=3.9";
    install: {
        command: "uv";
        args: ["tool", "install", "mempalace==3.6.0"];
        effects: string[];
    };
    compatibility: {
        policy: "exact-version";
        mismatch: "report-only-no-silent-replacement";
        upgrade: "requires-manifest-change-refreshed-official-evidence-and-compatibility-tests";
    };
    capabilityDetection: {
        version: ["--version"];
        mcp: ["mcp", "--help"];
        toolCount: "runtime-detected";
    };
    canonicalPalace: {
        defaultRelativePath: ".mempalace/aili-palace";
        overrideEnvironment: "AILI_MEMPALACE_PALACE_PATH";
    };
    operations: MemPalaceOperation[];
}
export interface MemPalaceReadiness {
    status: MemPalaceReadinessStatus;
    expectedVersion: string;
    observedVersion?: string;
    python: {
        required: string;
        observedVersion?: string;
        status: "compatible" | "missing" | "incompatible" | "invalid";
    };
    capabilities: {
        mcpConfiguration: "available" | "unavailable";
        toolCount: "runtime-detected";
    };
    concurrentWriteSafety: "Unverified";
    reason?: string;
}
export interface MemPalaceMcpPlan {
    status: MemPalaceMcpPlanStatus;
    adapter: string;
    operation: "mcp-configure";
    approval: "fresh-exact-separate";
    configuration?: {
        serverName: string;
        command: string[];
    };
    reason: string;
    refusalResult: string;
    concurrentWriteSafety: "Unverified";
}
export interface MemPalaceInstallSummary {
    status: "planned" | "skipped" | "preserved" | "installed" | "incompatible" | "failed";
    package: string;
    expectedVersion: string;
    command: string;
    argv: string[];
    effects: string[];
    readiness: MemPalaceReadiness;
    reason: string;
}
export interface MemPalaceInstallOptions {
    ailiHome: string;
    dryRun: boolean;
    enabled?: boolean;
    skip?: boolean;
    runner?: MemPalaceCommandRunner;
}
export interface PalaceMappingOptions {
    projectRoot: string;
    agent: string;
    home?: string;
    palacePath?: string;
}
export interface PalaceMapping {
    palacePath: string;
    projectRoot: string;
    projectWing: string;
    sharedWing: "shared";
    agentDiary: string;
}
export interface MemoryRequirement {
    readiness: MemPalaceReadiness;
    mcp: Pick<MemPalaceMcpPlan, "status">;
    mapping: PalaceMapping;
    operation: Exclude<MemPalaceOperation, "install" | "mcp-configure">;
    approvedOperation?: MemPalaceOperation;
    possibleConcurrentWriter?: boolean;
}
export declare class MemPalaceUnavailableError extends Error {
    readonly code = "MEMPALACE_MEMORY_BLOCKED";
}
export declare function loadMemPalaceManifest(ailiHome: string): Promise<MemPalaceManifest>;
export declare function inspectMemPalace(ailiHome: string, runner?: MemPalaceCommandRunner): Promise<MemPalaceReadiness>;
export declare function planMemPalaceMcpConfiguration(options: {
    ailiHome: string;
    adapter: string;
    readiness: MemPalaceReadiness;
    configured?: boolean;
}): Promise<MemPalaceMcpPlan>;
export declare function resolvePalaceMapping(options: PalaceMappingOptions): PalaceMapping;
export declare function resolveCanonicalPalacePath(options?: Pick<PalaceMappingOptions, "home" | "palacePath">): string;
export declare function requireMemPalaceMemory(options: MemoryRequirement): void;
export declare function planMemPalaceOperation(operation: MemPalaceOperation): {
    operation: MemPalaceOperation;
    approval: "fresh-exact-separate";
    refusalResult: string;
};
export declare function legacyRoseMemoryMigrationPrompt(projectRoot: string): {
    scope: "repository";
    scopeKey: string;
    oneTime: true;
    prompt: string;
};
export declare function runMemPalaceInstall(options: MemPalaceInstallOptions): Promise<MemPalaceInstallSummary>;
export {};