import { D as DocBridgeConfigV1, a as DocumentationStandardRuleId } from './index-DAeq_OIi.js';
export { A as AgentCorpusConfig, C as ConfigNotFoundError, b as DocBridgeConfigV1Schema, c as DocumentationStandardRuleIdSchema, d as DocumentationStandardV1Config, e as DocumentationStandardV1ConfigSchema, E as EcosystemContractEvidenceSchema, L as LoadConfigOptions, f as LoadConfigResult, g as applyConfigDefaults, h as defineConfig, l as loadConfig, p as projectRootFromConfigPath, r as resolveProjectRoot } from './index-DAeq_OIi.js';
import { z } from 'zod';

declare const HANDOFF_SCHEMA_VERSION: 1;
declare const HandoffTargetTypeSchema: z.ZodEnum<["package", "module", "app", "screen", "flow", "component", "intent", "change", "search"]>;
type HandoffTargetType = z.infer<typeof HandoffTargetTypeSchema>;
declare const HandoffTargetSchema: z.ZodObject<{
    type: z.ZodEnum<["package", "module", "app", "screen", "flow", "component", "intent", "change", "search"]>;
    id: z.ZodString;
    path: z.ZodOptional<z.ZodString>;
    group: z.ZodOptional<z.ZodString>;
    layer: z.ZodOptional<z.ZodString>;
}, "strict", z.ZodTypeAny, {
    type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
    id: string;
    path?: string | undefined;
    group?: string | undefined;
    layer?: string | undefined;
}, {
    type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
    id: string;
    path?: string | undefined;
    group?: string | undefined;
    layer?: string | undefined;
}>;
type HandoffTarget = z.infer<typeof HandoffTargetSchema>;
declare const HandoffBridgeSchema: z.ZodObject<{
    humanDoc: z.ZodEnum<["linked", "missing", "external"]>;
    action: z.ZodOptional<z.ZodString>;
    bootstrap: z.ZodOptional<z.ZodString>;
}, "strict", z.ZodTypeAny, {
    humanDoc: "linked" | "missing" | "external";
    action?: string | undefined;
    bootstrap?: string | undefined;
}, {
    humanDoc: "linked" | "missing" | "external";
    action?: string | undefined;
    bootstrap?: string | undefined;
}>;
type HandoffBridge = z.infer<typeof HandoffBridgeSchema>;
/** v1 — canonical AgentHandoff. Legacy payloads may omit schemaVersion. */
declare const AgentHandoffV1Schema: z.ZodObject<{
    type: z.ZodLiteral<"agent-handoff">;
    schemaVersion: z.ZodDefault<z.ZodLiteral<1>>;
    source: z.ZodString;
    target: z.ZodObject<{
        type: z.ZodEnum<["package", "module", "app", "screen", "flow", "component", "intent", "change", "search"]>;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        group: z.ZodOptional<z.ZodString>;
        layer: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
        id: string;
        path?: string | undefined;
        group?: string | undefined;
        layer?: string | undefined;
    }, {
        type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
        id: string;
        path?: string | undefined;
        group?: string | undefined;
        layer?: string | undefined;
    }>;
    startHere: z.ZodString;
    readBeforeEditing: z.ZodArray<z.ZodString, "many">;
    editRoots: z.ZodArray<z.ZodString, "many">;
    checks: z.ZodArray<z.ZodString, "many">;
    humanDoc: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    bridge: z.ZodOptional<z.ZodObject<{
        humanDoc: z.ZodEnum<["linked", "missing", "external"]>;
        action: z.ZodOptional<z.ZodString>;
        bootstrap: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        humanDoc: "linked" | "missing" | "external";
        action?: string | undefined;
        bootstrap?: string | undefined;
    }, {
        humanDoc: "linked" | "missing" | "external";
        action?: string | undefined;
        bootstrap?: string | undefined;
    }>>;
    playbookPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    notes: z.ZodArray<z.ZodString, "many">;
}, "strict", z.ZodTypeAny, {
    type: "agent-handoff";
    checks: string[];
    startHere: string;
    schemaVersion: 1;
    source: string;
    target: {
        type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
        id: string;
        path?: string | undefined;
        group?: string | undefined;
        layer?: string | undefined;
    };
    readBeforeEditing: string[];
    editRoots: string[];
    notes: string[];
    humanDoc?: string | null | undefined;
    bridge?: {
        humanDoc: "linked" | "missing" | "external";
        action?: string | undefined;
        bootstrap?: string | undefined;
    } | undefined;
    playbookPatterns?: string[] | undefined;
}, {
    type: "agent-handoff";
    checks: string[];
    startHere: string;
    source: string;
    target: {
        type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
        id: string;
        path?: string | undefined;
        group?: string | undefined;
        layer?: string | undefined;
    };
    readBeforeEditing: string[];
    editRoots: string[];
    notes: string[];
    humanDoc?: string | null | undefined;
    schemaVersion?: 1 | undefined;
    bridge?: {
        humanDoc: "linked" | "missing" | "external";
        action?: string | undefined;
        bootstrap?: string | undefined;
    } | undefined;
    playbookPatterns?: string[] | undefined;
}>;
type AgentHandoffV1 = z.infer<typeof AgentHandoffV1Schema>;
/** Accept legacy handoffs without schemaVersion. */
declare const AgentHandoffLegacySchema: z.ZodObject<Omit<{
    type: z.ZodLiteral<"agent-handoff">;
    schemaVersion: z.ZodDefault<z.ZodLiteral<1>>;
    source: z.ZodString;
    target: z.ZodObject<{
        type: z.ZodEnum<["package", "module", "app", "screen", "flow", "component", "intent", "change", "search"]>;
        id: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        group: z.ZodOptional<z.ZodString>;
        layer: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
        id: string;
        path?: string | undefined;
        group?: string | undefined;
        layer?: string | undefined;
    }, {
        type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
        id: string;
        path?: string | undefined;
        group?: string | undefined;
        layer?: string | undefined;
    }>;
    startHere: z.ZodString;
    readBeforeEditing: z.ZodArray<z.ZodString, "many">;
    editRoots: z.ZodArray<z.ZodString, "many">;
    checks: z.ZodArray<z.ZodString, "many">;
    humanDoc: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    bridge: z.ZodOptional<z.ZodObject<{
        humanDoc: z.ZodEnum<["linked", "missing", "external"]>;
        action: z.ZodOptional<z.ZodString>;
        bootstrap: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        humanDoc: "linked" | "missing" | "external";
        action?: string | undefined;
        bootstrap?: string | undefined;
    }, {
        humanDoc: "linked" | "missing" | "external";
        action?: string | undefined;
        bootstrap?: string | undefined;
    }>>;
    playbookPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    notes: z.ZodArray<z.ZodString, "many">;
}, "schemaVersion"> & {
    schemaVersion: z.ZodOptional<z.ZodLiteral<1>>;
}, "strict", z.ZodTypeAny, {
    type: "agent-handoff";
    checks: string[];
    startHere: string;
    source: string;
    target: {
        type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
        id: string;
        path?: string | undefined;
        group?: string | undefined;
        layer?: string | undefined;
    };
    readBeforeEditing: string[];
    editRoots: string[];
    notes: string[];
    humanDoc?: string | null | undefined;
    schemaVersion?: 1 | undefined;
    bridge?: {
        humanDoc: "linked" | "missing" | "external";
        action?: string | undefined;
        bootstrap?: string | undefined;
    } | undefined;
    playbookPatterns?: string[] | undefined;
}, {
    type: "agent-handoff";
    checks: string[];
    startHere: string;
    source: string;
    target: {
        type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
        id: string;
        path?: string | undefined;
        group?: string | undefined;
        layer?: string | undefined;
    };
    readBeforeEditing: string[];
    editRoots: string[];
    notes: string[];
    humanDoc?: string | null | undefined;
    schemaVersion?: 1 | undefined;
    bridge?: {
        humanDoc: "linked" | "missing" | "external";
        action?: string | undefined;
        bootstrap?: string | undefined;
    } | undefined;
    playbookPatterns?: string[] | undefined;
}>;
declare const AgentSearchV1Schema: z.ZodObject<{
    type: z.ZodLiteral<"agent-search">;
    schemaVersion: z.ZodDefault<z.ZodLiteral<1>>;
    source: z.ZodString;
    term: z.ZodString;
    count: z.ZodNumber;
    bestMatch: z.ZodNullable<z.ZodObject<{
        type: z.ZodString;
        id: z.ZodString;
        path: z.ZodString;
        summary: z.ZodOptional<z.ZodString>;
        score: z.ZodOptional<z.ZodNumber>;
        refs: z.ZodOptional<z.ZodNumber>;
    }, "strict", z.ZodTypeAny, {
        path: string;
        type: string;
        id: string;
        summary?: string | undefined;
        score?: number | undefined;
        refs?: number | undefined;
    }, {
        path: string;
        type: string;
        id: string;
        summary?: string | undefined;
        score?: number | undefined;
        refs?: number | undefined;
    }>>;
    matches: z.ZodArray<z.ZodObject<{
        type: z.ZodString;
        id: z.ZodString;
        path: z.ZodString;
        summary: z.ZodOptional<z.ZodString>;
        score: z.ZodOptional<z.ZodNumber>;
        refs: z.ZodOptional<z.ZodNumber>;
    }, "strict", z.ZodTypeAny, {
        path: string;
        type: string;
        id: string;
        summary?: string | undefined;
        score?: number | undefined;
        refs?: number | undefined;
    }, {
        path: string;
        type: string;
        id: string;
        summary?: string | undefined;
        score?: number | undefined;
        refs?: number | undefined;
    }>, "many">;
    nextCommands: z.ZodArray<z.ZodString, "many">;
}, "strict", z.ZodTypeAny, {
    type: "agent-search";
    schemaVersion: 1;
    source: string;
    term: string;
    count: number;
    bestMatch: {
        path: string;
        type: string;
        id: string;
        summary?: string | undefined;
        score?: number | undefined;
        refs?: number | undefined;
    } | null;
    matches: {
        path: string;
        type: string;
        id: string;
        summary?: string | undefined;
        score?: number | undefined;
        refs?: number | undefined;
    }[];
    nextCommands: string[];
}, {
    type: "agent-search";
    source: string;
    term: string;
    count: number;
    bestMatch: {
        path: string;
        type: string;
        id: string;
        summary?: string | undefined;
        score?: number | undefined;
        refs?: number | undefined;
    } | null;
    matches: {
        path: string;
        type: string;
        id: string;
        summary?: string | undefined;
        score?: number | undefined;
        refs?: number | undefined;
    }[];
    nextCommands: string[];
    schemaVersion?: 1 | undefined;
}>;
type AgentSearchV1 = z.infer<typeof AgentSearchV1Schema>;
declare const normalizeAgentHandoff: (input: unknown) => AgentHandoffV1;

