@praneeth_54/agentdoctor 0.3.0-beta → 1.1.0

package/dist/mcp/brain/compile.js

@@ -0,0 +1,42 @@
+import path from "node:path";
+import { inferArchitectures } from "../../core/understanding/architecture/index.js";
+import { buildProjectBrain } from "../../core/understanding/brain/index.js";
+import { discoverDependencies } from "../../core/understanding/dependencies/index.js";
+import { discoverDomains } from "../../core/understanding/domain/index.js";
+import { discoverEntrypoints } from "../../core/understanding/entrypoints/index.js";
+import { buildProjectModel } from "../../core/understanding/model/index.js";
+import { discoverRelationships } from "../../core/understanding/relationships/index.js";
+/**
+ * Compile discovery passes → ProjectModel → ProjectBrain for an explicit root.
+ */
+export async function compileProjectBrain(projectRoot, options = {}) {
+    const domains = await discoverDomains({ cwd: projectRoot });
+    const entrypoints = await discoverEntrypoints({ cwd: projectRoot });
+    const dependencies = await discoverDependencies({ cwd: projectRoot });
+    const relationships = await discoverRelationships({
+        cwd: projectRoot,
+        domains,
+        entrypoints,
+        dependencies,
+    });
+    const architectures = inferArchitectures({
+        domains,
+        entrypoints,
+        dependencies,
+        relationships,
+    });
+    const model = buildProjectModel({
+        domains,
+        entrypoints,
+        dependencies,
+        relationships,
+        architectures,
+        projectName: path.basename(projectRoot),
+        ...(options.generatedAt !== undefined ? { generatedAt: options.generatedAt } : {}),
+    });
+    return buildProjectBrain(model, {
+        cwd: projectRoot,
+        ...(options.previousClaims !== undefined ? { previousClaims: options.previousClaims } : {}),
+        ...(options.generatedAt !== undefined ? { generatedAt: options.generatedAt } : {}),
+    });
+}

package/dist/mcp/brain/errors.d.ts

@@ -0,0 +1,12 @@
+export type BrainMcpErrorCode = "invalid_root" | "path_escape" | "brain_not_found" | "brain_corrupt" | "unsupported_query" | "invalid_argument" | "not_found" | "read_only" | "internal";
+export declare class BrainMcpError extends Error {
+    readonly code: BrainMcpErrorCode;
+    constructor(code: BrainMcpErrorCode, message: string);
+}
+export declare function toToolErrorPayload(error: unknown): {
+    ok: false;
+    error: {
+        code: BrainMcpErrorCode | "unknown";
+        message: string;
+    };
+};

package/dist/mcp/brain/errors.js

@@ -0,0 +1,23 @@
+export class BrainMcpError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "BrainMcpError";
+        this.code = code;
+    }
+}
+export function toToolErrorPayload(error) {
+    if (error instanceof BrainMcpError) {
+        return { ok: false, error: { code: error.code, message: error.message } };
+    }
+    if (error instanceof Error) {
+        const message = error.message;
+        if (/checksum|corrupt|incompatible|contract|schema/i.test(message) ||
+            error.name === "BrainStorageError" ||
+            error.name === "BrainContractError") {
+            return { ok: false, error: { code: "brain_corrupt", message } };
+        }
+        return { ok: false, error: { code: "internal", message } };
+    }
+    return { ok: false, error: { code: "unknown", message: "unknown error" } };
+}

package/dist/mcp/brain/index.d.ts

@@ -0,0 +1,11 @@
+export { startBrainMcpServer, runBrainMcpStdio } from "./server.js";
+export type { StartBrainMcpServerOptions } from "./server.js";
+export { BrainMcpSession } from "./session.js";
+export type { BrainMcpSessionOptions } from "./session.js";
+export { compileProjectBrain } from "./compile.js";
+export { BrainMcpError, toToolErrorPayload } from "./errors.js";
+export { wrapProvenance, stableJson, snapshotProvenance } from "./provenance.js";
+export { resolveProjectRoot, assertPathInsideProject } from "./security/root.js";
+export { listBrainMcpTools, invokeBrainMcpTool, BRAIN_MCP_TOOL_NAMES } from "./tools/registry.js";
+export type { BrainMcpToolName } from "./tools/registry.js";
+export { BRAIN_MCP_QUERY_TYPES, BRAIN_MCP_TRACE_MODES, resolveQueryType, resolveTraceMode, } from "./schemas.js";

