@unson/brainbase-mcp 0.1.0

package/dist/operationalization.js

@@ -0,0 +1,87 @@
+export function buildOperationalizationPlan(input = {}) {
+    const target = input.target ?? 'agent';
+    const dataDir = input.dataDir ?? '<personal-os-dir>';
+    const cwd = input.cwd ?? '<brainbase-checkout>';
+    const installTarget = target === 'agent' ? '<agent>' : target;
+    const skillsTarget = target === 'claude' ? 'claude' : target === 'codex' ? 'codex' : 'portable';
+    const routinesTarget = target === 'claude' ? 'claude' : 'codex';
+    return {
+        goal: 'Keep onboarding open until the first value demo is followed by the operating setup the user still needs.',
+        completed: input.firstValueReady
+            ? [
+                'Initial approved context is seeded locally.',
+                'doctor can report the first value demo as ready.',
+                'onboard:demo produced a prompt, sample result, and plain-language value explanation.'
+            ]
+            : [
+                'Personal OS setup has started.'
+            ],
+        pending: [
+            {
+                id: 'public-skills',
+                title: 'Place the public Brainbase onboarding skills',
+                status: 'pending',
+                command: `brainbase onboard:skills --target ${skillsTarget}`,
+                why: 'Agents need the public onboarding, source import, candidate review, and daily routine instructions available where they run.',
+                safety: 'Generation is dry-run by default; write files only with an explicit --out path and do not overwrite existing SKILL.md files.'
+            },
+            {
+                id: 'routines',
+                title: 'Register ohayo / oyasumi / retro routines',
+                status: 'pending',
+                command: `brainbase onboard:routines --target ${routinesTarget} --cwd ${commandArg(cwd)}`,
+                why: 'The operating loop is not active until the morning, end-of-day, and weekly retrospective routines are scheduled.',
+                safety: 'Register routines paused or confirmation-gated first; generated definitions alone do not create a live scheduler.'
+            },
+            {
+                id: 'mcp-config',
+                title: 'Merge the Brainbase MCP config into the real agent config',
+                status: 'pending',
+                command: `brainbase onboard:install --target ${installTarget} --dir ${commandArg(dataDir)} --dry-run`,
+                why: 'A dry-run snippet proves the config shape, but the agent cannot call Brainbase until the real Codex / Claude / CodeCode config is updated.',
+                safety: 'Keep dry-run as preview only; merge into live config after user approval and restart the target agent.'
+            },
+            {
+                id: 'source-allowlist',
+                title: 'Decide source allowlists, import, and candidate review',
+                status: 'pending',
+                command: 'brainbase onboard:diagnose-sources --email <provider> --calendar <provider> --drive <provider> --drive-folder <folder-id> --tasks <tool>',
+                why: 'Mail, calendar, drive, files, and tasks are optional follow-up sources and need explicit allowlists before import.',
+                safety: 'Keep imported material under sources/ and promote only reviewed candidates into approved local memory.'
+            },
+            {
+                id: 'verification',
+                title: 'Verify doctor and MCP get_context / search',
+                status: 'pending',
+                command: `brainbase doctor --dir ${commandArg(dataDir)}`,
+                why: 'Onboarding is operational only when doctor and the MCP tools show the approved context from a fresh agent session.',
+                safety: 'Check get_context/search after config merge instead of assuming command generation was enough.'
+            }
+        ],
+        recommendedOrder: [
+            'Install or write public skills for the target agent.',
+            'Generate ohayo / oyasumi / retro routines and register them paused or confirmation-gated.',
+            'Merge the Brainbase MCP snippet into the real Codex / Claude / CodeCode config and restart the agent.',
+            'Decide source allowlists and run import / candidate review only where more context is needed.',
+            'Run doctor, then verify MCP get_context and search from a fresh agent session.'
+        ],
+        safetyRules: [
+            'Do not write live config, scheduler entries, or canonical facts without user approval.',
+            'Do not treat generated skills, generated routines, or MCP dry-run snippets as completed installation.',
+            'Do not ask users to paste OAuth tokens, passwords, API keys, or refresh tokens into chat.',
+            'Source imports stay local-first and reviewed before canonical promotion.'
+        ],
+        completionCheck: [
+            'The user has seen the first value output.',
+            'The completion report names all still-pending operationalization actions.',
+            'The target agent can call Brainbase MCP get_context/search after real config merge.',
+            'Source allowlists and candidate review are either completed or explicitly deferred.'
+        ]
+    };
+}
+function commandArg(value) {
+    if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}

