@crouton-kit/crouter 0.3.78 → 0.3.80

package/dist/commands/view-pick.d.ts

@@ -1,2 +1,6 @@
 import type { LeafDef } from '../core/command.js';
+import { type BindingId, type BindingResolution, type RawTerminalInput } from '../core/keybindings/index.js';
+declare const VIEW_PICK_ACTIONS: readonly ["crtr.view-picker.quit", "crtr.view-picker.down", "crtr.view-picker.up", "crtr.view-picker.run"];
+export declare function resolveViewPickAction(bindings: BindingResolution<BindingId>, raw: RawTerminalInput): (typeof VIEW_PICK_ACTIONS)[number] | null;
 export declare const viewPickLeaf: LeafDef;
+export {};

package/dist/commands/view-pick.js

@@ -10,6 +10,16 @@ import { defineLeaf } from '../core/command.js';
 import { listViews } from '../core/view/loader.js';
 import { setupTerminal, restoreTerminal, getTerminalSize, parseKeypress, } from '../core/tui/terminal.js';
 import { createDraw, detectColorCaps } from '../core/tui/draw.js';
+import { formatBinding, matchesTerminalInput, resolveUserKeybindings, } from '../core/keybindings/index.js';
+const VIEW_PICK_ACTIONS = [
+    'crtr.view-picker.quit',
+    'crtr.view-picker.down',
+    'crtr.view-picker.up',
+    'crtr.view-picker.run',
+];
+export function resolveViewPickAction(bindings, raw) {
+    return VIEW_PICK_ACTIONS.find((id) => matchesTerminalInput(bindings, id, raw)) ?? null;
+}
 export const viewPickLeaf = defineLeaf({
     name: 'pick',
     tier: 'hidden',
@@ -42,6 +52,7 @@ export const viewPickLeaf = defineLeaf({
             return;
         }
         const caps = detectColorCaps();
+        const bindings = resolveUserKeybindings();
         let cursor = 0;
         let scroll = 0;
         let restored = false;
@@ -58,7 +69,7 @@ export const viewPickLeaf = defineLeaf({
         const render = () => {
             const size = getTerminalSize();
             const { draw, frame } = createDraw(size, caps);
-            draw.text(0, 0, 'crtr views — j/k move · Enter run · q quit', { bold: true });
+            draw.text(0, 0, `crtr views — ${formatBinding(bindings, 'crtr.view-picker.down')}/${formatBinding(bindings, 'crtr.view-picker.up')} move · ${formatBinding(bindings, 'crtr.view-picker.run')} run · ${formatBinding(bindings, 'crtr.view-picker.quit')} quit`, { bold: true });
             draw.hline(1, 0, size.cols);
             const rect = { row: 2, col: 0, width: size.cols, height: Math.max(1, size.rows - 3) };
             const items = views.map((v) => ({
@@ -97,21 +108,20 @@ export const viewPickLeaf = defineLeaf({
                     return;
                 }
                 const { input, key } = parsed;
-                if (key.ctrl && input === 'c')
+                const action = resolveViewPickAction(bindings, { input, ...key });
+                if (action === 'crtr.view-picker.quit')
                     finish();
-                if (input === 'q' || key.escape)
-                    finish();
-                if (input === 'j' || key.downArrow) {
+                if (action === 'crtr.view-picker.down') {
                     cursor = Math.min(views.length - 1, cursor + 1);
                     render();
                     return;
                 }
-                if (input === 'k' || key.upArrow) {
+                if (action === 'crtr.view-picker.up') {
                     cursor = Math.max(0, cursor - 1);
                     render();
                     return;
                 }
-                if (key.return)
+                if (action === 'crtr.view-picker.run')
                     launch(views[cursor].id);
             });
         });

package/dist/core/__tests__/canvas-inbox-watcher.test.js

@@ -15,12 +15,13 @@ import registerCanvasInboxWatcher from '../../pi-extensions/canvas-inbox-watcher
 import { appendInbox } from '../feed/inbox.js';
 import { appendSituationalContext, SITUATIONAL_CONTEXT_CUSTOM_TYPE } from '../runtime/situational-context.js';
 // Drive the watcher's injectable cadence seam (CRTR_WATCHER_TICK_MS /
-// CRTR_WATCHER_DEBOUNCE_MS) at a fast tempo so the test sleeps milliseconds, not
-// seconds. SETTLE_MS still allows a resolve+seed tick, a read tick, and the
-// debounce window before asserting, exactly as against the real 800/1000 cadence.
+// CRTR_WATCHER_DEBOUNCE_MS) at a fast tempo so the watcher delivers in tens of
+// milliseconds, not seconds — exactly the resolve+seed tick, read tick, and
+// debounce window it runs against the real 800/1000 cadence. Tests then poll for
+// the delivery with waitFor() rather than sleeping a fixed settle window, so a
+// starved interval tick on a loaded CI runner can't race the assertion.
 const TICK_MS = 20;
 const DEBOUNCE_MS = 25;
-const SETTLE_MS = TICK_MS * 2 + DEBOUNCE_MS + 30;
 let origHome;
 let origNode;
 const homes = [];
@@ -45,6 +46,23 @@ function makeFakePi() {
     };
 }
 const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+// Poll `predicate` until it holds or `timeoutMs` elapses, then return either
+// way. The watcher delivers on its own setInterval cadence, which competes for
+// the event loop with this test's timers; a fixed sleep before asserting is
+// unreliable on an oversubscribed CI runner (--test-concurrency=4), where an
+// interval tick is starved past the debounce window and the assertion runs
+// before the flush — the observed `0 !== 1` flake. Polling returns the instant
+// delivery lands (fast in the common case) and tolerates scheduling jitter with
+// a generous ceiling; returning on timeout lets the following asserts produce a
+// precise message instead of a generic wait error.
+async function waitFor(predicate, timeoutMs = 3000, stepMs = 10) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate())
+            return;
+        await wait(stepMs);
+    }
+}
 let origTick;
 let origDebounce;
 before(() => {
@@ -92,7 +110,7 @@ describe('canvas inbox watcher — finished-node delivery', () => {
         pi.fire('agent_start', { type: 'agent_start' }, { isIdle: () => false });
         await wait(TICK_MS + 100);
         appendInbox('node-final', { from: 'child-1', tier: 'normal', kind: 'final', label: 'all done' });
-        await wait(SETTLE_MS);
+        await waitFor(() => pi.injected.length >= 1);
         assert.equal(pi.injected.length, 1, 'one coalesced injection');
         assert.equal(pi.injected[0].deliverAs, 'steer', 'a finished node steers, not follows up');
     });
@@ -103,7 +121,7 @@ describe('canvas inbox watcher — finished-node delivery', () => {
         pi.fire('agent_start', { type: 'agent_start' }, { isIdle: () => false });
         await wait(TICK_MS + 100);
         appendInbox('node-update', { from: 'child-2', tier: 'normal', kind: 'update', label: 'still working' });
-        await wait(SETTLE_MS);
+        await waitFor(() => pi.injected.length >= 1);
         assert.equal(pi.injected.length, 1);
         assert.equal(pi.injected[0].deliverAs, 'followUp', 'a normal update is not urgent → followUp');
     });
@@ -121,7 +139,10 @@ describe('canvas inbox watcher — hidden situational-context delivery', () => {
             label: '(ambient context updated)',
             data: { situational: true, situationalOnly: true },
         });
-        await wait(SETTLE_MS);
+        // A situational-only flush sets sentMessages (never injected) in a single
+        // synchronous flush(), so waiting on the hidden send is sufficient to also
+        // settle the injected.length === 0 assertion below.
+        await waitFor(() => pi.sentMessages.length >= 1);
         assert.equal(pi.injected.length, 0, 'a situational-only entry never triggers a visible digest');
         assert.equal(pi.sentMessages.length, 1, 'exactly one hidden custom message sent');
         assert.match(pi.sentMessages[0].content, /<situational-context>/);
@@ -144,7 +165,9 @@ describe('canvas inbox watcher — hidden situational-context delivery', () => {
             label: 'visible update',
             data: { body: 'the visible message body', situational: true },
         });
-        await wait(SETTLE_MS);
+        // The hidden send and the visible digest both fire in one synchronous
+        // flush(); the injection is the later of the two, so wait on it.
+        await waitFor(() => pi.injected.length >= 1 && pi.sentMessages.length >= 1);
         assert.equal(pi.injected.length, 1, 'the visible body still reaches the digest');
         assert.match(pi.injected[0].content, /the visible message body/);
         assert.doesNotMatch(pi.injected[0].content, /hidden ambient checkout state/, 'ambient text never rides the visible digest');
@@ -177,7 +200,9 @@ describe('canvas inbox watcher — hidden situational-context delivery', () => {
             label: '(ambient context updated)',
             data: { situational: true, situationalOnly: true },
         });
-        await wait(SETTLE_MS * 3);
+        // First send throws (re-queued), so a later flush retries: wait for the
+        // successful second delivery rather than a fixed multi-settle sleep.
+        await waitFor(() => calls >= 2 && pi.sentMessages.length >= 1);
         assert.ok(calls >= 2, 'sendMessage retried after the first failure instead of being swallowed once');
         assert.equal(pi.injected.length, 0, 'still never reaches the visible digest');
         assert.equal(pi.sentMessages.length, 1, 'eventually delivered exactly once after the retry succeeds');

package/dist/core/__tests__/command-plugins-surfaces.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/command-plugins-surfaces.test.js

@@ -0,0 +1,298 @@
+// Phase-2 surface tests: the lifecycle surfaces (pkg plugin install / show and
+// sys doctor) must surface the Phase-1 validator's STABLE TYPED ISSUES to the
+// caller, and must do so WITHOUT executing the plugin binary. Covers spec item
+// 6 at the surface seam (the validator itself is tested in
+// command-plugins.test.ts). Run with:
+//   node --import tsx/esm --test src/core/__tests__/command-plugins-surfaces.test.ts
+//
+// Every test runs against an ISOLATED home (HOME → temp) with cwd pinned to a
+// dir that has no .crouter ancestor, so discovery is deterministic. Each fixture
+// executable writes a sentinel file if it is ever spawned; every surface
+// assertion also checks the sentinel is absent — proving validation stayed
+// static.
+import { test, describe, before, after, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, chmodSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { pluginInstall, pluginUpdate } from '../../commands/pkg/plugin-manage.js';
+import { pluginShow } from '../../commands/pkg/plugin-inspect.js';
+import { sysDoctorLeaf } from '../../commands/sys/doctor.js';
+import { discoverCommandContributions } from '../command-plugins/discovery.js';
+import { resetScopeCache } from '../scope.js';
+// A real executable that records the fact it ran. No surface should ever spawn
+// it — the sentinel must never appear.
+const SENTINEL_EXEC = `#!/usr/bin/env node
+const fs = require('fs');
+if (process.env.CMDPLUGIN_SENTINEL) fs.writeFileSync(process.env.CMDPLUGIN_SENTINEL, 'executed');
+process.stdout.write(JSON.stringify({ protocolVersion: 1, ok: true, result: { app_id: 'x', status: 'running' } }));
+`;
+function validManifest() {
+    return {
+        schemaVersion: 1,
+        executable: 'bin/cmd.js',
+        mounts: [
+            {
+                parent: [],
+                node: {
+                    kind: 'branch',
+                    name: 'app',
+                    description: 'application lifecycle and inspection',
+                    whenToUse: 'you need to create, deploy, inspect, or remove an application',
+                    rootEntry: {
+                        concept: 'applications hosted by a crouter home',
+                        description: 'application lifecycle and inspection',
+                        whenToUse: 'you need to create, deploy, inspect, or remove an application',
+                    },
+                    summary: 'application lifecycle and inspection',
+                    children: [
+                        {
+                            kind: 'leaf',
+                            name: 'show',
+                            description: 'show one application',
+                            whenToUse: 'inspect a single application by id',
+                            summary: 'show one application details',
+                            params: [{ kind: 'positional', name: 'app-id', required: true, constraint: 'the application id' }],
+                            output: [{ name: 'app_id', type: 'string', required: true, constraint: 'the echoed application id' }],
+                            outputKind: 'object',
+                            effects: ['None. Read-only.'],
+                        },
+                    ],
+                },
+            },
+        ],
+    };
+}
+const CASES = [
+    (() => { const m = validManifest(); m['executable'] = '../../../../bin/sh'; return { name: 'escaping executable path', code: 'command_path_unsafe', manifest: m }; })(),
+    { name: 'non-executable file', code: 'command_not_executable', execBit: false },
+    (() => { const m = validManifest(); m['schemaVersion'] = 2; return { name: 'unknown schemaVersion', code: 'command_schema_version', manifest: m }; })(),
+    (() => { const m = validManifest(); m['requires'] = { crtr: '>=1' }; return { name: 'unknown top-level key', code: 'command_manifest_invalid', manifest: m }; })(),
+    (() => { const m = validManifest(); m['mounts'][0].parent = ['sys']; return { name: 'non-empty parent', code: 'command_parent_invalid', manifest: m }; })(),
+];
+// ---------------------------------------------------------------------------
+// Isolated home + cwd
+// ---------------------------------------------------------------------------
+let home;
+let userRoot;
+let emptyStart;
+let sourceRoot; // holds source plugin dirs for install tests
+let sentinel;
+let realHome;
+let realProfile;
+let realCwd;
+before(() => {
+    realHome = process.env['HOME'];
+    realProfile = process.env['CRTR_PROFILE_ID'];
+    realCwd = process.cwd();
+    delete process.env['CRTR_PROFILE_ID'];
+});
+after(() => {
+    process.chdir(realCwd);
+    if (realHome !== undefined)
+        process.env['HOME'] = realHome;
+    else
+        delete process.env['HOME'];
+    if (realProfile !== undefined)
+        process.env['CRTR_PROFILE_ID'] = realProfile;
+    delete process.env['CMDPLUGIN_SENTINEL'];
+    // Remove EVERY test's temp dirs, not just the last beforeEach's set.
+    for (const d of tempDirs) {
+        try {
+            rmSync(d, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    }
+    resetScopeCache();
+});
+const tempDirs = [];
+function mintDir(prefix) {
+    const d = mkdtempSync(join(tmpdir(), prefix));
+    tempDirs.push(d);
+    return d;
+}
+beforeEach(() => {
+    home = mintDir('crtr-cmdsurf-home-');
+    process.env['HOME'] = home;
+    userRoot = join(home, '.crouter');
+    mkdirSync(join(userRoot, 'plugins'), { recursive: true });
+    emptyStart = mintDir('crtr-cmdsurf-empty-');
+    sourceRoot = mintDir('crtr-cmdsurf-src-');
+    sentinel = join(emptyStart, 'EXECUTED');
+    process.env['CMDPLUGIN_SENTINEL'] = sentinel;
+    process.chdir(emptyStart); // no .crouter ancestor → project scope is empty
+    resetScopeCache();
+});
+/** Write a plugin at `<dir>/<name>/` with a command manifest + executable. */
+function writePlugin(dir, name, c) {
+    const root = join(dir, name);
+    mkdirSync(join(root, '.crouter-plugin'), { recursive: true });
+    mkdirSync(join(root, 'bin'), { recursive: true });
+    writeFileSync(join(root, '.crouter-plugin', 'plugin.json'), JSON.stringify({ name, version: '0.1.0', description: 'fixture', commands: 'commands.json' }));
+    writeFileSync(join(root, 'commands.json'), JSON.stringify(c.manifest ?? validManifest()));
+    const execPath = join(root, 'bin', 'cmd.js');
+    writeFileSync(execPath, SENTINEL_EXEC);
+    chmodSync(execPath, c.execBit === false ? 0o644 : 0o755);
+    return root;
+}
+function assertNotExecuted() {
+    assert.equal(existsSync(sentinel), false, 'the plugin binary must never be spawned by a validation surface');
+}
+// ---------------------------------------------------------------------------
+// pkg plugin show
+// ---------------------------------------------------------------------------
+describe('pkg plugin show surfaces command validation', () => {
+    for (const c of CASES) {
+        test(`${c.name} → ${c.code} in commands.issues, no execution`, async () => {
+            writePlugin(join(userRoot, 'plugins'), 'p', c);
+            resetScopeCache();
+            const out = await pluginShow.run({ name: 'p' });
+            const commands = out['commands'];
+            assert.ok(commands, 'show must inventory commands for a plugin declaring a manifest');
+            assert.ok(commands.issues.some((i) => i.code === c.code), `expected ${c.code}, got ${JSON.stringify(commands.issues.map((i) => i.code))}`);
+            // Typed issues render with received/expected/next.
+            const issue = commands.issues.find((i) => i.code === c.code);
+            assert.ok(typeof issue.received === 'string' && typeof issue.expected === 'string' && typeof issue.next === 'string');
+            assert.equal(commands.mounts.length, 0, 'a rejected manifest contributes no mounts');
+            assertNotExecuted();
+        });
+    }
+    test('valid manifest → inventory with the accepted mount and zero issues', async () => {
+        writePlugin(join(userRoot, 'plugins'), 'p', { name: 'valid', code: '' });
+        resetScopeCache();
+        const out = await pluginShow.run({ name: 'p' });
+        const commands = out['commands'];
+        assert.deepEqual(commands.mounts, ['app']);
+        assert.equal(commands.issues.length, 0);
+        assert.ok(typeof commands.executable === 'string', 'executable path is resolved for a valid manifest');
+        assertNotExecuted();
+    });
+});
+// ---------------------------------------------------------------------------
+// sys doctor
+// ---------------------------------------------------------------------------
+describe('sys doctor surfaces command validation', () => {
+    for (const c of CASES) {
+        test(`${c.name} → fail check with human_action remediation, no execution`, async () => {
+            writePlugin(join(userRoot, 'plugins'), 'p', c);
+            resetScopeCache();
+            const out = await sysDoctorLeaf.run({ scope: 'user', fix: false, remote: false });
+            const checks = out['checks'];
+            const cmdCheck = checks.find((k) => k.name.startsWith('plugin:p:commands') && k.status === 'fail');
+            assert.ok(cmdCheck, `expected a failing command check, got ${JSON.stringify(checks.map((k) => k.name + ':' + k.status))}`);
+            assert.match(cmdCheck.message, new RegExp(c.code));
+            assert.equal(cmdCheck.remediation?.kind, 'human_action', 'command remediation is never auto-applied');
+            assert.equal(out['ok'], false);
+            assertNotExecuted();
+        });
+    }
+    test('--fix never touches plugin content and leaves the command issue unresolved', async () => {
+        writePlugin(join(userRoot, 'plugins'), 'p', { name: 'non-executable file', code: 'command_not_executable', execBit: false });
+        resetScopeCache();
+        const out = await sysDoctorLeaf.run({ scope: 'user', fix: true, remote: false });
+        const checks = out['checks'];
+        const cmdCheck = checks.find((k) => k.name.startsWith('plugin:p:commands') && k.status === 'fail');
+        assert.ok(cmdCheck, 'the command issue is still reported under --fix');
+        assert.notEqual(cmdCheck.fixed, true, '--fix must not chmod the plugin executable');
+        assertNotExecuted();
+    });
+    test('valid manifest → a passing command check', async () => {
+        writePlugin(join(userRoot, 'plugins'), 'p', { name: 'valid', code: '' });
+        resetScopeCache();
+        const out = await sysDoctorLeaf.run({ scope: 'user', fix: false, remote: false });
+        const checks = out['checks'];
+        const cmdCheck = checks.find((k) => k.name === 'plugin:p:commands');
+        assert.ok(cmdCheck && cmdCheck.status === 'pass', 'a valid manifest yields a pass check');
+        assert.match(cmdCheck.message, /app/);
+        assertNotExecuted();
+    });
+});
+// ---------------------------------------------------------------------------
+// Cross-plugin top-level collision (drop-both + issue, visible on surfaces)
+// ---------------------------------------------------------------------------
+describe('cross-plugin top-level collision surfaces on doctor and show', () => {
+    function installTwoClaimants() {
+        // Two distinct plugins, both valid in isolation, both claiming `app`.
+        writePlugin(join(userRoot, 'plugins'), 'p-one', { name: 'valid', code: '' });
+        writePlugin(join(userRoot, 'plugins'), 'p-two', { name: 'valid', code: '' });
+        resetScopeCache();
+    }
+    test('neither claimant mounts: discovery drops the collided command from the tree', () => {
+        installTwoClaimants();
+        const snapshot = discoverCommandContributions(new Set(['sys']));
+        assert.equal(snapshot.contributions.length, 0, 'a collided top-level command must not be mounted by ANY claimant');
+        const collisions = snapshot.issues.filter((i) => i.code === 'command_collision');
+        assert.deepEqual(collisions.map((i) => i.plugin).sort(), ['p-one', 'p-two'], 'both claimants are flagged');
+    });
+    test('sys doctor fails BOTH claimants with the collision (no false pass)', async () => {
+        installTwoClaimants();
+        const out = await sysDoctorLeaf.run({ scope: 'user', fix: false, remote: false });
+        const checks = out['checks'];
+        for (const name of ['p-one', 'p-two']) {
+            const passCheck = checks.find((k) => k.name === `plugin:${name}:commands` && k.status === 'pass');
+            assert.equal(passCheck, undefined, `${name} must not PASS while its command is dropped by a collision`);
+            const failCheck = checks.find((k) => k.name.startsWith(`plugin:${name}:commands`) && k.status === 'fail' && /command_collision/.test(k.message));
+            assert.ok(failCheck, `${name} must fail with command_collision, got ${JSON.stringify(checks.map((k) => k.name + ':' + k.status))}`);
+            assert.match(failCheck.message, /claimed by multiple plugins/);
+            assert.match(failCheck.message, /p-one/);
+            assert.match(failCheck.message, /p-two/);
+            assert.equal(failCheck.remediation?.kind, 'human_action');
+        }
+        assert.equal(out['ok'], false);
+        assertNotExecuted();
+    });
+    test('pkg plugin show reports the collision on each claimant and lists no mounts', async () => {
+        installTwoClaimants();
+        for (const name of ['p-one', 'p-two']) {
+            const out = await pluginShow.run({ name });
+            const commands = out['commands'];
+            assert.deepEqual(commands.mounts, [], `${name} must not list the collided command as an accepted mount`);
+            const issue = commands.issues.find((i) => i.code === 'command_collision');
+            assert.ok(issue, `${name} show must carry the command_collision issue`);
+            assert.deepEqual(issue.received.split(', ').sort(), ['p-one', 'p-two'], 'the issue names both claimants');
+        }
+        assertNotExecuted();
+    });
+});
+// ---------------------------------------------------------------------------
+// pkg plugin install / update
+// ---------------------------------------------------------------------------
+describe('pkg plugin install/update surface command validation', () => {
+    for (const c of CASES) {
+        test(`install ${c.name} → ${c.code} in result.commands.issues, no execution`, async () => {
+            const src = writePlugin(sourceRoot, 'p', c);
+            resetScopeCache();
+            const out = await pluginInstall.run({ installRef: src, scope: 'user' });
+            const commands = out['commands'];
+            assert.ok(commands, 'install reports command validation for a plugin declaring a manifest');
+            assert.ok(commands.issues.some((i) => i.code === c.code), `expected ${c.code}, got ${JSON.stringify(commands.issues.map((i) => i.code))}`);
+            assert.equal(commands.mounts.length, 0);
+            assertNotExecuted();
+        });
+    }
+    test('install valid manifest → accepted contribution, zero issues, no execution', async () => {
+        const src = writePlugin(sourceRoot, 'p', { name: 'valid', code: '' });
+        resetScopeCache();
+        const out = await pluginInstall.run({ installRef: src, scope: 'user' });
+        const commands = out['commands'];
+        assert.deepEqual(commands.mounts, ['app']);
+        assert.equal(commands.issues.length, 0);
+        assertNotExecuted();
+    });
+    test('update re-reports the current command validation for an edited manifest', async () => {
+        // Install valid, then break the on-disk manifest, then update: the report
+        // must reflect the CURRENT (broken) state — validation is per-call.
+        const src = writePlugin(sourceRoot, 'p', { name: 'valid', code: '' });
+        resetScopeCache();
+        await pluginInstall.run({ installRef: src, scope: 'user' });
+        // Break the installed copy's manifest in place.
+        writeFileSync(join(userRoot, 'plugins', 'p', 'commands.json'), JSON.stringify((() => { const m = validManifest(); m['schemaVersion'] = 2; return m; })()));
+        resetScopeCache();
+        const out = await pluginUpdate.run({ name: 'p' });
+        const updated = out['updated'];
+        const entry = updated.find((u) => u.name === 'p');
+        assert.ok(entry.commands, 'update reports command validation');
+        assert.ok(entry.commands.issues.some((i) => i.code === 'command_schema_version'));
+        assertNotExecuted();
+    });
+});

package/dist/core/__tests__/command-plugins.test.d.ts

@@ -0,0 +1 @@
+export {};