@lidtop/loadout 0.1.0

package/dist/resolve.js

@@ -0,0 +1,80 @@
+import { validAnswer, } from './schema.js';
+export function resolveKits(catalog, selected) {
+    const done = new Set();
+    const visiting = [];
+    const visit = (id) => {
+        if (done.has(id))
+            return;
+        if (visiting.includes(id))
+            throw new Error(`Dependency cycle: ${[...visiting, id].join(' -> ')}`);
+        const kit = catalog.kits.get(id);
+        if (!kit)
+            throw new Error(`Unknown kit: ${id}${visiting.length ? ` (required by ${visiting.at(-1)})` : '. Remove it with loadout disable if it was deleted from the catalog.'}`);
+        if (kit.ready === false)
+            throw new Error(`${id} needs setup before it can be selected. Edit its kit.yaml and set ready: true.`);
+        visiting.push(id);
+        for (const required of [...kit.requires].sort())
+            visit(required);
+        visiting.pop();
+        done.add(id);
+    };
+    for (const id of [...new Set(selected)].sort())
+        visit(id);
+    return [...done];
+}
+export function reasons(catalog, selected, target) {
+    return [...new Set(selected)]
+        .sort()
+        .filter((id) => id !== target && resolveKits(catalog, [id]).includes(target));
+}
+export function disableKits(catalog, selected, target, cascade) {
+    // A removed catalog kit can still be deselected to recover saved state.
+    const dependents = reasons(catalog, selected.filter((id) => catalog.kits.has(id)), target);
+    if (dependents.length && !cascade)
+        throw new Error(`${target} is required by: ${dependents.join(', ')}. Use --cascade to disable those selections too.`);
+    return selected.filter((id) => id !== target && (!cascade || !dependents.includes(id)));
+}
+export async function configure(catalog, state, ask) {
+    const next = structuredClone(state);
+    next.selected = [...new Set(next.selected)].sort();
+    for (const id of resolveKits(catalog, next.selected)) {
+        for (const [key, question] of Object.entries(catalog.kits.get(id).questions).sort(([a], [b]) => a.localeCompare(b))) {
+            if (!Object.hasOwn(next.answers, id))
+                next.answers[id] = {};
+            const saved = Object.hasOwn(next.answers[id], key)
+                ? next.answers[id][key]
+                : undefined;
+            let answer = saved ?? question.default;
+            if (ask)
+                answer = await ask(id, key, question, validAnswer(question, answer) ? answer : undefined);
+            if (!validAnswer(question, answer))
+                throw new Error(`${id}.${key}: ${answer === undefined ? 'missing required answer' : 'invalid saved answer'}. Run loadout or pass --answer ${id}.${key}=VALUE.`);
+            next.answers[id][key] = answer;
+        }
+    }
+    return next;
+}
+export function setAnswers(catalog, state, values) {
+    for (const value of values) {
+        const match = /^([a-z0-9-]+)\.([a-z0-9-]+)=(.*)$/.exec(value);
+        if (!match)
+            throw new Error(`Invalid answer ${value}; expected kit.question=value`);
+        const id = match[1], key = match[2], raw = match[3];
+        const questions = catalog.kits.get(id)?.questions;
+        const q = questions && Object.hasOwn(questions, key) ? questions[key] : undefined;
+        if (!q)
+            throw new Error(`Unknown question: ${id}.${key}`);
+        const answer = q.type === 'boolean'
+            ? raw === 'true'
+                ? true
+                : raw === 'false'
+                    ? false
+                    : raw
+            : raw;
+        if (!validAnswer(q, answer))
+            throw new Error(`Invalid answer for ${id}.${key}: ${raw}`);
+        if (!Object.hasOwn(state.answers, id))
+            state.answers[id] = {};
+        state.answers[id][key] = answer;
+    }
+}

package/dist/retry.d.ts

@@ -0,0 +1,4 @@
+export declare class DownloadCancelledError extends Error {
+    constructor();
+}
+export declare function retryDownload<T>(attempt: () => Promise<T>, retry?: (error: Error) => Promise<boolean>, onRetry?: () => void): Promise<T>;

package/dist/retry.js

