@praneeth_54/agentdoctor 1.0.0 → 1.1.1

package/dist/mcp/brain/tools/handlers.js

@@ -0,0 +1,483 @@
+import { averageBrainConfidence, buildBrainDelta, createBrainQueryEngine, explainClaim, PROJECT_BRAIN_LIMITATIONS, redactEvidenceList, traceBrain, } from "../../../core/understanding/brain/index.js";
+import { BrainMcpError } from "../errors.js";
+import { wrapProvenance } from "../provenance.js";
+import { asObject, parseClaimStatus, requireString, resolveQueryType, resolveTraceMode, } from "../schemas.js";
+function optionalString(args, field) {
+    const value = args[field];
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    return requireString(value, field);
+}
+export async function handleBrainOverview(session) {
+    const brain = session.getBrain();
+    const activeClaims = brain.claims.filter((c) => c.status === "ACTIVE");
+    const contradicted = brain.claims.filter((c) => c.status === "CONTRADICTED");
+    const confidences = [
+        ...activeClaims.map((c) => c.confidence),
+        ...brain.components.map((c) => c.confidence),
+        ...brain.risks.risks.map((r) => r.confidence),
+    ];
+    return wrapProvenance({
+        brain,
+        evidenceIds: brain.evidence
+            .map((e) => e.id)
+            .slice()
+            .sort((a, b) => a.localeCompare(b)),
+        confidence: averageBrainConfidence(confidences),
+        metadata: { tool: "brain_overview" },
+        result: {
+            repository: {
+                projectName: brain.metadata.projectName,
+                brainId: brain.metadata.brainId,
+                root: session.getProjectRoot(),
+            },
+            snapshotId: brain.snapshot.id,
+            schemaVersion: brain.metadata.schemaVersion,
+            modelVersion: brain.model.metadata.schemaVersion,
+            domains: brain.model.domains
+                .map((d) => d.name)
+                .slice()
+                .sort((a, b) => a.localeCompare(b)),
+            entrypoints: brain.model.entrypoints
+                .map((e) => ({ file: e.file, framework: e.framework, confidence: e.confidence }))
+                .slice()
+                .sort((a, b) => a.file.localeCompare(b.file)),
+            components: brain.components
+                .map((c) => ({ id: c.id, name: c.name, type: c.type, path: c.path }))
+                .slice()
+                .sort((a, b) => a.path.localeCompare(b.path)),
+            architecture: brain.model.architectures
+                .map((a) => ({
+                pattern: a.pattern,
+                confidence: a.confidence,
+                matchedRules: a.matchedRules,
+            }))
+                .slice()
+                .sort((a, b) => a.pattern.localeCompare(b.pattern)),
+            ownershipSummary: {
+                matchCount: brain.ownership.ownerships.length,
+                unknowns: brain.ownership.unknowns.slice().sort((a, b) => a.localeCompare(b)),
+            },
+            riskSummary: {
+                riskKind: "change-danger",
+                notVulnerabilityScanner: true,
+                count: brain.risks.risks.length,
+                byKind: Object.fromEntries([...brain.risks.risks]
+                    .reduce((map, risk) => {
+                    map.set(risk.kind, (map.get(risk.kind) ?? 0) + 1);
+                    return map;
+                }, new Map())
+                    .entries()),
+            },
+            activeClaimCount: activeClaims.length,
+            contradictedClaimCount: contradicted.length,
+            contradictionCount: brain.contradictions.length,
+            unknownCount: brain.unknowns.length,
+            limitations: [...brain.limitations, ...PROJECT_BRAIN_LIMITATIONS],
+            confidenceSummary: {
+                contract: brain.confidenceContract,
+                average: averageBrainConfidence(confidences),
+            },
+        },
+    });
+}
+export async function handleBrainQuery(session, rawArgs) {
+    const args = asObject(rawArgs);
+    const typeInput = requireString(args.type ?? args.queryType ?? args.intent, "type");
+    const queryType = resolveQueryType(typeInput);
+    if (queryType === "ListChanges") {
+        throw new BrainMcpError("unsupported_query", "ListChanges requires an in-memory previous brain; use brain_delta with snapshot ids instead");
+    }
+    let query;
+    if (queryType === "Impact" || queryType === "BlastRadius") {
+        const target = requireString(args.target, "target");
+        query = { type: queryType, target };
+    }
+    else if (queryType === "ListClaims") {
+        const status = parseClaimStatus(optionalString(args, "status"));
+        query = status ? { type: "ListClaims", status } : { type: "ListClaims" };
+    }
+    else {
+        query = {
+            type: queryType,
+        };
+    }
+    const brain = session.getBrain();
+    const response = createBrainQueryEngine(brain).execute(query);
+    return wrapProvenance({
+        brain,
+        result: response.result,
+        evidenceIds: response.evidenceIds,
+        confidence: response.confidence,
+        metadata: {
+            tool: "brain_query",
+            queryType: response.metadata.queryType,
+            brainId: response.metadata.brainId,
+        },
+    });
+}
+export async function handleBrainExplain(session, rawArgs) {
+    const args = asObject(rawArgs);
+    const claimId = requireString(args.claimId ?? args.id, "claimId");
+    const brain = session.getBrain();
+    const explanation = explainClaim(brain, claimId);
+    if (!explanation) {
+        throw new BrainMcpError("not_found", `claim not found: ${claimId}`);
+    }
+    return wrapProvenance({
+        brain,
+        result: {
+            claim: explanation.claim,
+            status: explanation.status,
+            confidence: explanation.confidence,
+            evidence: redactEvidenceList(explanation.supportingEvidence),
+            contradictions: explanation.contradictions,
+            invalidation: explanation.invalidationState,
+            unknowns: explanation.unknowns,
+        },
+        evidenceIds: explanation.supportingEvidence.map((e) => e.id),
+        confidence: explanation.confidence,
+        claimStatus: explanation.status,
+        metadata: { tool: "brain_explain", claimId },
+    });
+}
+export async function handleBrainTrace(session, rawArgs) {
+    const args = asObject(rawArgs);
+    const target = requireString(args.target ?? args.root, "target");
+    const mode = resolveTraceMode(optionalString(args, "mode"));
+    const brain = session.getBrain();
+    const trace = traceBrain(brain, target, mode);
+    const evidenceIds = [
+        ...new Set(trace.edges.flatMap((edge) => [...edge.evidence])),
+    ].sort((a, b) => a.localeCompare(b));
+    const truncated = trace.edges.length >= 5000;
+    return wrapProvenance({
+        brain,
+        result: {
+            root: trace.root,
+            mode,
+            nodes: trace.nodes,
+            edges: trace.edges,
+            cycles: trace.cycles,
+            caps: { maxDepth: 25, maxEdges: 5000 },
+            truncated: truncated || trace.edges.length >= 5000,
+            confidence: trace.confidence,
+        },
+        evidenceIds,
+        confidence: trace.confidence,
+        metadata: { tool: "brain_trace", mode, target },
+    });
+}
+export async function handleBrainClaims(session, rawArgs) {
+    const args = asObject(rawArgs);
+    const status = parseClaimStatus(optionalString(args, "status"));
+    const includeHistorical = args.includeHistorical === true;
+    const brain = session.getBrain();
+    let claims = [...brain.claims];
+    if (status) {
+        claims = claims.filter((c) => c.status === status);
+    }
+    else if (!includeHistorical) {
+        // Truth filter: default excludes INVALIDATED / SUPERSEDED
+        claims = claims.filter((c) => c.status === "ACTIVE" || c.status === "CONTRADICTED");
+    }
+    claims.sort((a, b) => a.id.localeCompare(b.id));
+    return wrapProvenance({
+        brain,
+        result: {
+            claims: claims.map((c) => ({
+                id: c.id,
+                subject: c.subject,
+                predicate: c.predicate,
+                object: c.object,
+                status: c.status,
+                confidence: c.confidence,
+                evidenceIds: c.evidenceIds,
+                snapshotId: c.snapshotId,
+                contradictionIds: c.contradictionIds,
+                invalidatedAt: c.invalidatedAt,
+                supersededBy: c.supersededBy,
+            })),
+            truthFilter: status
+                ? `status=${status}`
+                : includeHistorical
+                    ? "all-statuses"
+                    : "ACTIVE+CONTRADICTED",
+        },
+        evidenceIds: claims.flatMap((c) => c.evidenceIds),
+        confidence: averageBrainConfidence(claims.map((c) => c.confidence)),
+        metadata: { tool: "brain_claims", includeHistorical, status: status ?? null },
+    });
+}
+export async function handleBrainEvidence(session, rawArgs) {
+    const args = asObject(rawArgs);
+    const evidenceId = optionalString(args, "evidenceId") ?? optionalString(args, "id");
+    const brain = session.getBrain();
+    let evidence = [...redactEvidenceList(brain.evidence)];
+    if (evidenceId) {
+        evidence = evidence.filter((e) => e.id === evidenceId);
+        if (evidence.length === 0) {
+            throw new BrainMcpError("not_found", `evidence not found: ${evidenceId}`);
+        }
+    }
+    evidence = [...evidence].sort((a, b) => a.id.localeCompare(b.id));
+    const claimLinks = brain.claims
+        .filter((c) => c.evidenceIds.some((id) => evidence.some((e) => e.id === id)))
+        .map((c) => ({
+        claimId: c.id,
+        status: c.status,
+        evidenceIds: c.evidenceIds.filter((id) => evidence.some((e) => e.id === id)),
+    }))
+        .sort((a, b) => a.claimId.localeCompare(b.claimId));
+    return wrapProvenance({
+        brain,
+        result: {
+            evidence: evidence.map((e) => ({
+                id: e.id,
+                kind: e.kind,
+                epistemics: e.epistemics,
+                locator: e.locator,
+                source: e.source,
+                symbol: e.symbol,
+                redaction: e.redaction,
+            })),
+            claimRelationships: claimLinks,
+            redacted: true,
+        },
+        evidenceIds: evidence.map((e) => e.id),
+        confidence: 1,
+        metadata: { tool: "brain_evidence" },
+    });
+}
+export async function handleBrainOwnership(session, rawArgs) {
+    const args = asObject(rawArgs);
+    const filePath = optionalString(args, "path") ?? optionalString(args, "filePath");
+    const brain = session.getBrain();
+    let ownerships = [...brain.ownership.ownerships];
+    if (filePath) {
+        ownerships = ownerships.filter((o) => o.path === filePath ||
+            o.path.endsWith(`/${filePath}`) ||
+            filePath.endsWith(o.path) ||
+            o.path.includes(filePath));
+    }
+    ownerships.sort((a, b) => a.path.localeCompare(b.path));
+    const result = filePath && ownerships.length === 0
+        ? {
+            path: filePath,
+            ownership: "UNKNOWN",
+            matches: [],
+            unknowns: brain.ownership.unknowns,
+            sourcesAllowed: ["CODEOWNERS", "MAINTAINERS", "package-metadata"],
+            note: "Ownership is UNKNOWN without explicit CODEOWNERS / MAINTAINERS / package evidence",
+        }
+        : {
+            matches: ownerships,
+            unknowns: brain.ownership.unknowns.slice().sort((a, b) => a.localeCompare(b)),
+            sourcesAllowed: ["CODEOWNERS", "MAINTAINERS", "package-metadata"],
+            inferenceForbidden: [
+                "git-blame",
+                "cwd-guessing",
+                "author-guessing",
+                "commit-frequency",
+            ],
+        };
+    return wrapProvenance({
+        brain,
+        result,
+        evidenceIds: [],
+        confidence: averageBrainConfidence(ownerships.map((o) => o.confidence)),
+        metadata: { tool: "brain_ownership", path: filePath ?? null },
+    });
+}
+export async function handleBrainRisk(session, rawArgs) {
+    const args = asObject(rawArgs);
+    const kind = optionalString(args, "kind");
+    const brain = session.getBrain();
+    let risks = [...brain.risks.risks];
+    if (kind) {
+        risks = risks.filter((r) => r.kind === kind);
+    }
+    risks.sort((a, b) => {
+        const byKind = a.kind.localeCompare(b.kind);
+        if (byKind !== 0)
+            return byKind;
+        return a.target.localeCompare(b.target);
+    });
+    return wrapProvenance({
+        brain,
+        result: {
+            riskKind: "change-danger",
+            notVulnerabilityScanner: true,
+            distinction: {
+                changeRisk: "Project Brain change-danger (entrypoint centrality, coupling, ownership clarity, architecture conflict)",
+                securityVulnerability: "AgentDoctor Safety Scan findings — not produced by this tool",
+            },
+            risks: risks.map((r) => ({
+                kind: r.kind,
+                severity: r.severity,
+                target: r.target,
+                rationale: r.rationale,
+                confidence: r.confidence,
+                evidence: r.evidence,
+            })),
+            unknowns: brain.risks.unknowns.slice().sort((a, b) => a.localeCompare(b)),
+        },
+        evidenceIds: [],
+        confidence: averageBrainConfidence(risks.map((r) => r.confidence)),
+        metadata: { tool: "brain_risk", kind: kind ?? null },
+    });
+}
+export async function handleBrainDelta(session, rawArgs) {
+    const args = asObject(rawArgs);
+    const fromSnapshot = requireString(args.fromSnapshot ?? args.from, "fromSnapshot");
+    const toSnapshot = optionalString(args, "toSnapshot") ??
+        optionalString(args, "to") ??
+        session.getBrain().snapshot.id;
+    const store = session.getStore();
+    let before;
+    let after;
+    try {
+        before = await store.loadSnapshot(fromSnapshot);
+        after =
+            toSnapshot === session.getBrain().snapshot.id
+                ? session.getBrain()
+                : await store.loadSnapshot(toSnapshot);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "failed to load snapshots";
+        throw new BrainMcpError("brain_corrupt", message);
+    }
+    const delta = buildBrainDelta(before, after);
+    return wrapProvenance({
+        brain: after,
+        result: {
+            fromSnapshot: delta.beforeSnapshotId,
+            toSnapshot: delta.afterSnapshotId,
+            added: delta.addedClaimIds,
+            removed: delta.removedClaimIds,
+            changed: delta.changedClaimIds,
+            invalidatedClaims: delta.invalidatedClaimIds,
+            newClaims: delta.addedClaimIds,
+            supersededClaims: delta.supersededClaimIds,
+            contradictedClaims: delta.contradictedClaimIds,
+            contradictions: {
+                added: delta.newContradictionIds,
+                resolved: delta.resolvedContradictionIds,
+            },
+            components: {
+                added: delta.addedComponentIds,
+                removed: delta.removedComponentIds,
+            },
+            ownershipChanges: delta.ownershipChanges,
+            riskChanges: delta.riskChanges,
+            dependencyChanges: delta.dependencyChanges,
+            summary: delta.summary,
+        },
+        evidenceIds: [],
+        confidence: 1,
+        metadata: {
+            tool: "brain_delta",
+            fromSnapshot,
+            toSnapshot,
+            readOnly: true,
+        },
+    });
+}
+export async function handleBrainSnapshot(session, rawArgs) {
+    const args = asObject(rawArgs);
+    const action = (optionalString(args, "action") ?? "current").toLowerCase();
+    if (action === "rebuild") {
+        const brain = await session.rebuild();
+        return wrapProvenance({
+            brain,
+            result: {
+                action: "rebuild",
+                snapshot: {
+                    id: brain.snapshot.id,
+                    contentHash: brain.snapshot.contentHash,
+                    createdAt: brain.snapshot.generatedAt,
+                },
+            },
+            evidenceIds: [],
+            confidence: 1,
+            metadata: { tool: "brain_snapshot", action },
+        });
+    }
+    if (action === "history") {
+        const brain = session.getBrain();
+        const snapshots = await session.listSnapshots();
+        const sorted = [...snapshots].sort((a, b) => a.id.localeCompare(b.id));
+        return wrapProvenance({
+            brain,
+            result: {
+                action: "history",
+                latestSnapshotId: brain.snapshot.id,
+                snapshots: sorted.map((s) => ({
+                    id: s.id,
+                    contentHash: s.contentHash,
+                    createdAt: s.createdAt,
+                    checksum: s.checksum,
+                    projectName: s.projectName,
+                    brainId: s.brainId,
+                })),
+            },
+            evidenceIds: [],
+            confidence: 1,
+            metadata: { tool: "brain_snapshot", action },
+        });
+    }
+    if (action === "compare") {
+        const leftId = requireString(args.leftId ?? args.fromSnapshot, "leftId");
+        const rightId = requireString(args.rightId ?? args.toSnapshot, "rightId");
+        const comparison = await session.compareSnapshots(leftId, rightId);
+        const brain = session.getBrain();
+        return wrapProvenance({
+            brain,
+            result: { action: "compare", comparison },
+            evidenceIds: [],
+            confidence: 1,
+            metadata: { tool: "brain_snapshot", action },
+        });
+    }
+    if (action === "load") {
+        const snapshotId = requireString(args.snapshotId ?? args.id, "snapshotId");
+        const brain = await session.loadSnapshot(snapshotId);
+        return wrapProvenance({
+            brain,
+            result: {
+                action: "load",
+                snapshot: {
+                    id: brain.snapshot.id,
+                    contentHash: brain.snapshot.contentHash,
+                    createdAt: brain.snapshot.generatedAt,
+                },
+            },
+            evidenceIds: [],
+            confidence: 1,
+            metadata: { tool: "brain_snapshot", action },
+        });
+    }
+    if (action === "current" || action === "latest" || action === "metadata") {
+        const brain = session.getBrain();
+        return wrapProvenance({
+            brain,
+            result: {
+                action: "current",
+                snapshot: {
+                    id: brain.snapshot.id,
+                    schemaVersion: brain.metadata.schemaVersion,
+                    contentHash: brain.snapshot.contentHash,
+                    createdAt: brain.snapshot.generatedAt,
+                    brainId: brain.metadata.brainId,
+                    projectName: brain.metadata.projectName,
+                },
+                storeRoot: session.getStore().root,
+            },
+            evidenceIds: [],
+            confidence: 1,
+            metadata: { tool: "brain_snapshot", action: "current" },
+        });
+    }
+    throw new BrainMcpError("invalid_argument", `unsupported brain_snapshot action "${action}"; use current|history|compare|load|rebuild`);
+}

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

