@crouton-kit/crouter 0.3.32 → 0.3.34

package/dist/commands/pkg/market-inspect.d.ts

@@ -1 +1,2 @@
-export declare const marketInspectBranch: import("../../core/command.js").BranchDef;
+export declare const marketList: import("../../core/command.js").LeafDef;
+export declare const marketBrowse: import("../../core/command.js").LeafDef;

package/dist/commands/pkg/market-inspect.js

@@ -1,25 +1,22 @@
-import { defineBranch, defineLeaf } from '../../core/command.js';
-import { notFound, usage } from '../../core/errors.js';
+import { defineLeaf } from '../../core/command.js';
+import { notFound } from '../../core/errors.js';
 import { paginate } from '../../core/pagination.js';
 import { listInstalledPlugins, listInstalledMarketplaces, listAllMarketplaces, findMarketplaceByName, } from '../../core/resolver.js';
 import { resolveScopeArg, projectScopeRoot } from '../../core/scope.js';
-// ---------------------------------------------------------------------------
-// market.inspect.list
-// ---------------------------------------------------------------------------
-const marketList = defineLeaf({
+export const marketList = defineLeaf({
     name: 'list',
     description: 'list registered marketplaces',
-    whenToUse: 'listing which marketplaces are registered, with their git URL, ref, and scope',
+    whenToUse: 'listing registered marketplace sources with their git URL, ref, scope, and clone path',
     help: {
-        name: 'pkg market inspect list',
+        name: 'pkg market list',
         summary: 'list registered marketplaces',
         params: [
-            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project', 'all'], required: false, constraint: 'One of: user, project, all. Default: all.' },
+            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project', 'all'], required: false, constraint: 'Default: all.' },
             { kind: 'flag', name: 'limit', type: 'int', required: false, default: 50, constraint: 'Default 50, max 200.' },
             { kind: 'flag', name: 'cursor', type: 'string', required: false, constraint: 'Opaque token from next_cursor. Omit on first call.' },
         ],
         output: [
-            { name: 'items', type: 'object[]', required: true, constraint: 'Each: {name, scope, url, ref, path, last_updated?}. Sorted by scope then name ascending.' },
+            { name: 'items', type: 'object[]', required: true, constraint: 'Each: {name, scope, url, ref, path}. Sorted by scope then name ascending.' },
             { name: 'next_cursor', type: 'string | null', required: true, constraint: 'null means no more items.' },
             { name: 'total', type: 'integer | null', required: true, constraint: 'Total count.' },
         ],
@@ -73,24 +70,21 @@ const marketList = defineLeaf({
         };
     },
 });
-// ---------------------------------------------------------------------------
-// market.inspect.browse
-// ---------------------------------------------------------------------------
-const marketBrowse = defineLeaf({
+export const marketBrowse = defineLeaf({
     name: 'browse',
     description: 'list plugins available in a marketplace',
-    whenToUse: 'exploring what a marketplace offers so you can decide before installing — lists every plugin in a marketplace index with its description, keywords, version, and whether it is already installed. Reach for this to pick which plugin to pull, then install it by name with `pkg market manage install`',
+    whenToUse: 'browsing one registered marketplace source to choose a plugin install ref; each item includes ref=marketplace/plugin for `pkg plugin install`',
     help: {
-        name: 'pkg market inspect browse',
+        name: 'pkg market browse',
         summary: 'list plugins available in a marketplace',
         params: [
-            { kind: 'flag', name: 'marketplace', type: 'string', required: false, constraint: 'Marketplace name. Omit to browse all registered marketplaces.' },
+            { kind: 'positional', name: 'name', type: 'string', required: true, constraint: 'Marketplace name.' },
             { kind: 'flag', name: 'limit', type: 'int', required: false, default: 50, constraint: 'Default 50, max 200.' },
             { kind: 'flag', name: 'cursor', type: 'string', required: false, constraint: 'Opaque token from next_cursor. Omit on first call.' },
         ],
         output: [
             { name: 'marketplace', type: 'string', required: true, constraint: 'Echo of the input marketplace name.' },
-            { name: 'items', type: 'object[]', required: true, constraint: 'Each: {name, source, version?, description?, keywords?, installed, installed_scope?}. Sorted by name ascending.' },
+            { name: 'items', type: 'object[]', required: true, constraint: 'Each: {name, ref, source, version?, description?, keywords?, installed, installed_scope?}. ref is marketplace/plugin. Sorted by name ascending.' },
             { name: 'next_cursor', type: 'string | null', required: true, constraint: 'null means no more items.' },
             { name: 'total', type: 'integer | null', required: true, constraint: 'Total plugins in the marketplace; null if unavailable.' },
         ],
@@ -98,13 +92,10 @@ const marketBrowse = defineLeaf({
         effects: ['None. Read-only.'],
     },
     run: async (input) => {
-        const mktName = input['marketplace'];
+        const mktName = input['name'];
         const limitRaw = input['limit'];
         const limit = limitRaw !== undefined ? Math.min(Math.max(1, limitRaw), 200) : 50;
         const cursor = input['cursor'];
-        if (mktName === undefined) {
-            throw usage('--marketplace is required for browse. Use `pkg market inspect list` to see registered marketplaces.');
-        }
         const mkt = findMarketplaceByName(mktName);
         if (!mkt)
             throw notFound(`marketplace not found: ${mktName}`);
@@ -131,6 +122,7 @@ const marketBrowse = defineLeaf({
                 const installed = installedScope !== undefined;
                 const item = {
                     name: entry.name,
+                    ref: `${mkt.name}/${entry.name}`,
                     source: entry.source,
                     version: entry.version,
                     description: entry.description,
@@ -147,13 +139,3 @@ const marketBrowse = defineLeaf({
         };
     },
 });
-export const marketInspectBranch = defineBranch({
-    name: 'inspect',
-    description: 'list or browse marketplaces',
-    whenToUse: 'reading marketplace metadata to decide before you install — list registered marketplaces, or browse the plugins available in one marketplace. Read-only; switch to `pkg market manage` to add a marketplace or install a plugin from it',
-    help: {
-        name: 'pkg market inspect',
-        summary: 'read marketplace metadata without modifying state',
-    },
-    children: [marketList, marketBrowse],
-});

package/dist/commands/pkg/market-manage.d.ts

@@ -1 +1,3 @@
-export declare const marketManageBranch: import("../../core/command.js").BranchDef;
+export declare const marketAdd: import("../../core/command.js").LeafDef;
+export declare const marketRemove: import("../../core/command.js").LeafDef;
+export declare const marketUpdate: import("../../core/command.js").LeafDef;

package/dist/commands/pkg/market-manage.js

@@ -1,28 +1,25 @@
-import { join, isAbsolute } from 'node:path';
+import { join } from 'node:path';
 import { renameSync } from 'node:fs';
-import { defineBranch, defineLeaf } from '../../core/command.js';
+import { defineLeaf } from '../../core/command.js';
 import { notFound } from '../../core/errors.js';
-import { listAllMarketplaces, findMarketplaceByName } from '../../core/resolver.js';
+import { listAllMarketplaces, listAllPlugins, findMarketplaceByName } from '../../core/resolver.js';
 import { resolveScopeArg, requireScopeRoot } from '../../core/scope.js';
 import { updateConfig, updateState, ensureScopeInitialized, readConfig } from '../../core/config.js';
-import { pathExists, ensureDir, removePath, linkOrCopy, isSymlink, nowIso } from '../../core/fs-utils.js';
-import { clone, pull, deriveNameFromUrl, currentSha } from '../../core/git.js';
-import { readMarketplaceManifest, readPluginManifest } from '../../core/manifest.js';
+import { pathExists, ensureDir, removePath, isSymlink, nowIso } from '../../core/fs-utils.js';
+import { clone, pull, deriveNameFromUrl, currentSha, isGitRepo } from '../../core/git.js';
+import { readMarketplaceManifest } from '../../core/manifest.js';
 import { resolveInstallScope } from './shared.js';
-// ---------------------------------------------------------------------------
-// market.manage.add
-// ---------------------------------------------------------------------------
-const marketAdd = defineLeaf({
+export const marketAdd = defineLeaf({
     name: 'add',
     description: 'add a marketplace by git URL',
-    whenToUse: 'registering a new marketplace by git URL so its plugins become installable by name',
+    whenToUse: 'registering a new marketplace source repo so its plugins appear in marketplace browse output and become installable by marketplace/plugin ref',
     help: {
-        name: 'pkg market manage add',
+        name: 'pkg market add',
         summary: 'add a marketplace by git URL',
         params: [
-            { kind: 'flag', name: 'url', type: 'string', required: true, constraint: 'Git URL of the marketplace repo.' },
+            { kind: 'positional', name: 'url', type: 'string', required: true, constraint: 'Git URL of the marketplace repo.' },
             { kind: 'flag', name: 'ref', type: 'string', required: false, constraint: 'Git ref to track. Default: main.' },
-            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'One of: user, project. Default: project if available, else user.' },
+            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Default: project if available, else user.' },
         ],
         output: [
             { name: 'name', type: 'string', required: true, constraint: 'Marketplace name as declared in marketplace.json.' },
@@ -71,26 +68,23 @@ const marketAdd = defineLeaf({
         return { name: finalName, scope, path: finalDest };
     },
 });
-// ---------------------------------------------------------------------------
-// market.manage.remove
-// ---------------------------------------------------------------------------
-const marketRemove = defineLeaf({
+export const marketRemove = defineLeaf({
     name: 'remove',
     description: 'remove a marketplace',
-    whenToUse: 'unregistering a marketplace: deletes it and any plugins installed from it',
+    whenToUse: 'unregistering a marketplace source: deletes the source clone and any plugins installed from it in the same scope',
     help: {
-        name: 'pkg market manage remove',
+        name: 'pkg market remove',
         summary: 'remove a marketplace and its directory',
         params: [
             { kind: 'positional', name: 'name', type: 'string', required: true, constraint: 'Marketplace name to remove.' },
-            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'One of: user, project.' },
+            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Narrows resolution.' },
         ],
         output: [
             { name: 'name', type: 'string', required: true, constraint: 'Removed marketplace name.' },
             { name: 'removed', type: 'boolean', required: true, constraint: 'Always true on success.' },
         ],
         outputKind: 'object',
-        effects: ['Deletes the marketplace directory. Removes the entry from config.json.'],
+        effects: ['Deletes the marketplace directory. Removes the entry from config.json. Removes plugin files and config entries sourced from that marketplace in the same scope.'],
     },
     run: async (input) => {
         const name = input['name'];
@@ -146,175 +140,85 @@ const marketRemove = defineLeaf({
         return { name, removed: true };
     },
 });
-// ---------------------------------------------------------------------------
-// market.manage.update
-// Single marketplace: blocking. All marketplaces: job handle.
-// ---------------------------------------------------------------------------
-const marketUpdate = defineLeaf({
+export const marketUpdate = defineLeaf({
     name: 'update',
-    description: 'pull latest marketplace index',
-    whenToUse: 'refreshing the plugin index of one named marketplace from git, or of all registered marketplaces when no name is given',
+    description: 'pull latest marketplace source',
+    whenToUse: 'refreshing one named marketplace source from git, or all registered marketplace sources when no name is given; also updates installed plugins sourced from refreshed marketplaces',
     help: {
-        name: 'pkg market manage update',
-        summary: 'git pull updates for one or all registered marketplaces',
+        name: 'pkg market update',
+        summary: 'git pull one or all registered marketplaces',
         params: [
-            { kind: 'flag', name: 'marketplace', type: 'string', required: false, constraint: 'Marketplace name to update. Omit to update all (returns a job handle).' },
+            { kind: 'flag', name: 'name', type: 'string', required: false, constraint: 'Marketplace name to update. Omit to update all registered marketplaces.' },
         ],
         output: [
-            { name: 'updated', type: 'object[]', required: false, constraint: 'Present for single (blocking) path: [{name, updated, sha}].' },
             { name: 'updated', type: 'object[]', required: true, constraint: 'One entry per marketplace processed: {name, updated, sha}.' },
         ],
         outputKind: 'object',
-        effects: ['Runs git pull in marketplace directories.'],
+        effects: ['Runs git pull in marketplace directories. Updates installed plugin content/version for plugins sourced from those marketplaces.'],
     },
     run: async (input) => {
-        const name = input['marketplace'];
+        const name = input['name'];
+        function pullIfGit(root) {
+            const shaBefore = currentSha(root);
+            if (!isGitRepo(root))
+                return { updated: false, sha: shaBefore ?? '' };
+            const res = pull(root);
+            if (res.status !== 0) {
+                return { updated: false, sha: shaBefore ?? '' };
+            }
+            const shaAfter = currentSha(root);
+            return { updated: shaBefore !== shaAfter, sha: shaAfter ?? '' };
+        }
         async function doUpdate(targets) {
             const results = [];
             for (const target of targets) {
-                const shaBefore = currentSha(target.root);
-                const res = pull(target.root);
-                if (res.status !== 0) {
-                    results.push({ name: target.name, updated: false, sha: shaBefore !== null ? shaBefore : '' });
-                    continue;
-                }
-                const shaAfter = currentSha(target.root);
-                const updated = shaBefore !== shaAfter;
+                const pullSummary = pullIfGit(target.root);
                 const freshManifest = readMarketplaceManifest(target.root);
+                if (freshManifest === null) {
+                    throw notFound(`marketplace manifest not found after refresh: ${target.root}/.crouter-marketplace/marketplace.json`);
+                }
                 updateState(target.scope, (s) => {
                     if (s.marketplaces[target.name] === undefined) {
                         s.marketplaces[target.name] = {};
                     }
                     s.marketplaces[target.name].last_updated = nowIso();
                 });
-                const cfg = readConfig(target.scope);
-                for (const [pluginName, entry] of Object.entries(cfg.plugins)) {
-                    if (entry.source_marketplace !== target.name)
-                        continue;
-                    const scopeRootPath = requireScopeRoot(target.scope);
-                    const pluginPath = join(scopeRootPath, 'plugins', pluginName);
-                    if (isSymlink(pluginPath)) {
-                        // content updated by marketplace pull above
+                const sourcedPlugins = listAllPlugins().filter((plugin) => plugin.scope !== 'builtin' && plugin.sourceMarketplace === target.name);
+                for (const plugin of sourcedPlugins) {
+                    if (isSymlink(plugin.root)) {
+                        // Marketplace pull above updates symlinked relative-source plugins.
                     }
-                    else if (pathExists(pluginPath)) {
-                        pull(pluginPath);
+                    else if (pathExists(plugin.root)) {
+                        pullIfGit(plugin.root);
                     }
-                    if (freshManifest !== null) {
-                        const pluginEntry = freshManifest.plugins.find((p) => p.name === pluginName);
-                        if (pluginEntry !== undefined && pluginEntry.version !== undefined) {
-                            updateConfig(target.scope, (c) => {
-                                if (c.plugins[pluginName] !== undefined) {
-                                    c.plugins[pluginName].version = pluginEntry.version;
-                                }
-                            });
-                        }
+                    const pluginEntry = freshManifest.plugins.find((p) => p.name === plugin.name);
+                    if (pluginEntry !== undefined && pluginEntry.version !== undefined) {
+                        updateConfig(plugin.scope, (c) => {
+                            if (c.plugins[plugin.name] !== undefined) {
+                                c.plugins[plugin.name].version = pluginEntry.version;
+                            }
+                        });
                     }
-                    updateState(target.scope, (s) => {
-                        if (s.plugins[pluginName] === undefined) {
-                            s.plugins[pluginName] = {};
+                    updateState(plugin.scope, (s) => {
+                        if (s.plugins[plugin.name] === undefined) {
+                            s.plugins[plugin.name] = {};
                         }
-                        s.plugins[pluginName].last_updated = nowIso();
+                        s.plugins[plugin.name].last_updated = nowIso();
                     });
                 }
-                results.push({ name: target.name, updated, sha: shaAfter !== null ? shaAfter : '' });
+                results.push({ name: target.name, updated: pullSummary.updated, sha: pullSummary.sha });
             }
             return results;
         }
         if (name !== undefined) {
-            // Single marketplace — blocking
             const found = findMarketplaceByName(name);
             if (!found)
                 throw notFound(`marketplace not found: ${name}`);
             const results = await doUpdate([{ name: found.name, scope: found.scope, root: found.root }]);
             return { updated: results };
         }
-        // All marketplaces — run synchronously (the underlying git pulls are sync).
-        const all = listAllMarketplaces();
-        const targets = all.map((m) => ({ name: m.name, scope: m.scope, root: m.root }));
+        const targets = listAllMarketplaces().map((m) => ({ name: m.name, scope: m.scope, root: m.root }));
         const results = await doUpdate(targets);
         return { updated: results };
     },
 });
-// ---------------------------------------------------------------------------
-// market.manage.install
-// ---------------------------------------------------------------------------
-const marketInstall = defineLeaf({
-    name: 'install',
-    description: 'install a plugin from a marketplace',
-    whenToUse: 'installing a plugin by name from a marketplace you have already registered',
-    help: {
-        name: 'pkg market manage install',
-        summary: 'install a plugin from an added marketplace by plugin name',
-        params: [
-            { kind: 'flag', name: 'marketplace', type: 'string', required: true, constraint: 'Marketplace name (must already be added via `pkg market manage add`).' },
-            { kind: 'flag', name: 'plugin', type: 'string', required: true, constraint: 'Plugin name as listed in the marketplace manifest.' },
-            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'One of: user, project. Default: project if available, else user.' },
-        ],
-        output: [
-            { name: 'name', type: 'string', required: true, constraint: 'Installed plugin name.' },
-            { name: 'scope', type: 'string', required: true, constraint: 'Scope the plugin was installed into.' },
-            { name: 'path', type: 'string', required: true, constraint: 'Absolute path to the installed plugin directory.' },
-        ],
-        outputKind: 'object',
-        effects: ['Clones or copies the plugin from the marketplace into the scope plugins directory. Registers the plugin in config.json with source_marketplace set.'],
-    },
-    run: async (input) => {
-        const mktName = input['marketplace'];
-        const pluginName = input['plugin'];
-        const scopeInput = input['scope'];
-        const mkt = findMarketplaceByName(mktName);
-        if (!mkt)
-            throw notFound(`marketplace not found: ${mktName}`);
-        const entry = mkt.manifest.plugins.find((p) => p.name === pluginName);
-        if (!entry)
-            throw notFound(`plugin "${pluginName}" not found in marketplace "${mktName}"`);
-        const destScope = resolveInstallScope(scopeInput);
-        const destRoot = requireScopeRoot(destScope);
-        ensureScopeInitialized(destScope, destRoot);
-        const destPluginDir = join(destRoot, 'plugins', pluginName);
-        const source = entry.source;
-        const isRelativePath = source.startsWith('./') ||
-            source.startsWith('../') ||
-            (!source.includes('://') && !isAbsolute(source));
-        if (isRelativePath) {
-            const sourcePath = join(mkt.root, source);
-            if (!pathExists(sourcePath)) {
-                throw notFound(`plugin source path does not exist: ${sourcePath}`);
-            }
-            linkOrCopy(sourcePath, destPluginDir);
-        }
-        else {
-            if (pathExists(destPluginDir)) {
-                removePath(destPluginDir);
-            }
-            clone(source, destPluginDir, { depth: 1 });
-        }
-        const pluginManifest = readPluginManifest(destPluginDir);
-        if (!pluginManifest) {
-            removePath(destPluginDir);
-            throw notFound(`plugin manifest not found at ${destPluginDir}/.crouter-plugin/plugin.json`);
-        }
-        const version = entry.version !== undefined ? entry.version : pluginManifest.version;
-        updateConfig(destScope, (cfg) => {
-            const pluginCfg = {
-                enabled: true,
-                source_marketplace: mktName,
-            };
-            if (version !== undefined) {
-                pluginCfg.version = version;
-            }
-            cfg.plugins[pluginName] = pluginCfg;
-        });
-        return { name: pluginName, scope: destScope, path: destPluginDir };
-    },
-});
-export const marketManageBranch = defineBranch({
-    name: 'manage',
-    description: 'add, remove, update, install',
-    whenToUse: 'changing marketplace state: add or remove a marketplace, refresh its index, or install a plugin from it',
-    help: {
-        name: 'pkg market manage',
-        summary: 'add, remove, update, or install from marketplaces',
-    },
-    children: [marketAdd, marketRemove, marketUpdate, marketInstall],
-});

package/dist/commands/pkg/market.js

@@ -1,14 +1,14 @@
 import { defineBranch } from '../../core/command.js';
-import { marketManageBranch } from './market-manage.js';
-import { marketInspectBranch } from './market-inspect.js';
+import { marketAdd, marketRemove, marketUpdate } from './market-manage.js';
+import { marketBrowse, marketList } from './market-inspect.js';
 export const marketBranch = defineBranch({
     name: 'market',
-    description: 'manage marketplace sources and install from them',
-    whenToUse: 'using curated plugin collections instead of raw git URLs — register a marketplace, browse its index of plugins, then install them by name. Use `pkg plugin` instead when you already have a specific git URL or local plugin to install directly, or when inspecting and toggling plugins that are already installed',
+    description: 'manage and browse marketplace sources',
+    whenToUse: 'working with marketplace sources: add or remove a marketplace repo, refresh registered sources, list them, or browse one source for plugin install refs. Use `pkg plugin install marketplace/plugin` to install a plugin from a marketplace.',
     help: {
         name: 'pkg market',
-        summary: 'manage and browse plugin marketplaces',
-        model: 'Marketplaces are git repos containing a .crouter-marketplace/marketplace.json index of plugins.',
+        summary: 'marketplace source management and browsing',
+        model: 'Marketplaces are git repos containing a .crouter-marketplace/marketplace.json index. This branch owns sources only; plugin lifecycle is under `pkg plugin`.',
     },
-    children: [marketManageBranch, marketInspectBranch],
+    children: [marketAdd, marketRemove, marketUpdate, marketList, marketBrowse],
 });

package/dist/commands/pkg/plugin-inspect.d.ts

@@ -1 +1,2 @@
-export declare const pluginInspectBranch: import("../../core/command.js").BranchDef;
+export declare const pluginList: import("../../core/command.js").LeafDef;
+export declare const pluginShow: import("../../core/command.js").LeafDef;

package/dist/commands/pkg/plugin-inspect.js

@@ -1,18 +1,15 @@
-import { defineBranch, defineLeaf } from '../../core/command.js';
+import { defineLeaf } from '../../core/command.js';
 import { notFound } from '../../core/errors.js';
 import { paginate } from '../../core/pagination.js';
 import { listInstalledPlugins, findPluginByName, } from '../../core/resolver.js';
 import { listAllMemoryDocs } from '../../core/memory-resolver.js';
 import { resolveScopeArg, projectScopeRoot } from '../../core/scope.js';
-// ---------------------------------------------------------------------------
-// plugin.inspect.list
-// ---------------------------------------------------------------------------
-const pluginList = defineLeaf({
+export const pluginList = defineLeaf({
     name: 'list',
     description: 'paginated list of installed plugins',
-    whenToUse: 'enumerating which plugins are installed across user and project scope, optionally including disabled ones',
+    whenToUse: 'enumerating installed plugins across user and project scope, optionally including disabled plugins',
     help: {
-        name: 'pkg plugin inspect list',
+        name: 'pkg plugin list',
         summary: 'paginated list of installed plugins',
         params: [
             { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project', 'all'], required: false, constraint: 'Default: all.' },
@@ -74,19 +71,16 @@ const pluginList = defineLeaf({
         };
     },
 });
-// ---------------------------------------------------------------------------
-// plugin.inspect.show
-// ---------------------------------------------------------------------------
-const pluginShow = defineLeaf({
+export const pluginShow = defineLeaf({
     name: 'show',
     description: 'read plugin manifest and substrate inventory',
-    whenToUse: 'reading one installed plugin in detail to decide before you enable, disable, or remove it — returns the full manifest, the substrate docs it provides (its `<pluginName>/` memory subtree), its scope, and whether it is currently enabled. Use `pkg plugin inspect list` instead to enumerate plugins rather than drill into one',
+    whenToUse: 'reading one installed plugin in detail: manifest, provided memory docs, scope, path, and enabled state',
     help: {
-        name: 'pkg plugin inspect show',
+        name: 'pkg plugin show',
         summary: 'read plugin manifest and metadata by name',
         params: [
             { kind: 'positional', name: 'name', type: 'string', required: true, constraint: 'Plugin name.' },
-            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'One of: user, project. Narrows resolution.' },
+            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Narrows resolution.' },
         ],
         output: [
             { name: 'name', type: 'string', required: true, constraint: 'Plugin name.' },
@@ -94,7 +88,7 @@ const pluginShow = defineLeaf({
             { name: 'path', type: 'string', required: true, constraint: 'Absolute path to the plugin directory.' },
             { name: 'enabled', type: 'boolean', required: true, constraint: 'Whether the plugin is active.' },
             { name: 'manifest', type: 'object', required: true, constraint: 'Full plugin.json contents.' },
-            { name: 'skills', type: 'object[]', required: true, constraint: 'Each: {name, path}. Substrate docs provided by the plugin (its `<pluginName>/` memory subtree).' },
+            { name: 'docs', type: 'object[]', required: true, constraint: 'Each: {name, path}. Memory docs provided by the plugin (its `<pluginName>/` memory subtree).' },
         ],
         outputKind: 'object',
         effects: ['None. Read-only.'],
@@ -119,27 +113,17 @@ const pluginShow = defineLeaf({
             throw notFound(`plugin not found: ${name}`);
         }
         const prefix = `${found.name}/`;
-        const skills = listAllMemoryDocs().filter((d) => d.name.startsWith(prefix));
+        const docs = listAllMemoryDocs().filter((d) => d.name.startsWith(prefix));
         return {
             name: found.name,
             scope: found.scope,
             path: found.root,
             enabled: found.enabled,
             manifest: found.manifest,
-            skills: skills.map((s) => ({
-                name: s.name,
-                path: s.path,
+            docs: docs.map((d) => ({
+                name: d.name,
+                path: d.path,
             })),
         };
     },
 });
-export const pluginInspectBranch = defineBranch({
-    name: 'inspect',
-    description: 'list or show installed plugins',
-    whenToUse: 'reading installed plugin metadata to decide before you change anything — list what is installed, or show the manifest and skills of one plugin. Read-only; switch to `pkg plugin manage` to actually install, enable, disable, or remove',
-    help: {
-        name: 'pkg plugin inspect',
-        summary: 'read plugin metadata without modifying state',
-    },
-    children: [pluginList, pluginShow],
-});

package/dist/commands/pkg/plugin-manage.d.ts

@@ -1 +1,5 @@
-export declare const pluginManageBranch: import("../../core/command.js").BranchDef;
+export declare const pluginInstall: import("../../core/command.js").LeafDef;
+export declare const pluginRemove: import("../../core/command.js").LeafDef;
+export declare const pluginEnable: import("../../core/command.js").LeafDef;
+export declare const pluginDisable: import("../../core/command.js").LeafDef;
+export declare const pluginUpdate: import("../../core/command.js").LeafDef;