package/dist/mcp/brain/index.js

@@ -0,0 +1,8 @@
+export { startBrainMcpServer, runBrainMcpStdio } from "./server.js";
+export { BrainMcpSession } from "./session.js";
+export { compileProjectBrain } from "./compile.js";
+export { BrainMcpError, toToolErrorPayload } from "./errors.js";
+export { wrapProvenance, stableJson, snapshotProvenance } from "./provenance.js";
+export { resolveProjectRoot, assertPathInsideProject } from "./security/root.js";
+export { listBrainMcpTools, invokeBrainMcpTool, BRAIN_MCP_TOOL_NAMES } from "./tools/registry.js";
+export { BRAIN_MCP_QUERY_TYPES, BRAIN_MCP_TRACE_MODES, resolveQueryType, resolveTraceMode, } from "./schemas.js";

package/dist/mcp/brain/provenance.d.ts

@@ -0,0 +1,29 @@
+import type { ProjectBrain } from "../../core/understanding/brain/index.js";
+export interface SnapshotProvenance {
+    id: string;
+    schemaVersion: string;
+    contentHash: string;
+    createdAt: string;
+    brainId: string;
+    projectName: string;
+}
+export interface BrainMcpEnvelope<T> {
+    ok: true;
+    result: T;
+    evidenceIds: readonly string[];
+    confidence: number;
+    snapshot: SnapshotProvenance;
+    claimStatus?: string;
+    metadata: Record<string, unknown>;
+}
+export declare function snapshotProvenance(brain: ProjectBrain): SnapshotProvenance;
+export declare function wrapProvenance<T>(options: {
+    brain: ProjectBrain;
+    result: T;
+    evidenceIds?: readonly string[];
+    confidence?: number;
+    claimStatus?: string;
+    metadata?: Record<string, unknown>;
+}): BrainMcpEnvelope<T>;
+/** Stable JSON for determinism checks (drops timing). */
+export declare function stableJson(value: unknown): string;

package/dist/mcp/brain/provenance.js

@@ -0,0 +1,59 @@
+export function snapshotProvenance(brain) {
+    return {
+        id: brain.snapshot.id,
+        schemaVersion: brain.metadata.schemaVersion,
+        contentHash: brain.snapshot.contentHash,
+        createdAt: brain.snapshot.generatedAt,
+        brainId: brain.metadata.brainId,
+        projectName: brain.metadata.projectName,
+    };
+}
+export function wrapProvenance(options) {
+    const envelope = {
+        ok: true,
+        result: options.result,
+        evidenceIds: options.evidenceIds ?? [],
+        confidence: options.confidence ?? 0,
+        snapshot: snapshotProvenance(options.brain),
+        metadata: options.metadata ?? {},
+    };
+    if (options.claimStatus !== undefined) {
+        envelope.claimStatus = options.claimStatus;
+    }
+    return envelope;
+}
+/** Stable JSON for determinism checks (drops timing). */
+export function stableJson(value) {
+    return `${JSON.stringify(sortKeysDeep(stripTiming(value)))}\n`;
+}
+function stripTiming(value) {
+    if (Array.isArray(value)) {
+        return value.map(stripTiming);
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        const next = {};
+        for (const [key, entry] of Object.entries(record)) {
+            if (key === "executionTimeMs" || key === "timingMs") {
+                continue;
+            }
+            next[key] = stripTiming(entry);
+        }
+        return next;
+    }
+    return value;
+}
+function sortKeysDeep(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortKeysDeep);
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        const sorted = {};
+        for (const key of Object.keys(record).sort((a, b) => a.localeCompare(b))) {
+            sorted[key] = sortKeysDeep(record[key]);
+        }
+        return sorted;
+    }
+    return value;
+}

package/dist/mcp/brain/schemas.d.ts

