brainctl 0.1.3 → 0.1.4

package/dist/cli.d.ts

@@ -2,13 +2,17 @@
 import { Command } from 'commander';
 import { type DoctorService } from './services/doctor-service.js';
 import { type InitService } from './services/init-service.js';
+import { type ProfileService } from './services/profile-service.js';
 import { type RunService } from './services/run-service.js';
 import { type StatusService } from './services/status-service.js';
+import { type SyncService } from './services/sync-service.js';
 export interface CliServices {
     initService: InitService;
     runService: RunService;
     statusService: StatusService;
     doctorService: DoctorService;
+    profileService: ProfileService;
+    syncService: SyncService;
 }
 export declare function createProgram(overrides?: Partial<CliServices>): Command;
 export declare function main(argv?: string[]): Promise<void>;

package/dist/cli.js

@@ -6,14 +6,18 @@ import { Command } from 'commander';
 import { registerDoctorCommand } from './commands/doctor.js';
 import { registerInitCommand } from './commands/init.js';
 import { registerMcpCommand } from './commands/mcp.js';
+import { registerProfileCommand } from './commands/profile.js';
 import { registerRunCommand } from './commands/run.js';
 import { registerStatusCommand } from './commands/status.js';
+import { registerSyncCommand } from './commands/sync.js';
 import { registerUiCommand } from './commands/ui.js';
 import { printError } from './output.js';
 import { createDoctorService } from './services/doctor-service.js';
 import { createInitService } from './services/init-service.js';
+import { createProfileService } from './services/profile-service.js';
 import { createRunService } from './services/run-service.js';
 import { createStatusService } from './services/status-service.js';