@@ -0,0 +1,26 @@
+export class DownloadCancelledError extends Error {
+    constructor() {
+        super('Cancelled. No kit selections or agent outputs saved.');
+        this.name = 'DownloadCancelledError';
+    }
+}
+export async function retryDownload(attempt, retry, onRetry) {
+    for (;;) {
+        for (let tries = 0; tries < 2; tries++) {
+            try {
+                return await attempt();
+            }
+            catch (failure) {
+                const error = failure instanceof Error ? failure : new Error(String(failure));
+                if (tries === 0) {
+                    onRetry?.();
+                    continue;
+                }
+                if (!retry)
+                    throw error;
+                if (!(await retry(error)))
+                    throw new DownloadCancelledError();
+            }
+        }
+    }
+}

package/dist/schema.d.ts

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+export declare const idSchema: z.ZodString;
+export declare const agents: readonly ['codex', 'claude'];
+export declare const relativePath: z.ZodString;
+export declare const scopeSchema: z.ZodString;
+declare const question: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"boolean">;
+    message: z.ZodString;
+    default: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"choice">;
+    message: z.ZodString;
+    choices: z.ZodArray<z.ZodString>;
+    default: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "type">;
+export declare const kitSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    description: z.ZodString;
+    ready: z.ZodOptional<z.ZodBoolean>;
+    requires: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    questions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"boolean">;
+        message: z.ZodString;
+        default: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"choice">;
+        message: z.ZodString;
+        choices: z.ZodArray<z.ZodString>;
+        default: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "type">>>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"instructions">;
+        source: z.ZodString;
+        scope: z.ZodDefault<z.ZodString>;
+        when: z.ZodOptional<z.ZodObject<{
+            answer: z.ZodString;
+            equals: z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"skill">;
+        source: z.ZodString;
+        when: z.ZodOptional<z.ZodObject<{
+            answer: z.ZodString;
+            equals: z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "type">>>;
+}, z.core.$strict>;
+export declare const externalSourceSchema: z.ZodObject<{
+    repo: z.ZodString;
+    ref: z.ZodString;
+    skills: z.ZodArray<z.ZodString>;
+    license: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export declare const externalKitSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    source: z.ZodObject<{
+        repo: z.ZodString;
+        ref: z.ZodString;
+        skills: z.ZodArray<z.ZodString>;
+        license: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ExternalSource = z.infer<typeof externalSourceSchema>;
+export type ExternalKit = z.infer<typeof externalKitSchema>;
+export declare const configSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    curated: z.ZodDefault<z.ZodBoolean>;
+    externalKits: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        source: z.ZodObject<{
+            repo: z.ZodString;
+            ref: z.ZodString;
+            skills: z.ZodArray<z.ZodString>;
+            license: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const stateSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    selected: z.ZodArray<z.ZodString>;
+    answers: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>>;
+}, z.core.$strict>;
+export declare const ownedSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    files: z.ZodRecord<z.ZodString, z.ZodObject<{
+        hash: z.ZodString;
+        mode: z.ZodUnion<readonly [z.ZodLiteral<420>, z.ZodLiteral<493>]>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Question = z.infer<typeof question>;
+export type Answer = boolean | string;
+export type State = z.infer<typeof stateSchema>;
+export type Kit = z.infer<typeof kitSchema> & {
+    directory: string;
+    external?: ExternalSource;
+    pinned?: ExternalSource;
+    origin?: 'curated' | 'external' | 'bundled';
+};
+export type Catalog = {
+    root: string;
+    kits: Map<string, Kit>;
+    global?: boolean;
+};
+export declare function validAnswer(q: Question, value: unknown): value is Answer;
+export declare function parse<T>(schema: z.ZodType<T>, value: unknown, label: string): T;
+export declare function kitSource(kit: Kit): string;
+export declare function sameSource(a: ExternalSource, b: ExternalSource): boolean;
+export {};

package/dist/schema.js

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+export const idSchema = z
+    .string()
+    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'Use lowercase words separated by hyphens');
+export const agents = ['codex', 'claude'];
+export const relativePath = z
+    .string()
+    .min(1)
+    .refine((p) => p === '.' ||
+    (!p.startsWith('/') &&
+        !/[\\:\x00-\x1f*?\[\]!#]/.test(p) &&
+        p
+            .split('/')
+            .every((s) => s !== '..' && s !== '.' && s !== '' && !s.endsWith(' '))), 'Use a relative path without traversal, glob characters, or backslashes');
+export const scopeSchema = relativePath.refine((p) => !p
+    .split('/')
+    .some((s) => ['.git', '.loadout', '.agents', '.claude', '.codex'].includes(s)), 'Scope must be a repository directory outside configuration directories');
+const condition = z
+    .object({ answer: idSchema, equals: z.union([z.boolean(), z.string()]) })
+    .strict();
+const question = z.discriminatedUnion('type', [
+    z
+        .object({
+        type: z.literal('boolean'),
+        message: z.string().min(1),
+        default: z.boolean().optional(),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal('choice'),
+        message: z.string().min(1),
+        choices: z.array(z.string().min(1)).min(1),
+        default: z.string().optional(),
+    })
+        .strict(),
+]);
+const output = z.discriminatedUnion('type', [
+    z
+        .object({
+        type: z.literal('instructions'),
+        source: relativePath,
+        scope: scopeSchema.default('.'),
+        when: condition.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        type: z.literal('skill'),
+        source: relativePath,
+        when: condition.optional(),
+    })
+        .strict(),
+]);
+export const kitSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    id: idSchema,
+    description: z.string().min(1),
+    ready: z.boolean().optional(),
+    requires: z.array(idSchema).default([]),
+    questions: z.record(idSchema, question).default({}),
+    outputs: z.array(output).default([]),
+})
+    .strict()
+    .refine((kit) => kit.ready === false || kit.outputs.length > 0, {
+    message: 'Ready kits need at least one output',
+    path: ['outputs'],
+});
+export const externalSourceSchema = z
+    .object({
+    repo: z
+        .string()
+        .regex(/^[A-Za-z0-9][A-Za-z0-9_.-]*\/[A-Za-z0-9][A-Za-z0-9_.-]*$/, 'Use owner/repository'),
+    ref: z
+        .string()
+        .regex(/^[a-f0-9]{40}$/, 'Use a full 40-character Git commit SHA'),
+    skills: z
+        .array(relativePath.refine((p) => p !== '.' && idSchema.safeParse(p.split('/').at(-1)).success, 'Use a skill directory with a lowercase name'))
+        .min(1)
+        .max(20),
+    license: relativePath.default('LICENSE'),
+})
+    .strict();
+export const externalKitSchema = z
+    .object({
+    id: idSchema,
+    description: z.string().min(1),
+    source: externalSourceSchema,
+})
+    .strict();
+export const configSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    curated: z.boolean().default(true),
+    externalKits: z.array(externalKitSchema).default([]),
+})
+    .strict();
+export const stateSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    selected: z.array(idSchema),
+    answers: z.record(idSchema, z.record(idSchema, z.union([z.boolean(), z.string()]))),
+})
+    .strict();
+export const ownedSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    files: z.record(z.string(), z
+        .object({
+        hash: z.string().regex(/^[a-f0-9]{64}$/),
+        mode: z.union([z.literal(420), z.literal(493)]),
+    })
+        .strict()),
+})
+    .strict();
+export function validAnswer(q, value) {
+    return q.type === 'boolean'
+        ? typeof value === 'boolean'
+        : typeof value === 'string' && q.choices.includes(value);
+}
+export function parse(schema, value, label) {
+    const result = schema.safeParse(value);
+    if (!result.success)
+        throw new Error(`${label}: ${result.error.issues.map((i) => `${i.path.join('.') || 'value'}: ${i.message}`).join('; ')}`);
+    return result.data;
+}
+export function kitSource(kit) {
+    return kit.origin === 'bundled'
+        ? 'loadout'
+        : ((kit.pinned ?? kit.external)?.repo ?? 'Repository');
+}
+export function sameSource(a, b) {
+    return (a.repo === b.repo &&
+        a.ref === b.ref &&
+        a.license === b.license &&
+        JSON.stringify([...a.skills].sort()) ===
+            JSON.stringify([...b.skills].sort()));
+}