declare const INDEX_SCHEMA_VERSION: 1;
declare const KnowledgeEntrySchema: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodString;
    title: z.ZodString;
    path: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    /** Flattened body excerpt for full-text search (not for display). */
    body: z.ZodOptional<z.ZodString>;
    links: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strict", z.ZodTypeAny, {
    path: string;
    type: string;
    id: string;
    title: string;
    links?: string[] | undefined;
    description?: string | undefined;
    body?: string | undefined;
    tags?: string[] | undefined;
}, {
    path: string;
    type: string;
    id: string;
    title: string;
    links?: string[] | undefined;
    description?: string | undefined;
    body?: string | undefined;
    tags?: string[] | undefined;
}>;
declare const DocBridgeIndexV1Schema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<1>;
    contentHash: z.ZodString;
    contentHashAlgo: z.ZodLiteral<"sha256-normalized-v1">;
    generatedAt: z.ZodOptional<z.ZodString>;
    project: z.ZodOptional<z.ZodObject<{
        name: z.ZodString;
        root: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        name: string;
        root?: string | undefined;
    }, {
        name: string;
        root?: string | undefined;
    }>>;
    properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        url: z.ZodOptional<z.ZodString>;
        llms: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        id: string;
        name: string;
        url?: string | undefined;
        llms?: string | undefined;
    }, {
        id: string;
        name: string;
        url?: string | undefined;
        llms?: string | undefined;
    }>, "many">>;
    knowledge: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodString;
        title: z.ZodString;
        path: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        /** Flattened body excerpt for full-text search (not for display). */
        body: z.ZodOptional<z.ZodString>;
        links: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strict", z.ZodTypeAny, {
        path: string;
        type: string;
        id: string;
        title: string;
        links?: string[] | undefined;
        description?: string | undefined;
        body?: string | undefined;
        tags?: string[] | undefined;
    }, {
        path: string;
        type: string;
        id: string;
        title: string;
        links?: string[] | undefined;
        description?: string | undefined;
        body?: string | undefined;
        tags?: string[] | undefined;
    }>, "many">;
    capabilities: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        kind: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        id: string;
        kind: string;
        description?: string | undefined;
    }, {
        id: string;
        kind: string;
        description?: string | undefined;
    }>, "many">>;
    handoffs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
        type: z.ZodLiteral<"agent-handoff">;
        schemaVersion: z.ZodDefault<z.ZodLiteral<1>>;
        source: z.ZodString;
        target: z.ZodObject<{
            type: z.ZodEnum<["package", "module", "app", "screen", "flow", "component", "intent", "change", "search"]>;
            id: z.ZodString;
            path: z.ZodOptional<z.ZodString>;
            group: z.ZodOptional<z.ZodString>;
            layer: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
            id: string;
            path?: string | undefined;
            group?: string | undefined;
            layer?: string | undefined;
        }, {
            type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
            id: string;
            path?: string | undefined;
            group?: string | undefined;
            layer?: string | undefined;
        }>;
        startHere: z.ZodString;
        readBeforeEditing: z.ZodArray<z.ZodString, "many">;
        editRoots: z.ZodArray<z.ZodString, "many">;
        checks: z.ZodArray<z.ZodString, "many">;
        humanDoc: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        bridge: z.ZodOptional<z.ZodObject<{
            humanDoc: z.ZodEnum<["linked", "missing", "external"]>;
            action: z.ZodOptional<z.ZodString>;
            bootstrap: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            humanDoc: "linked" | "missing" | "external";
            action?: string | undefined;
            bootstrap?: string | undefined;
        }, {
            humanDoc: "linked" | "missing" | "external";
            action?: string | undefined;
            bootstrap?: string | undefined;
        }>>;
        playbookPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        notes: z.ZodArray<z.ZodString, "many">;
    }, "schemaVersion"> & {
        schemaVersion: z.ZodOptional<z.ZodLiteral<1>>;
    }, "strict", z.ZodTypeAny, {
        type: "agent-handoff";
        checks: string[];
        startHere: string;
        source: string;
        target: {
            type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
            id: string;
            path?: string | undefined;
            group?: string | undefined;
            layer?: string | undefined;
        };
        readBeforeEditing: string[];
        editRoots: string[];
        notes: string[];
        humanDoc?: string | null | undefined;
        schemaVersion?: 1 | undefined;
        bridge?: {
            humanDoc: "linked" | "missing" | "external";
            action?: string | undefined;
            bootstrap?: string | undefined;
        } | undefined;
        playbookPatterns?: string[] | undefined;
    }, {
        type: "agent-handoff";
        checks: string[];
        startHere: string;
        source: string;
        target: {
            type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
            id: string;
            path?: string | undefined;
            group?: string | undefined;
            layer?: string | undefined;
        };
        readBeforeEditing: string[];
        editRoots: string[];
        notes: string[];
        humanDoc?: string | null | undefined;
        schemaVersion?: 1 | undefined;
        bridge?: {
            humanDoc: "linked" | "missing" | "external";
            action?: string | undefined;
            bootstrap?: string | undefined;
        } | undefined;
        playbookPatterns?: string[] | undefined;
    }>>>;
    lookup: z.ZodOptional<z.ZodObject<{
        packages: z.ZodArray<z.ZodString, "many">;
        ownership: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            id: z.ZodString;
            path: z.ZodString;
            group: z.ZodOptional<z.ZodString>;
            layer: z.ZodOptional<z.ZodString>;
            purpose: z.ZodOptional<z.ZodString>;
            checks: z.ZodArray<z.ZodString, "many">;
            agentDoc: z.ZodOptional<z.ZodString>;
            humanDoc: z.ZodOptional<z.ZodString>;
            readme: z.ZodOptional<z.ZodString>;
        }, "strict", z.ZodTypeAny, {
            path: string;
            checks: string[];
            id: string;
            group?: string | undefined;
            layer?: string | undefined;
            purpose?: string | undefined;
            agentDoc?: string | undefined;
            humanDoc?: string | undefined;
            readme?: string | undefined;
        }, {
            path: string;
            checks: string[];
            id: string;
            group?: string | undefined;
            layer?: string | undefined;
            purpose?: string | undefined;
            agentDoc?: string | undefined;
            humanDoc?: string | undefined;
            readme?: string | undefined;
        }>>>;
        intents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            id: z.ZodString;
            title: z.ZodString;
            paths: z.ZodArray<z.ZodString, "many">;
        }, "strict", z.ZodTypeAny, {
            id: string;
            title: string;
            paths: string[];
        }, {
            id: string;
            title: string;
            paths: string[];
        }>>>;
        changes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            id: z.ZodString;
            title: z.ZodString;
            startHere: z.ZodString;
            relatedPackages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        }, "strict", z.ZodTypeAny, {
            id: string;
            title: string;
            startHere: string;
            relatedPackages?: string[] | undefined;
        }, {
            id: string;
            title: string;
            startHere: string;
            relatedPackages?: string[] | undefined;
        }>>>;
    }, "strict", z.ZodTypeAny, {
        packages: string[];
        ownership?: Record<string, {
            path: string;
            checks: string[];
            id: string;
            group?: string | undefined;
            layer?: string | undefined;
            purpose?: string | undefined;
            agentDoc?: string | undefined;
            humanDoc?: string | undefined;
            readme?: string | undefined;
        }> | undefined;
        intents?: Record<string, {
            id: string;
            title: string;
            paths: string[];
        }> | undefined;
        changes?: Record<string, {
            id: string;
            title: string;
            startHere: string;
            relatedPackages?: string[] | undefined;
        }> | undefined;
    }, {
        packages: string[];
        ownership?: Record<string, {
            path: string;
            checks: string[];
            id: string;
            group?: string | undefined;
            layer?: string | undefined;
            purpose?: string | undefined;
            agentDoc?: string | undefined;
            humanDoc?: string | undefined;
            readme?: string | undefined;
        }> | undefined;
        intents?: Record<string, {
            id: string;
            title: string;
            paths: string[];
        }> | undefined;
        changes?: Record<string, {
            id: string;
            title: string;
            startHere: string;
            relatedPackages?: string[] | undefined;
        }> | undefined;
    }>>;
}, "strict", z.ZodTypeAny, {
    contentHash: string;
    schemaVersion: 1;
    contentHashAlgo: "sha256-normalized-v1";
    knowledge: {
        path: string;
        type: string;
        id: string;
        title: string;
        links?: string[] | undefined;
        description?: string | undefined;
        body?: string | undefined;
        tags?: string[] | undefined;
    }[];
    capabilities?: {
        id: string;
        kind: string;
        description?: string | undefined;
    }[] | undefined;
    project?: {
        name: string;
        root?: string | undefined;
    } | undefined;
    generatedAt?: string | undefined;
    properties?: {
        id: string;
        name: string;
        url?: string | undefined;
        llms?: string | undefined;
    }[] | undefined;
    handoffs?: Record<string, {
        type: "agent-handoff";
        checks: string[];
        startHere: string;
        source: string;
        target: {
            type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
            id: string;
            path?: string | undefined;
            group?: string | undefined;
            layer?: string | undefined;
        };
        readBeforeEditing: string[];
        editRoots: string[];
        notes: string[];
        humanDoc?: string | null | undefined;
        schemaVersion?: 1 | undefined;
        bridge?: {
            humanDoc: "linked" | "missing" | "external";
            action?: string | undefined;
            bootstrap?: string | undefined;
        } | undefined;
        playbookPatterns?: string[] | undefined;
    }> | undefined;
    lookup?: {
        packages: string[];
        ownership?: Record<string, {
            path: string;
            checks: string[];
            id: string;
            group?: string | undefined;
            layer?: string | undefined;
            purpose?: string | undefined;
            agentDoc?: string | undefined;
            humanDoc?: string | undefined;
            readme?: string | undefined;
        }> | undefined;
        intents?: Record<string, {
            id: string;
            title: string;
            paths: string[];
        }> | undefined;
        changes?: Record<string, {
            id: string;
            title: string;
            startHere: string;
            relatedPackages?: string[] | undefined;
        }> | undefined;
    } | undefined;
}, {
    contentHash: string;
    schemaVersion: 1;
    contentHashAlgo: "sha256-normalized-v1";
    knowledge: {
        path: string;
        type: string;
        id: string;
        title: string;
        links?: string[] | undefined;
        description?: string | undefined;
        body?: string | undefined;
        tags?: string[] | undefined;
    }[];
    capabilities?: {
        id: string;
        kind: string;
        description?: string | undefined;
    }[] | undefined;
    project?: {
        name: string;
        root?: string | undefined;
    } | undefined;
    generatedAt?: string | undefined;
    properties?: {
        id: string;
        name: string;
        url?: string | undefined;
        llms?: string | undefined;
    }[] | undefined;
    handoffs?: Record<string, {
        type: "agent-handoff";
        checks: string[];
        startHere: string;
        source: string;
        target: {
            type: "search" | "package" | "module" | "app" | "screen" | "flow" | "component" | "intent" | "change";
            id: string;
            path?: string | undefined;
            group?: string | undefined;
            layer?: string | undefined;
        };
        readBeforeEditing: string[];
        editRoots: string[];
        notes: string[];
        humanDoc?: string | null | undefined;
        schemaVersion?: 1 | undefined;
        bridge?: {
            humanDoc: "linked" | "missing" | "external";
            action?: string | undefined;
            bootstrap?: string | undefined;
        } | undefined;
        playbookPatterns?: string[] | undefined;
    }> | undefined;
    lookup?: {
        packages: string[];
        ownership?: Record<string, {
            path: string;
            checks: string[];
            id: string;
            group?: string | undefined;
            layer?: string | undefined;
            purpose?: string | undefined;
            agentDoc?: string | undefined;
            humanDoc?: string | undefined;
            readme?: string | undefined;
        }> | undefined;
        intents?: Record<string, {
            id: string;
            title: string;
            paths: string[];
        }> | undefined;
        changes?: Record<string, {
            id: string;
            title: string;
            startHere: string;
            relatedPackages?: string[] | undefined;
        }> | undefined;
    } | undefined;
}>;
type DocBridgeIndexV1 = z.infer<typeof DocBridgeIndexV1Schema>;
type KnowledgeEntry = z.infer<typeof KnowledgeEntrySchema>;