+import { createSyncService } from './services/sync-service.js';
 import { createExecutorResolver } from './executor/resolver.js';
 const packageVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 export function createProgram(overrides = {}) {
@@ -27,6 +31,8 @@ export function createProgram(overrides = {}) {
     registerStatusCommand(program, services.statusService);
     registerRunCommand(program, services.runService);
     registerDoctorCommand(program, services.doctorService);
+    registerProfileCommand(program, services.profileService);
+    registerSyncCommand(program, services.syncService);
     registerUiCommand(program);
     registerMcpCommand(program);
     return program;
@@ -49,11 +55,14 @@ export function shouldRunMain(entryPointPath, moduleUrl) {
 }
 function createDefaultServices(overrides) {
     const resolver = createExecutorResolver();
+    const profileService = createProfileService();
     return {
         initService: createInitService(),
         runService: createRunService({ resolver }),
         statusService: createStatusService({ resolver }),
         doctorService: createDoctorService({ resolver }),
+        profileService,
+        syncService: createSyncService({ profileService }),
         ...overrides
     };
 }

package/dist/commands/profile.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import type { ProfileService } from '../services/profile-service.js';
+export declare function registerProfileCommand(program: Command, profileService: ProfileService): void;

package/dist/commands/profile.js

@@ -0,0 +1,43 @@
+import pc from 'picocolors';
+export function registerProfileCommand(program, profileService) {
+    const profileCmd = program
+        .command('profile')
+        .description('Manage brainctl profiles');
+    profileCmd
+        .command('list')
+        .description('List available profiles')
+        .action(async () => {
+        const { profiles, activeProfile } = await profileService.list({ cwd: process.cwd() });
+        if (profiles.length === 0) {
+            console.log('No profiles found. Run "brainctl profile create <name>" to create one.');
+            return;
+        }
+        console.log(pc.bold('Profiles:'));
+        for (const name of profiles) {
+            const marker = name === activeProfile ? pc.green(' (active)') : '';
+            console.log(`  ${name}${marker}`);
+        }
+    });
+    profileCmd
+        .command('create')
+        .argument('<name>', 'Profile name')
+        .option('-d, --description <text>', 'Profile description')
+        .description('Create a new profile')
+        .action(async (name, options) => {
+        const result = await profileService.create({
+            cwd: process.cwd(),
+            name,
+            description: options.description,
+        });
+        console.log(`Created profile at ${result.profilePath}`);
+    });
+    profileCmd
+        .command('use')
+        .argument('<name>', 'Profile name to activate')
+        .description('Switch the active profile')
+        .action(async (name) => {
+        const result = await profileService.use({ cwd: process.cwd(), name });
+        const prev = result.previousProfile ? ` (was "${result.previousProfile}")` : '';
+        console.log(`Switched to profile "${name}"${prev}`);
+    });
+}

package/dist/commands/sync.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import type { SyncService } from '../services/sync-service.js';
+export declare function registerSyncCommand(program: Command, syncService: SyncService): void;

package/dist/commands/sync.js

@@ -0,0 +1,31 @@
+import pc from 'picocolors';
+export function registerSyncCommand(program, syncService) {
+    program
+        .command('sync')
+        .description('Sync active profile to agent configs')
+        .option('--restore', 'Restore agent configs from most recent backup')
+        .action(async (options) => {
+        const results = await syncService.execute({
+            cwd: process.cwd(),
+            restore: options.restore,
+        });
+        if (results.length === 0) {
+            console.log('No agents to sync.');
+            return;
+        }
+        if (options.restore) {
+            console.log(pc.bold('Restored agent configs:'));
+            for (const result of results) {
+                console.log(`  ${result.agent}: restored from ${result.configPath}`);
+            }
+            return;
+        }
+        console.log(pc.bold('Synced profile to agents:'));
+        for (const result of results) {
+            console.log(`  ${result.agent}: ${result.configPath} (${result.mcpCount} MCPs)`);
+            if (result.backedUpTo) {
+                console.log(`    backed up to ${result.backedUpTo}`);
+            }
+        }
+    });
+}

package/dist/errors.d.ts

@@ -25,3 +25,12 @@ export declare class AgentNotAvailableError extends BrainctlError {
 export declare class ExecutionError extends BrainctlError {
     constructor(message: string);
 }
+export declare class ProfileError extends BrainctlError {
+    constructor(message: string);
+}
+export declare class ProfileNotFoundError extends BrainctlError {
+    constructor(message: string);
+}
+export declare class SyncError extends BrainctlError {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -43,3 +43,18 @@ export class ExecutionError extends BrainctlError {
         super(message, 'system', 'EXECUTION_ERROR');
     }
 }
+export class ProfileError extends BrainctlError {
+    constructor(message) {
+        super(message, 'user', 'PROFILE_ERROR');
+    }
+}
+export class ProfileNotFoundError extends BrainctlError {
+    constructor(message) {
+        super(message, 'user', 'PROFILE_NOT_FOUND');
+    }
+}
+export class SyncError extends BrainctlError {
+    constructor(message) {
+        super(message, 'system', 'SYNC_ERROR');
+    }
+}

package/dist/executor/resolver.js

@@ -4,10 +4,11 @@ import path from 'node:path';
 import { AgentNotAvailableError } from '../errors.js';
 import { ClaudeExecutor } from './claude.js';
 import { CodexExecutor } from './codex.js';
-const SUPPORTED_AGENTS = ['claude', 'codex'];
+const SUPPORTED_AGENTS = ['claude', 'codex', 'gemini'];
 const AGENT_COMMANDS = {
     claude: 'claude',
-    codex: 'codex'
+    codex: 'codex',
+    gemini: 'gemini'
 };
 class DefaultExecutorResolver {
     availabilityCache = new Map();
@@ -45,6 +46,8 @@ function createExecutor(agentName) {
             return new ClaudeExecutor();
         case 'codex':
             return new CodexExecutor();
+        default:
+            throw new AgentNotAvailableError(`Agent "${agentName}" does not have an executor implementation.`);
     }
 }
 async function checkAvailability(agentName) {

package/dist/mcp/server.js

@@ -3,9 +3,13 @@ import path from 'node:path';
 import { FastMCP } from 'fastmcp';
 import { z } from 'zod';
 import { loadConfig } from '../config.js';
+import { loadMemory } from '../context/memory.js';
 import { createDoctorService } from '../services/doctor-service.js';
+import { createMemoryWriteService } from '../services/memory-write-service.js';
+import { createProfileService } from '../services/profile-service.js';
 import { createRunService } from '../services/run-service.js';
 import { createStatusService } from '../services/status-service.js';
+import { createSyncService } from '../services/sync-service.js';
 const packageVersion = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
 export function createMcpServer(options = {}) {
     const cwd = options.cwd ?? process.cwd();
@@ -80,6 +84,97 @@ export function createMcpServer(options = {}) {
             return JSON.stringify(result, null, 2);
         },
     });
+    server.addTool({
+        name: 'brainctl_read_memory',
+        description: 'Read all shared memory files. Returns every markdown file from configured memory paths with file names and content. Use this to understand context left by other agents.',
+        parameters: z.object({}),
+        execute: async () => {
+            const config = await loadConfig({ cwd });
+            const memory = await loadMemory({ paths: config.memory.paths });
+            const result = {
+                count: memory.count,
+                files: memory.entries.map((entry) => ({
+                    path: entry.path,
+                    content: entry.content,
+                })),
+            };
+            return JSON.stringify(result, null, 2);
+        },
+    });
+    server.addTool({
+        name: 'brainctl_write_memory',
+        description: 'Write or update a shared memory file. Use this to leave notes, decisions, or context for other agents. The file must be within a configured memory path.',
+        parameters: z.object({
+            file_path: z.string().describe('Relative path for the memory file (e.g., "memory/notes.md")'),
+            content: z.string().describe('Markdown content to write'),
+        }),
+        execute: async (args) => {
+            const memoryWriteService = createMemoryWriteService();
+            const result = await memoryWriteService.execute({
+                cwd,
+                filePath: args.file_path,
+                content: args.content,
+            });
+            return JSON.stringify({ written: result.filePath });
+        },
+    });
+    server.addTool({
+        name: 'brainctl_get_skill',
+        description: 'Get the full details of a specific skill including its prompt text and description. Use this to understand what a skill does before running it.',
+        parameters: z.object({
+            skill: z.string().describe('Skill name as defined in ai-stack.yaml'),
+        }),
+        execute: async (args) => {
+            const config = await loadConfig({ cwd });
+            const skillConfig = config.skills[args.skill];
+            if (!skillConfig) {
+                throw new Error(`Skill "${args.skill}" is not defined in ai-stack.yaml.`);
+            }
+            return JSON.stringify({
+                name: args.skill,
+                description: skillConfig.description ?? null,
+                prompt: skillConfig.prompt,
+            }, null, 2);
+        },
+    });
+    server.addTool({
+        name: 'brainctl_list_profiles',
+        description: 'List available profiles and show which one is active.',
+        parameters: z.object({}),
+        execute: async () => {
+            const profileService = createProfileService();
+            const result = await profileService.list({ cwd });
+            return JSON.stringify(result, null, 2);
+        },
+    });
+    server.addTool({
+        name: 'brainctl_switch_profile',
+        description: 'Switch the active profile and sync it to all configured agents. Combines profile switch + sync in one step.',
+        parameters: z.object({
+            name: z.string().describe('Profile name to activate'),
+        }),
+        execute: async (args) => {
+            const profileService = createProfileService();
+            const switchResult = await profileService.use({ cwd, name: args.name });
+            const syncService = createSyncService({ profileService });
+            const syncResult = await syncService.execute({ cwd });
+            return JSON.stringify({
+                previousProfile: switchResult.previousProfile,
+                activeProfile: args.name,
+                synced: syncResult,
+            }, null, 2);
+        },
+    });
+    server.addTool({
+        name: 'brainctl_sync',
+        description: 'Sync the active profile to all configured agent configs (Claude, Codex). Creates backups before overwriting.',
+        parameters: z.object({}),
+        execute: async () => {
+            const syncService = createSyncService();
+            const result = await syncService.execute({ cwd });
+            return JSON.stringify(result, null, 2);
+        },
+    });
     return server;
 }
 export async function startMcpServer(options = {}) {

package/dist/services/profile-service.d.ts

@@ -0,0 +1,30 @@
+import type { BrainctlMetaConfig, ProfileConfig } from '../types.js';
+export interface ProfileService {
+    list(options?: {
+        cwd?: string;
+    }): Promise<{
+        profiles: string[];
+        activeProfile: string | null;
+    }>;
+    get(options: {
+        cwd?: string;
+        name: string;
+    }): Promise<ProfileConfig>;
+    create(options: {
+        cwd?: string;
+        name: string;
+        description?: string;
+    }): Promise<{
+        profilePath: string;
+    }>;
+    use(options: {
+        cwd?: string;
+        name: string;
+    }): Promise<{
+        previousProfile: string | null;
+    }>;
+    getMetaConfig(options?: {
+        cwd?: string;
+    }): Promise<BrainctlMetaConfig>;
+}
+export declare function createProfileService(): ProfileService;

package/dist/services/profile-service.js

@@ -0,0 +1,190 @@
+import { readdir, readFile, writeFile, mkdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+import { ProfileError, ProfileNotFoundError } from '../errors.js';
+const BRAINCTL_DIR = '.brainctl';
+const PROFILES_DIR = '.brainctl/profiles';
+const META_CONFIG = '.brainctl/config.yaml';
+export function createProfileService() {
+    return {
+        async list(options = {}) {
+            const cwd = options.cwd ?? process.cwd();
+            const profilesDir = path.join(cwd, PROFILES_DIR);
+            let files = [];
+            try {
+                const entries = await readdir(profilesDir);
+                files = entries
+                    .filter((f) => f.endsWith('.yaml'))
+                    .map((f) => f.replace(/\.yaml$/, ''))
+                    .sort();
+            }
+            catch {
+                // No profiles directory yet
+            }
+            const meta = await loadMetaConfig(cwd);
+            return {
+                profiles: files,
+                activeProfile: meta.active_profile || null,
+            };
+        },
+        async get(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
+            let source;
+            try {
+                source = await readFile(profilePath, 'utf8');
+            }
+            catch {
+                throw new ProfileNotFoundError(`Profile "${options.name}" not found at ${profilePath}`);
+            }
+            return parseProfile(source, options.name);
+        },
+        async create(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const profilesDir = path.join(cwd, PROFILES_DIR);
+            const profilePath = path.join(profilesDir, `${options.name}.yaml`);
+            if (await pathExists(profilePath)) {
+                throw new ProfileError(`Profile "${options.name}" already exists.`);
+            }
+            const scaffold = {
+                name: options.name,
+                description: options.description ?? '',
+                skills: {
+                    example: {
+                        description: 'Example skill',
+                        prompt: 'Describe what this skill does...',
+                    },
+                },
+                mcps: {},
+                memory: {
+                    paths: ['./memory'],
+                },
+            };
+            await mkdir(profilesDir, { recursive: true });
+            await writeFile(profilePath, YAML.stringify(scaffold), 'utf8');
+            return { profilePath };
+        },
+        async use(options) {
+            const cwd = options.cwd ?? process.cwd();
+            // Validate profile exists
+            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
+            if (!(await pathExists(profilePath))) {
+                throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
+            }
+            const meta = await loadMetaConfig(cwd);
+            const previousProfile = meta.active_profile || null;
+            meta.active_profile = options.name;
+            const metaPath = path.join(cwd, META_CONFIG);
+            await mkdir(path.dirname(metaPath), { recursive: true });
+            await writeFile(metaPath, YAML.stringify(meta), 'utf8');
+            return { previousProfile };
+        },
+        async getMetaConfig(options = {}) {
+            const cwd = options.cwd ?? process.cwd();
+            return loadMetaConfig(cwd);
+        },
+    };
+}
+async function loadMetaConfig(cwd) {
+    const metaPath = path.join(cwd, META_CONFIG);
+    try {
+        const source = await readFile(metaPath, 'utf8');
+        const parsed = YAML.parse(source) ?? {};
+        return {
+            active_profile: typeof parsed.active_profile === 'string' ? parsed.active_profile : '',
+            agents: Array.isArray(parsed.agents) ? parsed.agents : ['claude', 'codex'],
+        };
+    }
+    catch {
+        return { active_profile: '', agents: ['claude', 'codex', 'gemini'] };
+    }
+}
+function parseProfile(source, name) {
+    let parsed;
+    try {
+        parsed = YAML.parse(source) ?? {};
+    }
+    catch {
+        throw new ProfileError(`Profile "${name}" has invalid YAML.`);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new ProfileError(`Profile "${name}" has invalid structure.`);
+    }
+    const data = parsed;
+    const skills = {};
+    if (data.skills && typeof data.skills === 'object' && !Array.isArray(data.skills)) {
+        for (const [key, value] of Object.entries(data.skills)) {
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                const s = value;
+                if (typeof s.prompt === 'string') {
+                    skills[key] = {
+                        prompt: s.prompt,
+                        description: typeof s.description === 'string' ? s.description : undefined,
+                    };
+                }
+            }
+        }
+    }
+    const mcps = {};
+    if (data.mcps && typeof data.mcps === 'object' && !Array.isArray(data.mcps)) {
+        for (const [key, value] of Object.entries(data.mcps)) {
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                const m = value;
+                if (m.type === 'npm' && typeof m.package === 'string') {
+                    mcps[key] = {
+                        type: 'npm',
+                        package: m.package,
+                        env: parseEnv(m.env),
+                    };
+                }
+                else if (m.type === 'bundled' && typeof m.command === 'string') {
+                    mcps[key] = {
+                        type: 'bundled',
+                        path: typeof m.path === 'string' ? m.path : '.',
+                        install: typeof m.install === 'string' ? m.install : undefined,
+                        command: m.command,
+                        args: Array.isArray(m.args) ? m.args.map(String) : undefined,
+                        env: parseEnv(m.env),
+                    };
+                }
+            }
+        }
+    }
+    const memoryPaths = [];
+    if (data.memory && typeof data.memory === 'object' && !Array.isArray(data.memory)) {
+        const mem = data.memory;
+        if (Array.isArray(mem.paths)) {
+            for (const p of mem.paths) {
+                if (typeof p === 'string') {
+                    memoryPaths.push(p);
+                }
+            }
+        }
+    }
+    return {
+        name: typeof data.name === 'string' ? data.name : name,
+        description: typeof data.description === 'string' ? data.description : undefined,
+        skills,
+        mcps,
+        memory: { paths: memoryPaths },
+    };
+}
+function parseEnv(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+        result[k] = String(v);
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+async function pathExists(targetPath) {
+    try {
+        await stat(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/services/sync/agent-writer.d.ts

@@ -0,0 +1,18 @@
+import type { McpServerConfig } from '../../types.js';
+export interface AgentWriteOptions {
+    mcpServers: Record<string, McpServerConfig>;
+    cwd: string;
+}
+export interface AgentWriteResult {
+    configPath: string;
+    backedUpTo: string | null;
+}
+export interface AgentConfigWriter {
+    write(options: AgentWriteOptions): Promise<AgentWriteResult>;
+    restore(options: {
+        cwd: string;
+    }): Promise<{
+        restoredFrom: string;
+    }>;
+}
+export declare function formatTimestamp(): string;

package/dist/services/sync/agent-writer.js

@@ -0,0 +1,5 @@
+export function formatTimestamp() {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}

package/dist/services/sync/claude-writer.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfigWriter } from './agent-writer.js';
+export declare function createClaudeWriter(): AgentConfigWriter;

package/dist/services/sync/claude-writer.js

@@ -0,0 +1,83 @@
+import { copyFile, readdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { SyncError } from '../../errors.js';
+import { formatTimestamp } from './agent-writer.js';
+export function createClaudeWriter() {
+    return {
+        async write(options) {
+            const configPath = path.join(homedir(), '.claude.json');
+            let existing = {};
+            let backedUpTo = null;
+            // Read existing config
+            try {
+                const source = await readFile(configPath, 'utf8');
+                existing = JSON.parse(source);
+            }
+            catch {
+                // No existing config, start fresh
+            }
+            // Backup if file exists
+            if (Object.keys(existing).length > 0) {
+                const backupPath = `${configPath}.bak.${formatTimestamp()}`;
+                await copyFile(configPath, backupPath);
+                backedUpTo = backupPath;
+            }
+            // Build mcpServers for this project
+            const mcpServers = {};
+            for (const [name, config] of Object.entries(options.mcpServers)) {
+                mcpServers[name] = toClaudeFormat(config);
+            }
+            // Always include brainctl itself
+            mcpServers['brainctl'] = {
+                type: 'stdio',
+                command: 'npx',
+                args: ['-y', 'brainctl', 'mcp'],
+            };
+            // Merge into existing config (preserve other projects)
+            const projects = (existing.projects ?? {});
+            const projectConfig = projects[options.cwd] ?? {};
+            projectConfig.mcpServers = mcpServers;
+            projects[options.cwd] = projectConfig;
+            existing.projects = projects;
+            // Atomic write: write to temp, then rename
+            const tmpPath = `${configPath}.tmp.${Date.now()}`;
+            await writeFile(tmpPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+            await rename(tmpPath, configPath);
+            return { configPath, backedUpTo };
+        },
+        async restore(options) {
+            const configPath = path.join(homedir(), '.claude.json');
+            const dir = path.dirname(configPath);
+            const base = path.basename(configPath);
+            const entries = await readdir(dir);
+            const backups = entries
+                .filter((f) => f.startsWith(`${base}.bak.`))
+                .sort()
+                .reverse();
+            if (backups.length === 0) {
+                throw new SyncError('No Claude config backup found.');
+            }
+            const latestBackup = path.join(dir, backups[0]);
+            await copyFile(latestBackup, configPath);
+            return { restoredFrom: latestBackup };
+        },
+    };
+}
+function toClaudeFormat(config) {
+    if (config.type === 'npm') {
+        return {
+            type: 'stdio',
+            command: 'npx',
+            args: ['-y', config.package],
+            ...(config.env ? { env: config.env } : {}),
+        };
+    }
+    // bundled
+    return {
+        type: 'stdio',
+        command: config.command,
+        args: config.args ?? [],
+        ...(config.env ? { env: config.env } : {}),
+    };
+}

package/dist/services/sync/codex-writer.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfigWriter } from './agent-writer.js';
+export declare function createCodexWriter(): AgentConfigWriter;

package/dist/services/sync/codex-writer.js

@@ -0,0 +1,116 @@
+import { copyFile, mkdir, readdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { SyncError } from '../../errors.js';
+import { formatTimestamp } from './agent-writer.js';
+export function createCodexWriter() {
+    return {
+        async write(options) {
+            const configDir = path.join(homedir(), '.codex');
+            const configPath = path.join(configDir, 'config.toml');
+            let existingContent = '';
+            let backedUpTo = null;
+            // Read existing config
+            try {
+                existingContent = await readFile(configPath, 'utf8');
+            }
+            catch {
+                // No existing config
+            }
+            // Backup if file exists
+            if (existingContent.length > 0) {
+                const backupPath = `${configPath}.bak.${formatTimestamp()}`;
+                await copyFile(configPath, backupPath);
+                backedUpTo = backupPath;
+            }
+            // Build MCP servers section
+            const allServers = { ...options.mcpServers };
+            // Always include brainctl itself
+            allServers['brainctl'] = {
+                type: 'npm',
+                package: 'brainctl',
+            };
+            const mcpToml = buildMcpToml(allServers);
+            // Preserve non-mcp_servers content from existing config
+            const existingNonMcp = stripMcpSections(existingContent);
+            const finalContent = existingNonMcp.trim().length > 0
+                ? `${existingNonMcp.trim()}\n\n${mcpToml}`
+                : mcpToml;
+            // Atomic write
+            await mkdir(configDir, { recursive: true });
+            const tmpPath = `${configPath}.tmp.${Date.now()}`;
+            await writeFile(tmpPath, finalContent + '\n', 'utf8');
+            await rename(tmpPath, configPath);
+            return { configPath, backedUpTo };
+        },
+        async restore(options) {
+            const configPath = path.join(homedir(), '.codex', 'config.toml');
+            const dir = path.dirname(configPath);
+            const base = path.basename(configPath);
+            let entries;
+            try {
+                entries = await readdir(dir);
+            }
+            catch {
+                throw new SyncError('No Codex config directory found.');
+            }
+            const backups = entries
+                .filter((f) => f.startsWith(`${base}.bak.`))
+                .sort()
+                .reverse();
+            if (backups.length === 0) {
+                throw new SyncError('No Codex config backup found.');
+            }
+            const latestBackup = path.join(dir, backups[0]);
+            await copyFile(latestBackup, configPath);
+            return { restoredFrom: latestBackup };
+        },
+    };
+}
+function buildMcpToml(servers) {
+    const lines = [];
+    for (const [name, config] of Object.entries(servers)) {
+        lines.push(`[mcp_servers.${name}]`);
+        if (config.type === 'npm') {
+            lines.push(`command = "npx"`);
+            lines.push(`args = ["-y", ${tomlString(config.package)}]`);
+        }
+        else {
+            lines.push(`command = ${tomlString(config.command)}`);
+            if (config.args && config.args.length > 0) {
+                const argsStr = config.args.map(tomlString).join(', ');
+                lines.push(`args = [${argsStr}]`);
+            }
+        }
+        if (config.env && Object.keys(config.env).length > 0) {
+            lines.push('');
+            lines.push(`[mcp_servers.${name}.env]`);
+            for (const [key, value] of Object.entries(config.env)) {
+                lines.push(`${key} = ${tomlString(value)}`);
+            }
+        }
+        lines.push('');
+    }
+    return lines.join('\n').trim();
+}
+function tomlString(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+function stripMcpSections(content) {
+    const lines = content.split('\n');
+    const result = [];
+    let inMcpSection = false;
+    for (const line of lines) {
+        if (/^\[mcp_servers[\].]/.test(line)) {
+            inMcpSection = true;
+            continue;
+        }
+        if (inMcpSection && /^\[/.test(line) && !/^\[mcp_servers[\].]/.test(line)) {
+            inMcpSection = false;
+        }
+        if (!inMcpSection) {
+            result.push(line);
+        }
+    }
+    return result.join('\n');
+}

package/dist/services/sync/gemini-writer.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfigWriter } from './agent-writer.js';
+export declare function createGeminiWriter(): AgentConfigWriter;

package/dist/services/sync/gemini-writer.js

@@ -0,0 +1,83 @@
+import { copyFile, mkdir, readdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { SyncError } from '../../errors.js';
+import { formatTimestamp } from './agent-writer.js';
+export function createGeminiWriter() {
+    return {
+        async write(options) {
+            const geminiDir = path.join(options.cwd, '.gemini');
+            const configPath = path.join(geminiDir, 'settings.json');
+            let existing = {};
+            let backedUpTo = null;
+            // Read existing config
+            try {
+                const source = await readFile(configPath, 'utf8');
+                existing = JSON.parse(source);
+            }
+            catch {
+                // No existing config, start fresh
+            }
+            // Backup if file exists with content
+            if (Object.keys(existing).length > 0) {
+                const backupPath = `${configPath}.bak.${formatTimestamp()}`;
+                await copyFile(configPath, backupPath);
+                backedUpTo = backupPath;
+            }
+            // Build mcpServers
+            const mcpServers = {};
+            for (const [name, config] of Object.entries(options.mcpServers)) {
+                mcpServers[name] = toGeminiFormat(config);
+            }
+            // Always include brainctl itself
+            mcpServers['brainctl'] = {
+                command: 'npx',
+                args: ['-y', 'brainctl', 'mcp'],
+            };
+            // Merge into existing config (preserve other settings)
+            existing.mcpServers = mcpServers;
+            // Atomic write
+            await mkdir(geminiDir, { recursive: true });
+            const tmpPath = `${configPath}.tmp.${Date.now()}`;
+            await writeFile(tmpPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+            await rename(tmpPath, configPath);
+            return { configPath, backedUpTo };
+        },
+        async restore(options) {
+            const configPath = path.join(options.cwd, '.gemini', 'settings.json');
+            const dir = path.dirname(configPath);
+            const base = path.basename(configPath);
+            let entries;
+            try {
+                entries = await readdir(dir);
+            }
+            catch {
+                throw new SyncError('No Gemini config directory found.');
+            }
+            const backups = entries
+                .filter((f) => f.startsWith(`${base}.bak.`))
+                .sort()
+                .reverse();
+            if (backups.length === 0) {
+                throw new SyncError('No Gemini config backup found.');
+            }
+            const latestBackup = path.join(dir, backups[0]);
+            await copyFile(latestBackup, configPath);
+            return { restoredFrom: latestBackup };
+        },
+    };
+}
+function toGeminiFormat(config) {
+    if (config.type === 'npm') {
+        return {
+            command: 'npx',
+            args: ['-y', config.package],
+            ...(config.env ? { env: config.env } : {}),
+        };
+    }
+    // bundled
+    return {
+        command: config.command,
+        args: config.args ?? [],
+        ...(config.env ? { env: config.env } : {}),
+    };
+}

package/dist/services/sync-service.d.ts

@@ -0,0 +1,15 @@
+import type { AgentName, SyncResult } from '../types.js';
+import type { AgentConfigWriter } from './sync/agent-writer.js';
+import { type ProfileService } from './profile-service.js';
+export interface SyncService {
+    execute(options?: {
+        cwd?: string;
+        restore?: boolean;
+    }): Promise<SyncResult>;
+}
+interface SyncServiceDependencies {
+    profileService?: ProfileService;
+    writers?: Partial<Record<AgentName, AgentConfigWriter>>;
+}
+export declare function createSyncService(dependencies?: SyncServiceDependencies): SyncService;
+export {};

package/dist/services/sync-service.js

@@ -0,0 +1,64 @@
+import { createClaudeWriter } from './sync/claude-writer.js';
+import { createCodexWriter } from './sync/codex-writer.js';
+import { createGeminiWriter } from './sync/gemini-writer.js';
+import { createProfileService } from './profile-service.js';
+export function createSyncService(dependencies = {}) {
+    const profileService = dependencies.profileService ?? createProfileService();
+    const defaultWriters = {
+        claude: createClaudeWriter(),
+        codex: createCodexWriter(),
+        gemini: createGeminiWriter(),
+    };
+    const writers = { ...defaultWriters, ...dependencies.writers };
+    return {
+        async execute(options = {}) {
+            const cwd = options.cwd ?? process.cwd();
+            if (options.restore) {
+                return restoreAll(writers, cwd);
+            }
+            const meta = await profileService.getMetaConfig({ cwd });
+            if (!meta.active_profile) {
+                throw new Error('No active profile set. Run "brainctl profile use <name>" first.');
+            }
+            const profile = await profileService.get({ cwd, name: meta.active_profile });
+            const results = [];
+            for (const agent of meta.agents) {
+                const writer = writers[agent];
+                if (!writer) {
+                    continue;
+                }
+                const result = await writer.write({
+                    mcpServers: profile.mcps,
+                    cwd,
+                });
+                results.push({
+                    agent,
+                    configPath: result.configPath,
+                    backedUpTo: result.backedUpTo,
+                    mcpCount: Object.keys(profile.mcps).length + 1, // +1 for brainctl itself
+                });
+            }
+            return results;
+        },
+    };
+}
+async function restoreAll(writers, cwd) {
+    const results = [];
+    for (const [agent, writer] of Object.entries(writers)) {
+        if (!writer)
+            continue;
+        try {
+            const { restoredFrom } = await writer.restore({ cwd });
+            results.push({
+                agent: agent,
+                configPath: restoredFrom,
+                backedUpTo: null,
+                mcpCount: 0,
+            });
+        }
+        catch {
+            // Skip agents with no backup
+        }
+    }
+    return results;
+}

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export type AgentName = 'claude' | 'codex';
+export type AgentName = 'claude' | 'codex' | 'gemini';
 export type ErrorCategory = 'user' | 'system';
 export type DiagnosticStatus = 'ok' | 'warn' | 'error';
 export interface SkillConfig {
@@ -55,3 +55,37 @@ export interface DiagnosticCheck {
     status: DiagnosticStatus;
     message: string;
 }
+export interface NpmMcpServerConfig {
+    type: 'npm';
+    package: string;
+    env?: Record<string, string>;
+}
+export interface BundledMcpServerConfig {
+    type: 'bundled';
+    path: string;
+    install?: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export type McpServerConfig = NpmMcpServerConfig | BundledMcpServerConfig;
+export interface ProfileConfig {
+    name: string;
+    description?: string;
+    skills: Record<string, SkillConfig>;
+    mcps: Record<string, McpServerConfig>;
+    memory: {
+        paths: string[];
+    };
+}
+export interface BrainctlMetaConfig {
+    active_profile: string;
+    agents: AgentName[];
+}
+export interface SyncAgentResult {
+    agent: AgentName;
+    configPath: string;
+    backedUpTo: string | null;
+    mcpCount: number;
+}
+export type SyncResult = SyncAgentResult[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainctl",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "CLI environment manager for consistent AI workflows",
   "type": "module",
   "repository": {