agentic-workflow-manager 2.1.0 → 2.1.1

package/dist/src/index.js

@@ -9,6 +9,8 @@ const commander_1 = require("commander");
 const config_1 = require("./utils/config");
 const grouping_1 = require("./utils/grouping");
 const registry_view_1 = require("./utils/registry-view");
+const tty_1 = require("./ui/tty");
+const picker_1 = require("./ui/picker");
 const providers_1 = require("./providers");
 const executor_1 = require("./core/executor");
 const regenerate_1 = require("./core/context/regenerate");
@@ -73,6 +75,7 @@ program.command('add [name]')
     .option('-s, --scope <scope>', 'Scope: local or global')
     .option('-m, --method <method>', 'Install method: symlink or copy')
     .option('-y, --yes', 'Skip confirmation prompts')
+    .option('--all', 'install all artifacts from all packages without prompting')
     .action(async (name, options) => {
     (0, prompts_1.intro)(picocolors_1.default.bgCyan(picocolors_1.default.black(' AWM - Agentic Workflow Manager ')));
     // 1. Sync the registry
@@ -142,6 +145,10 @@ program.command('add [name]')
             (0, prompts_1.outro)(`✅ Installed bundle ${picocolors_1.default.cyan(matchedBundle.name)}:\n  ${lines}${recordNote}`);
             return;
         }
+        // name given but no matching bundle found — report clearly regardless of TTY
+        console.error(picocolors_1.default.red(`Bundle "${name}" not found in registry.`));
+        console.error(picocolors_1.default.dim('Run `awm list` to see available packages.'));
+        process.exit(1);
     }
     // 2. Discover artifacts
     const skills = (0, discovery_1.discoverSkills)();
@@ -152,6 +159,103 @@ program.command('add [name]')
         process.exit(0);
     }
     const prefs = (0, config_1.getPreferences)();
+    // --all: install everything from every package headlessly
+    if (options.all) {
+        let targetAgents;
+        if (options.agent) {
+            const validAgents = Object.keys(providers_1.PROVIDERS);
+            const parsed = options.agent.split(',').map((a) => a.trim());
+            for (const a of parsed) {
+                if (!validAgents.includes(a)) {
+                    console.error(picocolors_1.default.red(`Invalid agent "${a}". Use: ${validAgents.join(', ')}.`));
+                    process.exit(1);
+                }
+            }
+            targetAgents = parsed;
+        }
+        else {
+            targetAgents = [prefs.defaultAgent];
+        }
+        let scopeVal;
+        if (options.scope) {
+            if (!['local', 'global'].includes(options.scope)) {
+                console.error(picocolors_1.default.red(`Invalid scope "${options.scope}". Use: local or global.`));
+                process.exit(1);
+            }
+            scopeVal = options.scope;
+        }
+        else {
+            scopeVal = prefs.defaultScope;
+        }
+        let methodVal;
+        if (options.method) {
+            if (!['symlink', 'copy'].includes(options.method)) {
+                console.error(picocolors_1.default.red(`Invalid method "${options.method}". Use: symlink or copy.`));
+                process.exit(1);
+            }
+            methodVal = options.method;
+        }
+        else {
+            methodVal = scopeVal === 'local' ? 'copy' : 'symlink';
+        }
+        const includeWorkflows = targetAgents.some((a) => providers_1.PROVIDERS[a].workflow !== null);
+        const includeAgents = targetAgents.some((a) => providers_1.PROVIDERS[a].agent !== null);
+        const allView = (0, registry_view_1.buildPackageView)(skills, includeWorkflows ? workflows : [], includeAgents ? agents : [], (0, bundles_1.discoverAllBundles)());
+        const allDedup = new Map();
+        for (const pkg of allView) {
+            for (const a of pkg.artifacts) {
+                allDedup.set((0, registry_view_1.artifactValue)(a), a);
+            }
+        }
+        const artifactsToInstall = Array.from(allDedup.values()).map((a) => ({
+            name: a.installName,
+            sourcePath: a.sourcePath,
+            type: a.type,
+        }));
+        if (artifactsToInstall.length === 0) {
+            (0, prompts_1.outro)(picocolors_1.default.yellow('No artifacts available.'));
+            return;
+        }
+        const installSpinner = (0, prompts_1.spinner)();
+        installSpinner.start('Installing artifacts...');
+        try {
+            const installed = [];
+            const skipped = [];
+            for (const currentAgent of targetAgents) {
+                for (const artifact of artifactsToInstall) {
+                    if (providers_1.PROVIDERS[currentAgent][artifact.type] === null) {
+                        skipped.push(`${artifact.name} (${currentAgent})`);
+                        continue;
+                    }
+                    const targetDir = (0, providers_1.getTargetPath)(artifact.type, currentAgent, scopeVal);
+                    const finalDest = path_1.default.join(targetDir, artifact.name);
+                    (0, executor_1.installArtifact)(artifact.sourcePath, finalDest, methodVal);
+                    installed.push(`${artifact.name} → ${currentAgent} (${scopeVal})`);
+                }
+            }
+            (0, config_1.savePreferences)({ defaultAgent: targetAgents[0], defaultScope: scopeVal, installMethod: methodVal });
+            installSpinner.stop('Installation complete!');
+            if (skipped.length > 0) {
+                for (const sk of skipped) {
+                    console.log(picocolors_1.default.yellow(`  ⚠️  Skipped: ${sk} (not supported by target agent)`));
+                }
+            }
+            const names = installed.map((n) => picocolors_1.default.green(n)).join('\n  ');
+            (0, prompts_1.outro)(`✅ Installed:\n  ${names}`);
+        }
+        catch (e) {
+            installSpinner.stop('Installation failed.');
+            console.error(picocolors_1.default.red(e.message));
+            process.exit(1);
+        }
+        return;
+    }
+    // Interactive selection requires a TTY. Bundle-by-name (handled above) works headless.
+    if (!(0, tty_1.isInteractive)()) {
+        console.error(picocolors_1.default.red('`awm add` needs an interactive terminal for selection.'));
+        console.error(picocolors_1.default.dim('Install a bundle non-interactively: `awm add <bundle>` (optionally with --agent/--scope).'));
+        process.exit(1);
+    }
     // 3. Agent & Scope Prompts (Moved up)
     let targetAgents;
     if (options.agent) {
@@ -207,27 +311,35 @@ program.command('add [name]')
         process.exit(0);
     }
     // 5. Level 1 — pick package(s)