package/dist/storage.d.ts

@@ -0,0 +1,27 @@
+import { type Catalog, type State } from './schema.js';
+import { type FileContent, type Rendered } from './render.js';
+export type Change = {
+    path: string;
+    before?: FileContent;
+    after?: FileContent;
+    kind: 'create' | 'update' | 'delete' | 'unchanged';
+};
+export type Plan = {
+    root: string;
+    changes: Change[];
+    adopted?: string[];
+    guard?: {
+        untracked: string[];
+        directories: {
+            path: string;
+            files: string[];
+        }[];
+    };
+};
+export declare function loadState(catalog: Catalog): State;
+export declare function ignoredText(original: string, paths: string[]): string;
+export declare function plan(catalog: Catalog, state: State, rendered: Rendered, options?: {
+    adopt?: boolean;
+}): Plan;
+export declare function apply(plan: Plan): number;
+export declare function applyAll(plans: Plan[]): number;

package/dist/storage.js

@@ -0,0 +1,298 @@
+import fs from 'node:fs';
+import { isOutput } from './output-path.js';
+import { prepareAdoption } from './adoption.js';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { exists, json, readOptional, safePath, walk, portableMode, } from './fs.js';
+import { parse, ownedSchema, stateSchema, } from './schema.js';
+const start = '# >>> loadout';
+const end = '# <<< loadout';
+const hash = (content) => createHash('sha256').update(content).digest('hex');
+export function loadState(catalog) {
+    const raw = readOptional(catalog.root, '.loadout/local.json');
+    return raw
+        ? parse(stateSchema, JSON.parse(raw.toString()), '.loadout/local.json')
+        : { schemaVersion: 1, selected: [], answers: {} };
+}
+function snapshot(root, relative) {
+    const content = readOptional(root, relative);
+    return content === undefined
+        ? undefined
+        : {
+            content,
+            mode: portableMode(fs.statSync(safePath(root, relative)).mode),
+        };
+}
+function equal(a, b) {
+    return a === undefined || b === undefined
+        ? a === b
+        : a.mode === b.mode && a.content.equals(b.content);
+}
+export function ignoredText(original, paths) {
+    const lines = original.split(/\r?\n/);
+    const first = lines.indexOf(start), last = lines.indexOf(end);
+    if (first < 0 !== last < 0 ||
+        last < first ||
+        lines.filter((l) => l === start).length > 1 ||
+        lines.filter((l) => l === end).length > 1)
+        throw new Error('Malformed Loadout block in .gitignore; repair its markers before applying.');
+    if (first >= 0)
+        lines.splice(first, last - first + 1);
+    const base = lines.join('\n').replace(/\n*$/, '');
+    // Escape gitignore metacharacters so these patterns own only exact paths.
+    const escape = (p) => p.replace(/[\\*?\[\]#! ]/g, '\\$&');
+    return `${base ? `${base}\n\n` : ''}${start}\n${[
+        ...new Set([
+            '.loadout/local.json',
+            '.loadout/generated.json',
+            '.loadout/external.json',
+            '.loadout/adopted.json',
+            '.loadout/adopted/',
+            '.loadout/apply.lock/',
+            ...paths,
+        ]),
+    ]
+        .sort()
+        .map((p) => `/${escape(p)}`)
+        .join('\n')}\n${end}\n`;
+}
+function trackedFiles(root) {
+    try {
+        return new Set(execFileSync('git', ['-C', root, 'ls-files', '-z'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        })
+            .split('\0')
+            .filter(Boolean));
+    }
+    catch (error) {
+        const e = error;
+        if (e.code === 'ENOENT' ||
+            e.stderr?.toString().includes('not a git repository'))
+            return new Set();
+        throw new Error(`Cannot check Git-tracked files: ${e.message}`);
+    }
+}
+export function plan(catalog, state, rendered, options = {}) {
+    const root = catalog.root;
+    const raw = readOptional(root, '.loadout/generated.json');
+    const owned = raw
+        ? parse(ownedSchema, JSON.parse(raw.toString()), '.loadout/generated.json')
+            .files
+        : {};
+    const adoption = prepareAdoption(root, rendered, owned, !!catalog.global, !!options.adopt);
+    rendered = { ...rendered, files: adoption.files };
+    const paths = [
+        ...new Set([...Object.keys(owned), ...rendered.files.keys()]),
+    ].sort();
+    const tracked = trackedFiles(root);
+    for (const local of [
+        '.loadout/local.json',
+        '.loadout/generated.json',
+        '.loadout/external.json',
+        '.loadout/adopted.json',
+        ...adoption.beforeOutputs.map((change) => change.path),
+        ...adoption.afterOutputs.map((change) => change.path),
+    ])
+        if (tracked.has(local))
+            throw new Error(`${local} is tracked by Git. Untrack personal state before applying.`);
+    const changes = [...adoption.beforeOutputs];
+    for (const relative of paths) {
+        if (!isOutput(relative, catalog.global))
+            throw new Error(`Invalid generated ownership path: ${relative}`);
+        if (tracked.has(relative))
+            throw new Error(`Refusing to manage Git-tracked file: ${relative}. Move its content into a kit and untrack it first.`);
+        const before = snapshot(root, relative), after = rendered.files.get(relative), previous = owned[relative];
+        if (before &&
+            !previous &&
+            adoption.adopted.includes(relative) &&
+            !equal(before, adoption.originals.get(relative)))
+            throw new Error(`File changed while preparing adoption: ${relative}`);
+        if (before && !previous && !adoption.adopted.includes(relative))
+            throw new Error(`Unmanaged file already exists: ${relative}. Run loadout to preserve existing content, or preview with --adopt --dry-run.`);
+        if (before &&
+            previous &&
+            (hash(before.content) !== previous.hash || before.mode !== previous.mode))
+            throw new Error(`Generated file was manually modified: ${relative}. Move your edits into a kit, then restore or remove the generated file before applying.`);
+        changes.push({
+            path: relative,
+            before,
+            after,
+            kind: equal(before, after)
+                ? 'unchanged'
+                : !before
+                    ? 'create'
+                    : !after
+                        ? 'delete'
+                        : 'update',
+        });
+    }
+    for (const skill of rendered.skillRoots) {
+        if (exists(safePath(root, skill)) &&
+            ![...Object.keys(owned), ...adoption.adopted].some((p) => p.startsWith(`${skill}/`)))
+            throw new Error(`Unmanaged skill directory already exists: ${skill}`);
+    }
+    const files = Object.fromEntries([...rendered.files]
+        .filter(([p]) => !adoption.released.has(p))
+        .map(([p, f]) => [p, { hash: hash(f.content), mode: f.mode }]));
+    const metadata = new Map([
+        ['.loadout/local.json', json(state)],
+        ['.loadout/generated.json', json({ schemaVersion: 1, files })],
+        [
+            '.gitignore',
+            Buffer.from(ignoredText(readOptional(root, '.gitignore')?.toString() ?? '', [
+                ...Object.keys(files),
+            ])),
+        ],
+    ]);
+    if (rendered.external) {
+        const current = readOptional(root, '.loadout/external.json');
+        if (current === undefined
+            ? rendered.external.before !== undefined
+            : !rendered.external.before?.equals(current))
+            throw new Error('External snapshots changed while preparing the preview. Run the command again.');
+        metadata.set('.loadout/external.json', rendered.external.content);
+    }
+    changes.push(...adoption.afterOutputs);
+    for (const [relative, content] of metadata) {
+        const before = snapshot(root, relative), after = { content, mode: before?.mode ?? 0o644 };
+        changes.push({
+            path: relative,
+            before,
+            after,
+            kind: equal(before, after) ? 'unchanged' : before ? 'update' : 'create',
+        });
+    }
+    return {
+        root,
+        changes,
+        adopted: adoption.adopted,
+        guard: {
+            untracked: changes
+                .filter((change) => change.path !== '.gitignore')
+                .map((change) => change.path),
+            directories: [...rendered.skillRoots]
+                .filter((skill) => adoption.adopted.some((file) => file.startsWith(`${skill}/`)))
+                .map((skill) => ({
+                path: skill,
+                files: [...rendered.files.keys()]
+                    .filter((file) => file.startsWith(`${skill}/`))
+                    .map((file) => file.slice(skill.length + 1))
+                    .sort(),
+            })),
+        },
+    };
+}
+function writeAtomic(root, relative, file) {
+    const target = safePath(root, relative);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const temp = path.join(path.dirname(target), `.loadout-${randomUUID()}.tmp`);
+    try {
+        fs.writeFileSync(temp, file.content, { flag: 'wx', mode: file.mode });
+        fs.chmodSync(temp, file.mode);
+        fs.renameSync(temp, target);
+    }
+    finally {
+        if (exists(temp))
+            fs.unlinkSync(temp);
+    }
+}
+function prune(root, relative) {
+    // Repository scopes and agent configuration roots may predate Loadout.
+    // Only prune empty skill directories and internal adoption backups.
+    const boundary = /^(\.(?:agents|claude)\/skills)\//.exec(relative)?.[1] ??
+        (relative.startsWith('.loadout/adopted/') ? '.loadout' : undefined);
+    if (!boundary)
+        return;
+    const stop = safePath(root, boundary);
+    let directory = path.dirname(safePath(root, relative));
+    while (directory !== stop) {
+        try {
+            fs.rmdirSync(directory);
+        }
+        catch {
+            break;
+        }
+        directory = path.dirname(directory);
+    }
+}
+export function apply(plan) {
+    return applyAll([plan]);
+}
+export function applyAll(plans) {
+    if (new Set(plans.map((plan) => plan.root)).size !== plans.length)
+        throw new Error('Cannot apply multiple plans for the same location.');
+    const locks = [];
+    const written = [];
+    try {
+        for (const plan of [...plans].sort((a, b) => a.root.localeCompare(b.root))) {
+            const lock = safePath(plan.root, '.loadout/apply.lock');
+            try {
+                fs.mkdirSync(lock);
+            }
+            catch (error) {
+                if (error.code === 'EEXIST')
+                    throw new Error('Another apply is running (or a previous process stopped). Remove .loadout/apply.lock only after confirming no Loadout process is running.');
+                throw error;
+            }
+            locks.push(lock);
+        }
+        // Recheck every location before writing to any of them.
+        for (const plan of plans) {
+            if (!plan.guard)
+                continue;
+            const tracked = trackedFiles(plan.root);
+            for (const file of plan.guard.untracked)
+                if (tracked.has(file))
+                    throw new Error(`File became Git-tracked since preview: ${file}`);
+            for (const directory of plan.guard.directories) {
+                const current = walk(safePath(plan.root, directory.path)).sort();
+                if (JSON.stringify(current) !== JSON.stringify(directory.files))
+                    throw new Error(`Skill directory changed since preview: ${directory.path}`);
+            }
+        }
+        for (const plan of plans)
+            for (const change of plan.changes)
+                if (!equal(snapshot(plan.root, change.path), change.before))
+                    throw new Error(`File changed since preview: ${change.path}. Run the command again.`);
+        for (const plan of plans) {
+            for (const change of plan.changes) {
+                if (change.kind === 'unchanged')
+                    continue;
+                if (change.after)
+                    writeAtomic(plan.root, change.path, change.after);
+                else
+                    fs.unlinkSync(safePath(plan.root, change.path));
+                written.push({ root: plan.root, change });
+            }
+        }
+    }
+    catch (error) {
+        const failures = [];
+        for (const { root, change } of written.reverse()) {
+            try {
+                if (change.before)
+                    writeAtomic(root, change.path, change.before);
+                else {
+                    fs.unlinkSync(safePath(root, change.path));
+                    prune(root, change.path);
+                }
+            }
+            catch {
+                failures.push(path.join(root, change.path));
+            }
+        }
+        if (failures.length)
+            throw new Error(`${error.message}; rollback failed for: ${failures.join(', ')}`);
+        throw error;
+    }
+    finally {
+        for (const lock of locks.reverse())
+            fs.rmdirSync(lock);
+    }
+    for (const { root, change } of written)
+        if (!change.after)
+            prune(root, change.path);
+    return written.length;
+}