package/dist/paths.d.ts

@@ -0,0 +1,2 @@
+export declare function defaultDataDir(): string;
+export declare function resolveDataDir(input?: string): string;

package/dist/paths.js

@@ -0,0 +1,8 @@
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+export function defaultDataDir() {
+    return resolve(process.env.BRAINBASE_PERSONAL_OS_DIR ?? join(homedir(), '.brainbase', 'personal-os'));
+}
+export function resolveDataDir(input) {
+    return resolve(input ?? defaultDataDir());
+}

package/dist/projects.d.ts

@@ -0,0 +1,51 @@
+import type { DecisionRecord, GraphEntity, PersonalKgEntry, RelationshipRecord } from './types.js';
+export type ProjectSourceArea = 'mail' | 'calendar' | 'drive' | 'tasks' | 'local' | 'other';
+export interface ProjectSourceReference {
+    area: ProjectSourceArea;
+    label: string;
+    ref: string;
+}
+export interface ProjectStakeholder {
+    person: string;
+    role?: string;
+    context: string;
+}
+export interface ProjectRegistrationInput {
+    name: string;
+    goal?: string;
+    status?: string;
+    role?: string;
+    stakeholders?: ProjectStakeholder[];
+    sources?: ProjectSourceReference[];
+    taskSources?: string[];
+    decisionPrinciples?: string[];
+    now?: string;
+}
+export interface ProjectRegistrationPlan {
+    goal: string;
+    canonicalWrites: false;
+    project: {
+        id: string;
+        name: string;
+        summary: string;
+        goal?: string;
+        status?: string;
+        role?: string;
+        sources: ProjectSourceReference[];
+        taskSources: string[];
+        decisionPrinciples: string[];
+    };
+    stakeholders: ProjectStakeholder[];
+    writes: {
+        graphEntities: GraphEntity[];
+        relationships: RelationshipRecord[];
+        personalKg: PersonalKgEntry[];
+        decisions: DecisionRecord[];
+    };
+    safetyRules: string[];
+    nextCommands: string[];
+}
+export declare function parseProjectSource(value: string): ProjectSourceReference;
+export declare function parseProjectStakeholder(value: string): ProjectStakeholder;
+export declare function buildProjectRegistrationPlan(input: ProjectRegistrationInput): ProjectRegistrationPlan;
+export declare function renderProjectRegistrationMarkdown(plan: ProjectRegistrationPlan, wrote: boolean, dataDir: string): string;

package/dist/projects.js