@@ -0,0 +1,13 @@
+import type { BrainQueryType } from "../../core/understanding/brain/index.js";
+import type { TraceMode } from "../../core/understanding/brain/index.js";
+export declare const BRAIN_MCP_QUERY_TYPES: readonly ["ProjectSummary", "ListDomains", "ListComponents", "ListEntrypoints", "ListDependencies", "ListRelationships", "ListArchitectures", "ListOwnership", "ListRisks", "ListClaims", "ListEvidence", "ListContradictions", "ListUnknowns", "ListInvalidations", "Impact", "BlastRadius"];
+export declare const BRAIN_MCP_TRACE_MODES: readonly ["dependencies", "dependents", "entrypoint-downstream", "blast-radius", "domain-modules"];
+export declare const CLAIM_STATUSES: readonly ["ACTIVE", "INVALIDATED", "SUPERSEDED", "CONTRADICTED"];
+export type ClaimStatusFilter = (typeof CLAIM_STATUSES)[number];
+export declare function resolveQueryType(input: string): BrainQueryType;
+export declare function resolveTraceMode(input: string | undefined): TraceMode;
+export declare function parseClaimStatus(input: string | undefined): ClaimStatusFilter | undefined;
+export declare function requireString(value: unknown, field: string, options?: {
+    allowEmpty?: boolean;
+}): string;
+export declare function asObject(value: unknown): Record<string, unknown>;

package/dist/mcp/brain/schemas.js

@@ -0,0 +1,105 @@
+import { BrainMcpError } from "./errors.js";
+export const BRAIN_MCP_QUERY_TYPES = [
+    "ProjectSummary",
+    "ListDomains",
+    "ListComponents",
+    "ListEntrypoints",
+    "ListDependencies",
+    "ListRelationships",
+    "ListArchitectures",
+    "ListOwnership",
+    "ListRisks",
+    "ListClaims",
+    "ListEvidence",
+    "ListContradictions",
+    "ListUnknowns",
+    "ListInvalidations",
+    "Impact",
+    "BlastRadius",
+];
+export const BRAIN_MCP_TRACE_MODES = [
+    "dependencies",
+    "dependents",
+    "entrypoint-downstream",
+    "blast-radius",
+    "domain-modules",
+];
+export const CLAIM_STATUSES = ["ACTIVE", "INVALIDATED", "SUPERSEDED", "CONTRADICTED"];
+const QUERY_ALIASES = {
+    project_summary: "ProjectSummary",
+    find_component: "ListComponents",
+    find_module: "ListComponents",
+    find_entrypoint: "ListEntrypoints",
+    find_ownership: "ListOwnership",
+    find_risks: "ListRisks",
+    find_claims: "ListClaims",
+    find_dependencies: "ListDependencies",
+    find_relationships: "ListRelationships",
+    list_domains: "ListDomains",
+    list_components: "ListComponents",
+    list_entrypoints: "ListEntrypoints",
+    list_dependencies: "ListDependencies",
+    list_relationships: "ListRelationships",
+    list_architectures: "ListArchitectures",
+    list_ownership: "ListOwnership",
+    list_risks: "ListRisks",
+    list_claims: "ListClaims",
+    list_evidence: "ListEvidence",
+    list_contradictions: "ListContradictions",
+    list_unknowns: "ListUnknowns",
+    list_invalidations: "ListInvalidations",
+    impact: "Impact",
+    blast_radius: "BlastRadius",
+};
+export function resolveQueryType(input) {
+    const trimmed = input.trim();
+    if (BRAIN_MCP_QUERY_TYPES.includes(trimmed)) {
+        return trimmed;
+    }
+    const alias = QUERY_ALIASES[trimmed.toLowerCase()];
+    if (alias) {
+        return alias;
+    }
+    throw new BrainMcpError("unsupported_query", `unsupported query type "${input}"; supported: ${BRAIN_MCP_QUERY_TYPES.join(", ")}`);
+}
+export function resolveTraceMode(input) {
+    if (input === undefined || input.trim() === "") {
+        return "blast-radius";
+    }
+    const trimmed = input.trim();
+    if (BRAIN_MCP_TRACE_MODES.includes(trimmed)) {
+        return trimmed;
+    }
+    throw new BrainMcpError("invalid_argument", `unsupported trace mode "${input}"; supported: ${BRAIN_MCP_TRACE_MODES.join(", ")}`);
+}
+export function parseClaimStatus(input) {
+    if (input === undefined || input.trim() === "") {
+        return undefined;
+    }
+    const trimmed = input.trim().toUpperCase();
+    if (CLAIM_STATUSES.includes(trimmed)) {
+        return trimmed;
+    }
+    throw new BrainMcpError("invalid_argument", `invalid claim status "${input}"; expected one of ${CLAIM_STATUSES.join(", ")}`);
+}
+export function requireString(value, field, options = {}) {
+    if (typeof value !== "string") {
+        throw new BrainMcpError("invalid_argument", `${field} must be a string`);
+    }
+    if (!options.allowEmpty && value.trim().length === 0) {
+        throw new BrainMcpError("invalid_argument", `${field} must not be empty`);
+    }
+    if (/[\r\n\0]/.test(value)) {
+        throw new BrainMcpError("invalid_argument", `${field} must not contain control characters`);
+    }
+    return value.trim();
+}
+export function asObject(value) {
+    if (value === undefined || value === null) {
+        return {};
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        throw new BrainMcpError("invalid_argument", "arguments must be an object");
+    }
+    return value;
+}