declare const MEMORY_CANDIDATE_SCHEMA_VERSION: 1;
declare const MemoryCandidateV1Schema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<1>;
    id: z.ZodString;
    source: z.ZodEnum<["cursor", "claude", "codex", "copilot", "agent-memory", "manual"]>;
    rawPath: z.ZodOptional<z.ZodString>;
    fact: z.ZodString;
    why: z.ZodOptional<z.ZodString>;
    howToApply: z.ZodOptional<z.ZodString>;
    suggestedType: z.ZodEnum<["user", "feedback", "project", "reference", "unknown"]>;
    confidence: z.ZodNumber;
    references: z.ZodArray<z.ZodString, "many">;
}, "strict", z.ZodTypeAny, {
    id: string;
    schemaVersion: 1;
    source: "cursor" | "claude" | "codex" | "copilot" | "agent-memory" | "manual";
    fact: string;
    suggestedType: "unknown" | "project" | "user" | "feedback" | "reference";
    confidence: number;
    references: string[];
    rawPath?: string | undefined;
    why?: string | undefined;
    howToApply?: string | undefined;
}, {
    id: string;
    schemaVersion: 1;
    source: "cursor" | "claude" | "codex" | "copilot" | "agent-memory" | "manual";
    fact: string;
    suggestedType: "unknown" | "project" | "user" | "feedback" | "reference";
    confidence: number;
    references: string[];
    rawPath?: string | undefined;
    why?: string | undefined;
    howToApply?: string | undefined;
}>;
type MemoryCandidateV1 = z.infer<typeof MemoryCandidateV1Schema>;