@@ -0,0 +1,9 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { BrainMcpSession } from "../session.js";
+export declare const BRAIN_MCP_TOOL_NAMES: readonly ["brain_overview", "brain_query", "brain_explain", "brain_trace", "brain_claims", "brain_evidence", "brain_ownership", "brain_risk", "brain_delta", "brain_snapshot"];
+export type BrainMcpToolName = (typeof BRAIN_MCP_TOOL_NAMES)[number];
+export declare function listBrainMcpTools(): Tool[];
+export declare function invokeBrainMcpTool(session: BrainMcpSession, name: string, args: unknown): Promise<{
+    structured: unknown;
+    isError: boolean;
+}>;

package/dist/mcp/brain/tools/registry.js

@@ -0,0 +1,191 @@
+import { toToolErrorPayload } from "../errors.js";
+import { handleBrainClaims, handleBrainDelta, handleBrainEvidence, handleBrainExplain, handleBrainOverview, handleBrainOwnership, handleBrainQuery, handleBrainRisk, handleBrainSnapshot, handleBrainTrace, } from "./handlers.js";
+export const BRAIN_MCP_TOOL_NAMES = [
+    "brain_overview",
+    "brain_query",
+    "brain_explain",
+    "brain_trace",
+    "brain_claims",
+    "brain_evidence",
+    "brain_ownership",
+    "brain_risk",
+    "brain_delta",
+    "brain_snapshot",
+];
+const emptyObjectSchema = {
+    type: "object",
+    properties: {},
+    additionalProperties: false,
+};
+export function listBrainMcpTools() {
+    return [
+        {
+            name: "brain_overview",
+            description: "READ: Compact Project Brain overview (domains, entrypoints, components, ownership/risk summaries, claim counts) with provenance. Not a file search.",
+            inputSchema: emptyObjectSchema,
+        },
+        {
+            name: "brain_query",
+            description: "READ: Typed BrainQueryEngine query only (ProjectSummary, ListEntrypoints, ListRisks, Impact, …). No arbitrary code/shell. Does not invent facts.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    type: {
+                        type: "string",
+                        description: "Query type or alias (e.g. ProjectSummary, find_risks, Impact)",
+                    },
+                    target: {
+                        type: "string",
+                        description: "Required for Impact / BlastRadius",
+                    },
+                    status: {
+                        type: "string",
+                        description: "Optional claim status filter for ListClaims",
+                    },
+                },
+                required: ["type"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "brain_explain",
+            description: "READ: Evidence-backed explainClaim for a claim id. Returns claim, status, confidence, evidence, contradictions. Never invents reasons.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    claimId: { type: "string", description: "Claim id" },
+                },
+                required: ["claimId"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "brain_trace",
+            description: "READ: Deterministic capped traceBrain (max depth 25, max edges 5000). Modes: dependencies, dependents, entrypoint-downstream, blast-radius, domain-modules.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    target: { type: "string" },
+                    mode: { type: "string" },
+                },
+                required: ["target"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "brain_claims",
+            description: "READ: List claims with lifecycle status. Default truth filter: ACTIVE + CONTRADICTED only (excludes INVALIDATED/SUPERSEDED unless requested).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    status: {
+                        type: "string",
+                        description: "ACTIVE | INVALIDATED | SUPERSEDED | CONTRADICTED",
+                    },
+                    includeHistorical: {
+                        type: "boolean",
+                        description: "When true without status, include INVALIDATED and SUPERSEDED",
+                    },
+                },
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "brain_evidence",
+            description: "READ: Typed evidence records after Brain redaction. Never returns secret plaintext. Optional evidenceId filter.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    evidenceId: { type: "string" },
+                },
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "brain_ownership",
+            description: "READ: Ownership from explicit CODEOWNERS / MAINTAINERS / package metadata only. Missing → UNKNOWN. No git-blame.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string" },
+                },
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "brain_risk",
+            description: "READ: Change-danger risk only (not SAST/vulnerabilities): critical entrypoint, centrality, coupling, ownership clarity, architecture conflict.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    kind: { type: "string" },
+                },
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "brain_delta",
+            description: "READ: Compare two snapshots without mutating. Returns claim/component/ownership/risk deltas between fromSnapshot and toSnapshot.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    fromSnapshot: { type: "string" },
+                    toSnapshot: { type: "string" },
+                },
+                required: ["fromSnapshot"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "brain_snapshot",
+            description: "Snapshot ops. READ: current|history|compare|load. CONTROLLED WRITE: rebuild writes only under <root>/.agentdoctor/project-brain/ (never source/agent configs; refuses divergent overwrite).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    action: { type: "string" },
+                    snapshotId: { type: "string" },
+                    leftId: { type: "string" },
+                    rightId: { type: "string" },
+                },
+                additionalProperties: false,
+            },
+        },
+    ];
+}
+export async function invokeBrainMcpTool(session, name, args) {
+    try {
+        switch (name) {
+            case "brain_overview":
+                return { structured: await handleBrainOverview(session), isError: false };
+            case "brain_query":
+                return { structured: await handleBrainQuery(session, args), isError: false };
+            case "brain_explain":
+                return { structured: await handleBrainExplain(session, args), isError: false };
+            case "brain_trace":
+                return { structured: await handleBrainTrace(session, args), isError: false };
+            case "brain_claims":
+                return { structured: await handleBrainClaims(session, args), isError: false };
+            case "brain_evidence":
+                return { structured: await handleBrainEvidence(session, args), isError: false };
+            case "brain_ownership":
+                return { structured: await handleBrainOwnership(session, args), isError: false };
+            case "brain_risk":
+                return { structured: await handleBrainRisk(session, args), isError: false };
+            case "brain_delta":
+                return { structured: await handleBrainDelta(session, args), isError: false };
+            case "brain_snapshot":
+                return { structured: await handleBrainSnapshot(session, args), isError: false };
+            default:
+                return {
+                    structured: {
+                        ok: false,
+                        error: { code: "invalid_argument", message: `unknown tool: ${name}` },
+                    },
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        return { structured: toToolErrorPayload(error), isError: true };
+    }
+}