skiller 0.9.10 → 0.9.12

package/dist/cli/commands.js

@@ -19,6 +19,17 @@ function skillsArgsBuilder(y) {
         description: 'Arguments passed through to the local skills CLI',
     });
 }
+function installArgsBuilder(y) {
+    return skillsArgsBuilder(y)
+        .positional('source', {
+        type: 'string',
+        description: 'Preset source for one-shot materialization (local path, GitHub repo, or GitHub URL)',
+    })
+        .option('preset', {
+        type: 'string',
+        description: 'Preset name to materialize from the source (defaults to auto-selecting a single preset or "default")',
+    });
+}
 function migrateClaudePluginsArgsBuilder(y) {
     return y
         .option('project-root', {
@@ -110,12 +121,12 @@ async function run() {
         })
             .option('local-only', {
             type: 'boolean',
-            description: 'Only search for local .claude directories, ignore global config',
+            description: 'Only search for local .agents directories, ignore global config',
             default: false,
         })
             .option('nested', {
             type: 'boolean',
-            description: 'Enable nested rule loading from nested .claude directories (default: from config or disabled)',
+            description: 'Enable nested rule loading from nested .agents directories (default: from config or disabled)',
         })
             .option('backup', {
             type: 'boolean',
@@ -143,14 +154,44 @@ async function run() {
         .command('list [args..]', 'Run the local skills CLI list command', skillsArgsBuilder, handlers_1.listHandler)
         .command('find [args..]', 'Run the local skills CLI find command', skillsArgsBuilder, handlers_1.findHandler)
         .command('check [args..]', 'Run the local skills CLI check command', skillsArgsBuilder, handlers_1.checkHandler)
-        .command('install [args..]', 'Restore lock-backed skills plus skiller-managed agent installs from lockfiles, then skiller apply', (y) => skillsArgsBuilder(y)
+        .command('install [source] [args..]', 'Materialize a preset when requested, or run inherited sync when configured, then restore lock-backed skills plus skiller-managed agent installs from lockfiles, then skiller apply', (y) => installArgsBuilder(y)
+        .option('nested', {
+        type: 'boolean',
+        description: 'Run the install lifecycle for every nested .agents project root',
+        default: false,
+    })
+        .option('no-sync', {
+        type: 'boolean',
+        description: 'Skip [sync] processing before install',
+        default: false,
+    })
+        .option('sync-only', {
+        type: 'boolean',
+        description: 'Run [sync] processing only, then stop before install/apply',
+        default: false,
+    })
         .option('verbose', {
         type: 'boolean',
         description: 'Enable verbose logging for the follow-up apply step',
         default: false,
     })
         .alias('verbose', 'v'), handlers_1.installHandler)
-        .command('update [args..]', 'Update local skills CLI installs plus skiller-managed agent installs, then skiller apply', (y) => skillsArgsBuilder(y)
+        .command('update [args..]', 'Optionally sync inherited preset files, then update local skills CLI installs plus skiller-managed agent installs, then skiller apply', (y) => skillsArgsBuilder(y)
+        .option('nested', {
+        type: 'boolean',
+        description: 'Run the update lifecycle for every nested .agents project root',
+        default: false,
+    })
+        .option('no-sync', {
+        type: 'boolean',
+        description: 'Skip [sync] processing before update',
+        default: false,
+    })
+        .option('sync-only', {
+        type: 'boolean',
+        description: 'Run [sync] processing only, then stop before update/apply',
+        default: false,
+    })
         .option('verbose', {
         type: 'boolean',
         description: 'Enable verbose logging for the follow-up apply step',

package/dist/cli/handlers.js

@@ -62,6 +62,9 @@ const skills_cli_1 = require("./skills-cli");
 const project_paths_1 = require("../core/project-paths");
 const SkillOwnership_1 = require("../core/SkillOwnership");
 const AgentSourceCompatibility_1 = require("../core/AgentSourceCompatibility");
+const SyncEngine_1 = require("../core/SyncEngine");
+const FileSystemUtils_1 = require("../core/FileSystemUtils");
+const PresetInstaller_1 = require("../core/PresetInstaller");
 const readline = __importStar(require("readline/promises"));
 async function executeSkillsWrapper(projectRoot, args) {
     try {
@@ -79,6 +82,89 @@ async function applyAfterSkillsLifecycleStep(projectRoot, verbose) {
         verbose,
     });
 }
+async function pruneSkillOutputs(projectRoot, skillNames) {
+    const normalizedNames = [...new Set(skillNames.filter(Boolean))];
+    if (normalizedNames.length === 0)
+        return;
+    const skillDirs = new Set([(0, SkillOwnership_1.getCanonicalSkillsDir)(projectRoot)]);
+    for (const agent of agents_2.allAgents) {
+        if (!agent.supportsNativeSkills?.() || !agent.getSkillsPath)
+            continue;
+        const skillsPath = agent.getSkillsPath(projectRoot);
+        if (skillsPath) {
+            skillDirs.add(skillsPath);
+        }
+    }
+    for (const skillName of normalizedNames) {
+        for (const skillsDir of skillDirs) {
+            await fs.rm(path.join(skillsDir, skillName), {
+                force: true,
+                recursive: true,
+            });
+        }
+    }
+}
+async function pruneStaleLockBackedSkills(projectRoot) {
+    const [nativePrune, agentPrune] = await Promise.all([
+        (0, AgentSourceCompatibility_1.pruneMissingNativeSkillsFromLock)(projectRoot),
+        (0, AgentSourceCompatibility_1.pruneMissingAgentSkillsFromLock)(projectRoot),
+    ]);
+    if (nativePrune.prunedOutputNames.length > 0) {
+        await pruneSkillOutputs(projectRoot, nativePrune.prunedOutputNames);
+        console.log(`[skiller] Pruned ${nativePrune.prunedKeys.length} stale upstream skill(s): ${nativePrune.prunedKeys.join(', ')}`);
+    }
+    if (agentPrune.prunedOutputNames.length > 0) {
+        await pruneSkillOutputs(projectRoot, agentPrune.prunedOutputNames);
+        console.log(`[skiller] Pruned ${agentPrune.prunedKeys.length} stale agent-derived skill(s): ${agentPrune.prunedKeys.join(', ')}`);
+    }
+    const warnings = [...nativePrune.warnings, ...agentPrune.warnings];
+    if (warnings.length > 0) {
+        console.log(warnings.map((warning) => `[skiller] ${warning}`).join('\n'));
+    }
+}
+function normalizeOutputSkillNames(skillNames) {
+    return [...new Set(skillNames.map((name) => name.replace(/:/g, '-')))].sort((a, b) => a.localeCompare(b));
+}
+async function pruneOutputsForRemovedLockEntries(projectRoot, args) {
+    const nativeOutputNames = normalizeOutputSkillNames(args.native);
+    const agentOutputNames = normalizeOutputSkillNames(args.agent);
+    if (nativeOutputNames.length > 0) {
+        await pruneSkillOutputs(projectRoot, nativeOutputNames);
+        console.log(`[skiller] Pruned ${args.native.length} skill output(s) removed by source update: ${args.native.join(', ')}`);
+    }
+    if (agentOutputNames.length > 0) {
+        await pruneSkillOutputs(projectRoot, agentOutputNames);
+        console.log(`[skiller] Pruned ${args.agent.length} agent-derived skill output(s) removed by source update: ${args.agent.join(', ')}`);
+    }
+}
+async function getLifecycleProjectRoots(projectRoot, nested) {
+    if (!nested) {
+        return [projectRoot];
+    }
+    const skillerDirs = await (0, FileSystemUtils_1.findAllSkillerDirs)(projectRoot);
+    const roots = [...new Set(skillerDirs.map((dir) => path.dirname(dir)))];
+    return roots.sort((a, b) => a.localeCompare(b));
+}
+async function maybeRunSync(projectRoot, options) {
+    if (options.skipSync) {
+        return {
+            applied: false,
+            synced: [],
+            removed: [],
+            removedNativeLockSkills: [],
+            removedAgentLockSkills: [],
+        };
+    }
+    const result = await (0, SyncEngine_1.syncProjectFiles)(projectRoot);
+    if (!result.applied)
+        return result;
+    const modeSuffix = result.mode ? ` (${result.mode})` : '';
+    console.log(`[skiller] Synced ${result.synced.length} file(s) from ${result.source}${modeSuffix}`);
+    if (result.removed.length > 0) {
+        console.log(`[skiller] Removed ${result.removed.length} stale synced file(s): ${result.removed.join(', ')}`);
+    }
+    return result;
+}
 function normalizeRequestedSkillNames(args) {
     if (!args || args.length === 0)
         return [];
@@ -187,6 +273,41 @@ async function readJsonObject(filePath) {
         return null;
     }
 }
+async function readLockSkillKeys(filePath) {
+    const raw = await readJsonObject(filePath);
+    const skills = raw?.skills;
+    if (!skills || typeof skills !== 'object') {
+        return [];
+    }
+    return Object.keys(skills).sort((a, b) => a.localeCompare(b));
+}
+function subtractStringSets(before, after) {
+    const afterSet = new Set(after);
+    return before.filter((entry) => !afterSet.has(entry));
+}
+function shouldUsePresetInstall(argv) {
+    if (argv.preset) {
+        return true;
+    }
+    if (!argv.source) {
+        return false;
+    }
+    try {
+        (0, AgentSourceCompatibility_1.parseCompatibleSource)(argv.source);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getInstallPassthroughArgs(argv) {
+    if (!shouldUsePresetInstall(argv)) {
+        return argv.source
+            ? [argv.source, ...(argv.args ?? [])]
+            : (argv.args ?? []);
+    }
+    return argv.args ?? [];
+}
 async function cleanupLegacyClaudePluginState(projectRoot, pluginIds) {
     const pluginIdSet = new Set(pluginIds);
     if (pluginIdSet.size === 0)
@@ -681,18 +802,66 @@ async function addHandler(argv) {
     await applyAfterSkillsLifecycleStep(projectRoot, argv.verbose ?? false);
 }
 async function installHandler(argv) {
-    await executeSkillsWrapper(argv['project-root'], [
-        'experimental_install',
-        ...(argv.args ?? []),
-    ]);
-    const restored = await (0, AgentSourceCompatibility_1.restoreAgentSkillsFromLock)(argv['project-root']);
-    if (restored.restored.length > 0) {
-        console.log(`[skiller] Restored ${restored.restored.length} agent-derived skill(s): ${restored.restored.join(', ')}`);
-    }
-    if (restored.warnings.length > 0) {
-        console.log(restored.warnings.map((warning) => `[skiller] ${warning}`).join('\n'));
+    if (argv['no-sync'] && argv['sync-only']) {
+        throw new Error('[skiller] --no-sync and --sync-only cannot be combined.');
+    }
+    const presetInstall = shouldUsePresetInstall(argv);
+    if (presetInstall && !argv.source) {
+        throw new Error('[skiller] install --preset requires a source: skiller install <source> --preset <name>');
+    }
+    const projectRoots = await getLifecycleProjectRoots(argv['project-root'], argv.nested);
+    const installArgs = getInstallPassthroughArgs(argv);
+    for (const projectRoot of projectRoots) {
+        if (presetInstall) {
+            const [previousNativeLockSkills, previousAgentLockSkills] = await Promise.all([
+                readLockSkillKeys(path.join(projectRoot, 'skills-lock.json')),
+                readLockSkillKeys(path.join(projectRoot, 'skiller-lock.json')),
+            ]);
+            const presetResult = await (0, PresetInstaller_1.installPresetIntoProject)(projectRoot, {
+                preset: argv.preset,
+                source: argv.source,
+            });
+            console.log(`[skiller] Materialized preset '${presetResult.preset}' from ${argv.source} (${presetResult.synced.length} file(s))`);
+            if (presetResult.removed.length > 0) {
+                console.log(`[skiller] Removed ${presetResult.removed.length} stale preset-managed file(s): ${presetResult.removed.join(', ')}`);
+            }
+            const [nextNativeLockSkills, nextAgentLockSkills] = await Promise.all([
+                readLockSkillKeys(path.join(projectRoot, 'skills-lock.json')),
+                readLockSkillKeys(path.join(projectRoot, 'skiller-lock.json')),
+            ]);
+            await pruneOutputsForRemovedLockEntries(projectRoot, {
+                native: subtractStringSets(previousNativeLockSkills, nextNativeLockSkills),
+                agent: subtractStringSets(previousAgentLockSkills, nextAgentLockSkills),
+            });
+        }
+        else {
+            const syncResult = await maybeRunSync(projectRoot, {
+                skipSync: argv['no-sync'] ?? false,
+            });
+            if (syncResult.applied) {
+                await pruneOutputsForRemovedLockEntries(projectRoot, {
+                    native: syncResult.removedNativeLockSkills,
+                    agent: syncResult.removedAgentLockSkills,
+                });
+            }
+        }
+        if (argv['sync-only']) {
+            continue;
+        }
+        await pruneStaleLockBackedSkills(projectRoot);
+        await executeSkillsWrapper(projectRoot, [
+            'experimental_install',
+            ...installArgs,
+        ]);
+        const restored = await (0, AgentSourceCompatibility_1.restoreAgentSkillsFromLock)(projectRoot);
+        if (restored.restored.length > 0) {
+            console.log(`[skiller] Restored ${restored.restored.length} agent-derived skill(s): ${restored.restored.join(', ')}`);
+        }
+        if (restored.warnings.length > 0) {
+            console.log(restored.warnings.map((warning) => `[skiller] ${warning}`).join('\n'));
+        }
+        await applyAfterSkillsLifecycleStep(projectRoot, argv.verbose ?? false);
     }
-    await applyAfterSkillsLifecycleStep(argv['project-root'], argv.verbose ?? false);
 }
 async function removeHandler(argv) {
     const projectRoot = argv['project-root'];
@@ -733,18 +902,34 @@ async function checkHandler(argv) {
     ]);
 }
 async function updateHandler(argv) {
-    await executeSkillsWrapper(argv['project-root'], [
-        'update',
-        ...(argv.args ?? []),
-    ]);
-    const updated = await (0, AgentSourceCompatibility_1.updateAgentSkillsFromLock)(argv['project-root']);
-    if (updated.updated.length > 0) {
-        console.log(`[skiller] Updated ${updated.updated.length} agent-derived skill(s): ${updated.updated.join(', ')}`);
+    if (argv['no-sync'] && argv['sync-only']) {
+        throw new Error('[skiller] --no-sync and --sync-only cannot be combined.');
     }
-    if (updated.warnings.length > 0) {
-        console.log(updated.warnings.map((warning) => `[skiller] ${warning}`).join('\n'));
+    const projectRoots = await getLifecycleProjectRoots(argv['project-root'], argv.nested);
+    for (const projectRoot of projectRoots) {
+        const syncResult = await maybeRunSync(projectRoot, {
+            skipSync: argv['no-sync'] ?? false,
+        });
+        if (syncResult.applied) {
+            await pruneOutputsForRemovedLockEntries(projectRoot, {
+                native: syncResult.removedNativeLockSkills,
+                agent: syncResult.removedAgentLockSkills,
+            });
+        }
+        if (argv['sync-only']) {
+            continue;
+        }
+        await pruneStaleLockBackedSkills(projectRoot);
+        await executeSkillsWrapper(projectRoot, ['update', ...(argv.args ?? [])]);
+        const updated = await (0, AgentSourceCompatibility_1.updateAgentSkillsFromLock)(projectRoot);
+        if (updated.updated.length > 0) {
+            console.log(`[skiller] Updated ${updated.updated.length} agent-derived skill(s): ${updated.updated.join(', ')}`);
+        }
+        if (updated.warnings.length > 0) {
+            console.log(updated.warnings.map((warning) => `[skiller] ${warning}`).join('\n'));
+        }
+        await applyAfterSkillsLifecycleStep(projectRoot, argv.verbose ?? false);
     }
-    await applyAfterSkillsLifecycleStep(argv['project-root'], argv.verbose ?? false);
 }
 async function outdatedHandler(argv) {
     await executeSkillsWrapper(argv['project-root'], [

package/dist/core/AgentSourceCompatibility.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCompatibleSource = parseCompatibleSource;
+exports.createSourceWorkspace = createSourceWorkspace;
 exports.hasListFlag = hasListFlag;
 exports.hasGlobalFlag = hasGlobalFlag;
 exports.extractAddSource = extractAddSource;
@@ -44,6 +45,8 @@ exports.restoreAgentSkillsFromLock = restoreAgentSkillsFromLock;
 exports.getOutdatedAgentSkills = getOutdatedAgentSkills;
 exports.updateAgentSkillsFromLock = updateAgentSkillsFromLock;
 exports.removeAgentManagedSkills = removeAgentManagedSkills;
+exports.pruneMissingNativeSkillsFromLock = pruneMissingNativeSkillsFromLock;
+exports.pruneMissingAgentSkillsFromLock = pruneMissingAgentSkillsFromLock;
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
@@ -67,12 +70,43 @@ const SKIP_DIRS = new Set([
     'tmp',
     'tmp-fixtures',
 ]);
+const NATIVE_SKILLS_LOCK_VERSION = 1;
 function hashContent(content) {
     return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
 }
 function normalizeSkillNameForFilesystem(name) {
     return name.trim().replace(/:/g, '-');
 }
+function createEmptyNativeSkillsLock() {
+    return {
+        version: NATIVE_SKILLS_LOCK_VERSION,
+        skills: {},
+    };
+}
+async function readNativeSkillsLock(projectRoot) {
+    try {
+        const raw = JSON.parse(await fs.readFile(path.join(projectRoot, 'skills-lock.json'), 'utf8'));
+        if (raw.version !== NATIVE_SKILLS_LOCK_VERSION ||
+            !raw.skills ||
+            typeof raw.skills !== 'object') {
+            return createEmptyNativeSkillsLock();
+        }
+        return raw;
+    }
+    catch {
+        return createEmptyNativeSkillsLock();
+    }
+}
+async function writeNativeSkillsLock(projectRoot, lock) {
+    const sortedSkills = {};
+    for (const key of Object.keys(lock.skills).sort((a, b) => a.localeCompare(b))) {
+        sortedSkills[key] = lock.skills[key];
+    }
+    await fs.writeFile(path.join(projectRoot, 'skills-lock.json'), JSON.stringify({
+        version: NATIVE_SKILLS_LOCK_VERSION,
+        skills: sortedSkills,
+    }, null, 2) + '\n', 'utf8');
+}
 function isLocalPath(input) {
     return (path.isAbsolute(input) ||
         input.startsWith('./') ||
@@ -207,6 +241,9 @@ async function withSourceWorkspace(rawSource) {
     const parsed = parseCompatibleSource(rawSource);
     return withParsedSourceWorkspace(parsed);
 }
+async function createSourceWorkspace(rawSource) {
+    return withSourceWorkspace(rawSource);
+}
 async function withParsedSourceWorkspace(parsed) {
     if (parsed.type === 'local') {
         const targetPath = parsed.subpath
@@ -708,3 +745,84 @@ async function removeAgentManagedSkills(projectRoot, skillNames) {
     }
     return removed;
 }
+async function pruneMissingNativeSkillsFromLock(projectRoot) {
+    const lock = await readNativeSkillsLock(projectRoot);
+    const prunedKeys = [];
+    const prunedOutputNames = [];
+    const warnings = [];
+    for (const entries of groupLockEntriesBySource(lock.skills).values()) {
+        const [, entry] = entries[0];
+        if (entry.sourceType === 'node_modules' ||
+            entry.sourceType === 'well-known') {
+            continue;
+        }
+        let workspace = null;
+        try {
+            workspace = await withSourceWorkspace(entry.source);
+            const availableSkillNames = new Set(await discoverSkillNames(workspace.searchPath));
+            for (const [skillName] of entries) {
+                const installName = normalizeSkillNameForFilesystem(skillName);
+                if (availableSkillNames.has(installName))
+                    continue;
+                prunedKeys.push(skillName);
+                prunedOutputNames.push(installName);
+            }
+        }
+        catch (error) {
+            warnings.push(`Could not inspect '${entry.source}' for stale skills: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            if (workspace) {
+                await workspace.cleanup();
+            }
+        }
+    }
+    if (prunedKeys.length > 0) {
+        for (const skillName of prunedKeys) {
+            delete lock.skills[skillName];
+        }
+        await writeNativeSkillsLock(projectRoot, lock);
+    }
+    return {
+        prunedKeys: prunedKeys.sort((a, b) => a.localeCompare(b)),
+        prunedOutputNames: prunedOutputNames.sort((a, b) => a.localeCompare(b)),
+        warnings,
+    };
+}
+async function pruneMissingAgentSkillsFromLock(projectRoot) {
+    const lock = await (0, SkillerLock_1.readSkillerLock)(projectRoot);
+    const prunedKeys = [];
+    const prunedOutputNames = [];
+    const warnings = [];
+    for (const entries of groupLockEntriesBySource(lock.skills).values()) {
+        const [, entry] = entries[0];
+        let workspace = null;
+        try {
+            workspace = await withParsedSourceWorkspace(parseSourceFromLockEntry(entry));
+            const agentSkills = await discoverAgentSkillCandidates(workspace.searchPath, workspace.rootPath);
+            const candidates = new Set(agentSkills.map((candidate) => candidate.sourceRelPath));
+            for (const [skillName, lockEntry] of entries) {
+                if (candidates.has(lockEntry.sourceRelPath))
+                    continue;
+                prunedKeys.push(skillName);
+                prunedOutputNames.push(normalizeSkillNameForFilesystem(skillName));
+            }
+        }
+        catch (error) {
+            warnings.push(`Could not inspect '${entry.source}' for stale agent-derived skills: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            if (workspace) {
+                await workspace.cleanup();
+            }
+        }
+    }
+    if (prunedKeys.length > 0) {
+        await (0, SkillerLock_1.removeSkillerLockEntries)(projectRoot, prunedKeys);
+    }
+    return {
+        prunedKeys: prunedKeys.sort((a, b) => a.localeCompare(b)),
+        prunedOutputNames: prunedOutputNames.sort((a, b) => a.localeCompare(b)),
+        warnings,
+    };
+}

package/dist/core/ConfigLoader.js

@@ -33,6 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripSymbols = stripSymbols;
+exports.isPlainRecord = isPlainRecord;
+exports.deepMergeConfig = deepMergeConfig;
+exports.withoutSync = withoutSync;
+exports.loadRawConfig = loadRawConfig;
 exports.loadConfig = loadConfig;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
@@ -56,10 +61,20 @@ const agentConfigSchema = zod_1.z
     mcp: mcpConfigSchema,
 })
     .optional();
+const syncConfigSchema = zod_1.z
+    .object({
+    source: zod_1.z.string(),
+    mode: zod_1.z.enum(['auto', 'preset', 'repo']).optional(),
+    clean: zod_1.z.boolean().optional(),
+    include: zod_1.z.array(zod_1.z.string()).optional(),
+    exclude: zod_1.z.array(zod_1.z.string()).optional(),
+})
+    .optional();
 const skillerConfigSchema = zod_1.z.object({
     default_agents: zod_1.z.array(zod_1.z.string()).optional(),
     root_folder: zod_1.z.string().optional(),
     agents: zod_1.z.record(zod_1.z.string(), agentConfigSchema).optional(),
+    sync: syncConfigSchema,
     mcp: zod_1.z
         .object({
         enabled: zod_1.z.boolean().optional(),
@@ -111,49 +126,120 @@ function stripSymbols(obj) {
     }
     return result;
 }
-/**
- * Loads and parses the skiller TOML configuration file, applying defaults.
- * If the file is missing or invalid, returns empty/default config.
- */
-async function loadConfig(options) {
-    const { projectRoot, configPath, cliAgents } = options;
-    let configFile;
-    if (configPath) {
-        configFile = path.resolve(configPath);
-    }
-    else {
-        const localConfigFile = path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, project_paths_1.SKILLER_CONFIG_FILE);
-        try {
-            await fs_1.promises.access(localConfigFile);
-            configFile = localConfigFile;
+function isPlainRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function deepMergeConfig(base, override) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value) || !isPlainRecord(value)) {
+            result[key] = value;
+            continue;
         }
-        catch {
-            // If local config doesn't exist, try global config
-            const xdgConfigDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
-            configFile = path.join(xdgConfigDir, 'skiller', 'skiller.toml');
+        const baseValue = result[key];
+        if (isPlainRecord(baseValue)) {
+            result[key] = deepMergeConfig(baseValue, value);
+            continue;
         }
+        result[key] = deepMergeConfig({}, value);
+    }
+    return result;
+}
+function withoutSync(raw) {
+    const next = { ...raw };
+    delete next.sync;
+    return next;
+}
+async function resolveConfigFile(projectRoot, configPath) {
+    if (configPath) {
+        return path.resolve(configPath);
+    }
+    const localConfigFile = path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, project_paths_1.SKILLER_CONFIG_FILE);
+    try {
+        await fs_1.promises.access(localConfigFile);
+        return localConfigFile;
+    }
+    catch {
+        const xdgConfigDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+        return path.join(xdgConfigDir, 'skiller', 'skiller.toml');
     }
-    let raw = {};
+}
+async function readRawConfigFile(filePath, warningLabel) {
     try {
-        const text = await fs_1.promises.readFile(configFile, 'utf8');
+        const text = await fs_1.promises.readFile(filePath, 'utf8');
         const parsed = text.trim() ? (0, toml_1.parse)(text) : {};
-        // Strip Symbol properties added by @iarna/toml (required for Zod v4+)
-        raw = stripSymbols(parsed);
-        // Validate the configuration with zod
-        const validationResult = skillerConfigSchema.safeParse(raw);
-        if (!validationResult.success) {
-            throw (0, constants_1.createSkillerError)('Invalid configuration file format', `File: ${configFile}, Errors: ${validationResult.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join(', ')}`);
-        }
+        return stripSymbols(parsed);
     }
     catch (err) {
         if (err instanceof Error && err.code !== 'ENOENT') {
-            if (err.message.includes('[skiller]')) {
-                throw err; // Re-throw validation errors
-            }
-            console.warn(`[skiller] Warning: could not read config file at ${configFile}: ${err.message}`);
+            const prefix = warningLabel
+                ? `${warningLabel} at ${filePath}`
+                : `config file at ${filePath}`;
+            console.warn(`[skiller] Warning: could not read ${prefix}: ${err.message}`);
         }
-        raw = {};
+        return {};
+    }
+}
+function validateRawConfig(raw, configFile) {
+    const validationResult = skillerConfigSchema.safeParse(raw);
+    if (!validationResult.success) {
+        throw (0, constants_1.createSkillerError)('Invalid configuration file format', `File: ${configFile}, Errors: ${validationResult.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join(', ')}`);
     }
+}
+function parseSyncConfig(raw, projectRoot) {
+    const syncSection = raw.sync;
+    if (!isPlainRecord(syncSection) || typeof syncSection.source !== 'string') {
+        return undefined;
+    }
+    const mode = syncSection.mode === 'preset' ||
+        syncSection.mode === 'repo' ||
+        syncSection.mode === 'auto'
+        ? syncSection.mode
+        : 'auto';
+    return {
+        source: path.resolve(projectRoot, syncSection.source),
+        mode,
+        clean: typeof syncSection.clean === 'boolean' ? syncSection.clean : true,
+        include: Array.isArray(syncSection.include)
+            ? syncSection.include.map((entry) => String(entry))
+            : undefined,
+        exclude: Array.isArray(syncSection.exclude)
+            ? syncSection.exclude.map((entry) => String(entry))
+            : undefined,
+    };
+}
+async function loadRawConfig(options) {
+    const configFile = await resolveConfigFile(options.projectRoot, options.configPath);
+    const localRaw = await readRawConfigFile(configFile);
+    validateRawConfig(localRaw, configFile);
+    const sync = parseSyncConfig(localRaw, options.projectRoot);
+    let baseRaw = {};
+    let baseConfigFile;
+    if (sync) {
+        baseConfigFile = path.join(sync.source, project_paths_1.CANONICAL_SKILLER_DIR, project_paths_1.SKILLER_CONFIG_FILE);
+        baseRaw = withoutSync(await readRawConfigFile(baseConfigFile, 'base sync config'));
+        validateRawConfig(baseRaw, baseConfigFile);
+    }
+    const raw = deepMergeConfig(baseRaw, localRaw);
+    validateRawConfig(raw, configFile);
+    return {
+        raw,
+        localRaw,
+        baseRaw,
+        configFile,
+        baseConfigFile,
+        sync,
+    };
+}
+/**
+ * Loads and parses the skiller TOML configuration file, applying defaults.
+ * If the file is missing or invalid, returns empty/default config.
+ */
+async function loadConfig(options) {
+    const { projectRoot, cliAgents } = options;
+    const { raw, sync } = await loadRawConfig(options);
     const defaultAgents = Array.isArray(raw.default_agents)
         ? raw.default_agents.map((a) => String(a))
         : undefined;
@@ -267,6 +353,7 @@ async function loadConfig(options) {
         backup: backupConfig,
         skills: skillsConfig,
         rules: rulesConfig,
+        sync,
         nested,
         nestedDefined,
     };

package/dist/core/PresetInstaller.js

@@ -0,0 +1,291 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPresetIntoProject = installPresetIntoProject;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const toml_1 = require("@iarna/toml");
+const AgentSourceCompatibility_1 = require("./AgentSourceCompatibility");
+const ConfigLoader_1 = require("./ConfigLoader");
+const FileSystemUtils_1 = require("./FileSystemUtils");
+const project_paths_1 = require("./project-paths");
+const PRESET_MANIFEST_RELATIVE_PATH = path
+    .join(project_paths_1.CANONICAL_SKILLER_DIR, '.skiller-preset-manifest.json')
+    .replace(/\\/g, '/');
+const HARD_DENY_PATTERNS = [
+    '.agents/skills/**',
+    '.claude/skills/**',
+    PRESET_MANIFEST_RELATIVE_PATH,
+    '.agents/.skiller-sync-manifest.json',
+    '.git/**',
+    'node_modules/**',
+];
+const COPY_EXCEPTIONS = new Set(['.agents/skiller.toml']);
+function normalizeRelativePath(value) {
+    return value.replace(/\\/g, '/');
+}
+function isLikelyLocalPath(input) {
+    return (path.isAbsolute(input) ||
+        input.startsWith('./') ||
+        input.startsWith('../') ||
+        input === '.' ||
+        input === '..' ||
+        /^[a-zA-Z]:[/\\]/.test(input));
+}
+function hashBuffer(buffer) {
+    return (0, crypto_1.createHash)('sha256').update(buffer).digest('hex');
+}
+async function pathExists(targetPath) {
+    try {
+        await fs_1.promises.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readPresetManifest(projectRoot) {
+    try {
+        return JSON.parse(await fs_1.promises.readFile(path.join(projectRoot, PRESET_MANIFEST_RELATIVE_PATH), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function writePresetManifest(projectRoot, manifest) {
+    const manifestPath = path.join(projectRoot, PRESET_MANIFEST_RELATIVE_PATH);
+    await fs_1.promises.mkdir(path.dirname(manifestPath), { recursive: true });
+    await fs_1.promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+}
+async function removeEmptyDirectoriesUpward(fromDir, stopDir) {
+    let current = fromDir;
+    const normalizedStop = path.resolve(stopDir);
+    while (path.resolve(current).startsWith(normalizedStop)) {
+        if (path.resolve(current) === normalizedStop)
+            return;
+        try {
+            const entries = await fs_1.promises.readdir(current);
+            if (entries.length > 0)
+                return;
+            await fs_1.promises.rmdir(current);
+        }
+        catch {
+            return;
+        }
+        current = path.dirname(current);
+    }
+}
+async function collectPresetFiles(rootDir) {
+    const results = [];
+    async function walk(currentDir) {
+        const entries = await fs_1.promises.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === '.git' || entry.name === 'node_modules')
+                continue;
+            const fullPath = path.join(currentDir, entry.name);
+            const relativePath = normalizeRelativePath(path.relative(rootDir, fullPath));
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+                continue;
+            }
+            if (entry.isFile()) {
+                results.push(relativePath);
+            }
+        }
+    }
+    await walk(rootDir);
+    return results.sort((a, b) => a.localeCompare(b));
+}
+function isHardDenied(relativePath) {
+    return HARD_DENY_PATTERNS.some((pattern) => (0, FileSystemUtils_1.matchesPattern)(relativePath, pattern));
+}
+function isPresetAllowlisted(relativePath) {
+    if (relativePath === 'skills-lock.json' ||
+        relativePath === 'skiller-lock.json') {
+        return true;
+    }
+    return (relativePath.startsWith('.agents/') ||
+        relativePath.startsWith('.claude/') ||
+        relativePath.startsWith('.codex/'));
+}
+async function readRawTomlFile(filePath) {
+    try {
+        const text = await fs_1.promises.readFile(filePath, 'utf8');
+        const parsed = text.trim() ? (0, toml_1.parse)(text) : {};
+        const stripped = (0, ConfigLoader_1.stripSymbols)(parsed);
+        return (0, ConfigLoader_1.isPlainRecord)(stripped) ? stripped : {};
+    }
+    catch {
+        return {};
+    }
+}
+async function looksLikePresetRoot(dirPath) {
+    try {
+        const stats = await fs_1.promises.stat(path.join(dirPath, '.agents'));
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function resolvePresetRoot(workspace, presetName) {
+    const { searchPath } = workspace;
+    const namedCandidates = presetName
+        ? [
+            path.join(searchPath, 'presets', presetName),
+            path.join(searchPath, presetName),
+            path.join(searchPath, '.agents', 'presets', presetName),
+        ]
+        : [];
+    if (presetName) {
+        if (path.basename(searchPath) === presetName &&
+            (await looksLikePresetRoot(searchPath))) {
+            return { preset: presetName, presetRoot: searchPath };
+        }
+        for (const candidate of namedCandidates) {
+            if (await looksLikePresetRoot(candidate)) {
+                return { preset: presetName, presetRoot: candidate };
+            }
+        }
+        throw new Error(`[skiller] Preset '${presetName}' was not found under source '${workspace.parsed.source}'.`);
+    }
+    if (await looksLikePresetRoot(searchPath)) {
+        return { preset: path.basename(searchPath), presetRoot: searchPath };
+    }
+    const presetsDir = path.join(searchPath, 'presets');
+    let presetDirs = [];
+    try {
+        const entries = await fs_1.promises.readdir(presetsDir, { withFileTypes: true });
+        presetDirs = (await Promise.all(entries
+            .filter((entry) => entry.isDirectory())
+            .map(async (entry) => {
+            const candidate = path.join(presetsDir, entry.name);
+            return (await looksLikePresetRoot(candidate)) ? candidate : null;
+        }))).filter((entry) => !!entry);
+    }
+    catch {
+        // Ignore missing presets directories.
+    }
+    if (presetDirs.length === 1) {
+        return {
+            preset: path.basename(presetDirs[0]),
+            presetRoot: presetDirs[0],
+        };
+    }
+    const defaultPreset = presetDirs.find((candidate) => path.basename(candidate) === 'default');
+    if (defaultPreset) {
+        return { preset: 'default', presetRoot: defaultPreset };
+    }
+    throw new Error(`[skiller] No preset could be selected from source '${workspace.parsed.source}'. Pass --preset <name>.`);
+}
+async function resolvePresetSourceInput(projectRoot, rawSource) {
+    if (!isLikelyLocalPath(rawSource)) {
+        return rawSource;
+    }
+    const cwdCandidate = path.resolve(rawSource);
+    if (await pathExists(cwdCandidate)) {
+        return cwdCandidate;
+    }
+    const projectCandidate = path.resolve(projectRoot, rawSource);
+    if (await pathExists(projectCandidate)) {
+        return projectCandidate;
+    }
+    return cwdCandidate;
+}
+async function writeMergedConfig(projectRoot, presetRoot) {
+    const baseConfigPath = path.join(presetRoot, project_paths_1.CANONICAL_SKILLER_DIR, project_paths_1.SKILLER_CONFIG_FILE);
+    const localConfigPath = path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, project_paths_1.SKILLER_CONFIG_FILE);
+    const [baseRaw, localRaw] = await Promise.all([
+        readRawTomlFile(baseConfigPath),
+        readRawTomlFile(localConfigPath),
+    ]);
+    const merged = (0, ConfigLoader_1.deepMergeConfig)((0, ConfigLoader_1.withoutSync)(baseRaw), (0, ConfigLoader_1.withoutSync)(localRaw));
+    const rendered = (0, toml_1.stringify)(merged);
+    await fs_1.promises.mkdir(path.dirname(localConfigPath), { recursive: true });
+    await fs_1.promises.writeFile(localConfigPath, rendered, 'utf8');
+    return hashBuffer(Buffer.from(rendered, 'utf8'));
+}
+async function installPresetIntoProject(projectRoot, options) {
+    const resolvedSource = await resolvePresetSourceInput(projectRoot, options.source);
+    const workspace = await (0, AgentSourceCompatibility_1.createSourceWorkspace)(resolvedSource);
+    try {
+        const { preset, presetRoot } = await resolvePresetRoot(workspace, options.preset);
+        const previousManifest = await readPresetManifest(projectRoot);
+        const selectedFiles = (await collectPresetFiles(presetRoot)).filter((relativePath) => !isHardDenied(relativePath) &&
+            !COPY_EXCEPTIONS.has(relativePath) &&
+            isPresetAllowlisted(relativePath));
+        const nextFiles = {};
+        const synced = [];
+        for (const relativePath of selectedFiles) {
+            const sourcePath = path.join(presetRoot, relativePath);
+            const targetPath = path.join(projectRoot, relativePath);
+            const content = await fs_1.promises.readFile(sourcePath);
+            await fs_1.promises.mkdir(path.dirname(targetPath), { recursive: true });
+            await fs_1.promises.writeFile(targetPath, content);
+            nextFiles[relativePath] = hashBuffer(content);
+            synced.push(relativePath);
+        }
+        const mergedConfigHash = await writeMergedConfig(projectRoot, presetRoot);
+        nextFiles['.agents/skiller.toml'] = mergedConfigHash;
+        synced.push('.agents/skiller.toml');
+        const removed = [];
+        if (previousManifest) {
+            for (const relativePath of Object.keys(previousManifest.files)) {
+                if (nextFiles[relativePath])
+                    continue;
+                const targetPath = path.join(projectRoot, relativePath);
+                await fs_1.promises.rm(targetPath, { force: true });
+                await removeEmptyDirectoriesUpward(path.dirname(targetPath), projectRoot);
+                removed.push(relativePath);
+            }
+        }
+        await writePresetManifest(projectRoot, {
+            version: 1,
+            source: options.source,
+            preset,
+            files: nextFiles,
+        });
+        return {
+            preset,
+            presetRoot,
+            removed: removed.sort((a, b) => a.localeCompare(b)),
+            synced: [...new Set(synced)].sort((a, b) => a.localeCompare(b)),
+        };
+    }
+    finally {
+        await workspace.cleanup();
+    }
+}

package/dist/core/SyncEngine.js

@@ -0,0 +1,296 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncProjectFiles = syncProjectFiles;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const FileSystemUtils_1 = require("./FileSystemUtils");
+const project_paths_1 = require("./project-paths");
+const ConfigLoader_1 = require("./ConfigLoader");
+const SYNC_MANIFEST_RELATIVE_PATH = path
+    .join(project_paths_1.CANONICAL_SKILLER_DIR, '.skiller-sync-manifest.json')
+    .replace(/\\/g, '/');
+const PRESET_ROOT_ALLOWLIST = new Set([
+    '.agents',
+    '.claude',
+    '.codex',
+    'skills-lock.json',
+    'skiller-lock.json',
+]);
+const PRESET_ROOT_IGNORES = new Set(['.DS_Store', '.git', 'node_modules']);
+const HARD_DENY_PATTERNS = [
+    '.agents/skills/**',
+    '.claude/skills/**',
+    '.agents/.skiller-sync-manifest.json',
+    '.git/**',
+    'node_modules/**',
+];
+const COPY_EXCEPTIONS = new Set(['.agents/skiller.toml']);
+function normalizeRelativePath(value) {
+    return value.replace(/\\/g, '/');
+}
+function hashBuffer(buffer) {
+    return (0, crypto_1.createHash)('sha256').update(buffer).digest('hex');
+}
+async function pathExists(targetPath) {
+    try {
+        await fs_1.promises.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJsonFile(filePath) {
+    try {
+        return JSON.parse(await fs_1.promises.readFile(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function readLockSkillNames(filePath) {
+    const raw = await readJsonFile(filePath);
+    return raw?.skills ? Object.keys(raw.skills) : [];
+}
+async function readManifest(projectRoot) {
+    return readJsonFile(path.join(projectRoot, SYNC_MANIFEST_RELATIVE_PATH));
+}
+async function collectSourceFiles(rootDir) {
+    const results = [];
+    async function walk(currentDir) {
+        const entries = await fs_1.promises.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === '.git' || entry.name === 'node_modules')
+                continue;
+            const fullPath = path.join(currentDir, entry.name);
+            const relativePath = normalizeRelativePath(path.relative(rootDir, fullPath));
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+                continue;
+            }
+            if (entry.isFile()) {
+                results.push(relativePath);
+            }
+        }
+    }
+    await walk(rootDir);
+    return results.sort((a, b) => a.localeCompare(b));
+}
+function isHardDenied(relativePath) {
+    return HARD_DENY_PATTERNS.some((pattern) => (0, FileSystemUtils_1.matchesPattern)(relativePath, pattern));
+}
+function isPresetAllowlisted(relativePath) {
+    if (relativePath === 'skills-lock.json' ||
+        relativePath === 'skiller-lock.json') {
+        return true;
+    }
+    return (relativePath.startsWith('.agents/') ||
+        relativePath.startsWith('.claude/') ||
+        relativePath.startsWith('.codex/'));
+}
+async function normalizePatterns(sourceRoot, patterns) {
+    if (!patterns || patterns.length === 0)
+        return undefined;
+    const normalized = [];
+    for (const pattern of patterns) {
+        const next = normalizeRelativePath(pattern);
+        if (next.includes('*')) {
+            normalized.push(next);
+            continue;
+        }
+        const candidate = path.join(sourceRoot, next);
+        try {
+            const stat = await fs_1.promises.stat(candidate);
+            if (stat.isDirectory()) {
+                normalized.push(`${next.replace(/\/$/, '')}/**`);
+            }
+            else {
+                normalized.push(next);
+            }
+        }
+        catch {
+            normalized.push(next);
+        }
+    }
+    return normalized;
+}
+async function detectSyncMode(sync) {
+    if (sync.mode === 'preset' || sync.mode === 'repo') {
+        return sync.mode;
+    }
+    if (sync.include && sync.include.length > 0) {
+        return 'repo';
+    }
+    const entries = await fs_1.promises.readdir(sync.source, { withFileTypes: true });
+    const interestingEntries = entries.filter((entry) => !PRESET_ROOT_IGNORES.has(entry.name));
+    if (interestingEntries.length > 0 &&
+        interestingEntries.every((entry) => PRESET_ROOT_ALLOWLIST.has(entry.name))) {
+        return 'preset';
+    }
+    throw new Error(`[skiller] Sync source '${sync.source}' is not a valid preset root. Set [sync].mode = "repo" and add include patterns, or point source at a curated preset directory.`);
+}
+async function selectSyncFiles(sourceRoot, mode, sync) {
+    const sourceFiles = await collectSourceFiles(sourceRoot);
+    const normalizedInclude = await normalizePatterns(sourceRoot, sync.include);
+    const normalizedExclude = await normalizePatterns(sourceRoot, sync.exclude);
+    if (mode === 'repo' &&
+        (!normalizedInclude || normalizedInclude.length === 0)) {
+        throw new Error('[skiller] Repo sync mode requires [sync].include to be set.');
+    }
+    return sourceFiles.filter((relativePath) => {
+        if (isHardDenied(relativePath) || COPY_EXCEPTIONS.has(relativePath)) {
+            return false;
+        }
+        if (mode === 'preset' && !isPresetAllowlisted(relativePath)) {
+            return false;
+        }
+        if (normalizedExclude?.some((pattern) => (0, FileSystemUtils_1.matchesPattern)(relativePath, pattern))) {
+            return false;
+        }
+        if (mode === 'repo' && normalizedInclude) {
+            return normalizedInclude.some((pattern) => (0, FileSystemUtils_1.matchesPattern)(relativePath, pattern));
+        }
+        return true;
+    });
+}
+async function readMergedConfigSourceHash(sourceRoot) {
+    const configPath = path.join(sourceRoot, project_paths_1.CANONICAL_SKILLER_DIR, project_paths_1.SKILLER_CONFIG_FILE);
+    try {
+        return hashBuffer(await fs_1.promises.readFile(configPath));
+    }
+    catch {
+        return null;
+    }
+}
+async function removeEmptyDirectoriesUpward(fromDir, stopDir) {
+    let current = fromDir;
+    const normalizedStop = path.resolve(stopDir);
+    while (path.resolve(current).startsWith(normalizedStop)) {
+        if (path.resolve(current) === normalizedStop)
+            return;
+        try {
+            const entries = await fs_1.promises.readdir(current);
+            if (entries.length > 0)
+                return;
+            await fs_1.promises.rmdir(current);
+        }
+        catch {
+            return;
+        }
+        current = path.dirname(current);
+    }
+}
+async function writeManifest(projectRoot, manifest) {
+    const manifestPath = path.join(projectRoot, SYNC_MANIFEST_RELATIVE_PATH);
+    await fs_1.promises.mkdir(path.dirname(manifestPath), { recursive: true });
+    await fs_1.promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+}
+async function syncProjectFiles(projectRoot) {
+    const config = await (0, ConfigLoader_1.loadConfig)({ projectRoot });
+    if (!config.sync) {
+        return {
+            applied: false,
+            synced: [],
+            removed: [],
+            removedNativeLockSkills: [],
+            removedAgentLockSkills: [],
+        };
+    }
+    const sync = config.sync;
+    if (!(await pathExists(sync.source))) {
+        throw new Error(`[skiller] Sync source '${sync.source}' does not exist.`);
+    }
+    const sourceStat = await fs_1.promises.stat(sync.source);
+    if (!sourceStat.isDirectory()) {
+        throw new Error(`[skiller] Sync source '${sync.source}' must be a directory.`);
+    }
+    const previousManifest = await readManifest(projectRoot);
+    const previousNativeLockNames = await readLockSkillNames(path.join(projectRoot, 'skills-lock.json'));
+    const previousAgentLockNames = await readLockSkillNames(path.join(projectRoot, 'skiller-lock.json'));
+    const mode = await detectSyncMode(sync);
+    const selectedFiles = await selectSyncFiles(sync.source, mode, sync);
+    const nextFiles = {};
+    const synced = [];
+    for (const relativePath of selectedFiles) {
+        const sourcePath = path.join(sync.source, relativePath);
+        const targetPath = path.join(projectRoot, relativePath);
+        const content = await fs_1.promises.readFile(sourcePath);
+        const hash = hashBuffer(content);
+        await fs_1.promises.mkdir(path.dirname(targetPath), { recursive: true });
+        await fs_1.promises.writeFile(targetPath, content);
+        nextFiles[relativePath] = hash;
+        synced.push(relativePath);
+    }
+    const removed = [];
+    if (sync.clean && previousManifest) {
+        for (const relativePath of Object.keys(previousManifest.files)) {
+            if (nextFiles[relativePath])
+                continue;
+            const targetPath = path.join(projectRoot, relativePath);
+            await fs_1.promises.rm(targetPath, { force: true });
+            await removeEmptyDirectoriesUpward(path.dirname(targetPath), projectRoot);
+            removed.push(relativePath);
+        }
+    }
+    const manifest = {
+        version: 1,
+        source: sync.source,
+        mode,
+        files: nextFiles,
+        mergedConfigSourceHash: await readMergedConfigSourceHash(sync.source),
+    };
+    await writeManifest(projectRoot, manifest);
+    const currentNativeLockNames = nextFiles['skills-lock.json'] || removed.includes('skills-lock.json')
+        ? await readLockSkillNames(path.join(projectRoot, 'skills-lock.json'))
+        : previousNativeLockNames;
+    const currentAgentLockNames = nextFiles['skiller-lock.json'] || removed.includes('skiller-lock.json')
+        ? await readLockSkillNames(path.join(projectRoot, 'skiller-lock.json'))
+        : previousAgentLockNames;
+    return {
+        applied: true,
+        source: sync.source,
+        mode,
+        synced: synced.sort((a, b) => a.localeCompare(b)),
+        removed: removed.sort((a, b) => a.localeCompare(b)),
+        removedNativeLockSkills: previousNativeLockNames
+            .filter((name) => !currentNativeLockNames.includes(name))
+            .sort((a, b) => a.localeCompare(b)),
+        removedAgentLockSkills: previousAgentLockNames
+            .filter((name) => !currentAgentLockNames.includes(name))
+            .sort((a, b) => a.localeCompare(b)),
+    };
+}

package/dist/core/UnifiedConfigLoader.js

@@ -34,7 +34,6 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadUnifiedConfig = loadUnifiedConfig;
-const toml_1 = require("@iarna/toml");
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const FileSystemUtils = __importStar(require("./FileSystemUtils"));
@@ -42,6 +41,7 @@ const FileSystemUtils_1 = require("./FileSystemUtils");
 const hash_1 = require("./hash");
 const RuleProcessor_1 = require("./RuleProcessor");
 const project_paths_1 = require("./project-paths");
+const ConfigLoader_1 = require("./ConfigLoader");
 /**
  * Expand environment variables in a string.
  * Supports ${VAR} syntax, replacing with process.env[VAR] or empty string if not found.
@@ -66,27 +66,15 @@ async function loadUnifiedConfig(options) {
         version: '0.0.0-dev',
     };
     const diagnostics = [];
-    // Read TOML if available
+    // Read merged TOML if available, including optional sync base inheritance.
     let tomlRaw = {};
-    const tomlFile = options.configPath
-        ? path.resolve(options.configPath)
-        : path.join(meta.skillerDir, project_paths_1.SKILLER_CONFIG_FILE);
-    try {
-        const text = await fs_1.promises.readFile(tomlFile, 'utf8');
-        tomlRaw = text.trim() ? (0, toml_1.parse)(text) : {};
-        meta.configFile = tomlFile;
-    }
-    catch (err) {
-        if (err.code !== 'ENOENT') {
-            diagnostics.push({
-                severity: 'warning',
-                code: 'TOML_READ_ERROR',
-                message: 'Failed to read skiller.toml',
-                file: tomlFile,
-                detail: err.message,
-            });
-        }
-    }
+    const rawConfig = await (0, ConfigLoader_1.loadRawConfig)({
+        projectRoot: options.projectRoot,
+        configPath: options.configPath,
+    });
+    const tomlFile = rawConfig.configFile;
+    tomlRaw = rawConfig.raw;
+    meta.configFile = tomlFile;
     let defaultAgents;
     if (tomlRaw &&
         typeof tomlRaw === 'object' &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skiller",
-  "version": "0.9.10",
+  "version": "0.9.12",
   "description": "Skiller — apply the same rules to all coding agents",
   "main": "dist/lib.js",
   "publishConfig": {