type JsonSchema = {
    readonly [key: string]: unknown;
};
declare const AgentHandoffV1JsonSchema: {
    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
    readonly $id: "https://agentskit.io/schemas/doc-bridge/agent-handoff-v1.schema.json";
    readonly title: "AgentHandoff v1";
    readonly type: "object";
    readonly additionalProperties: false;
    readonly required: readonly ["type", "schemaVersion", "source", "target", "startHere", "readBeforeEditing", "editRoots", "checks", "notes"];
    readonly properties: {
        readonly type: {
            readonly const: "agent-handoff";
        };
        readonly schemaVersion: {
            readonly const: 1;
        };
        readonly source: {
            readonly type: "string";
            readonly minLength: 1;
            readonly maxLength: 512;
        };
        readonly target: {
            readonly type: "object";
            readonly additionalProperties: false;
            readonly required: readonly ["type", "id"];
            readonly properties: {
                readonly type: {
                    readonly enum: readonly ["package", "module", "app", "screen", "flow", "component", "intent", "change", "search"];
                };
                readonly id: {
                    readonly type: "string";
                    readonly minLength: 1;
                    readonly maxLength: 256;
                };
                readonly path: {
                    readonly type: "string";
                    readonly minLength: 1;
                    readonly maxLength: 512;
                };
                readonly group: {
                    readonly type: "string";
                    readonly minLength: 1;
                    readonly maxLength: 128;
                };
                readonly layer: {
                    readonly type: "string";
                    readonly minLength: 1;
                    readonly maxLength: 32;
                };
            };
        };
        readonly startHere: {
            readonly type: "string";
            readonly minLength: 1;
            readonly maxLength: 512;
        };
        readonly readBeforeEditing: JsonSchema;
        readonly editRoots: JsonSchema;
        readonly checks: JsonSchema;
        readonly humanDoc: {
            readonly anyOf: readonly [{
                readonly type: "string";
                readonly minLength: 1;
                readonly maxLength: 512;
            }, {
                readonly type: "null";
            }];
        };
        readonly playbookPatterns: {
            readonly type: "array";
            readonly items: {
                readonly type: "string";
                readonly format: "uri";
            };
            readonly maxItems: 16;
        };
        readonly notes: JsonSchema;
    };
};
declare const MemoryCandidateV1JsonSchema: {
    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
    readonly $id: "https://agentskit.io/schemas/doc-bridge/memory-candidate-v1.schema.json";
    readonly title: "MemoryCandidate v1";
    readonly type: "object";
    readonly additionalProperties: false;
    readonly required: readonly ["schemaVersion", "id", "source", "fact", "suggestedType", "confidence", "references"];
    readonly properties: {
        readonly schemaVersion: {
            readonly const: 1;
        };
        readonly id: {
            readonly type: "string";
            readonly minLength: 1;
            readonly maxLength: 256;
        };
        readonly source: {
            readonly enum: readonly ["cursor", "claude", "codex", "copilot", "agent-memory", "manual"];
        };
        readonly rawPath: {
            readonly type: "string";
            readonly minLength: 1;
            readonly maxLength: 512;
        };
        readonly fact: {
            readonly type: "string";
            readonly minLength: 1;
            readonly maxLength: 8000;
        };
        readonly why: {
            readonly type: "string";
            readonly maxLength: 4000;
        };
        readonly howToApply: {
            readonly type: "string";
            readonly maxLength: 4000;
        };
        readonly suggestedType: {
            readonly enum: readonly ["user", "feedback", "project", "reference", "unknown"];
        };
        readonly confidence: {
            readonly type: "number";
            readonly minimum: 0;
            readonly maximum: 1;
        };
        readonly references: JsonSchema;
    };
};
declare const DocBridgeIndexV1JsonSchema: {
    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
    readonly $id: "https://agentskit.io/schemas/doc-bridge/doc-bridge-index-v1.schema.json";
    readonly title: "DocBridgeIndex v1";
    readonly type: "object";
    readonly additionalProperties: false;
    readonly required: readonly ["schemaVersion", "contentHash", "contentHashAlgo", "knowledge"];
    readonly properties: {
        readonly schemaVersion: {
            readonly const: 1;
        };
        readonly contentHash: {
            readonly type: "string";
            readonly pattern: "^[a-f0-9]{64}$";
        };
        readonly contentHashAlgo: {
            readonly const: "sha256-normalized-v1";
        };
        readonly generatedAt: {
            readonly type: "string";
            readonly format: "date-time";
        };
        readonly project: {
            readonly type: "object";
            readonly additionalProperties: false;
            readonly properties: {
                readonly name: {
                    readonly type: "string";
                    readonly minLength: 1;
                    readonly maxLength: 128;
                };
                readonly root: {
                    readonly type: "string";
                    readonly minLength: 1;
                    readonly maxLength: 512;
                };
            };
        };
        readonly properties: {
            readonly type: "array";
            readonly maxItems: 16;
            readonly items: {
                readonly type: "object";
                readonly additionalProperties: false;
                readonly required: readonly ["id", "name"];
                readonly properties: {
                    readonly id: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 64;
                    };
                    readonly name: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 128;
                    };
                    readonly url: {
                        readonly type: "string";
                        readonly format: "uri";
                    };
                    readonly llms: {
                        readonly type: "string";
                        readonly format: "uri";
                    };
                };
            };
        };
        readonly knowledge: {
            readonly type: "array";
            readonly maxItems: 10000;
            readonly items: {
                readonly type: "object";
                readonly additionalProperties: false;
                readonly required: readonly ["id", "type", "title", "path"];
                readonly properties: {
                    readonly id: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 256;
                    };
                    readonly type: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 128;
                    };
                    readonly title: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 256;
                    };
                    readonly path: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 512;
                    };
                    readonly description: {
                        readonly type: "string";
                        readonly maxLength: 2048;
                    };
                    readonly body: {
                        readonly type: "string";
                        readonly maxLength: 8000;
                    };
                    readonly links: JsonSchema;
                    readonly tags: JsonSchema;
                };
            };
        };
        readonly capabilities: {
            readonly type: "array";
            readonly maxItems: 5000;
            readonly items: {
                readonly type: "object";
                readonly additionalProperties: false;
                readonly required: readonly ["id", "kind"];
                readonly properties: {
                    readonly id: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 256;
                    };
                    readonly kind: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 64;
                    };
                    readonly description: {
                        readonly type: "string";
                        readonly maxLength: 512;
                    };
                };
            };
        };
        readonly handoffs: {
            readonly type: "object";
            readonly additionalProperties: {
                readonly type: "object";
            };
        };
        readonly lookup: {
            readonly type: "object";
        };
    };
};
declare const DocBridgeJsonSchemas: {
    readonly agentHandoffV1: {
        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
        readonly $id: "https://agentskit.io/schemas/doc-bridge/agent-handoff-v1.schema.json";
        readonly title: "AgentHandoff v1";
        readonly type: "object";
        readonly additionalProperties: false;
        readonly required: readonly ["type", "schemaVersion", "source", "target", "startHere", "readBeforeEditing", "editRoots", "checks", "notes"];
        readonly properties: {
            readonly type: {
                readonly const: "agent-handoff";
            };
            readonly schemaVersion: {
                readonly const: 1;
            };
            readonly source: {
                readonly type: "string";
                readonly minLength: 1;
                readonly maxLength: 512;
            };
            readonly target: {
                readonly type: "object";
                readonly additionalProperties: false;
                readonly required: readonly ["type", "id"];
                readonly properties: {
                    readonly type: {
                        readonly enum: readonly ["package", "module", "app", "screen", "flow", "component", "intent", "change", "search"];
                    };
                    readonly id: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 256;
                    };
                    readonly path: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 512;
                    };
                    readonly group: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 128;
                    };
                    readonly layer: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 32;
                    };
                };
            };
            readonly startHere: {
                readonly type: "string";
                readonly minLength: 1;
                readonly maxLength: 512;
            };
            readonly readBeforeEditing: JsonSchema;
            readonly editRoots: JsonSchema;
            readonly checks: JsonSchema;
            readonly humanDoc: {
                readonly anyOf: readonly [{
                    readonly type: "string";
                    readonly minLength: 1;
                    readonly maxLength: 512;
                }, {
                    readonly type: "null";
                }];
            };
            readonly playbookPatterns: {
                readonly type: "array";
                readonly items: {
                    readonly type: "string";
                    readonly format: "uri";
                };
                readonly maxItems: 16;
            };
            readonly notes: JsonSchema;
        };
    };
    readonly docBridgeIndexV1: {
        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
        readonly $id: "https://agentskit.io/schemas/doc-bridge/doc-bridge-index-v1.schema.json";
        readonly title: "DocBridgeIndex v1";
        readonly type: "object";
        readonly additionalProperties: false;
        readonly required: readonly ["schemaVersion", "contentHash", "contentHashAlgo", "knowledge"];
        readonly properties: {
            readonly schemaVersion: {
                readonly const: 1;
            };
            readonly contentHash: {
                readonly type: "string";
                readonly pattern: "^[a-f0-9]{64}$";
            };
            readonly contentHashAlgo: {
                readonly const: "sha256-normalized-v1";
            };
            readonly generatedAt: {
                readonly type: "string";
                readonly format: "date-time";
            };
            readonly project: {
                readonly type: "object";
                readonly additionalProperties: false;
                readonly properties: {
                    readonly name: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 128;
                    };
                    readonly root: {
                        readonly type: "string";
                        readonly minLength: 1;
                        readonly maxLength: 512;
                    };
                };
            };
            readonly properties: {
                readonly type: "array";
                readonly maxItems: 16;
                readonly items: {
                    readonly type: "object";
                    readonly additionalProperties: false;
                    readonly required: readonly ["id", "name"];
                    readonly properties: {
                        readonly id: {
                            readonly type: "string";
                            readonly minLength: 1;
                            readonly maxLength: 64;
                        };
                        readonly name: {
                            readonly type: "string";
                            readonly minLength: 1;
                            readonly maxLength: 128;
                        };
                        readonly url: {
                            readonly type: "string";
                            readonly format: "uri";
                        };
                        readonly llms: {
                            readonly type: "string";
                            readonly format: "uri";
                        };
                    };
                };
            };
            readonly knowledge: {
                readonly type: "array";
                readonly maxItems: 10000;
                readonly items: {
                    readonly type: "object";
                    readonly additionalProperties: false;
                    readonly required: readonly ["id", "type", "title", "path"];
                    readonly properties: {
                        readonly id: {
                            readonly type: "string";
                            readonly minLength: 1;
                            readonly maxLength: 256;
                        };
                        readonly type: {
                            readonly type: "string";
                            readonly minLength: 1;
                            readonly maxLength: 128;
                        };
                        readonly title: {
                            readonly type: "string";
                            readonly minLength: 1;
                            readonly maxLength: 256;
                        };
                        readonly path: {
                            readonly type: "string";
                            readonly minLength: 1;
                            readonly maxLength: 512;
                        };
                        readonly description: {
                            readonly type: "string";
                            readonly maxLength: 2048;
                        };
                        readonly body: {
                            readonly type: "string";
                            readonly maxLength: 8000;
                        };
                        readonly links: JsonSchema;
                        readonly tags: JsonSchema;
                    };
                };
            };
            readonly capabilities: {
                readonly type: "array";
                readonly maxItems: 5000;
                readonly items: {
                    readonly type: "object";
                    readonly additionalProperties: false;
                    readonly required: readonly ["id", "kind"];
                    readonly properties: {
                        readonly id: {
                            readonly type: "string";
                            readonly minLength: 1;
                            readonly maxLength: 256;
                        };
                        readonly kind: {
                            readonly type: "string";
                            readonly minLength: 1;
                            readonly maxLength: 64;
                        };
                        readonly description: {
                            readonly type: "string";
                            readonly maxLength: 512;
                        };
                    };
                };
            };
            readonly handoffs: {
                readonly type: "object";
                readonly additionalProperties: {
                    readonly type: "object";
                };
            };
            readonly lookup: {
                readonly type: "object";
            };
        };
    };
    readonly memoryCandidateV1: {
        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
        readonly $id: "https://agentskit.io/schemas/doc-bridge/memory-candidate-v1.schema.json";
        readonly title: "MemoryCandidate v1";
        readonly type: "object";
        readonly additionalProperties: false;
        readonly required: readonly ["schemaVersion", "id", "source", "fact", "suggestedType", "confidence", "references"];
        readonly properties: {
            readonly schemaVersion: {
                readonly const: 1;
            };
            readonly id: {
                readonly type: "string";
                readonly minLength: 1;
                readonly maxLength: 256;
            };
            readonly source: {
                readonly enum: readonly ["cursor", "claude", "codex", "copilot", "agent-memory", "manual"];
            };
            readonly rawPath: {
                readonly type: "string";
                readonly minLength: 1;
                readonly maxLength: 512;
            };
            readonly fact: {
                readonly type: "string";
                readonly minLength: 1;
                readonly maxLength: 8000;
            };
            readonly why: {
                readonly type: "string";
                readonly maxLength: 4000;
            };
            readonly howToApply: {
                readonly type: "string";
                readonly maxLength: 4000;
            };
            readonly suggestedType: {
                readonly enum: readonly ["user", "feedback", "project", "reference", "unknown"];
            };
            readonly confidence: {
                readonly type: "number";
                readonly minimum: 0;
                readonly maximum: 1;
            };
            readonly references: JsonSchema;
        };
    };
};

