@lidtop/loadout 0.3.1 → 0.4.0

package/README.md

@@ -2,6 +2,8 @@
 
 Choose agent skills and instructions for yourself or your team. Loadout configures Codex and Claude Code.
 
+[Watch the demo](demo.mp4)
+
 Private kits and selections live in `.loadout-personal/`, ignored by Git. Add reusable kits to `~/.loadout/kits/` and enable them per repository.
 
 ## Use it
@@ -13,13 +15,9 @@ npm install -g @lidtop/loadout
 loadout
 ```
 
-Pick your kits, select **Review changes**, and confirm. Inside a provider, choose **Back to providers** to keep browsing with your selections preserved. Run `loadout` again to change your selection.
-
-The destination selector above the tabs shows **Repository** in cyan (this repository only) and **Global** in magenta (your user configuration across repositories). Active controls and selection markers follow the destination's color. Press **Tab** to switch destinations instantly, or **Shift+Tab** to cycle backward. **←/→** switches between the Kits, Browse, and Installed sections. Each destination keeps its own selections, provider, search, and cursor position, ready to browse as soon as you switch. A **\*** marks destinations with unapplied selections; **Review changes** includes the session's changes across both. Descriptions appear beneath every provider and kit, with dependency or update notes when needed.
-
-Press **Esc** at a setup question or review prompt to return to the picker with your selections and position preserved. Press **Esc twice quickly** or **Ctrl+C** to cancel setup.
+Pick your kits, select **Review changes**, then **Apply changes**. Run `loadout` again to change your selection.
 
-Conflicting project instructions are skipped with a warning; the kit’s skills still install.
+Choose **Repository** for the current project or **Global** for your user configuration across repositories.
 
 ## Share kits with your team
 

package/dist/cli.js

@@ -5,10 +5,9 @@ import { readFileSync, realpathSync } from 'node:fs';
 import os from 'node:os';
 import { discover } from './catalog.js';
 import { initialize } from './init.js';
-import { interactive, confirmApply, selectUpdates, confirmRetry, confirmAdoption, } from './interactive.js';
-import { apply, applyAll, hasChanges, plan } from './storage.js';
+import { interactive } from './setup.js';
+import { apply, hasChanges, plan } from './storage.js';
 import { renderWithExternal } from './external.js';
-import { DownloadCancelledError } from './retry.js';
 import { loadTarget } from './targets.js';
 import { configure, disableKits, reasons, resolveKits, setAnswers, } from './resolve.js';
 import { kitSource } from './schema.js';
@@ -134,54 +133,9 @@ async function generate(catalog, state, opts) {
 }
 async function setup() {
     const { targets, initial } = interactiveTargets();
-    await interactive(targets, initial, { review: reviewSelections });
-}
-async function reviewSelections(configured) {
     const offline = program.opts().offline;
-    const plans = [];
-    for (const { target, state } of configured) {
-        const catalog = target.catalog;
-        console.log(`\n${target.label} · ${target.root}`);
-        const update = await selectUpdates(catalog, state, offline);
-        const rendered = await renderWithExternal(catalog, state, {
-            offline,
-            update,
-            retry: confirmRetry,
-            onRetry: (id) => console.log(`Retrying ${id}…`),
-            onFetch: (id, source) => console.log(`Fetching ${id} from ${source.repo}…`),
-        });
-        for (const id of resolveKits(catalog, state.selected)) {
-            const kit = catalog.kits.get(id);
-            if (kit.external) {
-                const source = update.includes(id)
-                    ? kit.external
-                    : (kit.pinned ?? kit.external);
-                console.log(`${id}: ${source.repo}@${source.ref.slice(0, 12)} · license: ${source.license}`);
-            }
-        }
-        const result = plan(catalog, state, rendered, { adopt: true });
-        preview(result, update.length > 0 || !!result.adopted?.length);
-        if (result.adopted?.length && !(await confirmAdoption(result.adopted)))
-            throw new DownloadCancelledError();
-        plans.push(result);
-    }
-    if (!plans.some(hasChanges))
-        return;
-    const scopes = configured
-        .filter((_, index) => hasChanges(plans[index]))
-        .map(({ target }) => target.label);
-    if (await confirmApply(undefined, scopes)) {
-        applyAll(plans);
-        console.log('\nYour loadout is ready.');
-        for (const result of plans) {
-            if (!result.skippedInstructions?.length)
-                continue;
-            console.log(result.root);
-            showSkipped(result);
-        }
-    }
-    else
-        console.log('Cancelled. No kit selections or agent outputs saved.');
+    await interactive(targets, initial, { offline });
+    console.log('\nYour loadout is ready.');
 }
 program.action(setup);
 program

package/dist/external.d.ts

@@ -33,6 +33,7 @@ declare const storeSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type Snapshot = z.infer<typeof snapshotSchema>;
+export type SnapshotCache = Map<string, Snapshot>;
 export type ExternalStore = z.infer<typeof storeSchema>;
 export type FetchBytes = (url: string, limit: number, signal?: AbortSignal) => Promise<Buffer>;
 export declare function readExternal(root: string): {
@@ -47,5 +48,8 @@ export declare function renderWithExternal(catalog: Catalog, state: State, optio
     onFetch?: (id: string, source: ExternalSource) => void;
     onRetry?: (id: string) => void;
     retry?: (id: string, error: Error) => Promise<boolean>;
+    signal?: AbortSignal;
+    cache?: SnapshotCache;
+    onReady?: (id: string) => void;
 }): Promise<Rendered>;
 export {};

package/dist/external.js

@@ -30,6 +30,12 @@ const storeSchema = z
     kits: z.record(idSchema, snapshotSchema),
 })
     .strict();
+const sourceKey = (source) => JSON.stringify({
+    repo: source.repo,
+    ref: source.ref,
+    license: source.license,
+    skills: [...source.skills].sort(),
+});
 export function readExternal(root) {
     const raw = readOptional(root, '.loadout-personal/external.json');
     return {
@@ -215,6 +221,7 @@ async function download(source, get) {
     return complete;
 }
 export async function renderWithExternal(catalog, state, options = {}) {
+    options.signal?.throwIfAborted();
     const result = render(catalog, state);
     const enabled = resolveKits(catalog, state.selected);
     const { raw, store } = readExternal(catalog.root);
@@ -222,34 +229,46 @@ export async function renderWithExternal(catalog, state, options = {}) {
         if (!enabled.includes(id) || !catalog.kits.get(id)?.external)
             throw new Error(`Cannot update ${id}: choose an enabled external kit.`);
     for (const id of enabled) {
+        options.signal?.throwIfAborted();
         const kit = catalog.kits.get(id);
         const source = kit.external;
-        if (!source)
+        if (!source) {
+            options.onReady?.(id);
             continue;
+        }
         let snapshot = Object.hasOwn(store.kits, id) ? store.kits[id] : undefined;
         const unchanged = snapshot && sameSource(snapshot.source, source);
         if (!snapshot ||
             (options.update?.includes(id) && !(options.offline && unchanged))) {
-            if (options.offline)
+            const cached = options.cache?.get(sourceKey(source));
+            if (!cached && options.offline)
                 throw new Error(`${id} is not available at the requested revision offline. Run without --offline once to fetch it.`);
-            options.onFetch?.(id, source);
-            snapshot = await retryDownload(async () => {
-                const controller = new AbortController();
-                const requests = new Map();
-                const get = (url, limit) => {
-                    if (!requests.has(url))
-                        requests.set(url, (options.fetch ?? fetchBytes)(url, limit, controller.signal));
-                    return requests.get(url);
-                };
-                try {
-                    return await download(source, get);
-                }
-                finally {
-                    controller.abort();
-                    await Promise.allSettled(requests.values());
-                    requests.clear();
-                }
-            }, options.retry ? (error) => options.retry(id, error) : undefined, () => options.onRetry?.(id));
+            if (!cached)
+                options.onFetch?.(id, source);
+            snapshot =
+                cached ??
+                    (await retryDownload(async () => {
+                        const controller = new AbortController();
+                        const requests = new Map();
+                        const get = (url, limit) => {
+                            if (!requests.has(url))
+                                requests.set(url, (options.fetch ?? fetchBytes)(url, limit, options.signal
+                                    ? AbortSignal.any([options.signal, controller.signal])
+                                    : controller.signal));
+                            return requests.get(url);
+                        };
+                        try {
+                            return await download(source, get);
+                        }
+                        finally {
+                            controller.abort();
+                            await Promise.allSettled(requests.values());
+                            requests.clear();
+                        }
+                    }, options.retry ? (error) => options.retry(id, error) : undefined, () => options.onRetry?.(id), options.signal));
+            options.signal?.throwIfAborted();
+            validateSnapshot(snapshot, id);
+            options.cache?.set(sourceKey(source), snapshot);
             store.kits[id] = snapshot;
         }
         validateSnapshot(snapshot, id);
@@ -271,6 +290,7 @@ export async function renderWithExternal(catalog, state, options = {}) {
                 });
             }
         }
+        options.onReady?.(id);
     }
     if (raw || Object.keys(store.kits).length)
         result.external = {

package/dist/interactive.d.ts

@@ -1,15 +1,16 @@
 import { checkbox, confirm, select } from '@inquirer/prompts';
-import { type Catalog, type State } from './schema.js';
-import { type TargetSelection } from './picker.js';
+import { type Answer, type Catalog, type State } from './schema.js';
 import { type Target } from './targets.js';
-type PromptContext = NonNullable<Parameters<typeof confirm>[1]>;
-export declare function interactive(targets: Target[], initial?: number, options?: {
-    context?: PromptContext;
-    review?: (selections: TargetSelection[], context?: PromptContext) => Promise<void>;
-}): Promise<TargetSelection[]>;
-export declare function configureSelection(target: Target, state: State, context?: Parameters<typeof confirm>[1]): Promise<State>;
+export type PromptContext = NonNullable<Parameters<typeof confirm>[1]>;
+export declare class BackNavigation extends Error {
+}
+export declare function configureSelection(target: Target, state: State, context?: Parameters<typeof confirm>[1], onAnswer?: (kit: string, key: string, answer: Answer) => void): Promise<State>;
 export declare function confirmApply(context?: PromptContext, scopes?: string[]): Promise<boolean>;
-export declare function selectUpdates(catalog: Catalog, state: State, offline?: boolean, context?: Parameters<typeof checkbox>[1]): Promise<string[]>;
+export declare function selectUpdates(catalog: Catalog, state: State, offline?: boolean, context?: Parameters<typeof checkbox>[1], options?: {
+    message?: string;
+    selected?: string[];
+    quiet?: boolean;
+}): Promise<string[]>;
 export declare function confirmRetry(id: string, error: Error, context?: Parameters<typeof select>[1]): Promise<boolean>;
-export declare function confirmAdoption(paths: string[], context?: Parameters<typeof confirm>[1]): Promise<boolean>;
-export {};
+export declare function confirmAdoption(paths: string[], context?: Parameters<typeof confirm>[1], scope?: string): Promise<boolean>;
+export declare function retryReview(error: unknown, context?: PromptContext): Promise<boolean>;

package/dist/interactive.js

@@ -1,10 +1,9 @@
 import { checkbox, confirm, select } from '@inquirer/prompts';
 import { configure } from './resolve.js';
-import { validAnswer } from './schema.js';
-import { targetPicker, } from './picker.js';
+import { validAnswer, } from './schema.js';
 import { availableUpdates, updateDescription } from './updates.js';
 import { prepareInput } from './terminal.js';
-class BackToPicker extends Error {
+export class BackNavigation extends Error {
 }
 async function backPrompt(prompt, context = {}) {
     const input = context.input ?? process.stdin;
@@ -12,7 +11,7 @@ async function backPrompt(prompt, context = {}) {
     const controller = new AbortController();
     const back = (_text, key) => {
         if (key.name === 'escape')
-            controller.abort(new BackToPicker());
+            controller.abort(new BackNavigation());
     };
     input.on('keypress', back);
     try {
@@ -24,7 +23,7 @@ async function backPrompt(prompt, context = {}) {
         });
     }
     catch (error) {
-        if (error instanceof Error && error.cause instanceof BackToPicker)
+        if (error instanceof Error && error.cause instanceof BackNavigation)
             throw error.cause;
         throw error;
     }
@@ -32,30 +31,9 @@ async function backPrompt(prompt, context = {}) {
         input.off('keypress', back);
     }
 }
-export async function interactive(targets, initial = 0, options = {}) {
-    if (!options.context && (!process.stdin.isTTY || !process.stdout.isTTY))
-        throw new Error('Interactive setup needs a terminal. Use loadout enable <kit>, then loadout apply.');
-    const session = {};
-    for (;;) {
-        const chosen = await targetPicker({ targets, initial, session }, options.context);
-        try {
-            const configured = [];
-            for (const { target, state } of chosen) {
-                const value = await configureSelection(target, state, options.context);
-                configured.push({ target, state: value });
-            }
-            await options.review?.(configured, options.context);
-            return configured;
-        }
-        catch (error) {
-            if (!(error instanceof BackToPicker))
-                throw error;
-        }
-    }
-}
-export async function configureSelection(target, state, context) {
+export async function configureSelection(target, state, context, onAnswer) {
     const change = new Map();
-    return configure(target.catalog, state, async (kit, key, question, value) => {
+    const ask = async (kit, key, question, value) => {
         if (!change.has(kit)) {
             const hasSaved = Object.entries(target.catalog.kits.get(kit).questions).some(([name, q]) => validAnswer(q, state.answers[kit]?.[name]));
             change.set(kit, hasSaved
@@ -76,6 +54,11 @@ export async function configureSelection(target, state, context) {
             choices: question.choices.map((v) => ({ name: v, value: v })),
             default: typeof value === 'string' ? value : undefined,
         }, context), context);
+    };
+    return configure(target.catalog, state, async (kit, key, question, value) => {
+        const answer = await ask(kit, key, question, value);
+        onAnswer?.(kit, key, answer);
+        return answer;
     });
 }
 export async function confirmApply(context, scopes = []) {
@@ -86,20 +69,23 @@ export async function confirmApply(context, scopes = []) {
         default: true,
     }, context), context);
 }
-export async function selectUpdates(catalog, state, offline = false, context) {
+export async function selectUpdates(catalog, state, offline = false, context, options = {}) {
     const updates = availableUpdates(catalog, state.selected);
     if (!updates.length)
         return [];
     if (offline) {
-        console.log(`${updates.length} catalog update(s) available. Run loadout online to review them; keeping saved versions.`);
+        if (!options.quiet)
+            console.log(`${updates.length} catalog update(s) available. Run loadout online to review them; keeping saved versions.`);
         return [];
     }
     return backPrompt((context) => checkbox({
-        message: 'Catalog updates available · choose kits to update (Enter skips)',
+        message: options.message ??
+            'Catalog updates available · choose kits to update (Enter skips)',
         choices: updates.map((kit) => ({
             name: kit.id,
             value: kit.id,
             description: updateDescription(kit),
+            checked: options.selected?.includes(kit.id) ?? false,
         })),
         required: false,
     }, context), context);
@@ -113,9 +99,25 @@ export async function confirmRetry(id, error, context) {
         ],
     }, context), context);
 }
-export async function confirmAdoption(paths, context) {
+export async function confirmAdoption(paths, context, scope) {
     return backPrompt((context) => confirm({
-        message: `Keep existing content and let Loadout manage ${paths.join(', ')}? Originals will be restored when disabled.`,
+        message: `${scope ? `${scope} · ` : ''}Keep existing content and let Loadout manage ${paths.join(', ')}? Originals will be restored when disabled.`,
         default: true,
     }, context), context);
 }
+export async function retryReview(error, context) {
+    try {
+        return await backPrompt((context) => select({
+            message: `Could not finish: ${error instanceof Error ? error.message : String(error)}`,
+            choices: [
+                { name: 'Try again', value: true },
+                { name: 'Back to kits', value: false },
+            ],
+        }, context), context);
+    }
+    catch (failure) {
+        if (failure instanceof BackNavigation)
+            return false;
+        throw failure;
+    }
+}

package/dist/picker.js

@@ -11,6 +11,11 @@ const muted = (value) => styleText('dim', value);
 const bold = (value) => styleText('bold', value);
 const scopeColor = (target, value) => styleText(target.global ? 'magenta' : 'cyan', value);
 const clean = (value) => stripVTControlCharacters(value).replace(/[\x00-\x1f\x7f]/g, ' ');
+function installationTime(value) {
+    const date = new Date(value);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
 function fit(value, width) {
     const text = clean(value);
     if (stringWidth(text) <= width)
@@ -182,13 +187,16 @@ const renderPicker = createPrompt((config, done) => {
             if (section === 'Kits')
                 return !providerFor(kit);
             if (section === 'Installed')
-                return (!!providerFor(kit) &&
-                    (!!kit.pinned ||
-                        enabledSet.has(kit.id) ||
-                        installedSet.has(kit.id)));
+                return installedSet.has(kit.id);
             return providerFor(kit) === provider;
         })
-            .sort((a, b) => Number(a.ready === false) - Number(b.ready === false))
+            .sort((a, b) => {
+            if (section === 'Installed') {
+                const time = (id) => target.installedAt?.[id] ? Date.parse(target.installedAt[id]) : 0;
+                return time(b.id) - time(a.id);
+            }
+            return Number(a.ready === false) - Number(b.ready === false);
+        })
             .map((kit) => ({ id: kit.id, description: kit.description, kit }));
     }
     if (provider)
@@ -352,7 +360,7 @@ const renderPicker = createPrompt((config, done) => {
             ...wordmark(width, height, accent),
             `  ${accent('✓')} ${selected.length} selected${requiredCount ? muted(` · ${requiredCount} required`) : ''}\n`,
         ].join('\n');
-    const updates = availableUpdates(catalog).length;
+    const updates = availableUpdates(catalog, selected).length;
     const counts = `${selected.length} selected${requiredCount ? ` · ${requiredCount} required` : ''}`;
     const tabLabel = (name) => name === 'Browse' && provider ? `Browse › ${clean(provider)}` : name;
     const inlineProvider = !!provider && sections.map(tabLabel).join('    ').length + 2 <= width - 2;
@@ -421,7 +429,8 @@ const renderPicker = createPrompt((config, done) => {
     const spacing = height - beforeList.length - footerHeight >= 8 ? 1 : 0;
     if (spacing)
         beforeList.push('');
-    const pageSize = Math.max(1, Math.min(8, Math.floor((height - beforeList.length - footerHeight) / 2)));
+    const pageSize = Math.max(1, Math.min(8, Math.floor((height - beforeList.length - footerHeight) /
+        (section === 'Installed' ? 3 : 2))));
     const listEntries = entries.filter((row) => !row.action);
     const listCursor = Math.min(cursor, Math.max(0, listEntries.length - 1));
     const start = Math.max(0, Math.min(listCursor - Math.floor(pageSize / 2), listEntries.length - pageSize));
@@ -472,6 +481,13 @@ const renderPicker = createPrompt((config, done) => {
         const name = fit(displayName(row.id), width - label.length - 9);
         const gap = ' '.repeat(Math.max(2, width - stringWidth(name) - label.length - 6));
         lines.push(`  ${focus ? accent('›') : ' '} ${marker} ${row.kit?.ready === false ? muted(name) : focus ? bold(name) : name}${gap}${badge}`, `      ${muted(fit(row.kit && section === 'Installed' ? `${kitSource(row.kit)} · ${row.description}` : row.description, width - 6))}`);
+        if (section === 'Installed' && row.kit) {
+            const timestamp = target.installedAt?.[row.id];
+            const installed = timestamp
+                ? `Installed ${installationTime(timestamp)}`
+                : 'Installed';
+            lines.push(`      ${muted(fit(installed, width - 6))}`);
+        }
     }
     if (!page.length) {
         const empty = !catalog.kits.size

package/dist/prepare.d.ts

@@ -0,0 +1,10 @@
+import { type PromptContext } from './interactive.js';
+import { type ReviewTarget, type PreparedTarget } from './review.js';
+type Progress = (scope: number, message: string) => void;
+type Retry = (scope: number, id: string, error: Error) => Promise<boolean>;
+type Config = {
+    selections: ReviewTarget[];
+    run: (progress: Progress, retry: Retry, signal: AbortSignal) => Promise<PreparedTarget[]>;
+};
+export declare function prepareScreen(config: Config, context?: PromptContext): Promise<PreparedTarget[]>;
+export {};

package/dist/prepare.js

@@ -0,0 +1,92 @@
+import { createPrompt, isEnterKey, useEffect, useKeypress, useRef, useState, } from '@inquirer/core';
+import { styleText } from 'node:util';
+import { BackNavigation } from './interactive.js';
+import { wrapReviewText, } from './review.js';
+// A single live screen owns all network activity, including retry decisions.
+const progressScreen = createPrompt((config, done) => {
+    const [statuses, setStatuses] = useState(config.selections.map(() => 'Waiting'));
+    const [failure, setFailure] = useState();
+    const [active, setActive] = useState(0);
+    const [visible, setVisible] = useState(false);
+    const controller = useRef(new AbortController());
+    const pending = useRef(undefined);
+    useEffect(() => {
+        let mounted = true;
+        // Cached and local kits go straight to review without flashing a screen.
+        const timer = setTimeout(() => setVisible(true), 150);
+        const signal = controller.current.signal;
+        const progress = (scope, message) => {
+            if (mounted)
+                setStatuses((previous) => previous.map((value, index) => (index === scope ? message : value)));
+        };
+        const retry = (scope, id, error) => new Promise((resolve, reject) => {
+            signal.throwIfAborted();
+            const abort = () => {
+                pending.current = undefined;
+                reject(signal.reason);
+            };
+            signal.addEventListener('abort', abort, { once: true });
+            pending.current = (value) => {
+                signal.removeEventListener('abort', abort);
+                pending.current = undefined;
+                setFailure(undefined);
+                resolve(value);
+            };
+            setActive(0);
+            setFailure({ scope, id, error });
+        });
+        void config.run(progress, retry, signal).then((prepared) => {
+            if (mounted)
+                done({ prepared });
+        }, (error) => {
+            if (mounted)
+                done({ error });
+        });
+        return () => {
+            mounted = false;
+            clearTimeout(timer);
+            controller.current.abort(new BackNavigation());
+        };
+    }, []);
+    useKeypress((key) => {
+        if (key.name === 'escape') {
+            controller.current.abort(new BackNavigation());
+            done({ error: new BackNavigation() });
+        }
+        else if (failure) {
+            if (key.name === 'up' || key.name === 'down')
+                setActive(active === 0 ? 1 : 0);
+            else if (isEnterKey(key)) {
+                if (active === 0)
+                    pending.current?.(true);
+                else {
+                    controller.current.abort(new BackNavigation());
+                    done({ error: new BackNavigation() });
+                }
+            }
+        }
+    });
+    const width = Math.max(20, (process.stdout.columns || 80) - 4);
+    if (!visible && !failure)
+        return '';
+    return [
+        ...config.selections.map(({ target }, index) => `  ${styleText(target.global ? 'magenta' : 'cyan', target.label)} · ${wrapReviewText(statuses[index], width - target.label.length - 3)[0]}`),
+        ...(failure
+            ? [
+                ...wrapReviewText(`${config.selections[failure.scope].target.label} · ${failure.id}: ${failure.error.message}`, width).map((line) => `  ${line}`),
+                `  ${active === 0 ? '›' : ' '} [ Retry download ]`,
+                `  ${active === 1 ? '›' : ' '} [ Back to kits ]`,
+            ]
+            : []),
+        '  Esc back · Ctrl+C cancel',
+    ].join('\n');
+});
+export async function prepareScreen(config, context) {
+    const result = await progressScreen(config, {
+        ...context,
+        clearPromptOnDone: true,
+    });
+    if ('error' in result)
+        throw result.error;
+    return result.prepared;
+}

package/dist/retry.d.ts

@@ -1,4 +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>;
+export declare function retryDownload<T>(attempt: () => Promise<T>, retry?: (error: Error) => Promise<boolean>, onRetry?: () => void, signal?: AbortSignal): Promise<T>;

package/dist/retry.js

@@ -4,13 +4,15 @@ export class DownloadCancelledError extends Error {
         this.name = 'DownloadCancelledError';
     }
 }
-export async function retryDownload(attempt, retry, onRetry) {
+export async function retryDownload(attempt, retry, onRetry, signal) {
     for (;;) {
         for (let tries = 0; tries < 2; tries++) {
             try {
+                signal?.throwIfAborted();
                 return await attempt();
             }
             catch (failure) {
+                signal?.throwIfAborted();
                 const error = failure instanceof Error ? failure : new Error(String(failure));
                 if (tries === 0) {
                     onRetry?.();

package/dist/review.d.ts

@@ -0,0 +1,35 @@
+import { type TargetSelection } from './picker.js';
+import { type PromptContext } from './interactive.js';
+import { type Change, type Plan } from './storage.js';
+export type ReviewTarget = TargetSelection & {
+    update: string[];
+    plan?: Plan;
+};
+export type PreparedTarget = ReviewTarget & {
+    plan: Plan;
+};
+export type ReviewAction = 'back' | 'apply' | 'done';
+type Row = {
+    text: string;
+    scope?: number;
+    heading?: boolean;
+    warning?: boolean;
+    expand?: number;
+    file?: Change;
+};
+export type KitReview = {
+    id: string;
+    effect: 'Add' | 'Remove' | 'Update' | 'Configure' | 'Keep';
+    notes: string[];
+    unchanged: boolean;
+};
+export declare function selectionSummary({ target, state, update, }: ReviewTarget): KitReview[];
+export declare function reviewRows(selections: ReviewTarget[], expanded: number[]): Row[];
+export declare function wrapReviewText(value: string, width: number): string[];
+type ReviewConfig = {
+    selections: ReviewTarget[];
+    columns?: number;
+    rows?: number;
+};
+export declare function reviewScreen(config: ReviewConfig, context?: PromptContext): Promise<ReviewAction>;
+export {};