xtrm-cli 2.1.4

package/src/core/preflight.ts

@@ -0,0 +1,142 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import { spawnSync } from 'child_process';
+import { calculateDiff } from './diff.js';
+import {
+    loadCanonicalMcpConfig,
+    getCurrentServers,
+    detectAgent,
+} from '../utils/sync-mcp-cli.js';
+import type { ChangeSet, ChangeSetCategory } from '../types/config.js';
+import type { AgentName } from '../utils/sync-mcp-cli.js';
+
+// ── Types ──────────────────────────────────────────────────────────────────
+
+export interface FileItem {
+    name: string;
+    status: 'missing' | 'outdated' | 'drifted';
+    category: string;
+}
+
+export interface McpItem {
+    name: string;
+    installed: boolean;
+}
+
+export interface TargetPlan {
+    target: string;
+    label: string;
+    agent: string | null;
+    files: FileItem[];
+    mcpCore: McpItem[];
+    changeSet: ChangeSet;
+}
+
+export interface OptionalServerItem {
+    name: string;
+    description: string;
+    prerequisite?: string;
+    installCmd?: string;
+    postInstallMessage?: string;
+}
+
+export interface PreflightPlan {
+    targets: TargetPlan[];
+    optionalServers: OptionalServerItem[];
+    repoRoot: string;
+    syncMode: 'copy' | 'symlink' | 'prune';
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function getCandidatePaths(): Array<{ label: string; path: string }> {
+    const home = os.homedir();
+    return [
+        { label: '~/.claude (hooks + skills)', path: path.join(home, '.claude') },
+        { label: '.qwen', path: path.join(home, '.qwen') },
+        { label: '~/.agents/skills', path: path.join(home, '.agents', 'skills') },
+    ];
+}
+
+export function isBinaryAvailable(binary: string): boolean {
+    // Uses spawnSync (not shell exec) to avoid shell injection; binary is always
+    // a hard-coded internal constant, never user-supplied input.
+    const result = spawnSync('which', [binary], { stdio: 'pipe' });
+    return result.status === 0;
+}
+
+// ── Main export ────────────────────────────────────────────────────────────
+
+export async function runPreflight(
+    repoRoot: string,
+    prune = false
+): Promise<PreflightPlan> {
+    const candidates = getCandidatePaths();
+
+    // Fix 4: Hoist canonical MCP config load outside the per-target map (read once, not N times)
+    const canonicalMcp = loadCanonicalMcpConfig(repoRoot);
+
+    // Run all target checks in parallel
+    const targetResults = await Promise.all(
+        candidates.map(async (c) => {
+            // Fix 1: Per-target error isolation — one bad target doesn't abort the whole preflight
+            try {
+                const exists = await fs.pathExists(c.path);
+                if (!exists) return null;
+
+                const agent = detectAgent(c.path);
+
+                const changeSet = await calculateDiff(repoRoot, c.path, prune);
+
+                // Fix 3: Use proper ChangeSetCategory type cast instead of `cat as any`
+                const files: FileItem[] = [];
+                for (const [category, cat] of Object.entries(changeSet) as [string, ChangeSetCategory][]) {
+                    for (const name of cat.missing)  files.push({ name, status: 'missing',  category });
+                    for (const name of cat.outdated) files.push({ name, status: 'outdated', category });
+                    for (const name of cat.drifted)  files.push({ name, status: 'drifted',  category });
+                }
+
+                const installedMcp = agent ? getCurrentServers(agent) : [];
+                const mcpCore: McpItem[] = Object.keys(canonicalMcp.mcpServers || {}).map(name => ({
+                    name,
+                    installed: installedMcp.includes(name),
+                }));
+
+                return { target: c.path, label: c.label, agent, files, mcpCore, changeSet };
+            } catch (err) {
+                console.warn(`⚠ Preflight skipped ${c.label}: ${(err as Error).message}`);
+                return null;
+            }
+        })
+    );
+
+    const targets = targetResults.filter((t): t is TargetPlan => t !== null);
+
+    // Fix 2: Gather all actually installed MCP servers (across all agents, core + optional)
+    // allInstalledMcp previously only contained core server names from mcpCore — optional servers
+    // installed via CLI were never excluded from the optionalServers list.
+    const allInstalledMcp = new Set<string>();
+    for (const t of targets) {
+        if (t.agent) {
+            const installed = getCurrentServers(t.agent as AgentName);
+            for (const name of installed) allInstalledMcp.add(name);
+        }
+    }
+
+    // Load optional servers config
+    const optionalConfig = loadCanonicalMcpConfig(repoRoot, true);
+
+    const optionalServers: OptionalServerItem[] = Object.entries(optionalConfig.mcpServers || {})
+        .filter(([name]) => !allInstalledMcp.has(name))
+        .map(([name, server]: [string, any]) => ({
+            name,
+            description: server._notes?.description || '',
+            prerequisite: server._notes?.prerequisite,
+            installCmd: server._notes?.install_cmd,
+            postInstallMessage: server._notes?.post_install_message,
+        }));
+
+    const syncMode: 'copy' | 'symlink' | 'prune' = prune ? 'prune' : 'copy';
+    return { targets, optionalServers, repoRoot, syncMode };
+}

package/src/core/rollback.ts

@@ -0,0 +1,32 @@
+import fs from 'fs-extra';
+
+export interface BackupInfo {
+    originalPath: string;
+    backupPath: string;
+    timestamp: Date;
+}
+
+export async function createBackup(filePath: string): Promise<BackupInfo> {
+    const timestamp = Date.now();
+    const backupPath = `${filePath}.backup-${timestamp}`;
+
+    if (await fs.pathExists(filePath)) {
+        await fs.copy(filePath, backupPath);
+    }
+
+    return {
+        originalPath: filePath,
+        backupPath,
+        timestamp: new Date(),
+    };
+}
+
+export async function restoreBackup(backup: BackupInfo): Promise<void> {
+    if (await fs.pathExists(backup.backupPath)) {
+        await fs.move(backup.backupPath, backup.originalPath, { overwrite: true });
+    }
+}
+
+export async function cleanupBackup(backup: BackupInfo): Promise<void> {
+    await fs.remove(backup.backupPath);
+}

package/src/core/sync-executor.ts

@@ -0,0 +1,399 @@
+import path from 'path';
+import fs from 'fs-extra';
+import kleur from 'kleur';
+import { safeMergeConfig } from '../utils/atomic-config.js';
+import { ConfigAdapter } from '../utils/config-adapter.js';
+import { syncMcpServersWithCli, loadCanonicalMcpConfig, detectAgent } from '../utils/sync-mcp-cli.js';
+import { createBackup, restoreBackup, cleanupBackup, type BackupInfo } from './rollback.js';
+import type { ChangeSet } from '../types/config.js';
+
+/**
+ * Execute a sync plan based on changeset and mode
+ */
+// Track which MCP agents have been synced in this process run to prevent duplicate syncs
+const syncedMcpAgents = new Set<string>();
+
+function extractHookCommandPath(command: string): string | null {
+    const quoted = command.match(/"([^"]+)"/);
+    if (quoted?.[1]) return quoted[1];
+
+    const singleQuoted = command.match(/'([^']+)'/);
+    if (singleQuoted?.[1]) return singleQuoted[1];
+
+    const bare = command.trim().split(/\s+/).slice(1).join(' ').trim();
+    return bare || null;
+}
+
+async function filterHooksByInstalledScripts(hooksConfig: any): Promise<any> {
+    if (!hooksConfig || typeof hooksConfig !== 'object' || !hooksConfig.hooks) {
+        return hooksConfig;
+    }
+
+    for (const [event, wrappers] of Object.entries(hooksConfig.hooks)) {
+        if (!Array.isArray(wrappers)) continue;
+
+        const keptWrappers: any[] = [];
+        for (const wrapper of wrappers) {
+            if (!wrapper || !Array.isArray(wrapper.hooks)) continue;
+
+            const keptInner: any[] = [];
+            for (const inner of wrapper.hooks) {
+                const command = inner?.command;
+                if (typeof command !== 'string' || !command.trim()) continue;
+
+                const scriptPath = extractHookCommandPath(command);
+                if (!scriptPath) continue;
+
+                if (await fs.pathExists(scriptPath)) {
+                    keptInner.push(inner);
+                }
+            }
+
+            if (keptInner.length > 0) {
+                keptWrappers.push({ ...wrapper, hooks: keptInner });
+            }
+        }
+
+        hooksConfig.hooks[event] = keptWrappers;
+    }
+
+    return hooksConfig;
+}
+
+export async function executeSync(
+    repoRoot: string,
+    systemRoot: string,
+    changeSet: ChangeSet,
+    mode: 'copy' | 'symlink' | 'prune',
+    actionType: 'sync' | 'backport',
+    isDryRun: boolean = false,
+    selectedMcpServers?: string[],
+    options?: { skipMcp?: boolean; force?: boolean },
+): Promise<number> {
+    const normalizedRoot = path.normalize(systemRoot).replace(/\\/g, '/');
+    const isAgentsSkills = normalizedRoot.includes('.agents/skills');
+    const isClaude = systemRoot.includes('.claude') || systemRoot.includes('Claude');
+
+    // ~/.agents/skills: skills-only, written directly into systemRoot (no subdirectory)
+    if (isAgentsSkills) {
+        return executeSyncAgentsSkills(repoRoot, systemRoot, changeSet, mode, actionType, isDryRun);
+    }
+
+    const categories: Array<keyof ChangeSet> = ['skills', 'hooks', 'config'];
+
+
+    let count = 0;
+    const adapter = new ConfigAdapter(systemRoot);
+    const backups: BackupInfo[] = [];
+
+    try {
+        const agent = detectAgent(systemRoot);
+
+        // Only sync MCP once per unique agent type per process run.
+        // Without this guard, selecting multiple Claude config directories causes
+        // syncMcpServersWithCli to fire 3 times with identical output.
+        if (agent && actionType === 'sync' && !syncedMcpAgents.has(agent) && !options?.skipMcp) {
+            const coreConfig = loadCanonicalMcpConfig(repoRoot);
+
+            // Build MCP config: core servers always + any pre-selected optionals
+            const mcpToSync: any = { mcpServers: { ...coreConfig.mcpServers } };
+
+            if (selectedMcpServers && selectedMcpServers.length > 0) {
+                const optionalConfig = loadCanonicalMcpConfig(repoRoot, true);
+                for (const name of selectedMcpServers) {
+                    if (optionalConfig.mcpServers[name]) {
+                        mcpToSync.mcpServers[name] = optionalConfig.mcpServers[name];
+                    }
+                }
+            }
+
+            if (!isDryRun) {
+                await syncMcpServersWithCli(agent, mcpToSync, isDryRun, false);
+            } else {
+                console.log(kleur.cyan(`  [DRY RUN] MCP sync for ${agent}`));
+            }
+            syncedMcpAgents.add(agent);
+            count++;
+        }
+
+        for (const category of categories) {
+            const itemsToProcess: string[] = [];
+
+            if (actionType === 'sync') {
+                const cat = changeSet[category] as any;
+                itemsToProcess.push(...cat.missing);
+                itemsToProcess.push(...cat.outdated);
+
+                if (options?.force) {
+                    itemsToProcess.push(...cat.drifted);
+                }
+
+                if (mode === 'prune') {
+                    for (const itemToDelete of cat.drifted || []) {
+                        const dest = path.join(systemRoot, category, itemToDelete);
+                        console.log(kleur.red(`  [x] PRUNING ${category}/${itemToDelete}`));
+                        if (!isDryRun) {
+                            if (await fs.pathExists(dest)) {
+                                backups.push(await createBackup(dest));
+                                await fs.remove(dest);
+                            }
+                        }
+                        count++;
+                    }
+                }
+            } else if (actionType === 'backport') {
+                const cat = changeSet[category] as any;
+                itemsToProcess.push(...cat.drifted);
+            }
+
+            for (const item of itemsToProcess) {
+                let src: string, dest: string;
+
+                if (category === 'config' && item === 'settings.json' && actionType === 'sync') {
+                    src = path.join(repoRoot, 'config', 'settings.json');
+                    dest = path.join(systemRoot, 'settings.json');
+
+                    const agent = detectAgent(systemRoot);
+
+                    console.log(kleur.gray(`  --> config/settings.json`));
+
+                    if (!isDryRun && await fs.pathExists(dest)) {
+                        backups.push(await createBackup(dest));
+                    }
+
+                    const repoConfig = await fs.readJson(src);
+                    let finalRepoConfig = resolveConfigPaths(repoConfig, systemRoot);
+
+                    // When agent CLI handles MCP servers, strip them from the config merge
+                    // but still merge hooks, permissions, plugins, skillSuggestions, etc.
+                    if (agent) {
+                        delete finalRepoConfig.mcpServers;
+                        if (!isDryRun) console.log(kleur.dim(`      (MCP servers managed by ${agent} CLI — merging non-MCP settings only)`));
+                    }
+
+                    const hooksSrc = path.join(repoRoot, 'config', 'hooks.json');
+                    if (await fs.pathExists(hooksSrc)) {
+                        const hooksRaw = await fs.readJson(hooksSrc);
+                        const hooksAdapted = await filterHooksByInstalledScripts(adapter.adaptHooksConfig(hooksRaw));
+                        if (hooksAdapted.hooks) {
+                            // hooks.json is the canonical source — replace template hooks entirely
+                            // to avoid Claude event names leaking into Gemini/Qwen configs
+                            finalRepoConfig.hooks = hooksAdapted.hooks;
+                            if (!isDryRun) console.log(kleur.dim(`      (Injected hooks)`));
+                        }
+                        if (hooksAdapted.statusLine) {
+                            finalRepoConfig.statusLine = hooksAdapted.statusLine;
+                        }
+                    }
+
+                    if (fs.existsSync(dest)) {
+                        const localConfig = await fs.readJson(dest);
+                        const resolvedLocalConfig = resolveConfigPaths(localConfig, systemRoot);
+
+                        if (mode === 'prune') {
+                            if (localConfig.mcpServers && finalRepoConfig.mcpServers) {
+                                const canonicalServers = new Set(Object.keys(finalRepoConfig.mcpServers));
+                                for (const serverName of Object.keys(localConfig.mcpServers)) {
+                                    if (!canonicalServers.has(serverName)) {
+                                        delete localConfig.mcpServers[serverName];
+                                        if (!isDryRun) console.log(kleur.red(`      (Pruned local MCP server: ${serverName})`));
+                                    }
+                                }
+                            }
+                        }
+
+                        const mergeResult = await safeMergeConfig(dest, finalRepoConfig, {
+                            backupOnSuccess: false,
+                            preserveComments: true,
+                            dryRun: isDryRun,
+                            resolvedLocalConfig: resolvedLocalConfig
+                        });
+
+                        if (mergeResult.updated) {
+                            console.log(kleur.blue(`      (Configuration safely merged)`));
+                        }
+                    } else {
+                        if (!isDryRun) {
+                            await fs.ensureDir(path.dirname(dest));
+                            await fs.writeJson(dest, finalRepoConfig, { spaces: 2 });
+                        }
+                        console.log(kleur.green(`      (Created new configuration)`));
+                    }
+                    count++;
+                    continue;
+                }
+
+                const repoPath = category === 'commands' ? path.join(repoRoot, '.gemini', 'commands') :
+                    category === 'qwen-commands' ? path.join(repoRoot, '.qwen', 'commands') :
+                        category === 'antigravity-workflows' ? path.join(repoRoot, '.gemini', 'antigravity', 'global_workflows') :
+                            path.join(repoRoot, category);
+
+                const systemPath = category === 'qwen-commands' ? path.join(systemRoot, 'commands') :
+                    category === 'antigravity-workflows' ? path.join(systemRoot, '.gemini', 'antigravity', 'global_workflows') :
+                        path.join(systemRoot, category);
+
+                if (actionType === 'backport') {
+                    src = path.join(systemPath, item);
+                    dest = path.join(repoPath, item);
+                } else {
+                    src = path.join(repoPath, item);
+                    dest = path.join(systemPath, item);
+                }
+
+                console.log(kleur.gray(`  ${actionType === 'backport' ? '<--' : '-->'} ${category}/${item}`));
+
+                if (!isDryRun && actionType === 'sync' && await fs.pathExists(dest)) {
+                    backups.push(await createBackup(dest));
+                }
+
+                if (mode === 'symlink' && actionType === 'sync' && category !== 'config') {
+                    if (!isDryRun) {
+                        if (process.platform === 'win32') {
+                            console.log(kleur.yellow('  ⚠ Symlinks require Developer Mode on Windows — falling back to copy.'));
+                            await fs.remove(dest);
+                            await fs.copy(src, dest);
+                        } else {
+                            await fs.remove(dest);
+                            await fs.ensureSymlink(src, dest);
+                        }
+                    }
+                } else {
+                    if (!isDryRun) {
+                        await fs.remove(dest);
+                        await fs.copy(src, dest);
+                    }
+                }
+
+                count++;
+            }
+        }
+
+        if (!isDryRun && actionType === 'sync') {
+            const manifestPath = path.join(systemRoot, '.jaggers-sync-manifest.json');
+            const existing = await fs.pathExists(manifestPath)
+                ? await fs.readJson(manifestPath)
+                : {};
+            await fs.writeJson(manifestPath, {
+                ...existing,
+                lastSync: new Date().toISOString(),
+                repoRoot,
+                items: count
+            }, { spaces: 2 });
+        }
+
+        for (const backup of backups) {
+            await cleanupBackup(backup);
+        }
+
+        return count;
+
+    } catch (error: any) {
+        console.error(kleur.red(`\nSync failed, rolling back ${backups.length} changes...`));
+        for (const backup of backups) {
+            try {
+                await restoreBackup(backup);
+            } finally {
+                await cleanupBackup(backup);
+            }
+        }
+        throw error;
+    }
+}
+
+/**
+ * Sync skills directly into ~/.agents/skills/<skill> (no subdirectory indirection).
+ * This target is skills-only — no hooks, config, MCP, or commands.
+ */
+async function executeSyncAgentsSkills(
+    repoRoot: string,
+    systemRoot: string,
+    changeSet: ChangeSet,
+    mode: 'copy' | 'symlink' | 'prune',
+    actionType: 'sync' | 'backport',
+    isDryRun: boolean,
+): Promise<number> {
+    let count = 0;
+    const backups: BackupInfo[] = [];
+
+    try {
+        const repoSkillsPath = path.join(repoRoot, 'skills');
+        const itemsToProcess: string[] = [];
+
+        if (actionType === 'sync') {
+            itemsToProcess.push(...changeSet.skills.missing, ...changeSet.skills.outdated);
+        } else if (actionType === 'backport') {
+            itemsToProcess.push(...changeSet.skills.drifted);
+        }
+
+        for (const item of itemsToProcess) {
+            const src = actionType === 'backport'
+                ? path.join(systemRoot, item)
+                : path.join(repoSkillsPath, item);
+            const dest = actionType === 'backport'
+                ? path.join(repoSkillsPath, item)
+                : path.join(systemRoot, item);
+
+            console.log(kleur.gray(`  ${actionType === 'backport' ? '<--' : '-->'} ${item}`));
+
+            if (!isDryRun) {
+                if (await fs.pathExists(dest)) backups.push(await createBackup(dest));
+                await fs.ensureDir(path.dirname(dest));
+
+                if (mode === 'symlink' && actionType === 'sync') {
+                    if (process.platform === 'win32') {
+                        console.log(kleur.yellow('  ⚠ Symlinks require Developer Mode on Windows — falling back to copy.'));
+                        await fs.remove(dest);
+                        await fs.copy(src, dest);
+                    } else {
+                        await fs.remove(dest);
+                        await fs.ensureSymlink(src, dest);
+                    }
+                } else {
+                    await fs.remove(dest);
+                    await fs.copy(src, dest);
+                }
+            }
+            count++;
+        }
+
+        for (const backup of backups) await cleanupBackup(backup);
+        return count;
+
+    } catch (error: any) {
+        console.error(kleur.red(`\nSync failed, rolling back ${backups.length} changes...`));
+        for (const backup of backups) {
+            try { await restoreBackup(backup); } finally { await cleanupBackup(backup); }
+        }
+        throw error;
+    }
+}
+
+function resolveConfigPaths(config: any, targetDir: string): any {
+    const newConfig = JSON.parse(JSON.stringify(config));
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+
+    function recursiveReplace(obj: any) {
+        for (const key in obj) {
+            if (typeof obj[key] === 'string') {
+                let val = obj[key];
+                // Resolve $HOME and ~ to actual home directory for comparison
+                // but only match absolute paths, not env-var paths like "$HOME/..."
+                if (!val.startsWith('$') && !val.startsWith('~')) {
+                    if (val.match(/\/[^\s"']+\/hooks\//)) {
+                        const hooksDir = path.join(targetDir, 'hooks');
+                        let replacementDir = `${hooksDir}/`;
+                        if (process.platform === 'win32') {
+                            replacementDir = replacementDir.replace(/\\/g, '/');
+                        }
+                        obj[key] = val.replace(/(\/[^\s"']+\/hooks\/)/g, replacementDir);
+                    }
+                }
+            } else if (typeof obj[key] === 'object' && obj[key] !== null) {
+                recursiveReplace(obj[key]);
+            }
+        }
+    }
+
+    recursiveReplace(newConfig);
+    return newConfig;
+}

package/src/index.ts

@@ -0,0 +1,69 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Command } from 'commander';
+import kleur from 'kleur';
+
+// __dirname is available in CJS output (tsup target: cjs)
+declare const __dirname: string;
+let version = '0.0.0';
+try { version = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf8')).version; } catch { /* fallback */ }
+
+import { createInstallCommand } from './commands/install.js';
+import { createProjectCommand } from './commands/install-project.js';
+import { createStatusCommand } from './commands/status.js';
+import { createResetCommand } from './commands/reset.js';
+import { createHelpCommand } from './commands/help.js';
+import { printBanner } from './utils/banner.js';
+
+const program = new Command();
+
+program
+    .name('xtrm')
+    .description('Claude Code tools installer (skills, hooks, MCP servers)')
+    .version(version);
+
+// Add exit override for cleaner unknown command error
+program.exitOverride((err) => {
+    if (err.code === 'commander.unknownCommand') {
+        console.error(kleur.red(`\n✗ Unknown command. Run 'xtrm --help'\n`));
+        process.exit(1);
+    }
+    process.exit(1);
+});
+
+// Main commands
+program.addCommand(createInstallCommand());
+program.addCommand(createProjectCommand());
+program.addCommand(createStatusCommand());
+program.addCommand(createResetCommand());
+program.addCommand(createHelpCommand());
+
+// Default action: show help
+program
+    .action(async () => {
+        program.help();
+    });
+
+// Global error handlers
+process.on('uncaughtException', (err) => {
+    if ((err as any).code?.startsWith('commander.')) {
+        return;
+    }
+    console.error(kleur.red(`\n✗ ${err.message}\n`));
+    process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+    console.error(kleur.red(`\n✗ ${String(reason)}\n`));
+    process.exit(1);
+});
+
+// Show startup banner unless --help or --version flag is present
+const isHelpOrVersion = process.argv.some(a => a === '--help' || a === '-h' || a === '--version' || a === '-V');
+
+(async () => {
+    if (!isHelpOrVersion) {
+        await printBanner(version);
+    }
+    program.parseAsync(process.argv);
+})();

package/src/types/config.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+export const SyncModeSchema = z.enum(['copy', 'symlink', 'prune']);
+export type SyncMode = z.infer<typeof SyncModeSchema>;
+
+export const TargetConfigSchema = z.object({
+    label: z.string(),
+    path: z.string(),
+    exists: z.boolean(),
+});
+export type TargetConfig = z.infer<typeof TargetConfigSchema>;
+
+export const ChangeSetCategorySchema = z.object({
+    missing: z.array(z.string()),
+    outdated: z.array(z.string()),
+    drifted: z.array(z.string()),
+    total: z.number(),
+});
+export type ChangeSetCategory = z.infer<typeof ChangeSetCategorySchema>;
+
+export const ChangeSetSchema = z.object({
+    skills: ChangeSetCategorySchema,
+    hooks: ChangeSetCategorySchema,
+    config: ChangeSetCategorySchema,
+    commands: ChangeSetCategorySchema,
+    'qwen-commands': ChangeSetCategorySchema,
+    'antigravity-workflows': ChangeSetCategorySchema,
+});
+export type ChangeSet = z.infer<typeof ChangeSetSchema>;
+
+export const SyncPlanSchema = z.object({
+    mode: SyncModeSchema,
+    targets: z.array(z.string()),
+});
+export type SyncPlan = z.infer<typeof SyncPlanSchema>;
+
+export const ManifestItemSchema = z.object({
+    type: z.enum(['skill', 'hook', 'config', 'command']),
+    name: z.string(),
+    hash: z.string(),
+    lastSync: z.string(),
+    source: z.string(),
+});
+export type ManifestItem = z.infer<typeof ManifestItemSchema>;
+
+export const ManifestSchema = z.object({
+    version: z.string().optional().default('1'),
+    lastSync: z.string(),
+    items: z.number().optional().default(0),
+});
+export type Manifest = z.infer<typeof ManifestSchema>;