@briefhq/mcp-server/dist/tools/index.d.ts

Brief MCP server and CLI – connect Cursor/Claude MCP to your Brief organization

import { z } from "zod";
declare const briefDiscoverContextSchema: z.ZodObject<{
    task: z.ZodOptional<z.ZodString>;
    cold_start: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    task?: string | undefined;
    cold_start?: boolean | undefined;
}, {
    task?: string | undefined;
    cold_start?: boolean | undefined;
}>;
declare const briefPlanContextSchema: z.ZodObject<{
    task: z.ZodOptional<z.ZodString>;
    categories: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
    cold_start: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    task?: string | undefined;
    cold_start?: boolean | undefined;
    categories?: any[] | undefined;
}, {
    task?: string | undefined;
    cold_start?: boolean | undefined;
    categories?: any[] | undefined;
}>;
declare const briefGetContextSchema: z.ZodObject<{
    keys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    keys?: string[] | undefined;
}, {
    keys?: string[] | undefined;
}>;
declare const briefGuardApproachSchema: z.ZodObject<{
    approach: z.ZodString;
}, "strip", z.ZodTypeAny, {
    approach: string;
}, {
    approach: string;
}>;
declare const briefRecordDecisionSchema: z.ZodObject<{
    topic: z.ZodOptional<z.ZodString>;
    decision: z.ZodString;
    rationale: z.ZodString;
    category: z.ZodOptional<z.ZodEnum<["tech", "product", "design", "process", "general"]>>;
    severity: z.ZodOptional<z.ZodEnum<["info", "important", "blocking"]>>;
    scope: z.ZodOptional<z.ZodEnum<["permanent", "temporary", "session"]>>;
    author: z.ZodOptional<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        name: z.ZodOptional<z.ZodString>;
        email: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        name?: string | undefined;
        id?: string | undefined;
        email?: string | undefined;
    }, {
        name?: string | undefined;
        id?: string | undefined;
        email?: string | undefined;
    }>>;
    supersedes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    decision: string;
    rationale: string;
    category?: "product" | "tech" | "design" | "process" | "general" | undefined;
    severity?: "info" | "important" | "blocking" | undefined;
    scope?: "permanent" | "temporary" | "session" | undefined;
    author?: {
        name?: string | undefined;
        id?: string | undefined;
        email?: string | undefined;
    } | undefined;
    supersedes?: string[] | undefined;
    topic?: string | undefined;
}, {
    decision: string;
    rationale: string;
    category?: "product" | "tech" | "design" | "process" | "general" | undefined;
    severity?: "info" | "important" | "blocking" | undefined;
    scope?: "permanent" | "temporary" | "session" | undefined;
    author?: {
        name?: string | undefined;
        id?: string | undefined;
        email?: string | undefined;
    } | undefined;
    supersedes?: string[] | undefined;
    topic?: string | undefined;
}>;
declare const briefConfirmDecisionSchema: z.ZodObject<{
    id: z.ZodString;
}, "strip", z.ZodTypeAny, {
    id: string;
}, {
    id: string;
}>;
declare const briefArchiveDecisionSchema: z.ZodObject<{
    id: z.ZodString;
    reason: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    id: string;
    reason?: string | undefined;
}, {
    id: string;
    reason?: string | undefined;
}>;
declare const briefCreateSessionDecisionSchema: z.ZodObject<{
    session_id: z.ZodString;
    decision: z.ZodString;
    rationale: z.ZodString;
    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    expires_in_minutes: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    decision: string;
    rationale: string;
    session_id: string;
    expires_in_minutes: number;
    context?: Record<string, unknown> | undefined;
}, {
    decision: string;
    rationale: string;
    session_id: string;
    context?: Record<string, unknown> | undefined;
    expires_in_minutes?: number | undefined;
}>;
declare const briefGetSessionDecisionsSchema: z.ZodObject<{
    session_id: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    session_id?: string | undefined;
}, {
    session_id?: string | undefined;
}>;
declare const briefDeleteSessionDecisionSchema: z.ZodObject<{
    session_id: z.ZodString;
}, "strip", z.ZodTypeAny, {
    session_id: string;
}, {
    session_id: string;
}>;
declare const briefProposeDecisionFromContextSchema: z.ZodObject<{
    detected_text: z.ZodString;
    rationale: z.ZodOptional<z.ZodString>;
    source_context: z.ZodOptional<z.ZodString>;
    confidence: z.ZodDefault<z.ZodNumber>;
    category: z.ZodOptional<z.ZodEnum<["tech", "product", "design", "process", "general"]>>;
    severity: z.ZodOptional<z.ZodEnum<["info", "important", "blocking"]>>;
    confirm: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    detected_text: string;
    confidence: number;
    confirm: boolean;
    rationale?: string | undefined;
    category?: "product" | "tech" | "design" | "process" | "general" | undefined;
    severity?: "info" | "important" | "blocking" | undefined;
    source_context?: string | undefined;
}, {
    detected_text: string;
    rationale?: string | undefined;
    category?: "product" | "tech" | "design" | "process" | "general" | undefined;
    severity?: "info" | "important" | "blocking" | undefined;
    confidence?: number | undefined;
    source_context?: string | undefined;
    confirm?: boolean | undefined;
}>;
declare const briefBatchProposeDecisionsSchema: z.ZodObject<{
    documents: z.ZodArray<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        content: z.ZodString;
        title: z.ZodOptional<z.ZodString>;
        source_url: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        content: string;
        title?: string | undefined;
        id?: string | undefined;
        source_url?: string | undefined;
    }, {
        content: string;
        title?: string | undefined;
        id?: string | undefined;
        source_url?: string | undefined;
    }>, "many">;
    min_confidence: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    documents: {
        content: string;
        title?: string | undefined;
        id?: string | undefined;
        source_url?: string | undefined;
    }[];
    min_confidence: number;
}, {
    documents: {
        content: string;
        title?: string | undefined;
        id?: string | undefined;
        source_url?: string | undefined;
    }[];
    min_confidence?: number | undefined;
}>;
declare const briefGetDecisionProposalsSchema: z.ZodObject<{
    status: z.ZodOptional<z.ZodEnum<["pending", "confirmed", "rejected"]>>;
    limit: z.ZodDefault<z.ZodNumber>;
    min_confidence: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    limit: number;
    status?: "pending" | "confirmed" | "rejected" | undefined;
    min_confidence?: number | undefined;
}, {
    status?: "pending" | "confirmed" | "rejected" | undefined;
    limit?: number | undefined;
    min_confidence?: number | undefined;
}>;
declare const briefConfirmDecisionProposalSchema: z.ZodObject<{
    proposal_id: z.ZodString;
    edits: z.ZodOptional<z.ZodObject<{
        decision: z.ZodOptional<z.ZodString>;
        rationale: z.ZodOptional<z.ZodString>;
        category: z.ZodOptional<z.ZodEnum<["tech", "product", "design", "process", "general"]>>;
        severity: z.ZodOptional<z.ZodEnum<["info", "important", "blocking"]>>;
        topic: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        decision?: string | undefined;
        rationale?: string | undefined;
        category?: "product" | "tech" | "design" | "process" | "general" | undefined;
        severity?: "info" | "important" | "blocking" | undefined;
        topic?: string | undefined;
    }, {
        decision?: string | undefined;
        rationale?: string | undefined;
        category?: "product" | "tech" | "design" | "process" | "general" | undefined;
        severity?: "info" | "important" | "blocking" | undefined;
        topic?: string | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    proposal_id: string;
    edits?: {
        decision?: string | undefined;
        rationale?: string | undefined;
        category?: "product" | "tech" | "design" | "process" | "general" | undefined;
        severity?: "info" | "important" | "blocking" | undefined;
        topic?: string | undefined;
    } | undefined;
}, {
    proposal_id: string;
    edits?: {
        decision?: string | undefined;
        rationale?: string | undefined;
        category?: "product" | "tech" | "design" | "process" | "general" | undefined;
        severity?: "info" | "important" | "blocking" | undefined;
        topic?: string | undefined;
    } | undefined;
}>;
declare const briefSearchDocumentsSchema: z.ZodObject<{
    query: z.ZodEffects<z.ZodString, string, string>;
    folder_id: z.ZodOptional<z.ZodString>;
    limit: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    query: string;
    limit: number;
    folder_id?: string | undefined;
}, {
    query: string;
    folder_id?: string | undefined;
    limit?: number | undefined;
}>;
declare const briefBrowseContextSchema: z.ZodObject<{
    folder_id: z.ZodOptional<z.ZodString>;
    limit: z.ZodDefault<z.ZodNumber>;
    include_subfolders: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    limit: number;
    folder_id?: string | undefined;
    include_subfolders?: boolean | undefined;
}, {
    folder_id?: string | undefined;
    include_subfolders?: boolean | undefined;
    limit?: number | undefined;
}>;
declare const briefRetrieveContentSchema: z.ZodEffects<z.ZodObject<{
    query: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
    document_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    folder_id: z.ZodOptional<z.ZodString>;
    max_tokens: z.ZodDefault<z.ZodNumber>;
    mode: z.ZodDefault<z.ZodEnum<["smart_subset", "summaries"]>>;
}, "strip", z.ZodTypeAny, {
    max_tokens: number;
    mode: "smart_subset" | "summaries";
    query?: string | undefined;
    folder_id?: string | undefined;
    document_ids?: string[] | undefined;
}, {
    query?: string | undefined;
    folder_id?: string | undefined;
    document_ids?: string[] | undefined;
    max_tokens?: number | undefined;
    mode?: "smart_subset" | "summaries" | undefined;
}>, {
    max_tokens: number;
    mode: "smart_subset" | "summaries";
    query?: string | undefined;
    folder_id?: string | undefined;
    document_ids?: string[] | undefined;
}, {
    query?: string | undefined;
    folder_id?: string | undefined;
    document_ids?: string[] | undefined;
    max_tokens?: number | undefined;
    mode?: "smart_subset" | "summaries" | undefined;
}>;
declare const briefFindRelatedSchema: z.ZodEffects<z.ZodObject<{
    document_id: z.ZodOptional<z.ZodString>;
    query: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
    limit: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    limit: number;
    query?: string | undefined;
    document_id?: string | undefined;
}, {
    query?: string | undefined;
    document_id?: string | undefined;
    limit?: number | undefined;
}>, {
    limit: number;
    query?: string | undefined;
    document_id?: string | undefined;
}, {
    query?: string | undefined;
    document_id?: string | undefined;
    limit?: number | undefined;
}>;
declare const briefGetRecentSchema: z.ZodObject<{
    limit: z.ZodDefault<z.ZodNumber>;
    folder_id: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    limit: number;
    folder_id?: string | undefined;
}, {
    folder_id?: string | undefined;
    limit?: number | undefined;
}>;
export declare const tools: {
    readonly brief_discover_context: {
        readonly description: "[DEPRECATED] Use brief_discover_capabilities instead. Discover available context or cold-start summary";
        readonly inputSchema: z.ZodObject<{
            task: z.ZodOptional<z.ZodString>;
            cold_start: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            task?: string | undefined;
            cold_start?: boolean | undefined;
        }, {
            task?: string | undefined;
            cold_start?: boolean | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefDiscoverContextSchema>) => Promise<unknown>;
    };
    readonly brief_plan_context: {
        readonly description: "Plan which context to fetch";
        readonly inputSchema: z.ZodObject<{
            task: z.ZodOptional<z.ZodString>;
            categories: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
            cold_start: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            task?: string | undefined;
            cold_start?: boolean | undefined;
            categories?: any[] | undefined;
        }, {
            task?: string | undefined;
            cold_start?: boolean | undefined;
            categories?: any[] | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefPlanContextSchema>) => Promise<unknown>;
    };
    readonly brief_get_context: {
        readonly description: "Fetch context by keys";
        readonly inputSchema: z.ZodObject<{
            keys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        }, "strip", z.ZodTypeAny, {
            keys?: string[] | undefined;
        }, {
            keys?: string[] | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefGetContextSchema>) => Promise<unknown>;
    };
    readonly brief_guard_approach: {
        readonly description: "Check for conflicts against decisions";
        readonly inputSchema: z.ZodObject<{
            approach: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            approach: string;
        }, {
            approach: string;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefGuardApproachSchema>) => Promise<unknown>;
    };
    readonly brief_record_decision: {
        readonly description: "Record a decision";
        readonly inputSchema: z.ZodObject<{
            topic: z.ZodOptional<z.ZodString>;
            decision: z.ZodString;
            rationale: z.ZodString;
            category: z.ZodOptional<z.ZodEnum<["tech", "product", "design", "process", "general"]>>;
            severity: z.ZodOptional<z.ZodEnum<["info", "important", "blocking"]>>;
            scope: z.ZodOptional<z.ZodEnum<["permanent", "temporary", "session"]>>;
            author: z.ZodOptional<z.ZodObject<{
                id: z.ZodOptional<z.ZodString>;
                name: z.ZodOptional<z.ZodString>;
                email: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                name?: string | undefined;
                id?: string | undefined;
                email?: string | undefined;
            }, {
                name?: string | undefined;
                id?: string | undefined;
                email?: string | undefined;
            }>>;
            supersedes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        }, "strip", z.ZodTypeAny, {
            decision: string;
            rationale: string;
            category?: "product" | "tech" | "design" | "process" | "general" | undefined;
            severity?: "info" | "important" | "blocking" | undefined;
            scope?: "permanent" | "temporary" | "session" | undefined;
            author?: {
                name?: string | undefined;
                id?: string | undefined;
                email?: string | undefined;
            } | undefined;
            supersedes?: string[] | undefined;
            topic?: string | undefined;
        }, {
            decision: string;
            rationale: string;
            category?: "product" | "tech" | "design" | "process" | "general" | undefined;
            severity?: "info" | "important" | "blocking" | undefined;
            scope?: "permanent" | "temporary" | "session" | undefined;
            author?: {
                name?: string | undefined;
                id?: string | undefined;
                email?: string | undefined;
            } | undefined;
            supersedes?: string[] | undefined;
            topic?: string | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefRecordDecisionSchema>) => Promise<unknown>;
    };
    readonly brief_confirm_decision: {
        readonly description: "Confirm a decision";
        readonly inputSchema: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefConfirmDecisionSchema>) => Promise<unknown>;
    };
    readonly brief_archive_decision: {
        readonly description: "Archive a decision (hide from active use but preserve for audit)";
        readonly inputSchema: z.ZodObject<{
            id: z.ZodString;
            reason: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            id: string;
            reason?: string | undefined;
        }, {
            id: string;
            reason?: string | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefArchiveDecisionSchema>) => Promise<unknown>;
    };
    readonly brief_search_documents: {
        readonly description: "Search documents by content, title, or metadata";
        readonly inputSchema: z.ZodObject<{
            query: z.ZodEffects<z.ZodString, string, string>;
            folder_id: z.ZodOptional<z.ZodString>;
            limit: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            query: string;
            limit: number;
            folder_id?: string | undefined;
        }, {
            query: string;
            folder_id?: string | undefined;
            limit?: number | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefSearchDocumentsSchema>) => Promise<any>;
    };
    readonly brief_browse_context: {
        readonly description: "Browse documents and folders in the organization";
        readonly inputSchema: z.ZodObject<{
            folder_id: z.ZodOptional<z.ZodString>;
            limit: z.ZodDefault<z.ZodNumber>;
            include_subfolders: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            limit: number;
            folder_id?: string | undefined;
            include_subfolders?: boolean | undefined;
        }, {
            folder_id?: string | undefined;
            include_subfolders?: boolean | undefined;
            limit?: number | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefBrowseContextSchema>) => Promise<any>;
    };
    readonly brief_retrieve_content: {
        readonly description: "Retrieve full document content with smart token budgeting";
        readonly inputSchema: z.ZodEffects<z.ZodObject<{
            query: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
            document_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            folder_id: z.ZodOptional<z.ZodString>;
            max_tokens: z.ZodDefault<z.ZodNumber>;
            mode: z.ZodDefault<z.ZodEnum<["smart_subset", "summaries"]>>;
        }, "strip", z.ZodTypeAny, {
            max_tokens: number;
            mode: "smart_subset" | "summaries";
            query?: string | undefined;
            folder_id?: string | undefined;
            document_ids?: string[] | undefined;
        }, {
            query?: string | undefined;
            folder_id?: string | undefined;
            document_ids?: string[] | undefined;
            max_tokens?: number | undefined;
            mode?: "smart_subset" | "summaries" | undefined;
        }>, {
            max_tokens: number;
            mode: "smart_subset" | "summaries";
            query?: string | undefined;
            folder_id?: string | undefined;
            document_ids?: string[] | undefined;
        }, {
            query?: string | undefined;
            folder_id?: string | undefined;
            document_ids?: string[] | undefined;
            max_tokens?: number | undefined;
            mode?: "smart_subset" | "summaries" | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefRetrieveContentSchema>) => Promise<{
            items: any;
            metadata: any;
            token_estimate: any;
            mode: any;
            expanded: any;
            warnings: any;
            requested_documents: any;
            accessible_documents: any;
        }>;
    };
    readonly brief_find_related: {
        readonly description: "Find documents related to given content";
        readonly inputSchema: z.ZodEffects<z.ZodObject<{
            document_id: z.ZodOptional<z.ZodString>;
            query: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
            limit: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            limit: number;
            query?: string | undefined;
            document_id?: string | undefined;
        }, {
            query?: string | undefined;
            document_id?: string | undefined;
            limit?: number | undefined;
        }>, {
            limit: number;
            query?: string | undefined;
            document_id?: string | undefined;
        }, {
            query?: string | undefined;
            document_id?: string | undefined;
            limit?: number | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefFindRelatedSchema>) => Promise<unknown>;
    };
    readonly brief_get_recent: {
        readonly description: "Get recently accessed or updated documents";
        readonly inputSchema: z.ZodObject<{
            limit: z.ZodDefault<z.ZodNumber>;
            folder_id: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            limit: number;
            folder_id?: string | undefined;
        }, {
            folder_id?: string | undefined;
            limit?: number | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefGetRecentSchema>) => Promise<any>;
    };
    readonly brief_create_session_decision: {
        readonly description: "Create an ephemeral session decision (not persisted permanently)";
        readonly inputSchema: z.ZodObject<{
            session_id: z.ZodString;
            decision: z.ZodString;
            rationale: z.ZodString;
            context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            expires_in_minutes: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            decision: string;
            rationale: string;
            session_id: string;
            expires_in_minutes: number;
            context?: Record<string, unknown> | undefined;
        }, {
            decision: string;
            rationale: string;
            session_id: string;
            context?: Record<string, unknown> | undefined;
            expires_in_minutes?: number | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefCreateSessionDecisionSchema>) => Promise<unknown>;
    };
    readonly brief_get_session_decisions: {
        readonly description: "Get ephemeral session decisions";
        readonly inputSchema: z.ZodObject<{
            session_id: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            session_id?: string | undefined;
        }, {
            session_id?: string | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefGetSessionDecisionsSchema>) => Promise<any>;
    };
    readonly brief_delete_session_decision: {
        readonly description: "Delete an ephemeral session decision";
        readonly inputSchema: z.ZodObject<{
            session_id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            session_id: string;
        }, {
            session_id: string;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefDeleteSessionDecisionSchema>) => Promise<any>;
    };
    readonly brief_propose_decision_from_context: {
        readonly description: "Propose a decision based on current document/conversation context";
        readonly inputSchema: z.ZodObject<{
            detected_text: z.ZodString;
            rationale: z.ZodOptional<z.ZodString>;
            source_context: z.ZodOptional<z.ZodString>;
            confidence: z.ZodDefault<z.ZodNumber>;
            category: z.ZodOptional<z.ZodEnum<["tech", "product", "design", "process", "general"]>>;
            severity: z.ZodOptional<z.ZodEnum<["info", "important", "blocking"]>>;
            confirm: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            detected_text: string;
            confidence: number;
            confirm: boolean;
            rationale?: string | undefined;
            category?: "product" | "tech" | "design" | "process" | "general" | undefined;
            severity?: "info" | "important" | "blocking" | undefined;
            source_context?: string | undefined;
        }, {
            detected_text: string;
            rationale?: string | undefined;
            category?: "product" | "tech" | "design" | "process" | "general" | undefined;
            severity?: "info" | "important" | "blocking" | undefined;
            confidence?: number | undefined;
            source_context?: string | undefined;
            confirm?: boolean | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefProposeDecisionFromContextSchema>) => Promise<unknown>;
    };
    readonly brief_batch_propose_decisions: {
        readonly description: "Process multiple documents and propose decisions";
        readonly inputSchema: z.ZodObject<{
            documents: z.ZodArray<z.ZodObject<{
                id: z.ZodOptional<z.ZodString>;
                content: z.ZodString;
                title: z.ZodOptional<z.ZodString>;
                source_url: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                content: string;
                title?: string | undefined;
                id?: string | undefined;
                source_url?: string | undefined;
            }, {
                content: string;
                title?: string | undefined;
                id?: string | undefined;
                source_url?: string | undefined;
            }>, "many">;
            min_confidence: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            documents: {
                content: string;
                title?: string | undefined;
                id?: string | undefined;
                source_url?: string | undefined;
            }[];
            min_confidence: number;
        }, {
            documents: {
                content: string;
                title?: string | undefined;
                id?: string | undefined;
                source_url?: string | undefined;
            }[];
            min_confidence?: number | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefBatchProposeDecisionsSchema>) => Promise<unknown>;
    };
    readonly brief_get_decision_proposals: {
        readonly description: "Retrieve pending decision proposals for review";
        readonly inputSchema: z.ZodObject<{
            status: z.ZodOptional<z.ZodEnum<["pending", "confirmed", "rejected"]>>;
            limit: z.ZodDefault<z.ZodNumber>;
            min_confidence: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            limit: number;
            status?: "pending" | "confirmed" | "rejected" | undefined;
            min_confidence?: number | undefined;
        }, {
            status?: "pending" | "confirmed" | "rejected" | undefined;
            limit?: number | undefined;
            min_confidence?: number | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefGetDecisionProposalsSchema>) => Promise<any>;
    };
    readonly brief_confirm_decision_proposal: {
        readonly description: "Convert proposal to confirmed decision";
        readonly inputSchema: z.ZodObject<{
            proposal_id: z.ZodString;
            edits: z.ZodOptional<z.ZodObject<{
                decision: z.ZodOptional<z.ZodString>;
                rationale: z.ZodOptional<z.ZodString>;
                category: z.ZodOptional<z.ZodEnum<["tech", "product", "design", "process", "general"]>>;
                severity: z.ZodOptional<z.ZodEnum<["info", "important", "blocking"]>>;
                topic: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                decision?: string | undefined;
                rationale?: string | undefined;
                category?: "product" | "tech" | "design" | "process" | "general" | undefined;
                severity?: "info" | "important" | "blocking" | undefined;
                topic?: string | undefined;
            }, {
                decision?: string | undefined;
                rationale?: string | undefined;
                category?: "product" | "tech" | "design" | "process" | "general" | undefined;
                severity?: "info" | "important" | "blocking" | undefined;
                topic?: string | undefined;
            }>>;
        }, "strip", z.ZodTypeAny, {
            proposal_id: string;
            edits?: {
                decision?: string | undefined;
                rationale?: string | undefined;
                category?: "product" | "tech" | "design" | "process" | "general" | undefined;
                severity?: "info" | "important" | "blocking" | undefined;
                topic?: string | undefined;
            } | undefined;
        }, {
            proposal_id: string;
            edits?: {
                decision?: string | undefined;
                rationale?: string | undefined;
                category?: "product" | "tech" | "design" | "process" | "general" | undefined;
                severity?: "info" | "important" | "blocking" | undefined;
                topic?: string | undefined;
            } | undefined;
        }>;
        readonly inputJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
            $schema?: string | undefined;
            definitions?: {
                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
            } | undefined;
        };
        readonly execute: (args: z.infer<typeof briefConfirmDecisionProposalSchema>) => Promise<unknown>;
    };
};
export type ToolName = keyof typeof tools;
export {};
//# sourceMappingURL=index.d.ts.map