package/dist/mcp/brain/security/root.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolve and validate an explicit project root for Brain MCP.
+ * Never falls back to process.cwd(). Rejects traversal and symlink escapes.
+ */
+export declare function resolveProjectRoot(explicitRoot: string): Promise<string>;
+export declare function assertPathInsideProject(projectRoot: string, candidate: string): Promise<string>;

package/dist/mcp/brain/security/root.js

@@ -0,0 +1,66 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { isPathInsideRoot } from "../../../utils/path.js";
+import { BrainMcpError } from "../errors.js";
+/**
+ * Resolve and validate an explicit project root for Brain MCP.
+ * Never falls back to process.cwd(). Rejects traversal and symlink escapes.
+ */
+export async function resolveProjectRoot(explicitRoot) {
+    const trimmed = explicitRoot.trim();
+    if (!trimmed) {
+        throw new BrainMcpError("invalid_root", "project root is required (pass --root)");
+    }
+    if (/[\r\n\0]/.test(trimmed)) {
+        throw new BrainMcpError("invalid_root", "project root must not contain control characters");
+    }
+    const resolved = path.resolve(trimmed);
+    let real;
+    try {
+        real = await fs.realpath(resolved);
+    }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+        if (code === "ENOENT") {
+            throw new BrainMcpError("invalid_root", `project root does not exist: ${resolved}`);
+        }
+        throw new BrainMcpError("invalid_root", `cannot resolve project root: ${resolved}`);
+    }
+    let stat;
+    try {
+        stat = await fs.stat(real);
+    }
+    catch {
+        throw new BrainMcpError("invalid_root", `project root is not accessible: ${real}`);
+    }
+    if (!stat.isDirectory()) {
+        throw new BrainMcpError("invalid_root", `project root must be a directory: ${real}`);
+    }
+    // Lexical resolve must stay aligned with realpath (symlink escape of the input itself).
+    if (!isPathInsideRoot(real, resolved) && path.resolve(resolved) !== real) {
+        // Input may be a symlink to real — require real to be the canonical root we use.
+    }
+    return real;
+}
+export async function assertPathInsideProject(projectRoot, candidate) {
+    const resolved = path.resolve(projectRoot, candidate);
+    if (!isPathInsideRoot(projectRoot, resolved)) {
+        throw new BrainMcpError("path_escape", "path escapes project root");
+    }
+    let real;
+    try {
+        real = await fs.realpath(resolved);
+    }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+        if (code === "ENOENT") {
+            // Non-existent paths are allowed for validation of relative refs; still check lexical.
+            return resolved;
+        }
+        throw new BrainMcpError("path_escape", "cannot resolve path inside project root");
+    }
+    if (!isPathInsideRoot(projectRoot, real)) {
+        throw new BrainMcpError("path_escape", "path escapes project root via symlink");
+    }
+    return real;
+}

package/dist/mcp/brain/server.d.ts

@@ -0,0 +1,12 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { BrainMcpSession, type BrainMcpSessionOptions } from "./session.js";
+export type StartBrainMcpServerOptions = BrainMcpSessionOptions;
+/**
+ * Start the AgentDoctor Brain MCP server over STDIO.
+ * Protocol traffic goes to stdout; diagnostics to stderr only.
+ */
+export declare function startBrainMcpServer(options: StartBrainMcpServerOptions): Promise<{
+    server: Server;
+    session: BrainMcpSession;
+}>;
+export declare function runBrainMcpStdio(options: StartBrainMcpServerOptions): Promise<void>;