type ParseIssue = {
    readonly path: string;
    readonly message: string;
};
type ParseResult<T> = {
    readonly ok: true;
    readonly value: T;
} | {
    readonly ok: false;
    readonly issues: readonly ParseIssue[];
};
declare const safeParseAgentHandoff: (input: unknown) => ParseResult<AgentHandoffV1>;
declare const parseAgentHandoff: (input: unknown) => AgentHandoffV1;
declare const parseAgentSearch: (input: unknown) => AgentSearchV1;
declare const parseDocBridgeIndex: (input: unknown) => DocBridgeIndexV1;
declare const parseMemoryCandidate: (input: unknown) => MemoryCandidateV1;
declare const parseDocBridgeConfig: (input: unknown) => DocBridgeConfigV1;

type BuildIndexOptions = {
    readonly root?: string;
    readonly config: DocBridgeConfigV1;
    readonly write?: boolean;
};
type BuildIndexResult = {
    readonly index: DocBridgeIndexV1;
    readonly indexPath: string;
    readonly llmsTxtPath?: string;
    readonly capabilitiesPath?: string;
};
declare const buildDocBridgeIndex: (opts: BuildIndexOptions) => BuildIndexResult;

/**
 * Canonical AgentsKit ecosystem section for llms.txt (and similar machine indexes).
 *
 * All products should render this block with the same heading and line shape so
 * agents can parse the seven-product mesh without per-repo inventiveness.
 */