-    const pkgChoice = await (0, prompts_1.multiselect)({
-        message: 'Select package(s)',
-        options: (0, registry_view_1.buildLevel1Options)(view),
-        required: true
+    const pickedPackages = await (0, picker_1.multiselectPicker)({
+        title: 'Select package(s)',
+        items: (0, registry_view_1.packagePickerItems)(view),
     });
-    handleCancel(pkgChoice);
-    const selectedPackages = pkgChoice
-        .map(name => view.find(p => p.name === name))
+    if (pickedPackages === null) {
+        (0, prompts_1.outro)('Operation cancelled.');
+        process.exit(0);
+    }
+    if (pickedPackages.length === 0) {
+        (0, prompts_1.outro)(picocolors_1.default.yellow('No packages selected.'));
+        return;
+    }
+    const selectedPackages = pickedPackages
+        .map((name) => view.find((p) => p.name === name))
         .filter(Boolean);
     // 5b. Level 2 — pick skills within each package, in sequence
     const dedup = new Map();
     for (let i = 0; i < selectedPackages.length; i++) {
         const pkg = selectedPackages[i];
-        const skillChoice = await (0, prompts_1.multiselect)({
-            message: `[${i + 1}/${selectedPackages.length}] ${pkg.name} — select artifacts`,
-            options: (0, registry_view_1.buildLevel2Options)(pkg),
-            initialValues: [registry_view_1.ALL_SENTINEL],
-            required: true
+        const picked = await (0, picker_1.multiselectPicker)({
+            title: `[${i + 1}/${selectedPackages.length}] ${pkg.name} — select artifacts`,
+            items: (0, registry_view_1.artifactPickerItems)(pkg),
+            initialSelected: [registry_view_1.ALL_SENTINEL, ...pkg.artifacts.map((a) => (0, registry_view_1.artifactValue)(a))],
         });
-        handleCancel(skillChoice);
-        for (const a of (0, registry_view_1.resolveLevel2Selection)(pkg, skillChoice)) {
+        if (picked === null) {
+            (0, prompts_1.outro)('Operation cancelled.');
+            process.exit(0);
+        }
+        for (const a of (0, registry_view_1.resolveLevel2Selection)(pkg, picked)) {
             dedup.set((0, registry_view_1.artifactValue)(a), a);
         }
     }
@@ -469,6 +581,7 @@ program.command('list [package]')
     if (packageName && options.all) {
         console.log(picocolors_1.default.dim('(Ignoring --all when a package name is provided.)'));
     }
+    const listWidth = process.stdout.isTTY ? process.stdout.columns : undefined;
     // Detail for a single package.
     if (packageName) {
         const { match, suggestion } = (0, registry_view_1.findPackage)(fullView, packageName);
@@ -480,7 +593,7 @@ program.command('list [package]')
             process.exit(1);
         }
         console.log();
-        for (const line of (0, registry_view_1.packageDetailLines)(match))
+        for (const line of (0, registry_view_1.packageDetailLines)(match, listWidth))
             console.log(line);
         console.log();
         (0, prompts_1.outro)(`Run ${picocolors_1.default.green(`awm add`)} to install artifacts from ${picocolors_1.default.cyan(match.name)}.`);
@@ -490,7 +603,7 @@ program.command('list [package]')
     if (options.all) {
         for (const pkg of view) {
             console.log();
-            for (const line of (0, registry_view_1.packageDetailLines)(pkg))
+            for (const line of (0, registry_view_1.packageDetailLines)(pkg, listWidth))
                 console.log(line);
         }
         console.log();
@@ -499,7 +612,7 @@ program.command('list [package]')
     }
     // Default: compact summary.
     console.log();
-    for (const line of (0, registry_view_1.packageSummaryLines)(view))
+    for (const line of (0, registry_view_1.packageSummaryLines)(view, listWidth))
         console.log(line);
     console.log();
     console.log(picocolors_1.default.dim(`  awm list <pkg>  ·  awm list --all`));

package/dist/src/ui/picker-view.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TWO_PANE_MIN_COLUMNS = void 0;
+exports.visibleItems = visibleItems;
+exports.renderPicker = renderPicker;
+const picocolors_1 = __importDefault(require("picocolors"));
+const text_1 = require("./text");
+exports.TWO_PANE_MIN_COLUMNS = 72;
+const FOOTER = '↑↓ move · space select · tab all · ⏎ confirm · esc clear';
+function visibleItems(state) {
+    if (!state.filter)
+        return state.items;
+    const q = state.filter.toLowerCase();
+    return state.items.filter((i) => i.label.toLowerCase().includes(q));
+}
+/** Compute a scroll window [start, end) around the cursor that fits `height` rows. */
+function windowFor(cursor, total, height) {
+    if (total <= height)
+        return [0, total];
+    let start = cursor - Math.floor(height / 2);
+    start = Math.max(0, Math.min(start, total - height));
+    return [start, start + height];
+}
+function checkbox(selected) {
+    return selected ? picocolors_1.default.green('◼') : '◻';
+}
+function renderPicker(state, vp) {
+    const vis = visibleItems(state);
+    const cursor = Math.max(0, Math.min(state.cursor, vis.length - 1));
+    const selCount = state.selected.size;
+    const filterPart = state.filter ? `   filter: ${state.filter}` : '';
+    const header = picocolors_1.default.bold(state.title) + filterPart + (selCount ? picocolors_1.default.dim(`   ${selCount} sel`) : '');
+    const out = [header];
+    if (vis.length === 0) {
+        out.push(picocolors_1.default.dim('  (no matches)'));
+        out.push(FOOTER);
+        return out;
+    }
+    const bodyHeight = Math.max(3, vp.rows - 4); // header + footer + breathing room
+    const [start, end] = windowFor(cursor, vis.length, bodyHeight);
+    const twoPane = vp.columns >= exports.TWO_PANE_MIN_COLUMNS;
+    const listWidth = twoPane ? Math.floor(vp.columns * 0.5) : vp.columns - 2;
+    const rows = [];
+    for (let i = start; i < end; i++) {
+        const item = vis[i];
+        const isCursor = i === cursor;
+        const marker = isCursor ? picocolors_1.default.cyan('❯') : ' ';
+        const box = checkbox(state.selected.has(item.value));
+        const labelWidth = listWidth - 5; // wide cursor marker (2 cells) + space + checkbox + space
+        const label = (0, text_1.truncate)(item.label, labelWidth);
+        rows.push(`${marker} ${box} ${label}`);
+    }
+    if (twoPane) {
+        const detailWidth = vp.columns - listWidth - 3; // gutter " │ "
+        const detail = (0, text_1.wrap)(vis[cursor].description, detailWidth).slice(0, rows.length);
+        const height = Math.max(rows.length, detail.length);
+        for (let i = 0; i < height; i++) {
+            const leftPadded = padToWidth(rows[i] ?? '', listWidth);
+            const right = detail[i] ?? '';
+            out.push(`${leftPadded} ${picocolors_1.default.dim('│')} ${picocolors_1.default.dim(right)}`);
+        }
+    }
+    else {
+        out.push(...rows);
+        out.push(picocolors_1.default.dim('  ' + ((0, text_1.wrap)(vis[cursor].description, vp.columns - 4)[0] ?? '')));
+    }
+    out.push(FOOTER);
+    return out;
+}
+/** Pad a possibly-colored string to `width` visible cells. */
+function padToWidth(s, width) {
+    const pad = width - (0, text_1.displayWidth)(s);
+    return pad > 0 ? s + ' '.repeat(pad) : s;
+}

package/dist/src/ui/picker.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_SENTINEL = void 0;
+exports.parseKey = parseKey;
+exports.pickerReducer = pickerReducer;
+exports.multiselectPicker = multiselectPicker;
+const picker_view_1 = require("./picker-view");
+const registry_view_1 = require("../utils/registry-view");
+// ALL_SENTINEL: single source of truth lives in registry-view.ts — re-exported here.
+exports.ALL_SENTINEL = registry_view_1.ALL_SENTINEL;
+function parseKey(data) {
+    switch (data) {
+        case '\x1b[A': return { action: 'up' };
+        case '\x1b[B': return { action: 'down' };
+        case '\r':
+        case '\n': return { action: 'confirm' };
+        case ' ': return { action: 'toggle' };
+        case '\t': return { action: 'toggleAll' };
+        case '\x7f':
+        case '\b': return { action: 'backspace' };
+        case '\x03': return { action: 'cancel' }; // Ctrl-C
+        case '\x1b': return { action: 'clearOrCancel' }; // Esc
+    }
+    if (data.length === 1 && /[a-zA-Z0-9-]/.test(data))
+        return { action: 'char', char: data };
+    return { action: 'none' };
+}
+function realValues(state) {
+    return state.items.filter((i) => i.value !== exports.ALL_SENTINEL).map((i) => i.value);
+}
+function pickerReducer(state, key) {
+    const vis = (0, picker_view_1.visibleItems)(state);
+    switch (key.type) {
+        case 'up': {
+            if (vis.length === 0)
+                return state;
+            return { ...state, cursor: (state.cursor - 1 + vis.length) % vis.length };
+        }
+        case 'down': {
+            if (vis.length === 0)
+                return state;
+            return { ...state, cursor: (state.cursor + 1) % vis.length };
+        }
+        case 'toggle': {
+            if (vis.length === 0)
+                return state;
+            const item = vis[Math.max(0, Math.min(state.cursor, vis.length - 1))];
+            const selected = new Set(state.selected);
+            if (item.value === exports.ALL_SENTINEL) {
+                const reals = realValues(state);
+                const allSel = reals.every((v) => selected.has(v));
+                if (allSel) {
+                    reals.forEach((v) => selected.delete(v));
+                    selected.delete(exports.ALL_SENTINEL);
+                }
+                else {
+                    reals.forEach((v) => selected.add(v));
+                    selected.add(exports.ALL_SENTINEL);
+                }
+            }
+            else {
+                if (selected.has(item.value)) {
+                    selected.delete(item.value);
+                    selected.delete(exports.ALL_SENTINEL); // no longer all-selected
+                }
+                else {
+                    selected.add(item.value);
+                    // if every real item is now selected, also mark the sentinel
+                    const reals = realValues(state);
+                    if (reals.every((v) => selected.has(v)))
+                        selected.add(exports.ALL_SENTINEL);
+                }
+            }
+            return { ...state, selected };
+        }
+        case 'toggleAll': {
+            const reals = vis.filter((i) => i.value !== exports.ALL_SENTINEL).map((i) => i.value);
+            const selected = new Set(state.selected);
+            const allSel = reals.every((v) => selected.has(v));
+            if (allSel) {
+                reals.forEach((v) => selected.delete(v));
+                selected.delete(exports.ALL_SENTINEL);
+            }
+            else {
+                reals.forEach((v) => selected.add(v));
+                selected.add(exports.ALL_SENTINEL);
+            }
+            return { ...state, selected };
+        }
+        case 'filterChar':
+            return { ...state, filter: state.filter + key.char, cursor: 0 };
+        case 'backspace':
+            return { ...state, filter: state.filter.slice(0, -1), cursor: 0 };
+    }
+}
+function defaultIO() {
+    return { input: process.stdin, output: process.stdout };
+}
+/**
+ * Interactive multiselect. Returns the selected values, or null if cancelled.
+ * Streams are injectable for testing. Always restores terminal state on exit.
+ */
+function multiselectPicker(opts, io = defaultIO()) {
+    return new Promise((resolve) => {
+        let state = {
+            title: opts.title,
+            items: opts.items,
+            selected: new Set(opts.initialSelected ?? []),
+            cursor: 0,
+            filter: '',
+        };
+        let lastLineCount = 0;
+        const size = () => ({
+            columns: io.output.columns ?? 80,
+            rows: io.output.rows ?? 24,
+        });
+        const draw = () => {
+            const lines = (0, picker_view_1.renderPicker)(state, size());
+            // Move up over the previous frame and clear downward.
+            if (lastLineCount > 0)
+                io.output.write(`\x1b[${lastLineCount}A`);
+            io.output.write('\x1b[0J');
+            io.output.write(lines.join('\n') + '\n');
+            lastLineCount = lines.length;
+        };
+        let onSigint;
+        const cleanup = () => {
+            io.input.removeListener('data', onData);
+            if (onSigint)
+                process.removeListener('SIGINT', onSigint);
+            try {
+                io.input.setRawMode?.(false);
+            }
+            catch { /* best-effort: terminal may not support raw mode */ }
+            io.input.pause?.();
+            io.output.write('\x1b[?25h'); // show cursor
+        };
+        const onData = (chunk) => {
+            const key = parseKey(chunk.toString());
+            switch (key.action) {
+                case 'confirm':
+                    cleanup();
+                    resolve(Array.from(state.selected));
+                    return;
+                case 'cancel':
+                    cleanup();
+                    resolve(null);
+                    return;
+                case 'clearOrCancel':
+                    if (state.filter) {
+                        state = { ...state, filter: '', cursor: 0 };
+                        break;
+                    }
+                    cleanup();
+                    resolve(null);
+                    return;
+                case 'up':
+                    state = pickerReducer(state, { type: 'up' });
+                    break;
+                case 'down':
+                    state = pickerReducer(state, { type: 'down' });
+                    break;
+                case 'toggle':
+                    state = pickerReducer(state, { type: 'toggle' });
+                    break;
+                case 'toggleAll':
+                    state = pickerReducer(state, { type: 'toggleAll' });
+                    break;
+                case 'backspace':
+                    state = pickerReducer(state, { type: 'backspace' });
+                    break;
+                case 'char':
+                    state = pickerReducer(state, { type: 'filterChar', char: key.char });
+                    break;
+                case 'none': return; // ignore, no redraw
+            }
+            draw();
+        };
+        onSigint = () => {
+            cleanup();
+            resolve(null);
+        };
+        process.once('SIGINT', onSigint);
+        try {
+            io.input.setRawMode?.(true);
+        }
+        catch { /* best-effort: degrade if raw mode unsupported */ }
+        io.input.resume?.();
+        io.input.setEncoding?.('utf8');
+        io.output.write('\x1b[?25l'); // hide cursor
+        io.input.on('data', onData);
+        draw();
+    });
+}

package/dist/src/ui/text.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAnsi = stripAnsi;
+exports.displayWidth = displayWidth;
+exports.truncate = truncate;
+exports.wrap = wrap;
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+    return s.replace(ANSI_RE, '');
+}
+function isWide(cp) {
+    return ((cp >= 0x1100 && cp <= 0x115f) || // Hangul Jamo
+        (cp >= 0x2300 && cp <= 0x23ff) || // misc technical (⏎ etc.)
+        (cp >= 0x2600 && cp <= 0x27bf) || // misc symbols / dingbats
+        (cp >= 0x4e00 && cp <= 0x9fff) || // CJK Unified Ideographs
+        (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables
+        (cp >= 0xff00 && cp <= 0xffef) || // Fullwidth Latin/symbols
+        (cp >= 0x1f000 && cp <= 0x1faff) // emoji
+    );
+}
+/** Visible terminal cells, ignoring ANSI color and treating known wide glyphs as 2. */
+function displayWidth(s) {
+    const plain = stripAnsi(s);
+    let w = 0;
+    for (const ch of plain) {
+        const cp = ch.codePointAt(0);
+        if (cp === 0xfe0f)
+            continue; // variation selector — zero width
+        w += isWide(cp) ? 2 : 1;
+    }
+    return w;
+}
+/** Truncate plain text to `width` cells, appending '…'. Strips ANSI — color AFTER truncating. */
+function truncate(s, width) {
+    if (width <= 0)
+        return '';
+    const plain = stripAnsi(s);
+    if (displayWidth(plain) <= width)
+        return plain;
+    if (width === 1)
+        return '…';
+    let out = '';
+    let w = 0;
+    for (const ch of plain) {
+        const cw = displayWidth(ch);
+        if (w + cw > width - 1)
+            break;
+        out += ch;
+        w += cw;
+    }
+    return out + '…';
+}
+/** Word-wrap plain text to `width` cells. Long single words are not split (acceptable). */
+function wrap(s, width) {
+    if (width <= 0)
+        return [s];
+    const words = stripAnsi(s).split(/\s+/).filter(Boolean);
+    const lines = [];
+    let cur = '';
+    for (const word of words) {
+        if (cur === '') {
+            cur = word;
+            continue;
+        }
+        if (displayWidth(cur) + 1 + displayWidth(word) <= width)
+            cur += ' ' + word;
+        else {
+            lines.push(cur);
+            cur = word;
+        }
+    }
+    if (cur)
+        lines.push(cur);
+    return lines.length ? lines : [''];
+}

package/dist/src/ui/tty.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInteractive = isInteractive;
+exports.terminalSize = terminalSize;
+/** True only when both ends are TTYs — the precondition for the interactive picker. */
+function isInteractive() {
+    return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+/** Current terminal size, with a safe 80x24 fallback when undefined (non-TTY). */
+function terminalSize() {
+    return {
+        columns: process.stdout.columns ?? 80,
+        rows: process.stdout.rows ?? 24,
+    };
+}

package/dist/src/utils/registry-view.js

@@ -10,11 +10,12 @@ exports.packageSummaryLines = packageSummaryLines;
 exports.packageDetailLines = packageDetailLines;
 exports.findPackage = findPackage;
 exports.artifactValue = artifactValue;
-exports.buildLevel1Options = buildLevel1Options;
-exports.buildLevel2Options = buildLevel2Options;
+exports.packagePickerItems = packagePickerItems;
+exports.artifactPickerItems = artifactPickerItems;
 exports.resolveLevel2Selection = resolveLevel2Selection;
 const picocolors_1 = __importDefault(require("picocolors"));
 const registries_1 = require("../core/registries");
+const text_1 = require("../ui/text");
 exports.STANDALONE_NAME = 'standalone';
 function makePackage(name, description, isStandalone, visibility, artifacts) {
     return {
@@ -73,7 +74,7 @@ function artifactCountLabel(counts) {
 function packageIcon(pkg) {
     return pkg.isStandalone ? '🔹' : '📦';
 }
-function packageSummaryLines(packages) {
+function packageSummaryLines(packages, width) {
     const uniqueSkillNames = new Set(packages.flatMap((p) => p.artifacts.filter((a) => a.type === 'skill').map((a) => a.name)));
     const totalSkills = uniqueSkillNames.size;
     const lines = [`AWM Registry — ${plural(packages.length, 'package')}, ${plural(totalSkills, 'skill')}`, ''];
@@ -83,12 +84,17 @@ function packageSummaryLines(packages) {
     packages.forEach((p, i) => {
         const name = p.name.padEnd(nameWidth);
         const count = countLabels[i].padEnd(countWidth);
-        const desc = p.isStandalone ? '' : p.description;
+        let desc = p.isStandalone ? '' : p.description;
+        if (width && desc) {
+            const used = 3 + nameWidth + 3 + countWidth + 3; // icon(2)+space(1), name, gap, count, gap
+            const avail = width - used;
+            desc = avail > 1 ? (0, text_1.truncate)(desc, avail) : '';
+        }
         lines.push(`${packageIcon(p)} ${name}   ${count}   ${desc}`.trimEnd());
     });
     return lines;
 }
-function packageDetailLines(pkg) {
+function packageDetailLines(pkg, width) {
     const lines = [];
     const header = pkg.isStandalone
         ? `${packageIcon(pkg)} ${pkg.name} — ${plural(pkg.artifacts.length, 'artifact')}`
@@ -99,8 +105,10 @@ function packageDetailLines(pkg) {
             ? picocolors_1.default.yellow(`  ← ${(0, registries_1.registryNameForPath)(a.sourcePath) ?? 'unknown'} (override)`)
             : '';
         lines.push(`  ${TYPE_ICON[a.type]}${a.name}${mark}`);
-        if (a.description)
-            lines.push(`     ${a.description}`);
+        if (a.description) {
+            const desc = width ? (0, text_1.truncate)(a.description, width - 5) : a.description;
+            lines.push(`     ${desc}`);
+        }
     });
     return lines;
 }
@@ -130,21 +138,27 @@ exports.ALL_SENTINEL = '__ALL__';
 function artifactValue(a) {
     return `${a.type}:${a.name}`;
 }
-function buildLevel1Options(packages) {
-    return packages.map((p) => {
-        const count = p.isStandalone ? plural(p.artifacts.length, 'artifact') : artifactCountLabel(p.counts);
-        const desc = p.isStandalone ? '' : ` · ${p.description}`;
-        return { value: p.name, label: `${packageIcon(p)} ${p.name}  ${picocolors_1.default.dim(`${count}${desc}`)}` };
-    });
+function packagePickerItems(packages) {
+    return packages.map((p) => ({
+        value: p.name,
+        label: `${packageIcon(p)} ${p.name}`,
+        description: p.isStandalone
+            ? plural(p.artifacts.length, 'artifact')
+            : `${artifactCountLabel(p.counts)} · ${p.description}`,
+    }));
 }
-function buildLevel2Options(pkg) {
-    const installAll = { value: exports.ALL_SENTINEL, label: `✨ Install entire package (${pkg.artifacts.length})` };
-    const rest = pkg.artifacts.map((a) => {
-        const title = `${TYPE_ICON[a.type]}${a.name}`;
-        const label = a.description ? `${title}\n     ${picocolors_1.default.dim(a.description)}` : title;
-        return { value: artifactValue(a), label };
-    });
-    return [installAll, ...rest];
+function artifactPickerItems(pkg) {
+    const all = {
+        value: exports.ALL_SENTINEL,
+        label: `✨ Install entire package (${pkg.artifacts.length})`,
+        description: 'Select every artifact in this package.',
+    };
+    const rest = pkg.artifacts.map((a) => ({
+        value: artifactValue(a),
+        label: `${TYPE_ICON[a.type]}${a.name}`,
+        description: a.description || '',
+    }));
+    return [all, ...rest];
 }
 function resolveLevel2Selection(pkg, selectedValues) {
     if (selectedValues.includes(exports.ALL_SENTINEL))

package/dist/tests/ui/picker-reducer.test.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const picker_1 = require("../../src/ui/picker");
+const items = [
+    { value: picker_1.ALL_SENTINEL, label: '✨ Install entire package (2)', description: '' },
+    { value: 'skill:a', label: 'alpha', description: '' },
+    { value: 'skill:b', label: 'beta', description: '' },
+];
+const base = (over = {}) => ({
+    title: 't', items, selected: new Set(), cursor: 0, filter: '', ...over,
+});
+describe('parseKey', () => {
+    it('maps arrow and control sequences', () => {
+        expect((0, picker_1.parseKey)('\x1b[A')).toEqual({ action: 'up' });
+        expect((0, picker_1.parseKey)('\x1b[B')).toEqual({ action: 'down' });
+        expect((0, picker_1.parseKey)('\r')).toEqual({ action: 'confirm' });
+        expect((0, picker_1.parseKey)(' ')).toEqual({ action: 'toggle' });
+        expect((0, picker_1.parseKey)('\t')).toEqual({ action: 'toggleAll' });
+        expect((0, picker_1.parseKey)('\x03')).toEqual({ action: 'cancel' });
+        expect((0, picker_1.parseKey)('\x1b')).toEqual({ action: 'clearOrCancel' });
+        expect((0, picker_1.parseKey)('\x7f')).toEqual({ action: 'backspace' });
+    });
+    it('maps filter characters and ignores the rest', () => {
+        expect((0, picker_1.parseKey)('c')).toEqual({ action: 'char', char: 'c' });
+        expect((0, picker_1.parseKey)('-')).toEqual({ action: 'char', char: '-' });
+        expect((0, picker_1.parseKey)('?')).toEqual({ action: 'none' });
+    });
+});
+describe('pickerReducer', () => {
+    it('moves the cursor and wraps around', () => {
+        expect((0, picker_1.pickerReducer)(base({ cursor: 0 }), { type: 'up' }).cursor).toBe(2);
+        expect((0, picker_1.pickerReducer)(base({ cursor: 2 }), { type: 'down' }).cursor).toBe(0);
+    });
+    it('toggles the current item', () => {
+        const s = (0, picker_1.pickerReducer)(base({ cursor: 1 }), { type: 'toggle' });
+        expect(s.selected.has('skill:a')).toBe(true);
+        const s2 = (0, picker_1.pickerReducer)(s, { type: 'toggle' });
+        expect(s2.selected.has('skill:a')).toBe(false);
+    });
+    it('toggling the ALL sentinel selects every real item plus the sentinel', () => {
+        const s = (0, picker_1.pickerReducer)(base({ cursor: 0 }), { type: 'toggle' });
+        expect(s.selected.has('skill:a')).toBe(true);
+        expect(s.selected.has('skill:b')).toBe(true);
+        expect(s.selected.has(picker_1.ALL_SENTINEL)).toBe(true);
+    });
+    it('Tab toggles all real items without needing the sentinel row', () => {
+        const s = (0, picker_1.pickerReducer)(base(), { type: 'toggleAll' });
+        expect(s.selected.has('skill:a')).toBe(true);
+        expect(s.selected.has('skill:b')).toBe(true);
+        expect(s.selected.has(picker_1.ALL_SENTINEL)).toBe(true);
+    });
+    it('toggleAll via Tab syncs ALL_SENTINEL when all become selected', () => {
+        const s = (0, picker_1.pickerReducer)(base(), { type: 'toggleAll' });
+        expect(s.selected.has('skill:a')).toBe(true);
+        expect(s.selected.has('skill:b')).toBe(true);
+        expect(s.selected.has(picker_1.ALL_SENTINEL)).toBe(true);
+    });
+    it('typing filters and resets the cursor to 0', () => {
+        const s = (0, picker_1.pickerReducer)(base({ cursor: 2 }), { type: 'filterChar', char: 'b' });
+        expect(s.filter).toBe('b');
+        expect(s.cursor).toBe(0);
+    });
+    it('backspace edits the filter', () => {
+        expect((0, picker_1.pickerReducer)(base({ filter: 'be' }), { type: 'backspace' }).filter).toBe('b');
+    });
+    it('does not move the cursor when the filtered list is empty', () => {
+        const s = base({ filter: 'zzz', cursor: 0 });
+        expect((0, picker_1.pickerReducer)(s, { type: 'down' }).cursor).toBe(0);
+    });
+    it('toggling an individual item off removes ALL_SENTINEL from selected', () => {
+        // Start with all items pre-selected (the initialSelected scenario)
+        const all = new Set([picker_1.ALL_SENTINEL, 'skill:a', 'skill:b']);
+        const s = (0, picker_1.pickerReducer)(base({ cursor: 1, selected: all }), { type: 'toggle' });
+        // Unchecked skill:a — sentinel should be gone
+        expect(s.selected.has('skill:a')).toBe(false);
+        expect(s.selected.has(picker_1.ALL_SENTINEL)).toBe(false);
+        expect(s.selected.has('skill:b')).toBe(true);
+    });
+    it('toggling the last missing item on syncs the ALL_SENTINEL', () => {
+        // skill:a is missing, skill:b is selected — select skill:a and sentinel should appear
+        const partial = new Set(['skill:b']);
+        const s = (0, picker_1.pickerReducer)(base({ cursor: 1, selected: partial }), { type: 'toggle' });
+        expect(s.selected.has('skill:a')).toBe(true);
+        expect(s.selected.has(picker_1.ALL_SENTINEL)).toBe(true);
+    });
+    it('toggleAll with active filter only toggles visible items', () => {
+        // filter to 'beta' — only skill:b is visible (ALL_SENTINEL label '✨ Install entire package (2)' does not match)
+        const s = (0, picker_1.pickerReducer)(base({ filter: 'beta' }), { type: 'toggleAll' });
+        expect(s.selected.has('skill:b')).toBe(true);
+        expect(s.selected.has('skill:a')).toBe(false); // not visible, should NOT be selected
+    });
+});

package/dist/tests/ui/picker-shell.test.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+const picker_1 = require("../../src/ui/picker");
+function fakeIO() {
+    const input = new events_1.EventEmitter();
+    input.setRawMode = jest.fn();
+    input.resume = jest.fn();
+    input.pause = jest.fn();
+    input.setEncoding = jest.fn();
+    const writes = [];
+    const output = { write: (s) => { writes.push(s); return true; }, columns: 100, rows: 20 };
+    return { io: { input, output }, writes, send: (s) => input.emit('data', s) };
+}
+const items = [
+    { value: picker_1.ALL_SENTINEL, label: '✨ all', description: '' },
+    { value: 'skill:a', label: 'alpha', description: 'A.' },
+    { value: 'skill:b', label: 'beta', description: 'B.' },
+];
+it('resolves with the toggled selection on Enter', async () => {
+    const { io, send } = fakeIO();
+    const p = (0, picker_1.multiselectPicker)({ title: 't', items }, io);
+    send('\x1b[B'); // down → cursor on alpha
+    send(' '); // toggle alpha
+    send('\r'); // confirm
+    await expect(p).resolves.toEqual(['skill:a']);
+    expect(io.input.setRawMode).toHaveBeenLastCalledWith(false); // restored
+});
+it('resolves null on Ctrl-C and restores raw mode', async () => {
+    const { io, send } = fakeIO();
+    const p = (0, picker_1.multiselectPicker)({ title: 't', items }, io);
+    send('\x03');
+    await expect(p).resolves.toBeNull();
+    expect(io.input.setRawMode).toHaveBeenLastCalledWith(false);
+});
+it('seeds the initial selection', async () => {
+    const { io, send } = fakeIO();
+    const p = (0, picker_1.multiselectPicker)({ title: 't', items, initialSelected: [picker_1.ALL_SENTINEL, 'skill:a', 'skill:b'] }, io);
+    send('\r');
+    const result = await p;
+    expect(new Set(result)).toEqual(new Set([picker_1.ALL_SENTINEL, 'skill:a', 'skill:b']));
+});
+it('Esc with empty filter cancels and returns null', async () => {
+    const { io, send } = fakeIO();
+    const p = (0, picker_1.multiselectPicker)({ title: 't', items }, io);
+    send('\x1b'); // Esc with no active filter → cancel
+    await expect(p).resolves.toBeNull();
+    expect(io.input.setRawMode).toHaveBeenLastCalledWith(false);
+});
+it('Esc with active filter clears it instead of cancelling', async () => {
+    const { io, send } = fakeIO();
+    const p = (0, picker_1.multiselectPicker)({ title: 't', items }, io);
+    send('a'); // type 'a' → filter becomes 'a'
+    send('\x1b'); // Esc → should clear filter, NOT cancel
+    send('\r'); // Enter → confirm (with no selection)
+    await expect(p).resolves.toEqual([]);
+    // setRawMode(false) called on confirm, not on Esc
+    expect(io.input.setRawMode).toHaveBeenLastCalledWith(false);
+});

package/dist/tests/ui/picker-view.test.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const picker_view_1 = require("../../src/ui/picker-view");
+const items = [
+    { value: 'skill:architecture-advisor', label: 'architecture-advisor', description: 'Define and review system architecture.' },
+    { value: 'skill:brainstorming', label: 'brainstorming', description: 'Turn ideas into designs.' },
+    { value: 'skill:cicd-proposal-builder', label: 'cicd-proposal-builder', description: 'Specialist in CI/CD pipeline design. Use when defining a pipeline.' },
+];
+const base = (over = {}) => ({
+    title: 'dev — select artifacts',
+    items,
+    selected: new Set(),
+    cursor: 0,
+    filter: '',
+    ...over,
+});
+describe('visibleItems', () => {
+    it('returns all items with an empty filter', () => {
+        expect((0, picker_view_1.visibleItems)(base())).toHaveLength(3);
+    });
+    it('filters by label substring, case-insensitive', () => {
+        expect((0, picker_view_1.visibleItems)(base({ filter: 'CIC' })).map((i) => i.value)).toEqual(['skill:cicd-proposal-builder']);
+    });
+});
+describe('renderPicker', () => {
+    it('shows the title in the header', () => {
+        const lines = (0, picker_view_1.renderPicker)(base(), { columns: 100, rows: 20 });
+        expect(lines[0]).toContain('dev — select artifacts');
+    });
+    it('marks the cursor row and selected rows', () => {
+        const lines = (0, picker_view_1.renderPicker)(base({ cursor: 1, selected: new Set(['skill:brainstorming']) }), { columns: 100, rows: 20 });
+        const body = lines.join('\n');
+        expect(body).toContain('❯'); // cursor marker
+        expect(body).toContain('◼'); // a selected checkbox
+        expect(body).toContain('◻'); // an unselected checkbox
+    });
+    it('uses two panes (a gutter) when wide', () => {
+        const lines = (0, picker_view_1.renderPicker)(base(), { columns: picker_view_1.TWO_PANE_MIN_COLUMNS + 10, rows: 20 });
+        expect(lines.some((l) => l.includes(' │ '))).toBe(true);
+    });
+    it('collapses to one pane (no gutter) when narrow', () => {
+        const lines = (0, picker_view_1.renderPicker)(base(), { columns: 50, rows: 20 });
+        expect(lines.some((l) => l.includes(' │ '))).toBe(false);
+        // the highlighted item's description still appears below the list
+        expect(lines.join('\n')).toContain('Define and review');
+    });
+    it('shows the filter text in the header when filtering', () => {
+        expect((0, picker_view_1.renderPicker)(base({ filter: 'cic' }), { columns: 100, rows: 20 })[0]).toContain('filter: cic');
+    });
+    it('reports no matches when the filter excludes everything', () => {
+        expect((0, picker_view_1.renderPicker)(base({ filter: 'zzz' }), { columns: 100, rows: 20 }).join('\n').toLowerCase()).toContain('no matches');
+    });
+    it('always ends with the key hint footer', () => {
+        const lines = (0, picker_view_1.renderPicker)(base(), { columns: 100, rows: 20 });
+        expect(lines[lines.length - 1]).toContain('confirm');
+    });
+});

package/dist/tests/ui/text.test.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const text_1 = require("../../src/ui/text");
+const picocolors_1 = __importDefault(require("picocolors"));
+describe('stripAnsi', () => {
+    it('removes color escape sequences', () => {
+        expect((0, text_1.stripAnsi)(picocolors_1.default.green('hi'))).toBe('hi');
+    });
+});
+describe('displayWidth', () => {
+    it('counts plain ASCII one cell each', () => {
+        expect((0, text_1.displayWidth)('hello')).toBe(5);
+    });
+    it('ignores color codes', () => {
+        expect((0, text_1.displayWidth)(picocolors_1.default.red('abc'))).toBe(3);
+    });
+    it('counts an emoji as two cells and ignores the VS16 selector', () => {
+        expect((0, text_1.displayWidth)('📦')).toBe(2);
+        expect((0, text_1.displayWidth)('✍️')).toBe(2);
+    });
+    it('counts CJK ideographs as 2 cells', () => {
+        expect((0, text_1.displayWidth)('你好')).toBe(4);
+    });
+    it('counts Hangul syllables as 2 cells', () => {
+        expect((0, text_1.displayWidth)('안녕')).toBe(4);
+    });
+    it('counts fullwidth Latin as 2 cells', () => {
+        // U+FF21 = Ａ (fullwidth A)
+        expect((0, text_1.displayWidth)('ＡＢ')).toBe(4);
+    });
+});
+describe('truncate', () => {
+    it('returns the string unchanged when it fits', () => {
+        expect((0, text_1.truncate)('abc', 5)).toBe('abc');
+    });
+    it('truncates and appends an ellipsis, never exceeding width', () => {
+        const out = (0, text_1.truncate)('abcdefgh', 5);
+        expect(out).toBe('abcd…');
+        expect((0, text_1.displayWidth)(out)).toBeLessThanOrEqual(5);
+    });
+    it('returns empty for non-positive width', () => {
+        expect((0, text_1.truncate)('abc', 0)).toBe('');
+    });
+});
+describe('wrap', () => {
+    it('breaks text at word boundaries within width', () => {
+        expect((0, text_1.wrap)('the quick brown fox', 9)).toEqual(['the quick', 'brown fox']);
+    });
+    it('returns a single empty line for empty input', () => {
+        expect((0, text_1.wrap)('', 10)).toEqual(['']);
+    });
+});

package/dist/tests/ui/tty.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tty_1 = require("../../src/ui/tty");
+describe('isInteractive', () => {
+    const outTTY = process.stdout.isTTY;
+    const inTTY = process.stdin.isTTY;
+    afterEach(() => {
+        Object.defineProperty(process.stdout, 'isTTY', { value: outTTY, configurable: true });
+        Object.defineProperty(process.stdin, 'isTTY', { value: inTTY, configurable: true });
+    });
+    it('is true only when both stdin and stdout are TTYs', () => {
+        Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
+        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+        expect((0, tty_1.isInteractive)()).toBe(true);
+    });
+    it('is false when stdout is not a TTY (piped output)', () => {
+        Object.defineProperty(process.stdout, 'isTTY', { value: false, configurable: true });
+        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+        expect((0, tty_1.isInteractive)()).toBe(false);
+    });
+});
+describe('terminalSize', () => {
+    const cols = process.stdout.columns;
+    const rows = process.stdout.rows;
+    afterEach(() => {
+        Object.defineProperty(process.stdout, 'columns', { value: cols, configurable: true });
+        Object.defineProperty(process.stdout, 'rows', { value: rows, configurable: true });
+    });
+    it('reports the stdout dimensions', () => {
+        Object.defineProperty(process.stdout, 'columns', { value: 120, configurable: true });
+        Object.defineProperty(process.stdout, 'rows', { value: 40, configurable: true });
+        expect((0, tty_1.terminalSize)()).toEqual({ columns: 120, rows: 40 });
+    });
+    it('falls back to 80x24 when dimensions are undefined', () => {
+        Object.defineProperty(process.stdout, 'columns', { value: undefined, configurable: true });
+        Object.defineProperty(process.stdout, 'rows', { value: undefined, configurable: true });
+        expect((0, tty_1.terminalSize)()).toEqual({ columns: 80, rows: 24 });
+    });
+});

package/dist/tests/utils/registry-view.test.js

@@ -89,42 +89,6 @@ describe('findPackage', () => {
         expect(res.suggestion).toBe('core-dev');
     });
 });
-describe('buildLevel1Options', () => {
-    it('produces one option per package keyed by package name', () => {
-        const view = (0, registry_view_1.buildPackageView)([skill('brainstorming'), skill('shared')], [], [], processes);
-        const opts = (0, registry_view_1.buildLevel1Options)(view);
-        expect(opts.map((o) => o.value).sort()).toEqual(['core-dev', 'docs']);
-        expect(opts.find((o) => o.value === 'core-dev').label).toContain('core-dev');
-        expect(opts.find((o) => o.value === 'core-dev').label).toContain('Dev lifecycle');
-    });
-    it('uses artifact-count label for standalone packages', () => {
-        const view = (0, registry_view_1.buildPackageView)([skill('orphan')], [], [], []);
-        const opts = (0, registry_view_1.buildLevel1Options)(view);
-        expect(opts[0].value).toBe(registry_view_1.STANDALONE_NAME);
-        expect(opts[0].label).toContain('1 artifact');
-    });
-});
-describe('buildLevel2Options', () => {
-    it('puts an "install entire package" sentinel first, then one option per artifact', () => {
-        const view = (0, registry_view_1.buildPackageView)([skill('brainstorming', 'explore')], [wf('exec')], [agent('plan')], processes);
-        const core = view.find((p) => p.name === 'core-dev');
-        const opts = (0, registry_view_1.buildLevel2Options)(core);
-        expect(opts[0].value).toBe(registry_view_1.ALL_SENTINEL);
-        expect(opts[0].label).toContain('Install entire package');
-        const values = opts.slice(1).map((o) => o.value);
-        expect(values).toContain('skill:brainstorming');
-        expect(values).toContain('workflow:exec');
-        expect(values).toContain('agent:plan');
-        expect(opts.find((o) => o.value === 'skill:brainstorming').label).toContain('explore');
-    });
-    it('uses plain title for artifact with no description', () => {
-        const view = (0, registry_view_1.buildPackageView)([skill('brainstorming', 'explore')], [wf('exec')], [agent('plan')], processes);
-        const core = view.find((p) => p.name === 'core-dev');
-        const opts = (0, registry_view_1.buildLevel2Options)(core);
-        const wfOpt = opts.find((o) => o.value === 'workflow:exec');
-        expect(wfOpt.label).toBe('⚡ exec');
-    });
-});
 describe('resolveLevel2Selection', () => {
     const view = (0, registry_view_1.buildPackageView)([skill('brainstorming'), skill('shared')], [], [], processes);
     const core = view.find((p) => p.name === 'core-dev');
@@ -154,3 +118,42 @@ describe('visibility', () => {
         expect(view.find((p) => p.name === 'core-dev').visibility).toBe('public');
     });
 });
+describe('packageSummaryLines width-awareness', () => {
+    it('truncates the description column when a width is given', () => {
+        const view = (0, registry_view_1.buildPackageView)([skill('brainstorming', 'x'.repeat(200))], [], [], [
+            bundle({ name: 'core-dev', description: 'x'.repeat(200), skills: [{ name: 'brainstorming', onSignal: false }] }),
+        ]);
+        const lines = (0, registry_view_1.packageSummaryLines)(view, 60);
+        for (const l of lines)
+            expect(l.length).toBeLessThanOrEqual(60);
+        expect(lines.some((l) => l.includes('…'))).toBe(true);
+    });
+    it('does not truncate when no width is given (piped output)', () => {
+        const view = (0, registry_view_1.buildPackageView)([skill('brainstorming', 'y'.repeat(200))], [], [], [
+            bundle({ name: 'core-dev', description: 'z'.repeat(200), skills: [{ name: 'brainstorming', onSignal: false }] }),
+        ]);
+        const lines = (0, registry_view_1.packageSummaryLines)(view); // no width
+        expect(lines.some((l) => l.includes('z'.repeat(200)))).toBe(true);
+    });
+});
+describe('artifactPickerItems', () => {
+    it('prepends an "install entire package" sentinel item, then one per artifact', () => {
+        const view = (0, registry_view_1.buildPackageView)([skill('a', 'desc a'), skill('b', 'desc b')], [], [], [
+            bundle({ name: 'p', description: 'pkg', skills: [{ name: 'a', onSignal: false }, { name: 'b', onSignal: false }] }),
+        ]);
+        const items = (0, registry_view_1.artifactPickerItems)(view.find((p) => p.name === 'p'));
+        expect(items[0].value).toBe(registry_view_1.ALL_SENTINEL);
+        expect(items.slice(1).map((i) => i.label)).toEqual(['a', 'b']);
+        expect(items.find((i) => i.label === 'a').description).toBe('desc a');
+    });
+});
+describe('packagePickerItems', () => {
+    it('builds one item per package with a count+description summary', () => {
+        const view = (0, registry_view_1.buildPackageView)([skill('a')], [], [], [
+            bundle({ name: 'p', description: 'pkg desc', skills: [{ name: 'a', onSignal: false }] }),
+        ]);
+        const items = (0, registry_view_1.packagePickerItems)(view);
+        expect(items[0].value).toBe('p');
+        expect(items[0].description).toContain('pkg desc');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"