@north-light/crouter 0.3.164 → 0.3.166

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

@@ -18,8 +18,8 @@
 //     recoverable error propagation, and every malformed case.
 //  5. Lifecycle without restart — install/disable/edit/remove all take effect
 //     on the next discovery call (per-invocation, no cache).
-//  6/7. Typed issues for path/exec-bit/schema/unknown-key/parent violations
-//     without executing the fixture binary.
+//  6/7. Typed issues for path/exec-bit/schema/unknown-key violations and nested
+//     mount composition without executing the fixture binary.
 import { test, describe, before, after, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, chmodSync } from 'node:fs';
@@ -30,6 +30,7 @@ import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { discoverCommandContributions, effectiveCommandPlugins, validatePluginCommands, } from '../command-plugins/discovery.js';
 import { composeExternalSubtrees, adaptPluginContributions } from '../command-plugins/compose.js';
+import { resolveCommandRegistry } from '../command-manifests/registry.js';
 import { defineRoot } from '../command.js';
 import { renderRoot, renderBranch, renderLeafArgv } from '../help.js';
 import { renderResult } from '../render.js';
@@ -69,7 +70,6 @@ process.stdin.on('end', () => {
 function commandsJson(topName = 'app') {
     return {
         schemaVersion: 1,
-        executable: 'bin/cmd.js',
         mounts: [
             {
                 parent: [],
@@ -110,6 +110,28 @@ function commandsJson(topName = 'app') {
         ],
     };
 }
+function passthroughCommandsJson() {
+    return {
+        schemaVersion: 1,
+        mounts: [{
+                parent: [],
+                node: {
+                    kind: 'branch',
+                    name: 'capture',
+                    description: 'browser automation',
+                    whenToUse: 'driving a browser through the Capture CLI',
+                    rootEntry: {
+                        concept: 'browser automation',
+                        description: 'browser automation through Capture',
+                        whenToUse: 'driving a browser through the Capture CLI',
+                    },
+                    summary: 'browser automation through Capture',
+                    passthrough: { bin: 'capture', installHint: 'Install @crouton-kit/capture globally.' },
+                    children: [],
+                },
+            }],
+    };
+}
 /** Write a plugin into `scopeRoot/plugins/<name>/` with a command manifest +
  *  executable. `manifest` is the commands.json object (default fixture). */
 function installPlugin(scopeRoot, name, opts = {}) {
@@ -117,7 +139,13 @@ function installPlugin(scopeRoot, name, opts = {}) {
     mkdirSync(join(root, '.crouter-plugin'), { recursive: true });
     mkdirSync(join(root, 'bin'), { recursive: true });
     const pointer = opts.commandsPointer ?? 'commands.json';
-    writeFileSync(join(root, '.crouter-plugin', 'plugin.json'), JSON.stringify({ name, version: '0.1.0', description: 'fixture', commands: pointer }));
+    writeFileSync(join(root, '.crouter-plugin', 'plugin.json'), JSON.stringify({
+        name,
+        version: '0.1.0',
+        description: 'fixture',
+        commands: pointer,
+        transport: { kind: 'exec', ...(opts.executable === null ? {} : { executable: opts.executable ?? 'bin/cmd.js' }) },
+    }));
     writeFileSync(join(root, 'commands.json'), JSON.stringify(opts.manifest ?? commandsJson()));
     const execPath = join(root, 'bin', 'cmd.js');
     writeFileSync(execPath, opts.exec ?? FIXTURE_EXEC);
@@ -229,12 +257,13 @@ describe('core collision', () => {
     test('a fixture claiming a core top-level name is skipped + recorded', () => {
         installPlugin(userRoot, 'rogue', { manifest: commandsJson('push') });
         resetScopeCache();
-        const snapshot = discoverCommandContributions(RESERVED, emptyStart);
-        const registrySnapshot = adaptPluginContributions(snapshot.contributions);
+        const candidates = discoverCommandContributions(new Set(), emptyStart);
+        const registrySnapshot = resolveCommandRegistry(adaptPluginContributions(candidates.contributions).contributions, RESERVED);
         assert.equal(composeExternalSubtrees(registrySnapshot).length, 0, 'the colliding branch must not enter the tree');
-        const collision = snapshot.issues.find((i) => i.code === 'command_collision');
+        const collision = registrySnapshot.issues.find((i) => i.code === 'command_collision');
         assert.ok(collision, 'a command_collision issue must be recorded for doctor/show');
-        assert.equal(collision.received, 'push');
+        assert.equal(collision.path, 'push');
+        assert.equal(collision.contributor.name, 'rogue');
     });
 });
 // ---------------------------------------------------------------------------
@@ -412,27 +441,57 @@ describe('typed validation issues', () => {
         const v = validate(m);
         assert.ok(v.issues.some((i) => i.code === 'command_manifest_invalid'));
     });
-    test('non-empty parent → command_parent_invalid', () => {
+    test('a child mount declared before its non-empty parent materializes into the nested branch', () => {
         const m = commandsJson();
-        m.mounts[0].parent = ['sys'];
+        const topLevel = m.mounts[0];
+        const child = topLevel.node['children'][0];
+        topLevel.node['children'] = [{
+                kind: 'branch',
+                name: 'tools',
+                description: 'application tools',
+                whenToUse: 'inspect application tools',
+                summary: 'application tools',
+                children: [],
+            }];
+        m.mounts = [
+            { parent: ['app', 'tools'], node: { ...child, name: 'status' } },
+            topLevel,
+        ];
         const v = validate(m);
-        assert.ok(v.issues.some((i) => i.code === 'command_parent_invalid'));
-        assert.equal(v.contributions.length, 0);
+        assert.equal(v.issues.length, 0, JSON.stringify(v.issues));
+        assert.equal(v.contributions.length, 1);
+        const tools = (v.contributions[0].node.children.find((node) => node.name === 'tools'));
+        assert.equal(tools.kind, 'branch');
+        assert.deepEqual(tools.children.map((node) => node.name), ['status']);
     });
     test('non-executable file → command_not_executable', () => {
         const v = validate(commandsJson(), { execBit: false });
         assert.ok(v.issues.some((i) => i.code === 'command_not_executable'));
     });
+    test('exec transport omits executable only for a passthrough-only manifest', () => {
+        const passthrough = validate(passthroughCommandsJson(), { executable: null });
+        assert.equal(passthrough.issues.length, 0, JSON.stringify(passthrough.issues));
+        assert.equal(passthrough.contributions.length, 1);
+        assert.equal(passthrough.contributions[0].node.passthrough?.bin, 'capture');
+        assert.equal(composeExternalSubtrees(adaptPluginContributions(passthrough.contributions))[0].passthrough?.bin, 'capture');
+        const nestedPassthrough = passthroughCommandsJson();
+        nestedPassthrough.mounts.push({
+            parent: ['capture'],
+            node: { kind: 'branch', name: 'child', description: 'nested child', whenToUse: 'testing invalid composition', summary: 'nested child', children: [] },
+        });
+        const rejectedNestedMount = validate(nestedPassthrough, { executable: null });
+        assert.ok(rejectedNestedMount.issues.some((issue) => issue.code === 'command_parent_invalid' && /passthrough branch/.test(issue.message)));
+        const executableLeaf = validate(commandsJson(), { executable: null });
+        assert.equal(executableLeaf.contributions.length, 0);
+        assert.ok(executableLeaf.issues.some((i) => i.path === 'transport.executable' && /requires executable/.test(i.message)));
+    });
     test('executable escaping the plugin root → command_path_unsafe', () => {
-        const m = commandsJson();
-        m['executable'] = '../../../../bin/sh';
-        const v = validate(m);
+        const v = validate(commandsJson(), { executable: '../../../../bin/sh' });
         assert.ok(v.issues.some((i) => i.code === 'command_path_unsafe'));
     });
     test('a top-level leaf (no rootEntry) → command_node_invalid', () => {
         const m = {
             schemaVersion: 1,
-            executable: 'bin/cmd.js',
             mounts: [{ parent: [], node: { kind: 'leaf', name: 'x', description: 'd', whenToUse: 'w', summary: 's', params: [], output: [], outputKind: 'object', effects: ['None. Read-only.'] } }],
         };
         const v = validate(m);

package/dist/core/__tests__/review-model-floor.test.js

@@ -46,10 +46,10 @@ test('base review ignores a light override and keeps its medium floor', () => {
 test('no base kind defaults below the medium rung', () => {
     const kinds = defaultKindsConfig();
     for (const kind of [
-        'general', 'developer', 'design', 'plan', 'spec', 'product', 'review',
+        'general', 'developer', 'design', 'plan', 'spec', 'review',
         'plan/reviewers/requirements-coverage', 'plan/reviewers/pattern-consistency',
         'plan/reviewers/code-smells', 'plan/reviewers/security', 'plan/reviewers/architecture-fit',
-        'spec/requirements', 'product/teardown',
+        'spec/requirements',
     ]) {
         // Kind defaults are provider-qualified and differ per kind; what must hold
         // for every one of these is the rung, not the provider or the concrete id.

package/dist/core/__tests__/tmux-surface.test.js

@@ -24,7 +24,7 @@ import { fileURLToPath } from 'node:url';
 import { dirname, join, basename } from 'node:path';
 import { ensureSession } from '../runtime/placement.js';
 import { installTmuxBindings, legacyInboxKeyFile } from '../runtime/tmux-chrome.js';
-import { resolveKeybindings } from '../keybindings/index.js';
+import { ATTACH_CONTROL_BINDINGS, resolveKeybindings } from '../keybindings/index.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SRC_ROOT = join(__dirname, '..', '..'); // .../src
 const TMUX_TS = join(SRC_ROOT, 'core', 'runtime', 'tmux.ts');
@@ -214,6 +214,9 @@ test('tmux installer remaps owned pairs and preserves occupied user bindings', (
         }
         assert.ok(defaultMenu.indexOf('fork into idle root') > lifecycle && defaultMenu.indexOf('fork into idle root') < system, 'fork belongs in Lifecycle');
         assert.match(defaultMenu, /"view settings ›" w .*display-menu.*fold finished tool calls/);
+        assert.match(defaultMenu, /"attach ›" a .*display-menu.*search profile files/);
+        assert.match(defaultMenu, /send-keys -l/);
+        assert.match(defaultMenu, /crtr\.attach\.profile-files/, 'the menu path must work while the profile-files direct binding is disabled by default');
         // Matched with its selector, so the Explore group's "view settings ›" item
         // (selector `w`) cannot satisfy this assertion by substring.
         assert.ok(defaultMenu.indexOf('settings p ') > system, 'settings belongs in System');
@@ -221,6 +224,12 @@ test('tmux installer remaps owned pairs and preserves occupied user bindings', (
         assert.match(tmuxBinding(socket, 'root', 'M-v') ?? '', /switch-client/);
         // The inbox toggle installs at its default key (alt+i → M-i) in the same sweep.
         assert.match(tmuxBinding(socket, 'root', 'M-i') ?? '', /hl inbox toggle/);
+        const attachMenuDisabled = Object.fromEntries(ATTACH_CONTROL_BINDINGS.map(({ menuId }) => [menuId, []]));
+        const withoutAttach = installTmuxBindings(resolveKeybindings(attachMenuDisabled));
+        assert.equal(withoutAttach.ok, true, JSON.stringify(withoutAttach.diagnostics));
+        const menuWithoutAttach = tmuxBinding(socket, 'root', 'M-c') ?? '';
+        assert.doesNotMatch(menuWithoutAttach, /attach ›/, 'an empty attach submenu must hide its opener');
+        assert.doesNotMatch(menuWithoutAttach, /search profile files/);
         const remapped = installTmuxBindings(resolveKeybindings({
             'crtr.tmux.menu.open': ['alt+shift+z'],
             'crtr.tmux.menu.graph': ['shift+z'],

package/dist/core/command-manifests/manifest.d.ts

@@ -0,0 +1,24 @@
+import type { DeclLeaf, TransportKind, DeclBranch, ManifestTimeouts, CommandManifestIssue } from './schema.js';
+export interface ValidatedCommandManifest {
+    schemaVersion: 1;
+    baseUrl?: string;
+    timeouts?: ManifestTimeouts;
+    /** Top-level branches, each ready to mount at parent []. */
+    roots: DeclBranch<DeclLeaf>[];
+}
+export interface CommandManifestValidation {
+    /** The validated, materialized manifest (present only if all issues are fixed). */
+    manifest?: ValidatedCommandManifest;
+    /** All typed validation issues. Any issue means zero contributions. */
+    issues: CommandManifestIssue[];
+}
+/**
+ * Validates a HTTP-transport plugin manifest exactly per §4, performing strict atomic
+ * validation and order-independent forest materialization. Returns either a
+ * valid manifest with roots ready to mount, or a complete issues list with
+ * zero contributions.
+ */
+export declare function validateCommandManifest(raw: unknown, options: {
+    transport: TransportKind;
+    reservedCoreNames: ReadonlySet<string>;
+}): CommandManifestValidation;

package/dist/core/{configured-clis → command-manifests}/manifest.js

@@ -1,13 +1,13 @@
-// Configured CLI manifest validation and forest materialization.
+// Transport-parameterized command manifest validation and forest materialization.
 //
-// Implements §4 of the configured-CLI spec: strict atomic validation of a remote
-// manifest JSON, order-independent self-contained forest materialization,
-// REST mapping validation, and the canonical coalesced-body-source rule (exactly
-// one stdin + one non-stdin flag/positional sharing a body `as`).
+// Validates command manifests atomically, materializes self-contained forests
+// independent of nested-mount order when the parent is inline, validates REST
+// mappings, and enforces the canonical coalesced-body-source rule (exactly one
+// stdin + one non-stdin flag/positional sharing a body `as`).
 //
 // This is pure validation: no fetch, no registration lookup, no file I/O beyond
 // the raw manifest bytes passed in.
-import { validateConfiguredCliNode } from '../command-manifests/schema.js';
+import { validateCommandNode } from './schema.js';
 // ---------------------------------------------------------------------------
 // Validation helpers
 // ---------------------------------------------------------------------------
@@ -27,27 +27,29 @@ function typeName(v) {
 // Top-level manifest validation
 // ---------------------------------------------------------------------------
 /**
- * Validates a configured CLI manifest exactly per §4, performing strict atomic
+ * Validates a HTTP-transport plugin manifest exactly per §4, performing strict atomic
  * validation and order-independent forest materialization. Returns either a
  * valid manifest with roots ready to mount, or a complete issues list with
  * zero contributions.
  */
-export function validateConfiguredCliManifest(raw, options) {
+export function validateCommandManifest(raw, options) {
     const issues = [];
     const issue = (code, message, received, expected, next, path) => {
         issues.push({ code, message, received, expected, next, ...(path ? { path } : {}) });
     };
     // Top-level structure check
     if (!isObject(raw)) {
-        issue('command_manifest_invalid', 'manifest must be an object', typeName(raw), '{ schemaVersion, baseUrl?, timeouts?, mounts }', 'Provide a valid JSON manifest object.');
+        issue('command_manifest_invalid', 'manifest must be an object', typeName(raw), options.transport === 'http' ? '{ schemaVersion, baseUrl?, timeouts?, mounts }' : '{ schemaVersion, mounts }', 'Provide a valid JSON manifest object.');
         return { issues };
     }
     // Check for unknown top-level keys
     const topKeys = Object.keys(raw);
-    const allowedTopKeys = new Set(['schemaVersion', 'baseUrl', 'timeouts', 'mounts']);
+    const allowedTopKeys = options.transport === 'http'
+        ? new Set(['schemaVersion', 'baseUrl', 'timeouts', 'mounts'])
+        : new Set(['schemaVersion', 'mounts']);
     const unknownKeys = topKeys.filter((k) => !allowedTopKeys.has(k));
     if (unknownKeys.length > 0) {
-        issue('command_manifest_invalid', `unknown top-level keys`, unknownKeys.join(', '), 'only: schemaVersion, baseUrl, timeouts, mounts', 'Remove the unknown keys.');
+        issue('command_manifest_invalid', `unknown top-level keys`, unknownKeys.join(', '), options.transport === 'http' ? 'only: schemaVersion, baseUrl, timeouts, mounts' : 'only: schemaVersion, mounts', 'Remove the unknown keys.');
         return { issues };
     }
     // Validate schemaVersion
@@ -57,7 +59,7 @@ export function validateConfiguredCliManifest(raw, options) {
     }
     // Validate optional baseUrl
     let baseUrl;
-    if (raw['baseUrl'] !== undefined) {
+    if (options.transport === 'http' && raw['baseUrl'] !== undefined) {
         if (typeof raw['baseUrl'] !== 'string') {
             issue('command_manifest_invalid', 'baseUrl must be a string', typeName(raw['baseUrl']), 'an absolute HTTP(S) URL or omitted', 'Provide a valid baseUrl or remove it.', 'baseUrl');
             return { issues };
@@ -77,7 +79,7 @@ export function validateConfiguredCliManifest(raw, options) {
     }
     // Validate optional timeouts
     let timeouts;
-    if (raw['timeouts'] !== undefined) {
+    if (options.transport === 'http' && raw['timeouts'] !== undefined) {
         const t = validateTimeouts(raw['timeouts'], issue);
         if (t === null)
             return { issues };
@@ -96,7 +98,7 @@ export function validateConfiguredCliManifest(raw, options) {
     // Validate and collect all mounts
     const validatedMounts = [];
     for (let i = 0; i < mounts.length; i++) {
-        const m = validateMount(mounts[i], i, issue);
+        const m = validateMount(mounts[i], i, options.transport, issue);
         if (m === null)
             return { issues };
         validatedMounts.push(m);
@@ -146,7 +148,7 @@ function validateTimeouts(raw, issue) {
     }
     return out;
 }
-function validateMount(raw, index, issue) {
+function validateMount(raw, index, transport, issue) {
     const path = `mounts[${index}]`;
     if (!isObject(raw)) {
         issue('command_manifest_invalid', 'mount must be an object', typeName(raw), '{ parent, node }', 'Fix the mount.', path);
@@ -175,7 +177,7 @@ function validateMount(raw, index, issue) {
     // Validate node
     const nodeRaw = raw['node'];
     const topLevel = parent.length === 0;
-    const node = validateConfiguredCliNode(nodeRaw, `${path}.node`, topLevel, issue);
+    const node = validateCommandNode(nodeRaw, [`${path}.node`], topLevel, transport, issue);
     if (node === null)
         return null;
     // Top-level mount must be a branch with rootEntry
@@ -183,7 +185,7 @@ function validateMount(raw, index, issue) {
         issue('command_node_invalid', 'top-level mount node must be a branch', node.kind, 'a branch with a rootEntry', 'Wrap the command in a top-level branch.', `${path}.node.kind`);
         return null;
     }
-    // Ensure the node is properly typed (should only be ConfiguredCliDeclLeaf at this point)
+    // Ensure the node is properly typed (should only be DeclLeaf at this point)
     const typedNode = node;
     return { parent, node: typedNode };
 }
@@ -192,8 +194,7 @@ function validateMount(raw, index, issue) {
 // ---------------------------------------------------------------------------
 /**
  * Materializes a flat list of mounts into a forest of top-level branches,
- * resolving parent paths order-independently. Validates self-containment
- * (no external parents), no duplicates, and no childless branches.
+ * resolving nested mounts whose parent exists in a top-level inline tree regardless of order. Nested mounts that provide another nested mount's parent must appear first. Validates self-containment and no duplicates.
  */
 function materializeForest(mounts, reservedCoreNames, issue) {
     // Separate top-level (parent: []) from nested (parent non-empty)
@@ -202,7 +203,7 @@ function materializeForest(mounts, reservedCoreNames, issue) {
     // Check for core-name collisions in top-level nodes
     for (const m of topLevel) {
         if (reservedCoreNames.has(m.node.name)) {
-            issue('command_parent_invalid', `node name conflicts with a crtr core command`, m.node.name, `a name not in core (not one of: ${[...reservedCoreNames].join(', ')})`, 'Rename the node or remove this mount.', `${m.node.name}`);
+            issue('command_collision', `node name conflicts with a crtr core command`, m.node.name, `a name not in core (not one of: ${[...reservedCoreNames].join(', ')})`, 'Rename the node or remove this mount.', `${m.node.name}`);
             return null;
         }
     }
@@ -216,6 +217,7 @@ function materializeForest(mounts, reservedCoreNames, issue) {
         ...(m.node.rootEntry !== undefined ? { rootEntry: m.node.rootEntry } : {}),
         summary: m.node.summary,
         ...(m.node.model !== undefined ? { model: m.node.model } : {}),
+        ...(m.node.passthrough !== undefined ? { passthrough: m.node.passthrough } : {}),
         children: [...m.node.children],
     }));
     // Attach nested mounts
@@ -269,6 +271,12 @@ function resolveAndAttachMount(roots, mount, issue) {
         }
         current = child;
     }
+    // A passthrough owns every token below its path, so nested mounts would make
+    // the materialized branch invalid even though its inline children are empty.
+    if (current.passthrough !== undefined) {
+        issue('command_parent_invalid', 'parent path resolves to a passthrough branch', mount.parent.join('.'), 'a branch without passthrough', 'Remove the nested mount or remove passthrough from its parent branch.', mount.parent.join('.'));
+        return false;
+    }
     // Attach the node
     if (current.children.some((c) => c.name === mount.node.name)) {
         issue('command_node_invalid', `duplicate child name`, mount.node.name, 'unique child names within a branch', 'Rename the node or remove the duplicate.', `${mount.parent.join('.')}.${mount.node.name}`);
@@ -277,8 +285,3 @@ function resolveAndAttachMount(roots, mount, issue) {
     current.children.push(mount.node);
     return true;
 }
-// ---------------------------------------------------------------------------
-// Configured CLI node validator (implements §4.3 + §4.4)
-// ---------------------------------------------------------------------------
-// Re-export and use the schema validator
-export { validateConfiguredCliNode } from '../command-manifests/schema.js';

package/dist/core/command-manifests/registry.d.ts

@@ -1,8 +1,7 @@
 import type { LeafDef } from '../command.js';
 import type { DeclLeafBase, DeclBranch, CommandManifestIssue } from './schema.js';
-/** Reference to an external contributor (plugin or configured CLI). */
+/** Reference to an external contributor (plugin or HTTP-transport plugin). */
 export type CommandContributorRef = {
-    kind: 'plugin' | 'configured-cli';
     name: string;
     scope: 'user' | 'project';
 };

package/dist/core/command-manifests/registry.js

@@ -1,6 +1,6 @@
 // Unified command registry: transport-neutral collision resolution and
 // contributor attribution. This module takes raw candidates (from plugins,
-// configured CLIs, or any external source) and runs one unified pass that:
+// HTTP-transport plugins, or any external source) and runs one unified pass that:
 //
 // 1. Detects collisions by resolved path (shortest collision wins).
 // 2. Drops all claimants at each collided path.
@@ -63,7 +63,7 @@ export function resolveCommandRegistry(candidates, reservedCoreNames) {
         if (collisions.has(pathKey)) {
             const collision = collisions.get(pathKey);
             const claimantNames = collision.claimants.map((c) => c.contributor.name).join(', ');
-            const claimantKinds = collision.claimants.map((c) => `${c.contributor.name} (${c.contributor.kind})`).join(', ');
+            const claimantKinds = collision.claimants.map((c) => c.contributor.name).join(', ');
             // Record an issue on this claimant. A core collision has exactly one
             // claimant contesting a reserved built-in name, not "multiple contributors".
             issues.push(collision.isCoreCollision

package/dist/core/command-manifests/schema.d.ts

@@ -14,10 +14,10 @@ export interface DeclBranch<L = DeclLeafBase> {
     rootEntry?: DeclRootEntry;
     summary: string;
     model?: string;
-    /** Plugin dialect only: forward every argv token after this branch to an
+    /** Exec transport only: forward every argv token after this branch to an
      *  external binary instead of parsing children. A passthrough branch is
-     *  childless by construction. Forbidden in the configured-CLI dialect — a
-     *  remote manifest naming a local binary to exec is a trust hole. */
+     *  childless by construction. HTTP manifests reject passthrough because an
+     *  HTTP transport must not name a local binary to execute. */
     passthrough?: DeclPassthrough;
     children: DeclNode<L>[];
 }
@@ -36,11 +36,11 @@ export interface DeclLeafBase {
     output: Field[];
     effects: string[];
 }
-/** Plugin-dialect leaf: requires outputKind: 'object' (no streaming in v1). */
-export interface PluginDeclLeaf extends DeclLeafBase {
+/** Exec-transport leaf: requires outputKind: 'object'. */
+export interface ExecDeclLeaf extends DeclLeafBase {
     outputKind: 'object';
 }
-/** Configured CLI REST mapping (placeholder types; full spec in manifest.ts). */
+/** HTTP-transport plugin REST mapping (placeholder types; full spec in manifest.ts). */
 export type RestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 export type RestParamPlacement = 'path' | 'query' | 'body' | 'header';
 export interface RestParamMapping {
@@ -64,11 +64,11 @@ export interface ManifestTimeouts {
     requestMs?: number;
     streamIdleMs?: number;
 }
-/** Configured CLI-dialect leaf: requires rest (derives outputKind from streaming). */
-export interface ConfiguredCliDeclLeaf extends DeclLeafBase {
+/** HTTP-transport leaf: requires rest (derives outputKind from streaming). */
+export interface HttpDeclLeaf extends DeclLeafBase {
     rest: RestMapping;
 }
-export type DeclLeaf = PluginDeclLeaf | ConfiguredCliDeclLeaf;
+export type DeclLeaf = ExecDeclLeaf | HttpDeclLeaf;
 export type DeclNode<L = DeclLeafBase> = DeclBranch<L> | (L extends DeclLeafBase ? DeclLeaf : never);
 export interface CommandManifestIssue {
     code: CommandIssueCode;
@@ -80,8 +80,6 @@ export interface CommandManifestIssue {
 }
 export type CommandIssueCode = 'command_manifest_unreadable' | 'command_manifest_invalid' | 'command_schema_version' | 'command_path_unsafe' | 'command_not_executable' | 'command_parent_invalid' | 'command_node_invalid' | 'command_collision' | 'command_rest_invalid';
 type IssueFn = (code: CommandIssueCode, message: string, received: string, expected: string, next: string, path?: string) => void;
-/** Validate a node for the plugin dialect (leaf must have outputKind: 'object'). */
-export declare function validatePluginNode(raw: unknown, path: string, topLevel: boolean, issue: IssueFn): DeclBranch<PluginDeclLeaf> | PluginDeclLeaf | null;
-/** Validate a node for the configured CLI dialect (leaf must have rest). */
-export declare function validateConfiguredCliNode(raw: unknown, path: string, topLevel: boolean, issue: IssueFn): DeclBranch<ConfiguredCliDeclLeaf> | ConfiguredCliDeclLeaf | null;
+export type TransportKind = 'exec' | 'http';
+export declare function validateCommandNode(raw: unknown, path: string[], topLevel: boolean, transport: TransportKind, issue: IssueFn): DeclBranch<DeclLeaf> | DeclLeaf | null;
 export {};