package/dist/mcp/brain/server.js

@@ -0,0 +1,46 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { PACKAGE_VERSION } from "../../constants.js";
+import { BrainMcpSession } from "./session.js";
+import { invokeBrainMcpTool, listBrainMcpTools } from "./tools/registry.js";
+/**
+ * Start the AgentDoctor Brain MCP server over STDIO.
+ * Protocol traffic goes to stdout; diagnostics to stderr only.
+ */
+export async function startBrainMcpServer(options) {
+    const session = new BrainMcpSession(options);
+    await session.initialize();
+    const server = new Server({
+        name: "agentdoctor-brain",
+        version: PACKAGE_VERSION,
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: listBrainMcpTools(),
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const name = request.params.name;
+        const args = request.params.arguments ?? {};
+        const { structured, isError } = await invokeBrainMcpTool(session, name, args);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(structured),
+                },
+            ],
+            structuredContent: structured,
+            isError,
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    return { server, session };
+}
+export async function runBrainMcpStdio(options) {
+    await startBrainMcpServer(options);
+}

package/dist/mcp/brain/session.d.ts

@@ -0,0 +1,33 @@
+import { LocalBrainStore, type ProjectBrain, type SnapshotMeta } from "../../core/understanding/brain/index.js";
+export interface BrainMcpSessionOptions {
+    /** Explicit project root — required. Never defaults to process.cwd(). */
+    root: string;
+    /** When true, rebuild brain if no snapshot exists. Default true. */
+    buildIfMissing?: boolean;
+    /** Optional fixed timestamp for deterministic rebuilds in tests. */
+    generatedAt?: string;
+    /** stderr logger — never write protocol traffic. */
+    log?: (message: string) => void;
+}
+/**
+ * Holds a loaded ProjectBrain for the lifetime of an MCP server process.
+ * Brain is loaded once; tools query the in-memory snapshot.
+ */
+export declare class BrainMcpSession {
+    private readonly options;
+    private root;
+    private store;
+    private brain;
+    private readonly buildIfMissing;
+    private readonly generatedAt;
+    private readonly log;
+    constructor(options: BrainMcpSessionOptions);
+    initialize(): Promise<void>;
+    getProjectRoot(): string;
+    getStore(): LocalBrainStore;
+    getBrain(): ProjectBrain;
+    rebuild(): Promise<ProjectBrain>;
+    loadSnapshot(snapshotId: string): Promise<ProjectBrain>;
+    listSnapshots(): Promise<SnapshotMeta[]>;
+    compareSnapshots(leftId: string, rightId: string): Promise<import("../../core/understanding/brain/index.js").SnapshotComparison>;
+}

package/dist/mcp/brain/session.js