type EcosystemLlmsProduct = {
    readonly id: string;
    readonly name: string;
    readonly role?: string;
    readonly promise: string;
    readonly maturity?: string;
    readonly surfaces: {
        readonly home?: string;
        readonly docs?: string;
        readonly llms?: string;
    };
};
type FormatEcosystemLlmsBlockOptions = {
    readonly products: readonly EcosystemLlmsProduct[];
    /** When set, marks this product with **(current)**. */
    readonly currentProductId?: string;
    /** Heading line without leading hashes — default `AgentsKit ecosystem`. */
    readonly heading?: string;
    /**
     * Prefer docs URL when available; otherwise home.
     * Default: home, falling back to docs.
     */
    readonly prefer?: 'home' | 'docs';
};
/**
 * Returns markdown lines for the shared ecosystem block, including a trailing blank line.
 */
declare function formatEcosystemLlmsBlock(options: FormatEcosystemLlmsBlockOptions): string[];
/** Join the block into a single string ending with a newline. */
declare function formatEcosystemLlmsSection(options: FormatEcosystemLlmsBlockOptions): string;

type HumanDocRecord = {
    readonly id: string;
    readonly url: string;
    readonly path: string;
};
type HumanDocMap = Record<string, string>;

declare const scanHumanDocRecords: (root: string, config: DocBridgeConfigV1) => HumanDocRecord[];
declare const scanHumanDocs: (root: string, config: DocBridgeConfigV1) => HumanDocMap;

declare const DOCUMENTATION_STANDARD_V1_ID: "documentation-standard-v1";
declare const DOCUMENTATION_STANDARD_V1_STATUS: "stable";

type DocumentationStandardRuleLevel = 'required' | 'recommended';
type DocumentationStandardRuleStatus = 'pass' | 'fail' | 'excepted';
type DocumentationStandardEvidence = {
    readonly path: string;
    readonly detail: string;
};
type DocumentationStandardRemediation = {
    readonly command: string;
    readonly detail: string;
};
type DocumentationStandardRuleResult = {
    readonly id: DocumentationStandardRuleId;
    readonly level: DocumentationStandardRuleLevel;
    readonly status: DocumentationStandardRuleStatus;
    readonly ok: boolean;
    readonly message: string;
    readonly evidence: readonly DocumentationStandardEvidence[];
    readonly remediation: DocumentationStandardRemediation;
    readonly exception?: {
        readonly reason: string;
        readonly approvedBy: string;
        readonly trackingUrl: string;
    };
};
type DocumentationConformanceReportV1 = {
    readonly schemaVersion: 1;
    readonly profile: {
        readonly id: typeof DOCUMENTATION_STANDARD_V1_ID;
        readonly version: 1;
        readonly status: typeof DOCUMENTATION_STANDARD_V1_STATUS;
    };
    readonly ok: boolean;
    readonly recommendedOk: boolean;
    readonly summary: {
        readonly required: {
            readonly passed: number;
            readonly failed: number;
            readonly excepted: number;
        };
        readonly recommended: {
            readonly passed: number;
            readonly failed: number;
            readonly excepted: number;
        };
    };
    readonly results: readonly DocumentationStandardRuleResult[];
};
declare const runDocumentationStandardV1: (root: string, config: DocBridgeConfigV1) => DocumentationConformanceReportV1;
declare const formatDocumentationStandardText: (report: DocumentationConformanceReportV1) => string[];

type GateId = 'index-freshness' | 'human-guide-links' | 'okf-type' | 'docs-style' | 'documentation-standard-v1';
type GateResult = {
    readonly id: GateId;
    readonly ok: boolean;
    readonly message: string;
    readonly expected?: string;
    readonly actual?: string;
    readonly details?: DocumentationConformanceReportV1;
};
type GateRunResult = {
    readonly ok: boolean;
    readonly results: GateResult[];
};
declare const runGate: (root: string, config: DocBridgeConfigV1, id: GateId) => GateResult;
declare const runGates: (root: string, config: DocBridgeConfigV1, ids?: readonly GateId[]) => GateRunResult;
declare const resolveGateIds: (config: DocBridgeConfigV1) => GateId[];

type JsonRpcRequest = {
    readonly jsonrpc?: '2.0';
    readonly id?: string | number | null;
    readonly method?: string;
    readonly params?: unknown;
};
type McpContext = {
    readonly root: string;
    readonly config: DocBridgeConfigV1;
    readonly loadIndex?: () => DocBridgeIndexV1;
};
declare const MCP_TOOLS: readonly [{
    readonly name: "handoff.resolve";
    readonly title: "Resolve repository handoff";
    readonly description: "Resolve a package or ownership id to its deterministic AgentHandoff.";
    readonly annotations: {
        readonly readOnlyHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {
            readonly id: {
                readonly type: "string";
            };
            readonly kind: {
                readonly type: "string";
                readonly enum: readonly ["package", "ownership"];
            };
        };
        readonly required: readonly ["id"];
    };
}, {
    readonly name: "doc.search";
    readonly title: "Search repository documentation";
    readonly description: "Search the deterministic Doc Bridge index for repository documentation.";
    readonly annotations: {
        readonly readOnlyHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {
            readonly term: {
                readonly type: "string";
            };
            readonly limit: {
                readonly type: "number";
            };
        };
        readonly required: readonly ["term"];
    };
}, {
    readonly name: "doc.get";
    readonly title: "Read indexed documentation";
    readonly description: "Read one indexed agent documentation file by id or indexed path.";
    readonly annotations: {
        readonly readOnlyHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {
            readonly id: {
                readonly type: "string";
            };
            readonly path: {
                readonly type: "string";
            };
        };
    };
}, {
    readonly name: "gate.status";
    readonly title: "Check documentation gates";
    readonly description: "Evaluate documentation gates without writing files.";
    readonly annotations: {
        readonly readOnlyHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {};
    };
}, {
    readonly name: "retriever.query";
    readonly title: "Retrieve documentation context";
    readonly description: "Return relevant local Doc Bridge index chunks for a query.";
    readonly annotations: {
        readonly readOnlyHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {
            readonly query: {
                readonly type: "string";
            };
            readonly limit: {
                readonly type: "number";
            };
        };
        readonly required: readonly ["query"];
    };
}, {
    readonly name: "memory.classify";
    readonly title: "Classify memory candidates";
    readonly description: "Classify local memory candidates into agent, human, playbook, or discard routes.";
    readonly annotations: {
        readonly readOnlyHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {};
    };
}, {
    readonly name: "memory.promoteDraft";
    readonly title: "Draft memory promotion";
    readonly description: "Build a reviewable draft promotion body from local memory candidates without publishing it.";
    readonly annotations: {
        readonly readOnlyHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {};
    };
}, {
    readonly name: "registry.topology";
    readonly title: "Inspect registry topology";
    readonly description: "Return the static Doc Bridge curator and delegate topology.";
    readonly annotations: {
        readonly readOnlyHint: true;
    };
    readonly inputSchema: {
        readonly type: "object";
        readonly properties: {};
    };
}];
declare const handleMcpRequest: (ctx: McpContext, request: JsonRpcRequest) => unknown;
declare const startMcpStdioServer: (ctx: McpContext) => void;

