brainctl 0.1.18 → 0.1.19

package/dist/cli.d.ts

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import { type DoctorService } from './services/doctor-service.js';
-import { type ProfileApplyService } from './services/profile-apply-service.js';
-import { type ProfileExportService } from './services/profile-export-service.js';
-import { type ProfileImportService } from './services/profile-import-service.js';
-import { type ProfileService } from './services/profile-service.js';
-import { type ProfileSnapshotService } from './services/profile-snapshot-service.js';
-import { type StatusService } from './services/status-service.js';
+import { type DoctorService } from './services/platform/doctor-service.js';
+import { type ProfileApplyService } from './services/profile/profile-apply-service.js';
+import { type ProfileExportService } from './services/profile/profile-export-service.js';
+import { type ProfileImportService } from './services/profile/profile-import-service.js';
+import { type ProfileService } from './services/profile/profile-service.js';
+import { type ProfileSnapshotService } from './services/profile/profile-snapshot-service.js';
+import { type StatusService } from './services/platform/status-service.js';
 export interface CliServices {
     statusService: StatusService;
     doctorService: DoctorService;

package/dist/cli.js

@@ -10,15 +10,15 @@ import { registerProfileCommand } from './commands/profile.js';
 import { registerStatusCommand } from './commands/status.js';
 import { registerUiCommand } from './commands/ui.js';
 import { printError } from './output.js';
-import { createUpdateCheckService } from './services/update-check-service.js';
-import { createDoctorService } from './services/doctor-service.js';
-import { createProfileApplyService } from './services/profile-apply-service.js';
-import { createProfileExportService } from './services/profile-export-service.js';
-import { createProfileImportService } from './services/profile-import-service.js';
-import { createProfileService } from './services/profile-service.js';
-import { createProfileSnapshotService } from './services/profile-snapshot-service.js';
-import { createStatusService } from './services/status-service.js';
-import { createAgentAvailabilityService } from './services/agent-availability-service.js';
+import { createUpdateCheckService } from './services/platform/update-check-service.js';
+import { createDoctorService } from './services/platform/doctor-service.js';
+import { createProfileApplyService } from './services/profile/profile-apply-service.js';
+import { createProfileExportService } from './services/profile/profile-export-service.js';
+import { createProfileImportService } from './services/profile/profile-import-service.js';
+import { createProfileService } from './services/profile/profile-service.js';
+import { createProfileSnapshotService } from './services/profile/profile-snapshot-service.js';
+import { createStatusService } from './services/platform/status-service.js';
+import { createAgentAvailabilityService } from './services/agent/agent-availability-service.js';
 const packageVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 export function createProgram(overrides = {}) {
     const services = createDefaultServices(overrides);

package/dist/commands/doctor.d.ts

@@ -1,3 +1,3 @@
 import type { Command } from 'commander';
-import type { DoctorService } from '../services/doctor-service.js';
+import type { DoctorService } from '../services/platform/doctor-service.js';
 export declare function registerDoctorCommand(program: Command, doctorService: DoctorService): void;

package/dist/commands/mcp.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
-import { startMcpServer } from '../mcp/server.js';
-import { createUpdateCheckService } from '../services/update-check-service.js';
+import { startMcpServer } from '../mcp-server.js';
+import { createUpdateCheckService } from '../services/platform/update-check-service.js';
 export function registerMcpCommand(program) {
     program
         .command('mcp')

package/dist/commands/profile.d.ts

@@ -1,9 +1,9 @@
 import type { Command } from 'commander';
-import type { ProfileApplyService } from '../services/profile-apply-service.js';
-import type { ProfileExportService } from '../services/profile-export-service.js';
-import type { ProfileImportService } from '../services/profile-import-service.js';
-import type { ProfileService } from '../services/profile-service.js';
-import type { ProfileSnapshotService } from '../services/profile-snapshot-service.js';
+import type { ProfileApplyService } from '../services/profile/profile-apply-service.js';
+import type { ProfileExportService } from '../services/profile/profile-export-service.js';
+import type { ProfileImportService } from '../services/profile/profile-import-service.js';
+import type { ProfileService } from '../services/profile/profile-service.js';
+import type { ProfileSnapshotService } from '../services/profile/profile-snapshot-service.js';
 export interface ProfileCommandServices {
     profileService: ProfileService;
     profileExportService: ProfileExportService;

package/dist/commands/profile.js

@@ -131,7 +131,7 @@ export function registerProfileCommand(program, services) {
             throw new Error('Provide --agent <claude|codex|gemini>.');
         }
         const agent = options.agent;
-        const { defaultBackupProfileName } = await import('../services/profile-snapshot-service.js');
+        const { defaultBackupProfileName } = await import('../services/profile/profile-snapshot-service.js');
         const profileName = options.as ?? defaultBackupProfileName(agent);
         const result = await profileSnapshotService.execute({
             cwd: process.cwd(),

package/dist/commands/status.d.ts

@@ -1,3 +1,3 @@
 import type { Command } from 'commander';
-import type { StatusService } from '../services/status-service.js';
+import type { StatusService } from '../services/platform/status-service.js';
 export declare function registerStatusCommand(program: Command, statusService: StatusService): void;

package/dist/{mcp/server.d.ts → mcp-server.d.ts}

@@ -1,5 +1,5 @@
 import { FastMCP } from 'fastmcp';
-import { type UiServer } from '../ui/server.js';
+import { type UiServer } from './ui/server.js';
 export interface UiServerState {
     current: UiServer | null;
 }

package/dist/{mcp/server.js → mcp-server.js}

@@ -2,17 +2,17 @@ import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { FastMCP } from 'fastmcp';
 import { z } from 'zod';
-import { createAgentConfigService } from '../services/agent-config-service.js';
-import { createDoctorService } from '../services/doctor-service.js';
-import { startUiServer } from '../ui/server.js';
-import { createProfileExportService } from '../services/profile-export-service.js';
-import { createProfileImportService } from '../services/profile-import-service.js';
-import { createProfileApplyService } from '../services/profile-apply-service.js';
-import { createProfileService } from '../services/profile-service.js';
-import { createProfileSnapshotService, defaultBackupProfileName, } from '../services/profile-snapshot-service.js';
-import { createStatusService } from '../services/status-service.js';
+import { createAgentConfigService } from './services/agent/agent-config-service.js';
+import { createDoctorService } from './services/platform/doctor-service.js';
+import { startUiServer } from './ui/server.js';
+import { createProfileExportService } from './services/profile/profile-export-service.js';
+import { createProfileImportService } from './services/profile/profile-import-service.js';
+import { createProfileApplyService } from './services/profile/profile-apply-service.js';
+import { createProfileService } from './services/profile/profile-service.js';
+import { createProfileSnapshotService, defaultBackupProfileName, } from './services/profile/profile-snapshot-service.js';
+import { createStatusService } from './services/platform/status-service.js';
 const ALL_AGENTS = ['claude', 'codex', 'gemini'];
-const packageVersion = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+const packageVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 export function createMcpServer(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const uiState = options.uiServerState ?? { current: null };

package/dist/services/{agent-asset-installer.d.ts → agent/agent-asset-installer.d.ts}

@@ -1,3 +1,3 @@
-import type { PortablePluginSnapshot, PortableUserSkillSnapshot } from '../types.js';
+import type { PortablePluginSnapshot, PortableUserSkillSnapshot } from '../../types.js';
 export declare function installPlugin(sourceDir: string, plugin: PortablePluginSnapshot): Promise<void>;
 export declare function installUserSkill(sourceDir: string, skill: PortableUserSkillSnapshot): Promise<void>;

package/dist/services/{agent-asset-installer.js → agent/agent-asset-installer.js}

@@ -1,8 +1,8 @@
 import { copyFile, cp, mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
-import { ProfileError } from '../errors.js';
-import { formatTimestamp } from './sync/agent-writer.js';
+import { ProfileError } from '../../errors.js';
+import { formatTimestamp } from '../sync/agent-writer.js';
 export async function installPlugin(sourceDir, plugin) {
     try {
         await stat(sourceDir);

package/dist/services/{agent-availability-service.d.ts → agent/agent-availability-service.d.ts}

@@ -1,4 +1,4 @@
-import type { AgentName } from '../types.js';
+import type { AgentName } from '../../types.js';
 export interface AgentAvailability {
     agent: AgentName;
     available: boolean;

package/dist/services/{agent-availability-service.js → agent/agent-availability-service.js}

@@ -1,4 +1,4 @@
-import { findExecutable } from '../system/executables.js';
+import { findExecutable } from '../../executables.js';
 const SUPPORTED_AGENTS = ['claude', 'codex', 'gemini'];
 const AGENT_COMMANDS = {
     claude: 'claude',

package/dist/services/{agent-config-service.d.ts → agent/agent-config-service.d.ts}

@@ -1,9 +1,9 @@
-import type { AgentName } from '../types.js';
-import { type AgentLiveConfig, type AgentMcpEntry, type PortableRemoteMcpMetadata } from './sync/agent-reader.js';
-import { type McpPreflightService } from './mcp-preflight-service.js';
-import { type SkillPreflightService } from './skill-preflight-service.js';
-export type { AgentLiveConfig, AgentMcpEntry, AgentSkillEntry } from './sync/agent-reader.js';
-export type { PortableRemoteMcpMetadata } from './sync/agent-reader.js';
+import type { AgentName } from '../../types.js';
+import { type AgentLiveConfig, type AgentMcpEntry, type PortableRemoteMcpMetadata } from '../sync/agent-reader.js';
+import { type McpPreflightService } from '../platform/mcp-preflight-service.js';
+import { type SkillPreflightService } from '../plugin/skill-preflight-service.js';
+export type { AgentLiveConfig, AgentMcpEntry, AgentSkillEntry } from '../sync/agent-reader.js';
+export type { PortableRemoteMcpMetadata } from '../sync/agent-reader.js';
 export interface AgentConfigService {
     readAll(options: {
         cwd: string;

package/dist/services/{agent-config-service.js → agent/agent-config-service.js}

@@ -1,12 +1,12 @@
 import { copyFile, cp, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
-import { ValidationError } from '../errors.js';
-import { createClaudeReader, createCodexReader, createGeminiReader, } from './sync/agent-reader.js';
-import { formatTimestamp } from './sync/agent-writer.js';
-import { createMcpPreflightService } from './mcp-preflight-service.js';
-import { createSkillPreflightService } from './skill-preflight-service.js';
-import { getSkillDir } from './skill-paths.js';
+import { ValidationError } from '../../errors.js';
+import { createClaudeReader, createCodexReader, createGeminiReader, } from '../sync/agent-reader.js';
+import { formatTimestamp } from '../sync/agent-writer.js';
+import { createMcpPreflightService } from '../platform/mcp-preflight-service.js';
+import { createSkillPreflightService } from '../plugin/skill-preflight-service.js';
+import { getSkillDir } from '../plugin/skill-paths.js';
 const readers = {
     claude: createClaudeReader(),
     codex: createCodexReader(),

package/dist/services/{credential-redaction-service.d.ts → credential/credential-redaction-service.d.ts}

@@ -1,4 +1,4 @@
-import type { McpServerConfig, PortableCredentialSpec } from '../types.js';
+import type { McpServerConfig, PortableCredentialSpec } from '../../types.js';
 export interface CredentialRedactionResult<T extends McpServerConfig> {
     redacted: T;
     credentials: PortableCredentialSpec[];

package/dist/services/{credential-resolution-service.d.ts → credential/credential-resolution-service.d.ts}

@@ -1,4 +1,4 @@
-import type { McpServerConfig, PortableCredentialPlaceholder, PortableCredentialSpec } from '../types.js';
+import type { McpServerConfig, PortableCredentialPlaceholder, PortableCredentialSpec } from '../../types.js';
 export interface CredentialResolutionResult<T extends McpServerConfig> {
     resolved: T;
     missing: PortableCredentialSpec[];

package/dist/services/{doctor-service.d.ts → platform/doctor-service.d.ts}

@@ -1,5 +1,5 @@
-import { type AgentAvailabilityService } from './agent-availability-service.js';
-import type { DiagnosticCheck } from '../types.js';
+import { type AgentAvailabilityService } from '../agent/agent-availability-service.js';
+import type { DiagnosticCheck } from '../../types.js';
 export interface DoctorResult {
     checks: DiagnosticCheck[];
     hasIssues: boolean;

package/dist/services/{doctor-service.js → platform/doctor-service.js}

@@ -1,4 +1,4 @@
-import { createAgentAvailabilityService, } from './agent-availability-service.js';
+import { createAgentAvailabilityService, } from '../agent/agent-availability-service.js';
 export function createDoctorService(dependencies = {}) {
     const availabilityService = dependencies.availabilityService ?? createAgentAvailabilityService();
     return {

package/dist/services/{mcp-preflight-service.d.ts → platform/mcp-preflight-service.d.ts}

@@ -1,5 +1,5 @@
-import type { AgentName } from '../types.js';
-import type { AgentMcpEntry, PortableRemoteMcpMetadata } from './agent-config-service.js';
+import type { AgentName } from '../../types.js';
+import type { AgentMcpEntry, PortableRemoteMcpMetadata } from '../agent/agent-config-service.js';
 export interface McpPreflightCheck {
     label: string;
     status: 'ok' | 'warn' | 'error';

package/dist/services/{mcp-preflight-service.js → platform/mcp-preflight-service.js}

@@ -1,6 +1,6 @@
 import { stat } from 'node:fs/promises';
 import path from 'node:path';
-import { findExecutable } from '../system/executables.js';
+import { findExecutable } from '../../executables.js';
 const ENTRYPOINT_RUNNERS = new Set(['node', 'nodejs', 'python', 'python3', 'bash', 'sh', 'zsh', 'deno', 'bun']);
 const SUPPORTED_LOCAL_LAUNCHERS = ['npx', 'uvx', 'node', 'python', 'python3', 'java -jar', 'go run', 'cargo run', 'and local binaries/scripts'];
 export function createMcpPreflightService(dependencies = {}) {

package/dist/services/{runtime-detector.d.ts → platform/runtime-detector.d.ts}

@@ -1,4 +1,4 @@
-import type { McpRuntime } from '../types.js';
+import type { McpRuntime } from '../../types.js';
 export declare function detectMcpRuntime(command: string): McpRuntime | null;
 export declare function extractEntrypoint(command: string, args: string[]): string | null;
 export declare function findProjectRoot(entrypointPath: string, runtime: McpRuntime): {

package/dist/services/{status-service.d.ts → platform/status-service.d.ts}

@@ -1,6 +1,6 @@
-import { type AgentAvailability, type AgentAvailabilityService } from './agent-availability-service.js';
-import { type ProfileService } from './profile-service.js';
-import type { AgentName } from '../types.js';
+import { type AgentAvailability, type AgentAvailabilityService } from '../agent/agent-availability-service.js';
+import { type ProfileService } from '../profile/profile-service.js';
+import type { AgentName } from '../../types.js';
 export interface StatusResult {
     agents: Record<AgentName, AgentAvailability>;
     profiles: {

package/dist/services/{status-service.js → platform/status-service.js}

@@ -1,5 +1,5 @@
-import { createAgentAvailabilityService, } from './agent-availability-service.js';
-import { createProfileService } from './profile-service.js';
+import { createAgentAvailabilityService, } from '../agent/agent-availability-service.js';
+import { createProfileService } from '../profile/profile-service.js';
 export function createStatusService(dependencies = {}) {
     const availabilityService = dependencies.availabilityService ?? createAgentAvailabilityService();
     const profileService = dependencies.profileService ?? createProfileService();

package/dist/services/{update-check-service.js → platform/update-check-service.js}

@@ -9,7 +9,7 @@ const execFileAsync = promisify(execFile);
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 const CACHE_DIR = path.join(homedir(), '.brainctl');
 const CACHE_PATH = path.join(CACHE_DIR, 'update-check.json');
-const packageVersion = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+const packageVersion = JSON.parse(readFileSync(new URL('../../../package.json', import.meta.url), 'utf8'));
 export function createUpdateCheckService(dependencies = {}) {
     const currentVersion = dependencies.currentVersion ?? packageVersion.version;
     const fetchLatestVersion = dependencies.fetchLatestVersion ?? fetchFromRegistry;

package/dist/services/plugin/plugin-install-bundle.d.ts

@@ -0,0 +1,20 @@
+import type { AgentName } from '../../types.js';
+import type { AgentMcpEntry } from '../agent/agent-config-service.js';
+export interface PluginBundleAgent {
+    name: string;
+    sourceFormat: 'claude-md' | 'codex-toml';
+    content: string;
+}
+export interface PluginBundleCommand {
+    name: string;
+    content: string;
+}
+export interface PluginBundle {
+    skills: string[];
+    mcps: Record<string, AgentMcpEntry>;
+    agents: PluginBundleAgent[];
+    commands: PluginBundleCommand[];
+}
+export declare function isAgentInstallableOnTarget(target: AgentName): boolean;
+export declare function isCommandInstallableOnTarget(target: AgentName): boolean;
+export declare function defaultReadInstalledPluginBundle(installPath: string): Promise<PluginBundle>;

package/dist/services/plugin/plugin-install-bundle.js

@@ -0,0 +1,80 @@
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+export function isAgentInstallableOnTarget(target) {
+    return target === 'claude' || target === 'codex';
+}
+export function isCommandInstallableOnTarget(target) {
+    return target === 'claude' || target === 'codex';
+}
+export async function defaultReadInstalledPluginBundle(installPath) {
+    const skillsDir = path.join(installPath, 'skills');
+    let skills = [];
+    try {
+        const entries = await readdir(skillsDir, { withFileTypes: true });
+        skills = entries
+            .filter((entry) => !entry.name.startsWith('.') && entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        skills = [];
+    }
+    let mcps = {};
+    try {
+        const mcpSource = await readFile(path.join(installPath, '.mcp.json'), 'utf8');
+        const parsed = JSON.parse(mcpSource);
+        mcps = Object.fromEntries(Object.entries(parsed)
+            .filter(([, value]) => typeof value?.command === 'string')
+            .map(([key, value]) => [
+            key,
+            {
+                command: String(value.command),
+                args: Array.isArray(value.args) ? value.args.map(String) : undefined,
+                env: value.env && typeof value.env === 'object' && !Array.isArray(value.env)
+                    ? Object.fromEntries(Object.entries(value.env).map(([envKey, envValue]) => [
+                        envKey,
+                        String(envValue),
+                    ]))
+                    : undefined,
+            },
+        ]));
+    }
+    catch {
+        mcps = {};
+    }
+    const agents = [];
+    try {
+        const entries = await readdir(path.join(installPath, 'agents'), { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            if (entry.name.endsWith('.md')) {
+                const content = await readFile(path.join(installPath, 'agents', entry.name), 'utf8');
+                agents.push({ name: entry.name.replace(/\.md$/, ''), sourceFormat: 'claude-md', content });
+            }
+            else if (entry.name.endsWith('.toml')) {
+                const content = await readFile(path.join(installPath, 'agents', entry.name), 'utf8');
+                agents.push({ name: entry.name.replace(/\.toml$/, ''), sourceFormat: 'codex-toml', content });
+            }
+        }
+        agents.sort((left, right) => left.name.localeCompare(right.name));
+    }
+    catch {
+        // no agents dir
+    }
+    const commands = [];
+    try {
+        const entries = await readdir(path.join(installPath, 'commands'), { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            const content = await readFile(path.join(installPath, 'commands', entry.name), 'utf8');
+            commands.push({ name: entry.name.replace(/\.md$/, ''), content });
+        }
+        commands.sort((left, right) => left.name.localeCompare(right.name));
+    }
+    catch {
+        // no commands dir
+    }
+    return { skills, mcps, agents, commands };
+}

package/dist/services/plugin/plugin-install-compatibility.d.ts

@@ -0,0 +1,15 @@
+import type { AgentName } from '../../types.js';
+import type { PluginInstallCheck } from './plugin-install-service.js';
+export interface IncompatibleArtifacts {
+    hasAppConnector: boolean;
+    hasHooks: boolean;
+    hasCommands: boolean;
+    codexAgentSkills: string[];
+    claudeAgents: string[];
+}
+export declare function pathExists(target: string): Promise<boolean>;
+export declare function detectIncompatibleArtifacts(installPath: string): Promise<IncompatibleArtifacts>;
+export declare function formatCompatibilityWarnings(artifacts: IncompatibleArtifacts, context: {
+    sourceAgent: AgentName;
+    targetAgent: AgentName;
+}): PluginInstallCheck[];

package/dist/services/plugin/plugin-install-compatibility.js

@@ -0,0 +1,91 @@
+import { readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+export async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function detectIncompatibleArtifacts(installPath) {
+    const [hasAppConnector, hasHooks, hasCommands, codexAgentSkills, claudeAgents] = await Promise.all([
+        pathExists(path.join(installPath, '.app.json')),
+        pathExists(path.join(installPath, 'hooks')),
+        pathExists(path.join(installPath, 'commands')),
+        listCodexAgentSkills(installPath),
+        listClaudeAgentFiles(installPath),
+    ]);
+    return { hasAppConnector, hasHooks, hasCommands, codexAgentSkills, claudeAgents };
+}
+async function listCodexAgentSkills(installPath) {
+    const skillsDir = path.join(installPath, 'skills');
+    try {
+        const entries = await readdir(skillsDir, { withFileTypes: true });
+        const matches = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            if (await pathExists(path.join(skillsDir, entry.name, 'agents'))) {
+                matches.push(entry.name);
+            }
+        }
+        return matches.sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}
+async function listClaudeAgentFiles(installPath) {
+    const agentsDir = path.join(installPath, 'agents');
+    try {
+        const entries = await readdir(agentsDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+            .map((entry) => entry.name.replace(/\.md$/, ''))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}
+export function formatCompatibilityWarnings(artifacts, context) {
+    const warnings = [];
+    if (artifacts.hasAppConnector && context.targetAgent !== 'codex') {
+        warnings.push({
+            label: 'App connector',
+            status: 'warn',
+            message: `Plugin ships a Codex app connector (.app.json) that will NOT transfer. Skill instructions will copy over but the backing integration will not work on ${context.targetAgent}.`,
+        });
+    }
+    if (artifacts.codexAgentSkills.length > 0 && context.targetAgent !== 'codex') {
+        warnings.push({
+            label: 'Codex agent YAML',
+            status: 'warn',
+            message: `Skills ${artifacts.codexAgentSkills.join(', ')} include Codex-specific agent YAML that will not transfer to ${context.targetAgent}.`,
+        });
+    }
+    if (artifacts.hasHooks && context.targetAgent !== 'claude') {
+        warnings.push({
+            label: 'Claude hooks',
+            status: 'warn',
+            message: `Plugin ships session hooks that only work on Claude and will NOT transfer to ${context.targetAgent}.`,
+        });
+    }
+    if (context.targetAgent === 'gemini' && artifacts.claudeAgents.length > 0) {
+        warnings.push({
+            label: 'Subagents',
+            status: 'warn',
+            message: `Plugin ships subagent definitions (${artifacts.claudeAgents.join(', ')}) that cannot be converted to ${context.targetAgent}.`,
+        });
+    }
+    if (context.targetAgent === 'gemini' && artifacts.hasCommands) {
+        warnings.push({
+            label: 'Slash commands',
+            status: 'warn',
+            message: `Plugin ships slash commands that cannot be converted to ${context.targetAgent}.`,
+        });
+    }
+    return warnings;
+}

package/dist/services/plugin/plugin-install-fs.d.ts

@@ -0,0 +1,27 @@
+import type { AgentName } from '../../types.js';
+import type { PluginBundleAgent, PluginBundleCommand } from './plugin-install-bundle.js';
+export declare function defaultInstallAgent(options: {
+    targetAgent: AgentName;
+    agent: PluginBundleAgent;
+}): Promise<void>;
+export declare function defaultInstallCommand(options: {
+    targetAgent: AgentName;
+    command: PluginBundleCommand;
+}): Promise<void>;
+export declare function defaultRemoveAgentFile(options: {
+    targetAgent: AgentName;
+    agentName: string;
+}): Promise<void>;
+export declare function defaultRemoveCommandFile(options: {
+    targetAgent: AgentName;
+    commandName: string;
+}): Promise<void>;
+export declare function defaultCopySkillDirectory(options: {
+    sourceInstallPath: string;
+    skillName: string;
+    targetAgent: AgentName;
+}): Promise<void>;
+export declare function defaultRemoveSkillDirectory(options: {
+    targetAgent: AgentName;
+    skillName: string;
+}): Promise<void>;

package/dist/services/plugin/plugin-install-fs.js

@@ -0,0 +1,65 @@
+import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { claudeAgentMdToCodexToml, claudeCommandMdToCodexSkill, codexAgentTomlToClaudeMd, } from '../agent/agent-converter-service.js';
+import { getAgentFilePath, getCommandFilePath, getSkillDir } from './skill-paths.js';
+export async function defaultInstallAgent(options) {
+    const targetPath = getAgentFilePath(options.targetAgent, options.agent.name);
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    let output;
+    if (options.targetAgent === 'claude') {
+        output = options.agent.sourceFormat === 'claude-md'
+            ? options.agent.content
+            : codexAgentTomlToClaudeMd(options.agent.content);
+    }
+    else if (options.targetAgent === 'codex') {
+        output = options.agent.sourceFormat === 'codex-toml'
+            ? options.agent.content
+            : claudeAgentMdToCodexToml(options.agent.content);
+    }
+    else {
+        throw new Error(`Agent install is not supported for ${options.targetAgent}`);
+    }
+    await writeFile(targetPath, output, 'utf8');
+}
+export async function defaultInstallCommand(options) {
+    if (options.targetAgent === 'claude') {
+        const targetPath = getCommandFilePath('claude', options.command.name);
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        await writeFile(targetPath, options.command.content, 'utf8');
+        return;
+    }
+    if (options.targetAgent === 'codex') {
+        const skillDir = getSkillDir('codex', options.command.name);
+        await mkdir(skillDir, { recursive: true });
+        const { skillMarkdown } = claudeCommandMdToCodexSkill(options.command.content);
+        await writeFile(path.join(skillDir, 'SKILL.md'), skillMarkdown, 'utf8');
+        return;
+    }
+    throw new Error(`Command install is not supported for ${options.targetAgent}`);
+}
+export async function defaultRemoveAgentFile(options) {
+    const targetPath = getAgentFilePath(options.targetAgent, options.agentName);
+    await rm(targetPath, { force: true });
+}
+export async function defaultRemoveCommandFile(options) {
+    if (options.targetAgent === 'claude') {
+        const targetPath = getCommandFilePath('claude', options.commandName);
+        await rm(targetPath, { force: true });
+        return;
+    }
+    if (options.targetAgent === 'codex') {
+        const skillDir = getSkillDir('codex', options.commandName);
+        await rm(skillDir, { recursive: true, force: true });
+        return;
+    }
+}
+export async function defaultCopySkillDirectory(options) {
+    const sourceDir = path.join(options.sourceInstallPath, 'skills', options.skillName);
+    const targetDir = getSkillDir(options.targetAgent, options.skillName);
+    await mkdir(path.dirname(targetDir), { recursive: true });
+    await cp(sourceDir, targetDir, { recursive: true });
+}
+export async function defaultRemoveSkillDirectory(options) {
+    const targetDir = getSkillDir(options.targetAgent, options.skillName);
+    await rm(targetDir, { recursive: true, force: true });
+}