@@ -0,0 +1,227 @@
+export function parseProjectSource(value) {
+    const [areaRaw, labelRaw, refRaw] = value.split('|').map((part) => part.trim());
+    const area = parseProjectSourceArea(areaRaw);
+    const label = labelRaw || area;
+    const ref = refRaw || labelRaw || area;
+    if (!ref) {
+        throw new Error('project source must be "area|label|ref" or "area|ref"');
+    }
+    return { area, label, ref };
+}
+export function parseProjectStakeholder(value) {
+    const [person, role, context] = value.split('|').map((part) => part.trim());
+    if (!person || !context) {
+        throw new Error('project stakeholder must be "person|role|context" or "person||context"');
+    }
+    return { person, role: role || undefined, context };
+}
+export function buildProjectRegistrationPlan(input) {
+    const name = input.name.trim();
+    if (!name) {
+        throw new Error('onboard:projects requires --name <project-name>');
+    }
+    const now = input.now ?? 'dry-run';
+    const projectId = `project-${stableHash(name)}`;
+    const stakeholders = dedupeStakeholders(input.stakeholders ?? []);
+    const sources = dedupeSources(input.sources ?? []);
+    const taskSources = dedupeStrings(input.taskSources ?? []);
+    const decisionPrinciples = dedupeStrings(input.decisionPrinciples ?? []);
+    const summary = buildProjectSummary(input);
+    const projectEntity = {
+        id: projectId,
+        type: 'project',
+        name,
+        summary,
+        tags: ['work', 'project'],
+        metadata: {
+            goal: emptyToUndefined(input.goal),
+            status: emptyToUndefined(input.status),
+            role: emptyToUndefined(input.role),
+            sources,
+            taskSources,
+            decisionPrinciples
+        }
+    };
+    const stakeholderEntities = stakeholders.map((stakeholder) => ({
+        id: `person-${stableHash(stakeholder.person)}`,
+        type: 'person',
+        name: stakeholder.person,
+        summary: `Stakeholder for ${name}: ${stakeholder.context}`,
+        tags: ['relationship', 'project-stakeholder'],
+        metadata: { project: name, projectId }
+    }));
+    const relationships = stakeholders.map((stakeholder) => ({
+        id: `relationship-${stableHash(`${name}|${stakeholder.person}|${stakeholder.context}`)}`,
+        person: stakeholder.person,
+        role: stakeholder.role,
+        context: `${name}: ${stakeholder.context}`,
+        tags: ['project', 'relationship'],
+        updatedAt: now
+    }));
+    const personalKg = [{
+            id: `work-${stableHash(`${name}|${summary}`)}`,
+            type: 'work',
+            text: buildProjectWorkText(name, input, sources, taskSources),
+            tags: ['project', 'work'],
+            source: 'onboard:projects',
+            updatedAt: now
+        }];
+    const decisions = decisionPrinciples.map((principle) => ({
+        id: `decision-${stableHash(`${name}|${principle}`)}`,
+        title: `Project principle: ${name}`,
+        decision: principle,
+        rationale: 'Registered during Brainbase project onboarding.',
+        tags: ['project', 'principle'],
+        updatedAt: now
+    }));
+    return {
+        goal: 'Review project registration before promoting it into canonical Brainbase SSOT.',
+        canonicalWrites: false,
+        project: {
+            id: projectId,
+            name,
+            summary,
+            goal: emptyToUndefined(input.goal),
+            status: emptyToUndefined(input.status),
+            role: emptyToUndefined(input.role),
+            sources,
+            taskSources,
+            decisionPrinciples
+        },
+        stakeholders,
+        writes: {
+            graphEntities: [projectEntity, ...stakeholderEntities],
+            relationships,
+            personalKg,
+            decisions
+        },
+        safetyRules: [
+            'Project registration works from user interview answers first; connected sources are optional.',
+            'Source references are metadata-only allowlists and are not read by onboard:projects.',
+            'Canonical SSOT writes happen only when the command is rerun with --write.',
+            'Review stakeholders and decision principles with the user before promotion.'
+        ],
+        nextCommands: [
+            'Review this project registration with the user.',
+            'brainbase onboard:projects --name "<project>" ... --write',
+            'brainbase doctor'
+        ]
+    };
+}
+export function renderProjectRegistrationMarkdown(plan, wrote, dataDir) {
+    const lines = ['# Brainbase Project Registration', ''];
+    lines.push(`- Canonical writes: ${wrote}`);
+    lines.push(`- Data dir: ${dataDir}`);
+    lines.push(`- Project: ${plan.project.name}`);
+    lines.push(`- Summary: ${plan.project.summary}`);
+    if (plan.project.role) {
+        lines.push(`- My role: ${plan.project.role}`);
+    }
+    lines.push('', '## Source Allowlists');
+    if (plan.project.sources.length === 0) {
+        lines.push('- (none)');
+    }
+    for (const source of plan.project.sources) {
+        lines.push(`- ${source.area}: ${source.label} (${source.ref})`);
+    }
+    lines.push('', '## Task Sources');
+    if (plan.project.taskSources.length === 0) {
+        lines.push('- (none)');
+    }
+    for (const taskSource of plan.project.taskSources) {
+        lines.push(`- ${taskSource}`);
+    }
+    lines.push('', '## Stakeholders');
+    if (plan.stakeholders.length === 0) {
+        lines.push('- (none)');
+    }
+    for (const stakeholder of plan.stakeholders) {
+        lines.push(`- ${stakeholder.person}${stakeholder.role ? ` (${stakeholder.role})` : ''}: ${stakeholder.context}`);
+    }
+    lines.push('', '## Decision Principles');
+    if (plan.project.decisionPrinciples.length === 0) {
+        lines.push('- (none)');
+    }
+    for (const principle of plan.project.decisionPrinciples) {
+        lines.push(`- ${principle}`);
+    }
+    lines.push('', '## Safety Rules');
+    for (const rule of plan.safetyRules) {
+        lines.push(`- ${rule}`);
+    }
+    if (!wrote) {
+        lines.push('', 'Dry-run only. Re-run with --write after user approval to promote this project into canonical SSOT.');
+    }
+    return `${lines.join('\n')}\n`;
+}
+function parseProjectSourceArea(value) {
+    if (value === 'mail' || value === 'calendar' || value === 'drive' || value === 'tasks' || value === 'local' || value === 'other') {
+        return value;
+    }
+    throw new Error('project source area must be mail|calendar|drive|tasks|local|other');
+}
+function buildProjectSummary(input) {
+    const parts = [
+        input.goal ? `Goal: ${input.goal.trim()}` : '',
+        input.status ? `Status: ${input.status.trim()}` : '',
+        input.role ? `My role: ${input.role.trim()}` : ''
+    ].filter(Boolean);
+    return parts.length > 0 ? parts.join(' / ') : 'Registered during Brainbase project onboarding.';
+}
+function buildProjectWorkText(name, input, sources, taskSources) {
+    const lines = [`Project ${name}`];
+    if (input.goal) {
+        lines.push(`Goal: ${input.goal.trim()}`);
+    }
+    if (input.status) {
+        lines.push(`Status: ${input.status.trim()}`);
+    }
+    if (input.role) {
+        lines.push(`My role: ${input.role.trim()}`);
+    }
+    if (sources.length > 0) {
+        lines.push(`Allowed sources: ${sources.map((source) => `${source.area}:${source.label}`).join(', ')}`);
+    }
+    if (taskSources.length > 0) {
+        lines.push(`Task sources: ${taskSources.join(', ')}`);
+    }
+    return lines.join('\n');
+}
+function dedupeSources(sources) {
+    const seen = new Set();
+    const result = [];
+    for (const source of sources) {
+        const key = `${source.area}|${source.label}|${source.ref}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(source);
+        }
+    }
+    return result;
+}
+function dedupeStakeholders(stakeholders) {
+    const seen = new Set();
+    const result = [];
+    for (const stakeholder of stakeholders) {
+        const key = `${stakeholder.person}|${stakeholder.role ?? ''}|${stakeholder.context}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(stakeholder);
+        }
+    }
+    return result;
+}
+function dedupeStrings(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function emptyToUndefined(value) {
+    const trimmed = value?.trim();
+    return trimmed || undefined;
+}
+function stableHash(value) {
+    let hashValue = 0;
+    for (const char of value) {
+        hashValue = ((hashValue << 5) - hashValue + char.charCodeAt(0)) | 0;
+    }
+    return Math.abs(hashValue).toString(36);
+}

package/dist/routines.d.ts

@@ -0,0 +1,34 @@
+export type RoutineKind = 'ohayo' | 'oyasumi' | 'retro';
+export type RoutineTarget = 'codex' | 'claude';
+export interface ScheduleOptions {
+    ohayoHour?: number;
+    ohayoMinute?: number;
+    oyasumiHour?: number;
+    oyasumiMinute?: number;
+    retroDow?: string;
+    retroHour?: number;
+    retroMinute?: number;
+}
+export interface RoutineSchedule {
+    freq: 'daily' | 'weekly';
+    hour: number;
+    minute: number;
+    dayOfWeek?: string;
+}
+export interface RoutineDefinition {
+    id: string;
+    kind: RoutineKind;
+    name: string;
+    schedule: RoutineSchedule;
+    rrule: string;
+    cron: string;
+    prompt: string;
+}
+export declare function parseRoutineTarget(value: string | undefined): RoutineTarget;
+export declare function parseRoutineKinds(value: string | undefined): RoutineKind[];
+export declare function buildRoutines(kinds: RoutineKind[], options?: ScheduleOptions): RoutineDefinition[];
+export declare function scheduleToRrule(schedule: RoutineSchedule): string;
+export declare function scheduleToCron(schedule: RoutineSchedule): string;
+export declare function renderCodexAutomations(definitions: RoutineDefinition[], cwd: string, model?: string): string;
+export declare function renderCodexAutomation(definition: RoutineDefinition, cwd: string, model?: string): string;
+export declare function buildClaudeScheduledTasks(definitions: RoutineDefinition[], cwd: string): Record<string, unknown>;

package/dist/routines.js

@@ -0,0 +1,136 @@
+const ALL_KINDS = ['ohayo', 'oyasumi', 'retro'];
+const DOW_TO_RRULE = {
+    MON: 'MO', TUE: 'TU', WED: 'WE', THU: 'TH', FRI: 'FR', SAT: 'SA', SUN: 'SU'
+};
+// cron day-of-week: Sunday = 0
+const DOW_TO_CRON = {
+    SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6
+};
+const ROUTINE_PROMPTS = {
+    ohayo: 'Run my personal morning input routine using the local Brainbase MCP. Read my Brainbase get_context for who and what matters to me, review today and the next few days of my own Google Calendar and my unread Gmail metadata-first via gog, and surface today\'s priorities and pending follow-ups. Treat anything new (people, tasks, decisions) as Brainbase candidates for review, not canonical memory. Do not send messages, publish anything, modify my calendar, or delete records without my explicit confirmation; draft or report pending work instead. Treat authentication, gog, or source failures as unavailable, not as zero items.',
+    oyasumi: 'Run my personal end-of-day routine using the local Brainbase MCP. Summarize what I decided and worked on today, update my open task candidates from my calendar and notes, and capture reflections and decisions as Brainbase candidates for review. Promote nothing into canonical SSOT without my explicit approval. Do not send messages, publish, modify my calendar, or delete records without confirmation.',
+    retro: 'Run my weekly retrospective using the local Brainbase MCP. From my Brainbase context and this week\'s calendar, mail metadata, and notes, summarize the week\'s meetings, decisions, and completed versus pending work, then propose next week\'s focus. Write the retrospective as a local review note and record any durable lessons as Brainbase candidates for review. Do not send, publish, edit my calendar, or delete anything without my explicit confirmation.'
+};
+const ROUTINE_NAMES = {
+    ohayo: 'Brainbase personal ohayo (morning input)',
+    oyasumi: 'Brainbase personal oyasumi (end of day)',
+    retro: 'Brainbase personal retro (weekly retrospective)'
+};
+export function parseRoutineTarget(value) {
+    if (value === 'codex' || value === 'claude') {
+        return value;
+    }
+    throw new Error('onboard:routines requires --target codex|claude');
+}
+export function parseRoutineKinds(value) {
+    if (!value) {
+        return [...ALL_KINDS];
+    }
+    const requested = value.split(',').map((part) => part.trim().toLowerCase());
+    const kinds = [];
+    for (const kind of ALL_KINDS) {
+        if (requested.includes(kind)) {
+            kinds.push(kind);
+        }
+    }
+    if (kinds.length === 0) {
+        throw new Error('--routines must include at least one of: ohayo, oyasumi, retro');
+    }
+    return kinds;
+}
+export function buildRoutines(kinds, options = {}) {
+    const ohayoHour = clampHour(options.ohayoHour, 7);
+    const ohayoMinute = clampMinute(options.ohayoMinute, 0);
+    const oyasumiHour = clampHour(options.oyasumiHour, 21);
+    const oyasumiMinute = clampMinute(options.oyasumiMinute, 0);
+    const retroDow = normalizeDow(options.retroDow, 'FRI');
+    const retroHour = clampHour(options.retroHour, 17);
+    const retroMinute = clampMinute(options.retroMinute, 0);
+    const schedules = {
+        ohayo: { freq: 'daily', hour: ohayoHour, minute: ohayoMinute },
+        oyasumi: { freq: 'daily', hour: oyasumiHour, minute: oyasumiMinute },
+        retro: { freq: 'weekly', hour: retroHour, minute: retroMinute, dayOfWeek: retroDow }
+    };
+    return kinds.map((kind) => {
+        const schedule = schedules[kind];
+        return {
+            id: `brainbase-${kind}`,
+            kind,
+            name: ROUTINE_NAMES[kind],
+            schedule,
+            rrule: scheduleToRrule(schedule),
+            cron: scheduleToCron(schedule),
+            prompt: ROUTINE_PROMPTS[kind]
+        };
+    });
+}
+export function scheduleToRrule(schedule) {
+    if (schedule.freq === 'weekly') {
+        const byday = DOW_TO_RRULE[schedule.dayOfWeek ?? 'FRI'] ?? 'FR';
+        return `FREQ=WEEKLY;BYDAY=${byday};BYHOUR=${schedule.hour};BYMINUTE=${schedule.minute};BYSECOND=0`;
+    }
+    return `FREQ=DAILY;BYHOUR=${schedule.hour};BYMINUTE=${schedule.minute};BYSECOND=0`;
+}
+export function scheduleToCron(schedule) {
+    if (schedule.freq === 'weekly') {
+        const dow = DOW_TO_CRON[schedule.dayOfWeek ?? 'FRI'] ?? 5;
+        return `${schedule.minute} ${schedule.hour} * * ${dow}`;
+    }
+    return `${schedule.minute} ${schedule.hour} * * *`;
+}
+export function renderCodexAutomations(definitions, cwd, model = 'gpt-5') {
+    // Each Codex automation is a flat TOML document saved as its own file at
+    // ~/.codex/automations/<id>/automation.toml. They are delimited by a file
+    // marker comment so a single output can be split into per-file documents.
+    return `${definitions.map((definition) => renderCodexAutomation(definition, cwd, model)).join('\n')}`;
+}
+export function renderCodexAutomation(definition, cwd, model = 'gpt-5') {
+    return [
+        `# file: ~/.codex/automations/${definition.id}/automation.toml`,
+        'version = 1',
+        `id = ${tomlString(definition.id)}`,
+        'kind = "cron"',
+        `name = ${tomlString(definition.name)}`,
+        `prompt = ${tomlString(definition.prompt)}`,
+        'status = "ACTIVE"',
+        `rrule = ${tomlString(definition.rrule)}`,
+        `model = ${tomlString(model)}`,
+        'reasoning_effort = "high"',
+        'execution_environment = "local"',
+        `cwds = [${tomlString(cwd)}]`,
+        ''
+    ].join('\n');
+}
+export function buildClaudeScheduledTasks(definitions, cwd) {
+    return {
+        scheduledTasks: definitions.map((definition) => ({
+            id: definition.id,
+            name: definition.name,
+            cron: definition.cron,
+            cwd,
+            prompt: definition.prompt
+        }))
+    };
+}
+function clampHour(value, fallback) {
+    if (value === undefined || Number.isNaN(value)) {
+        return fallback;
+    }
+    return Math.min(23, Math.max(0, Math.trunc(value)));
+}
+function clampMinute(value, fallback) {
+    if (value === undefined || Number.isNaN(value)) {
+        return fallback;
+    }
+    return Math.min(59, Math.max(0, Math.trunc(value)));
+}
+function normalizeDow(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const upper = value.trim().toUpperCase().slice(0, 3);
+    return DOW_TO_RRULE[upper] ? upper : fallback;
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}

package/dist/server.d.ts

@@ -0,0 +1,127 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+export declare const toolDefinitions: readonly [{
+    readonly name: "get_context";
+    readonly description: "Return initial AI context from local Graph and Personal KG canonical files.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly dataDir: {
+                readonly type: "string";
+            };
+        };
+    };
+}, {
+    readonly name: "list_entities";
+    readonly description: "List person, org, project, relationship, and decision entities from local SSOT.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly dataDir: {
+                readonly type: "string";
+            };
+            readonly type: {
+                readonly enum: readonly ["person", "org", "project", "relationship", "decision"];
+            };
+        };
+    };
+}, {
+    readonly name: "search";
+    readonly description: "Search canonical local Graph, Personal KG, relationships, and decisions.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["query"];
+        readonly properties: {
+            readonly dataDir: {
+                readonly type: "string";
+            };
+            readonly query: {
+                readonly type: "string";
+            };
+            readonly limit: {
+                readonly type: "number";
+            };
+        };
+    };
+}, {
+    readonly name: "search_personal_kg";
+    readonly description: "Search owner-local Personal KG only.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["query"];
+        readonly properties: {
+            readonly dataDir: {
+                readonly type: "string";
+            };
+            readonly query: {
+                readonly type: "string";
+            };
+            readonly limit: {
+                readonly type: "number";
+            };
+        };
+    };
+}, {
+    readonly name: "onboarding_status";
+    readonly description: "Report seeded areas, first value demo readiness, missing setup, and local connection status.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly dataDir: {
+                readonly type: "string";
+            };
+        };
+    };
+}, {
+    readonly name: "get_ontology";
+    readonly description: "Return the bundled immutable Brainbase Portable Ontology Kernel release.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+    };
+}, {
+    readonly name: "audit_ontology";
+    readonly description: "Audit local canonical Personal OS files using the active or recorded historical ontology semantics.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly dataDir: {
+                readonly type: "string";
+            };
+            readonly ontologyVersion: {
+                readonly enum: readonly ["0.0.0", "1.0.0"];
+            };
+        };
+    };
+}, {
+    readonly name: "infer_decisions";
+    readonly description: "Derive active, superseded, and conflicting decisions using explicit ontology rules.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly dataDir: {
+                readonly type: "string";
+            };
+            readonly asOf: {
+                readonly type: "string";
+                readonly format: "date-time";
+            };
+            readonly ontologyVersion: {
+                readonly enum: readonly ["0.0.0", "1.0.0"];
+            };
+        };
+    };
+}, {
+    readonly name: "ontology_impact";
+    readonly description: "Describe compatibility, migration, and rollback from an ontology version to the active release.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly fromVersion: {
+                readonly type: "string";
+            };
+        };
+    };
+}];
+export declare function callBrainbaseTool(name: string, rawArgs?: unknown): Promise<unknown>;
+export declare function createServer(): Server;
+export declare function runMcpServer(): Promise<void>;