type McpInstallTarget = 'cursor' | 'claude';
type McpInstallResult = {
    readonly ok: boolean;
    readonly target: McpInstallTarget;
    readonly configPath: string;
    readonly created: boolean;
    readonly serverName: string;
    readonly nextSteps: readonly string[];
};
declare const installMcpConfig: (root: string, target: McpInstallTarget) => McpInstallResult;
declare const mcpSnippet: (root: string) => string;

type DoctorBadgeMetrics = {
    readonly handoffPct: number;
    readonly bridgePct: number;
    readonly score: number;
    readonly grade: DoctorReport['grade'];
    readonly packages: number;
};
declare const doctorBadgeMetrics: (report: DoctorReport) => DoctorBadgeMetrics;
declare const formatDoctorBadgeMarkdown: (metrics: DoctorBadgeMetrics) => string;
declare const formatDoctorBadgeJson: (metrics: DoctorBadgeMetrics) => string;

type DoctorIssue = {
    readonly severity: 'error' | 'warn' | 'info';
    readonly code: string;
    readonly message: string;
    readonly action?: string;
};
type DoctorCoverage = {
    readonly packages: {
        readonly total: number;
        readonly withAgentDoc: number;
        readonly withHumanDoc: number;
        readonly missingAgentDoc: readonly string[];
        readonly missingHumanDoc: readonly string[];
    };
    readonly agentDocs: {
        readonly total: number;
        readonly indexed: number;
        readonly unindexed: readonly string[];
    };
    readonly freshness: {
        readonly ok: boolean;
        readonly message: string;
        readonly hasIndex: boolean;
    };
    readonly gates: GateRunResult;
};
type DoctorReport = {
    readonly ok: boolean;
    readonly score: number;
    readonly grade: 'A' | 'B' | 'C' | 'D' | 'F';
    readonly coverage: DoctorCoverage;
    readonly badge: DoctorBadgeMetrics;
    readonly issues: readonly DoctorIssue[];
    readonly nextActions: readonly string[];
};
declare const runDoctor: (root: string, config: DocBridgeConfigV1) => DoctorReport;
declare const formatDoctorText: (report: DoctorReport) => string[];

type WatchIndexOptions = {
    readonly root: string;
    readonly config: DocBridgeConfigV1;
    readonly configPath?: string;
    readonly debounceMs?: number;
    readonly onRebuild?: (summary: {
        knowledgeCount: number;
        handoffCount: number;
        hash: string;
    }) => void;
};
declare const watchDocBridgeIndex: (opts: WatchIndexOptions) => Promise<number>;

type MemoryRoute = 'agent' | 'human' | 'playbook' | 'discard';
type MemoryClassification = {
    readonly candidate: MemoryCandidateV1;
    readonly route: MemoryRoute;
    readonly reason: string;
    readonly target?: string;
    readonly duplicateOf?: string;
};
type SafetyFinding = {
    readonly candidateId: string;
    readonly kind: 'secret' | 'private-email';
    readonly message: string;
};
type MemoryPromotionDraft = {
    readonly ok: boolean;
    readonly title: string;
    readonly body: string;
    readonly findings: SafetyFinding[];
    readonly classifications: MemoryClassification[];
};
declare const classifyMemoryCandidates: (candidates: readonly MemoryCandidateV1[], index: DocBridgeIndexV1) => MemoryClassification[];
declare const scanMemorySafety: (classifications: readonly MemoryClassification[]) => SafetyFinding[];
declare const draftMemoryPromotion: (classifications: readonly MemoryClassification[]) => MemoryPromotionDraft;

type GithubPrOptions = {
    readonly dryRun?: boolean;
    readonly force?: boolean;
    readonly branch?: string;
    readonly base?: string;
};
type GithubPrResult = {
    readonly ok: boolean;
    readonly dryRun: boolean;
    readonly draftPath: string;
    readonly branch: string;
    readonly prUrl?: string;
    readonly previewUrl?: string;
    readonly commands: readonly string[];
    readonly message: string;
};
declare const defaultPromotionDraftPath: (root: string) => string;
declare const writePromotionDraft: (root: string, draft: MemoryPromotionDraft, path?: string) => string;
declare const promoteMemoryToGithubPr: (root: string, draft: MemoryPromotionDraft, options?: GithubPrOptions) => GithubPrResult;

declare const sha256NormalizedV1: (payload: unknown) => string;

declare class IndexNotFoundError extends Error {
    readonly path: string;
    constructor(path: string);
}
declare const indexFilePath: (root: string, config: DocBridgeConfigV1) => string;
declare const loadDocBridgeIndex: (root: string, config: DocBridgeConfigV1) => DocBridgeIndexV1;
declare const resolveRoot: (cwd?: string) => string;

type QueryKind = 'package' | 'ownership' | 'intent' | 'change' | 'search';
type QueryRequest = {
    readonly kind: QueryKind;
    readonly id?: string;
    readonly term?: string;
    readonly agent?: boolean;
};
type QueryResult = {
    readonly type: 'package' | 'ownership' | 'intent' | 'change' | 'search';
    readonly data: unknown;
} | AgentHandoffV1 | AgentSearchV1;
declare const runQuery: (index: DocBridgeIndexV1, config: DocBridgeConfigV1, req: QueryRequest) => QueryResult;

type SearchMatch = {
    readonly type: string;
    readonly id: string;
    readonly path: string;
    readonly summary?: string;
    readonly score: number;
};
declare const searchIndex: (index: DocBridgeIndexV1, term: string, limit?: number) => SearchMatch[];

declare const ingestCursorRules: (root: string) => MemoryCandidateV1[];
declare const ingestAgentMemory: (root: string) => MemoryCandidateV1[];
declare const ingestMemoryCandidates: (root: string) => MemoryCandidateV1[];

type DocBridgeRetrieverOptions = {
    readonly property?: string;
    readonly limit?: number;
};
type DocBridgeRetrievedChunk = {
    readonly chunkKey: string;
    readonly property: string;
    readonly type: string;
    readonly id: string;
    readonly path: string;
    readonly title?: string;
    readonly summary?: string;
    readonly score: number;
};
type DocBridgeRetriever = {
    readonly retrieve: (query: string, options?: Pick<DocBridgeRetrieverOptions, 'limit'>) => DocBridgeRetrievedChunk[];
};
declare const retrieveDocBridgeChunks: (index: DocBridgeIndexV1, query: string, options?: DocBridgeRetrieverOptions) => DocBridgeRetrievedChunk[];
declare const createDocBridgeRetriever: (index: DocBridgeIndexV1, options?: DocBridgeRetrieverOptions) => DocBridgeRetriever;

type FetchText = (url: string) => Promise<string>;
type FederatedRetrieverOptions = {
    readonly fetchText?: FetchText;
    readonly limit?: number;
};
declare const parseLlmsTxtLinks: (raw: string) => {
    title: string;
    url: string;
    description?: string;
}[];
declare const chunksFromMarkdown: (property: string, raw: string, sourceUrl: string) => DocBridgeRetrievedChunk[];
declare const loadFederatedChunks: (root: string, config: DocBridgeConfigV1, options?: FederatedRetrieverOptions) => Promise<DocBridgeRetrievedChunk[]>;
declare const retrieveHybridChunks: (root: string, config: DocBridgeConfigV1, index: DocBridgeIndexV1, query: string, options?: FederatedRetrieverOptions) => Promise<DocBridgeRetrievedChunk[]>;

declare const PACKAGE_VERSION = "1.4.1";