@@ -0,0 +1,117 @@
+import { LocalBrainStore, } from "../../core/understanding/brain/index.js";
+import { compileProjectBrain } from "./compile.js";
+import { BrainMcpError } from "./errors.js";
+import { resolveProjectRoot } from "./security/root.js";
+/**
+ * Holds a loaded ProjectBrain for the lifetime of an MCP server process.
+ * Brain is loaded once; tools query the in-memory snapshot.
+ */
+export class BrainMcpSession {
+    options;
+    root = null;
+    store = null;
+    brain = null;
+    buildIfMissing;
+    generatedAt;
+    log;
+    constructor(options) {
+        this.options = options;
+        this.buildIfMissing = options.buildIfMissing !== false;
+        this.generatedAt = options.generatedAt;
+        this.log = options.log ?? ((message) => process.stderr.write(`${message}\n`));
+    }
+    async initialize() {
+        this.root = await resolveProjectRoot(this.options.root);
+        this.store = LocalBrainStore.underRepo(this.root);
+        let loaded = null;
+        try {
+            loaded = await this.store.loadLatest();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "corrupt brain store";
+            throw new BrainMcpError("brain_corrupt", message);
+        }
+        if (loaded) {
+            this.brain = loaded;
+            this.log(`agentdoctor brain-mcp: loaded snapshot ${loaded.snapshot.id} from ${this.root}`);
+            return;
+        }
+        if (!this.buildIfMissing) {
+            throw new BrainMcpError("brain_not_found", "no Project Brain snapshot found; rebuild with brain_snapshot action=rebuild");
+        }
+        this.log(`agentdoctor brain-mcp: no snapshot found; compiling Project Brain…`);
+        await this.rebuild();
+    }
+    getProjectRoot() {
+        if (!this.root) {
+            throw new BrainMcpError("invalid_root", "session not initialized");
+        }
+        return this.root;
+    }
+    getStore() {
+        if (!this.store) {
+            throw new BrainMcpError("internal", "session not initialized");
+        }
+        return this.store;
+    }
+    getBrain() {
+        if (!this.brain) {
+            throw new BrainMcpError("brain_not_found", "no Project Brain loaded; rebuild with brain_snapshot action=rebuild");
+        }
+        return this.brain;
+    }
+    async rebuild() {
+        const root = this.getProjectRoot();
+        const store = this.getStore();
+        const previous = this.brain;
+        const brain = await compileProjectBrain(root, {
+            ...(previous ? { previousClaims: previous.claims } : {}),
+            ...(this.generatedAt !== undefined ? { generatedAt: this.generatedAt } : {}),
+        });
+        try {
+            await store.saveSnapshot(brain);
+            this.log(`agentdoctor brain-mcp: saved snapshot ${brain.snapshot.id}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "";
+            if (/refusing overwrite/i.test(message)) {
+                // Model identity unchanged while claim lifecycle/content differs — keep memory fresh.
+                this.log(`agentdoctor brain-mcp: snapshot ${brain.snapshot.id} unchanged structurally; refreshed in-memory brain`);
+            }
+            else {
+                throw error instanceof BrainMcpError
+                    ? error
+                    : new BrainMcpError("brain_corrupt", message || "failed to save snapshot");
+            }
+        }
+        this.brain = brain;
+        return brain;
+    }
+    async loadSnapshot(snapshotId) {
+        const store = this.getStore();
+        try {
+            const brain = await store.loadSnapshot(snapshotId);
+            this.brain = brain;
+            return brain;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "failed to load snapshot";
+            if (/not found|ENOENT/i.test(message)) {
+                throw new BrainMcpError("not_found", message);
+            }
+            throw new BrainMcpError("brain_corrupt", message);
+        }
+    }
+    async listSnapshots() {
+        return this.getStore().listSnapshots();
+    }
+    async compareSnapshots(leftId, rightId) {
+        try {
+            return await this.getStore().compareSnapshots(leftId, rightId);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "compare failed";
+            throw new BrainMcpError("brain_corrupt", message);
+        }
+    }
+}

package/dist/mcp/brain/tools/handlers.d.ts

@@ -0,0 +1,13 @@
+import { type BrainMcpEnvelope } from "../provenance.js";
+import type { BrainMcpSession } from "../session.js";
+export type ToolResult = BrainMcpEnvelope<unknown>;
+export declare function handleBrainOverview(session: BrainMcpSession): Promise<ToolResult>;
+export declare function handleBrainQuery(session: BrainMcpSession, rawArgs: unknown): Promise<ToolResult>;
+export declare function handleBrainExplain(session: BrainMcpSession, rawArgs: unknown): Promise<ToolResult>;
+export declare function handleBrainTrace(session: BrainMcpSession, rawArgs: unknown): Promise<ToolResult>;
+export declare function handleBrainClaims(session: BrainMcpSession, rawArgs: unknown): Promise<ToolResult>;
+export declare function handleBrainEvidence(session: BrainMcpSession, rawArgs: unknown): Promise<ToolResult>;
+export declare function handleBrainOwnership(session: BrainMcpSession, rawArgs: unknown): Promise<ToolResult>;
+export declare function handleBrainRisk(session: BrainMcpSession, rawArgs: unknown): Promise<ToolResult>;
+export declare function handleBrainDelta(session: BrainMcpSession, rawArgs: unknown): Promise<ToolResult>;
+export declare function handleBrainSnapshot(session: BrainMcpSession, rawArgs: unknown): Promise<ToolResult>;