type FrontmatterValue = string | boolean | readonly string[];
type FrontmatterData = Record<string, FrontmatterValue>;

type CorpusDoc = KnowledgeEntry & {
    readonly absPath: string;
    readonly relPath: string;
    readonly frontmatter: FrontmatterData;
};

type DiscoveredPackage = {
    readonly id: string;
    readonly path: string;
    readonly name?: string;
    readonly checks?: readonly string[];
};

type IndexLookup = {
    packages: string[];
    ownership: Record<string, OwnershipRecord>;
    intents: Record<string, IntentRecord>;
    changes: Record<string, ChangeRecord>;
};
type OwnershipRecord = {
    id: string;
    path: string;
    group?: string;
    layer?: string;
    purpose?: string;
    checks: string[];
    agentDoc?: string;
    humanDoc?: string;
    readme?: string;
};
type IntentRecord = {
    id: string;
    title: string;
    paths: string[];
};
type ChangeRecord = {
    id: string;
    title: string;
    startHere: string;
    relatedPackages?: string[];
};
/**
 * Merge package identity from:
 * 1. routing.options.ownership (explicit)
 * 2. pnpm / workspace discovery
 * 3. agent-doc frontmatter (package + editRoot)
 * 4. corpus path heuristics (packages/<id>.md, pillars patterns, etc.)
 */
declare const collectPackages: (config: DocBridgeConfigV1, discovered: readonly DiscoveredPackage[], corpus: readonly CorpusDoc[]) => DiscoveredPackage[];
declare const buildLookup: (config: DocBridgeConfigV1, packages: readonly DiscoveredPackage[], corpus: readonly CorpusDoc[], indexOutFile: string, humanDocs?: HumanDocMap, root?: string) => {
    lookup: IndexLookup;
    handoffs: Record<string, AgentHandoffV1>;
};

declare const discoverNxProjects: (root: string, config: DocBridgeConfigV1) => DiscoveredPackage[];

type RagSearchHit = {
    readonly id?: string;
    readonly content: string;
    readonly score?: number;
    readonly source?: string;
    readonly metadata?: Record<string, unknown>;
};
type DocBridgeRag = {
    readonly ingest: () => Promise<{
        documentCount: number;
        storePath: string;
    }>;
    readonly search: (query: string, topK?: number) => Promise<RagSearchHit[]>;
    readonly retriever: unknown;
    readonly storePath: string;
};
declare const createDocBridgeRag: (root: string, config: DocBridgeConfigV1, index: DocBridgeIndexV1) => Promise<DocBridgeRag>;

declare const runChatOnce: (root: string, config: DocBridgeConfigV1, index: DocBridgeIndexV1, question: string) => Promise<{
    content: string;
    handoffPrefixed: boolean;
}>;
declare const startInkChat: (root: string, config: DocBridgeConfigV1, index: DocBridgeIndexV1) => Promise<void>;

declare class PeerMissingError extends Error {
    readonly peer: string;
    readonly installHint: string;
    constructor(peer: string, installHint: string);
}
declare const layer1InstallHint: () => string;

declare const DOC_BRIDGE_PATTERN_ID: "doc-bridge-pattern";
declare const DOC_BRIDGE_PATTERN_META: {
    readonly id: "doc-bridge-pattern";
    readonly title: "Doc Bridge Pattern";
    readonly slug: "pillars/ai-collaboration/doc-bridge-pattern";
    readonly license: "CC-BY-4.0";
    readonly visibility: "public";
    readonly playbookUrl: "https://playbook.agentskit.io/patterns/doc-bridge-pattern";
    readonly npmPackage: "@agentskit/doc-bridge";
    readonly cli: "ak-docs";
};
declare const docBridgePatternMarkdown: () => string;
declare const docBridgePatternPayload: () => {
    format: string;
    body: string;
    id: "doc-bridge-pattern";
    title: "Doc Bridge Pattern";
    slug: "pillars/ai-collaboration/doc-bridge-pattern";
    license: "CC-BY-4.0";
    visibility: "public";
    playbookUrl: "https://playbook.agentskit.io/patterns/doc-bridge-pattern";
    npmPackage: "@agentskit/doc-bridge";
    cli: "ak-docs";
};

export { AgentHandoffLegacySchema, type AgentHandoffV1, AgentHandoffV1JsonSchema, AgentHandoffV1Schema, type AgentSearchV1, AgentSearchV1Schema, type BuildIndexOptions, type BuildIndexResult, DOCUMENTATION_STANDARD_V1_ID, DOCUMENTATION_STANDARD_V1_STATUS, DOC_BRIDGE_PATTERN_ID, DOC_BRIDGE_PATTERN_META, DocBridgeConfigV1, type DocBridgeIndexV1, DocBridgeIndexV1JsonSchema, DocBridgeIndexV1Schema, DocBridgeJsonSchemas, type DocBridgeRetrievedChunk, type DocBridgeRetriever, type DocBridgeRetrieverOptions, type DoctorBadgeMetrics, type DoctorCoverage, type DoctorIssue, type DoctorReport, type DocumentationConformanceReportV1, type DocumentationStandardEvidence, type DocumentationStandardRemediation, DocumentationStandardRuleId, type DocumentationStandardRuleLevel, type DocumentationStandardRuleResult, type DocumentationStandardRuleStatus, type EcosystemLlmsProduct, type FederatedRetrieverOptions, type FetchText, type FormatEcosystemLlmsBlockOptions, type GateId, type GateResult, type GateRunResult, type GithubPrOptions, type GithubPrResult, HANDOFF_SCHEMA_VERSION, type HandoffBridge, HandoffBridgeSchema, type HandoffTarget, type HandoffTargetType, HandoffTargetTypeSchema, type HumanDocMap, type HumanDocRecord, INDEX_SCHEMA_VERSION, IndexNotFoundError, type KnowledgeEntry, KnowledgeEntrySchema, MCP_TOOLS, MEMORY_CANDIDATE_SCHEMA_VERSION, type McpInstallResult, type McpInstallTarget, type MemoryCandidateV1, MemoryCandidateV1JsonSchema, MemoryCandidateV1Schema, type MemoryClassification, type MemoryPromotionDraft, type MemoryRoute, PACKAGE_VERSION, type ParseIssue, type ParseResult, PeerMissingError, type QueryKind, type QueryRequest, type QueryResult, type SafetyFinding, type SearchMatch, type WatchIndexOptions, buildDocBridgeIndex, buildLookup, chunksFromMarkdown, classifyMemoryCandidates, collectPackages, createDocBridgeRag, createDocBridgeRetriever, defaultPromotionDraftPath, discoverNxProjects, docBridgePatternMarkdown, docBridgePatternPayload, doctorBadgeMetrics, draftMemoryPromotion, formatDoctorBadgeJson, formatDoctorBadgeMarkdown, formatDoctorText, formatDocumentationStandardText, formatEcosystemLlmsBlock, formatEcosystemLlmsSection, handleMcpRequest, indexFilePath, ingestAgentMemory, ingestCursorRules, ingestMemoryCandidates, installMcpConfig, layer1InstallHint, loadDocBridgeIndex, loadFederatedChunks, mcpSnippet, normalizeAgentHandoff, parseAgentHandoff, parseAgentSearch, parseDocBridgeConfig, parseDocBridgeIndex, parseLlmsTxtLinks, parseMemoryCandidate, promoteMemoryToGithubPr, resolveGateIds, resolveRoot, retrieveDocBridgeChunks, retrieveHybridChunks, runChatOnce, runDoctor, runDocumentationStandardV1, runGate, runGates, runQuery, safeParseAgentHandoff, scanHumanDocRecords, scanHumanDocs, scanMemorySafety, searchIndex, sha256NormalizedV1, startInkChat, startMcpStdioServer, watchDocBridgeIndex, writePromotionDraft };