@phnx-labs/agents-cli 1.18.1 → 1.18.3

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 1.18.3
+
+**Plugins** ([#22](https://github.com/phnx-labs/agents-cli/issues/22))
+
+- `agents plugins sync` now installs plugins via Claude Code's native marketplace path — `<versionHome>/.{claude,openclaw}/plugins/marketplaces/agents-cli/plugins/<name>/` — instead of flattening contents into `~/.claude/skills/<plugin>--<skill>/`. Skills resolve as `/plugin:skill` (the documented form) instead of `/plugin--skill`. Plugins appear in Claude's `/plugins` UI under Installed and respond to `/plugin enable`, `/plugin disable`.
+- A synthetic `agents-cli` marketplace is materialized per version: `.claude-plugin/marketplace.json` is synthesized from discovered plugins, an entry is added to `<versionHome>/.claude/plugins/known_marketplaces.json`, and `settings.json#enabledPlugins["<plugin>@agents-cli"]` is flipped to `true`. Removal is symmetric — last plugin out drops the marketplace dir and the known_marketplaces entry.
+- The sync now copies the whole plugin tree verbatim (single `fs.cpSync`) instead of re-implementing per-feature merges into `settings.json`. Every Claude plugin feature — skills, commands, subagents, hooks, `.mcp.json`, `.lsp.json`, `monitors/monitors.json`, `bin/`, `settings.json` — is preserved end-to-end. `${CLAUDE_PLUGIN_ROOT}` and `${CLAUDE_PLUGIN_DATA}` are left intact so Claude can expand them at runtime; only `${user_config.*}` (agents-cli-specific) is pre-expanded in copied text files.
+- Legacy dual-dash layout from prior versions is auto-migrated at sync time — `~/.claude/skills/<plugin>--*`, `~/.claude/commands/<plugin>--*.md`, `~/.claude/agents/<plugin>--*.md`, `plugin-bin/<plugin>/`, and namespaced `mcpServers["<plugin>--*"]` entries are removed after the marketplace install succeeds.
+- `agents plugins view <name>` surfaces every feature the plugin ships: Skills, Commands, Subagents, Hooks, MCP Servers, LSP Servers, Monitors, Bin, Scripts, Settings. The `agents view <agent>@<version>` Plugins section gains MCP/LSP/Monitor/Bin/Settings counts. New `discoverPluginMcpServers`, `discoverPluginLspServers`, `discoverPluginMonitors` helpers parse `.mcp.json`, `.lsp.json`, and `monitors/monitors.json`.
+
+## 1.18.2
+
+**Teams**
+
+- Dropped `~/.agents/teams/config.json` entirely. It duplicated information agents-cli already has — agent commands, enabled flags, model defaults, provider endpoints — none of which the team runner was actually reading. Teams now discover agents via `listInstalledVersions()` (the same source `agents view` uses) and invoke them via the canonical `agents run` subcommand. One spawn path, one canonical exec module (`src/lib/exec.ts`). The deprecated `AGENT_COMMANDS`, `applyEditMode`, `applyFullMode`, `readConfig`, `writeConfig`, `setAgentEnabled`, `AgentConfig`, `SwarmConfig`, `ProviderConfig`, `ModelOverrides`, `ReadConfigResult`, and `EffortLevel` (the persistence-module copy) exports are removed from `@phnx-labs/agents-cli/teams`. Migration deletes both `~/.agents/teams/config.json` and the legacy `~/.agents/config.json`.
+- `~/.agents/teams/registry.json` moves to `~/.agents/.history/teams/registry.json` — it's per-machine runtime state (timestamps + absolute worktree paths) and shouldn't be synced across machines via `agents repo push`.
+- New `agents run --quiet` flag suppresses the rotation banner and `Running: …` preamble lines. Used by the team runner so stream-json events reach the parser without non-JSON preamble.
+
+**Dev builds**
+
+- The CLI auto-detects dev builds (version stamped `0.0.0-dev.<sha>` by `scripts/install.sh`, or invoked from a working tree where `<cli-dir>/../.git/` exists) and defaults `AGENTS_NO_AUTOPULL=1`, `AGENTS_SKIP_MIGRATION=1`, and `AGENTS_CLI_DISABLE_AUTO_UPDATE=1`. No more typing those three env vars on every iteration. Production installs (registry global, no `.git/` at package root) are unaffected.
+
 ## 1.18.1
 
 **Fixes**

package/dist/commands/doctor.js

@@ -1,8 +1,8 @@
 import chalk from 'chalk';
 import { checkAllClis } from '../lib/teams/agents.js';
 import { AGENTS, ALL_AGENT_IDS, resolveAgentName, formatAgentError } from '../lib/agents.js';
-import { getAvailableResources, getGlobalDefault, getVersionHomePath, isVersionInstalled, listInstalledVersions, parseAgentSpec, } from '../lib/versions.js';
-import { loadSyncManifest, isSyncStale } from '../lib/sync-manifest.js';
+import { getGlobalDefault, getVersionHomePath, isVersionInstalled, listInstalledVersions, parseAgentSpec, } from '../lib/versions.js';
+import { loadManifest, isStale } from '../lib/staleness/index.js';
 import { diffVersionCommands, iterCommandsCapableVersions } from '../lib/commands.js';
 import { diffVersionSkills, iterSkillsCapableVersions } from '../lib/skills.js';
 import { diffVersionHooks, iterHooksCapableVersions } from '../lib/hooks.js';
@@ -17,13 +17,12 @@ function checkSyncStatus(cwd) {
         const version = getGlobalDefault(agent);
         if (!version)
             continue;
-        const manifest = loadSyncManifest(agent, version);
+        const manifest = loadManifest(agent, version);
         if (!manifest) {
             rows.push({ agent, version, status: 'never-synced' });
             continue;
         }
-        const available = getAvailableResources(cwd);
-        const stale = isSyncStale(manifest, available, agent, version, cwd);
+        const stale = isStale(manifest, agent, version, cwd);
         rows.push({ agent, version, status: stale ? 'stale' : 'fresh' });
     }
     return rows;
@@ -270,6 +269,21 @@ function renderTargetText(report, options) {
             : null,
     ].filter(Boolean).join(' ');
     console.log(chalk.gray(`  layers: ${layerStr}`));
+    // Staleness manifest verdict — single-line summary from the staleness
+    // library, sitting alongside the detailed per-resource diff below.
+    const manifest = loadManifest(report.agent, report.version);
+    if (!manifest) {
+        console.log(chalk.gray(`  manifest: ${chalk.gray('cold')} (never synced)`));
+    }
+    else {
+        const stale = isStale(manifest, report.agent, report.version, report.cwd);
+        if (stale) {
+            console.log(chalk.gray('  manifest: ') + chalk.yellow('stale') + chalk.gray(' (sources changed since last sync)'));
+        }
+        else {
+            console.log(chalk.gray('  manifest: ') + chalk.green('fresh'));
+        }
+    }
     console.log();
     for (const kind of DOCTOR_ALL_KINDS) {
         const rows = report.kinds[kind];

package/dist/commands/exec.js

@@ -51,6 +51,7 @@ export function registerRunCommand(program) {
         .option('--cwd <dir>', 'Working directory for the agent (defaults to current directory)')
         .option('--add-dir <dir>', 'Grant access to an additional directory outside the project (Claude only, repeatable)', (val, prev) => [...prev, val], [])
         .option('--json', 'Stream events as JSON lines (for parsing by other tools)')
+        .option('--quiet', 'Suppress preamble (rotation banner, "Running:" line). Useful when piping JSON events to a parser.', false)
         .option('--headless', 'Non-interactive mode (auto-enabled when prompt provided)', false)
         .option('-i, --interactive', 'Force interactive mode even when a prompt is provided')
         .option('--session-id <id>', 'Resume a previous conversation (Claude only)')
@@ -249,17 +250,19 @@ Examples:
                     const resolved = await resolveRunVersion(agent, strategy, cwd);
                     if (resolved.version) {
                         version = resolved.version;
-                        if (resolved.rotation) {
+                        if (resolved.rotation && !options.quiet) {
                             const banner = formatRotationBanner(resolved.rotation, strategy);
                             process.stderr.write(chalk.gray(banner + '\n'));
                         }
                     }
-                    else {
+                    else if (!options.quiet) {
                         process.stderr.write(chalk.yellow(`[agents] strategy ${strategy} found no usable ${agent} version; falling back to defaults\n`));
                     }
                 }
                 catch (err) {
-                    process.stderr.write(chalk.yellow(`[agents] strategy ${strategy} skipped: ${err.message}\n`));
+                    if (!options.quiet) {
+                        process.stderr.write(chalk.yellow(`[agents] strategy ${strategy} skipped: ${err.message}\n`));
+                    }
                 }
             }
         }
@@ -388,7 +391,9 @@ Examples:
             }
         }
         const cmd = buildExecCommand(execOptions);
-        process.stderr.write(chalk.gray(`Running: ${cmd.join(' ')}\n\n`));
+        if (!options.quiet) {
+            process.stderr.write(chalk.gray(`Running: ${cmd.join(' ')}\n\n`));
+        }
         try {
             let exitCode;
             if (fallback.length > 0) {

package/dist/commands/plugins.js

@@ -149,7 +149,19 @@ Examples:
         if (plugin.skills.length > 0) {
             console.log(chalk.bold('\n  Skills'));
             for (const skill of plugin.skills) {
-                console.log(`    ${chalk.cyan(`${plugin.name}:${skill}`)}`);
+                console.log(`    ${chalk.cyan(`/${plugin.name}:${skill}`)}`);
+            }
+        }
+        if (plugin.commands.length > 0) {
+            console.log(chalk.bold('\n  Commands'));
+            for (const cmd of plugin.commands) {
+                console.log(`    ${chalk.cyan(`/${plugin.name}:${cmd}`)}`);
+            }
+        }
+        if (plugin.agentDefs.length > 0) {
+            console.log(chalk.bold('\n  Subagents'));
+            for (const a of plugin.agentDefs) {
+                console.log(`    ${chalk.magenta(a)}`);
             }
         }
         if (plugin.hooks.length > 0) {
@@ -158,12 +170,40 @@ Examples:
                 console.log(`    ${chalk.yellow(hook)}`);
             }
         }
+        if (plugin.mcpServers.length > 0) {
+            console.log(chalk.bold('\n  MCP Servers'));
+            for (const s of plugin.mcpServers) {
+                console.log(`    ${chalk.green(s)}`);
+            }
+        }
+        if (plugin.lspServers.length > 0) {
+            console.log(chalk.bold('\n  LSP Servers'));
+            for (const s of plugin.lspServers) {
+                console.log(`    ${chalk.green(s)}`);
+            }
+        }
+        if (plugin.monitors.length > 0) {
+            console.log(chalk.bold('\n  Monitors'));
+            for (const m of plugin.monitors) {
+                console.log(`    ${chalk.blue(m)}`);
+            }
+        }
+        if (plugin.bin.length > 0) {
+            console.log(chalk.bold('\n  Bin'));
+            for (const b of plugin.bin) {
+                console.log(`    ${chalk.white(b)}`);
+            }
+        }
         if (plugin.scripts.length > 0) {
             console.log(chalk.bold('\n  Scripts'));
             for (const script of plugin.scripts) {
                 console.log(`    ${chalk.gray(script)}`);
             }
         }
+        if (plugin.hasSettings) {
+            console.log(chalk.bold('\n  Settings'));
+            console.log(`    ${chalk.gray('settings.json')}`);
+        }
         // Show installation status per agent version
         console.log(chalk.bold('\n  Installation Status'));
         let anyInstalled = false;
@@ -572,20 +612,24 @@ function formatPluginDetail(plugin, targets) {
         lines.push('  ' + chalk.gray('Supports: ') + supported.join(chalk.gray(' · ')));
     }
     lines.push('  ' + chalk.gray(formatPath(plugin.root)));
-    if (plugin.skills.length > 0) {
-        lines.push('');
-        lines.push(chalk.bold('  Skills'));
-        lines.push('  ' + plugin.skills.map((s) => chalk.cyan(s)).join(chalk.gray(', ')));
-    }
-    if (plugin.hooks.length > 0) {
-        lines.push('');
-        lines.push(chalk.bold('  Hooks'));
-        lines.push('  ' + plugin.hooks.map((h) => chalk.yellow(h)).join(chalk.gray(', ')));
-    }
-    if (plugin.scripts.length > 0) {
+    const section = (label, items, colorFn) => {
+        if (items.length === 0)
+            return;
         lines.push('');
-        lines.push(chalk.bold('  Scripts'));
-        lines.push('  ' + plugin.scripts.map((s) => chalk.white(s)).join(chalk.gray(', ')));
+        lines.push(chalk.bold(`  ${label}`));
+        lines.push('  ' + items.map(colorFn).join(chalk.gray(', ')));
+    };
+    section('Skills', plugin.skills.map((s) => `/${plugin.name}:${s}`), chalk.cyan);
+    section('Commands', plugin.commands.map((c) => `/${plugin.name}:${c}`), chalk.cyan);
+    section('Subagents', plugin.agentDefs, chalk.magenta);
+    section('Hooks', plugin.hooks, chalk.yellow);
+    section('MCP Servers', plugin.mcpServers, chalk.green);
+    section('LSP Servers', plugin.lspServers, chalk.green);
+    section('Monitors', plugin.monitors, chalk.blue);
+    section('Bin', plugin.bin, chalk.white);
+    section('Scripts', plugin.scripts, chalk.white);
+    if (plugin.hasSettings) {
+        section('Settings', ['settings.json'], chalk.gray);
     }
     if (targets.length > 0) {
         lines.push('');

package/dist/commands/view.js

@@ -604,19 +604,28 @@ async function showAgentResources(agentId, requestedVersion) {
             const versionStr = agentData.version ? ` (${agentData.version})` : '';
             const agentHeader = home ? termLink(agentData.agentName, home) : agentData.agentName;
             console.log(`  ${chalk.bold(agentHeader)}${chalk.gray(versionStr)}:`);
+            const pluralize = (n, singular) => `${n} ${singular}${n === 1 ? '' : 's'}`;
             for (const p of plugins) {
                 const linkedName = termLink(p.name, linkTarget(p.root));
                 const parts = [];
                 if (p.skills.length > 0)
-                    parts.push(`${p.skills.length} skill${p.skills.length === 1 ? '' : 's'}`);
+                    parts.push(pluralize(p.skills.length, 'skill'));
                 if (p.commands.length > 0)
-                    parts.push(`${p.commands.length} command${p.commands.length === 1 ? '' : 's'}`);
-                if (p.hooks.length > 0)
-                    parts.push(`${p.hooks.length} hook${p.hooks.length === 1 ? '' : 's'}`);
+                    parts.push(pluralize(p.commands.length, 'command'));
                 if (p.agentDefs.length > 0)
-                    parts.push(`${p.agentDefs.length} subagent${p.agentDefs.length === 1 ? '' : 's'}`);
-                if (p.hasMcp)
-                    parts.push('mcp');
+                    parts.push(pluralize(p.agentDefs.length, 'subagent'));
+                if (p.hooks.length > 0)
+                    parts.push(pluralize(p.hooks.length, 'hook'));
+                if (p.mcpServers.length > 0)
+                    parts.push(`${p.mcpServers.length} MCP`);
+                if (p.lspServers.length > 0)
+                    parts.push(`${p.lspServers.length} LSP`);
+                if (p.monitors.length > 0)
+                    parts.push(pluralize(p.monitors.length, 'monitor'));
+                if (p.bin.length > 0)
+                    parts.push(pluralize(p.bin.length, 'bin'));
+                if (p.hasSettings)
+                    parts.push('settings');
                 const contents = parts.length > 0 ? chalk.gray(` (${parts.join(', ')})`) : '';
                 console.log(`    ${chalk.cyan(linkedName)}${contents} ${chalk.cyan('[user]')}`);
             }

package/dist/index.js

@@ -23,6 +23,36 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const packageJsonPath = path.join(__dirname, '..', 'package.json');
 const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
 const VERSION = packageJson.version;
+// Detect dev/working-tree builds and default the noisy startup steps off.
+// Three cases trip this:
+//   1. Dev install (scripts/install.sh) — package.json version stamped 0.0.0-dev.<sha>
+//   2. Running `node dist/index.js` from a working tree — repo root has .git/
+//   3. Running tsx/ts-node from src/ — also has .git/ at the repo root
+// For all three: skip auto-pull (no network noise + no surprise FF on the
+// system repo while iterating), skip migration (a buggy in-progress migration
+// must not scribble on the user's real ~/.agents/), and skip the update prompt
+// (the "0.0.0-dev -> 1.x.y" message is misleading). Each individual env var
+// can still be set explicitly to override (set to '0' to re-enable).
+const IS_DEV_BUILD = (() => {
+    if (VERSION.startsWith('0.0.0-dev'))
+        return true;
+    try {
+        const cliPath = process.argv[1] || '';
+        const repoRoot = path.dirname(path.dirname(cliPath));
+        return fs.existsSync(path.join(repoRoot, '.git'));
+    }
+    catch {
+        return false;
+    }
+})();
+if (IS_DEV_BUILD) {
+    if (process.env.AGENTS_NO_AUTOPULL === undefined)
+        process.env.AGENTS_NO_AUTOPULL = '1';
+    if (process.env.AGENTS_SKIP_MIGRATION === undefined)
+        process.env.AGENTS_SKIP_MIGRATION = '1';
+    if (process.env.AGENTS_CLI_DISABLE_AUTO_UPDATE === undefined)
+        process.env.AGENTS_CLI_DISABLE_AUTO_UPDATE = '1';
+}
 // Import command registrations
 import { registerPullCommand } from './commands/pull.js';
 import { registerRepoCommands } from './commands/repo.js';

package/dist/lib/hooks.js

@@ -51,6 +51,18 @@ function isManagedHookCommand(command, prefixes) {
     return false;
 }
 import { getEffectiveHome, getVersionHomePath, listInstalledVersions } from './versions.js';
+/**
+ * Extensions that are NEVER hooks — docs, configuration, plain data. A file
+ * in hooks/ with one of these extensions is auxiliary content (e.g., the
+ * `promptcuts.yaml` data file read directly by the expand-promptcuts
+ * script, or the `README.md` that documents the hooks directory). They
+ * sometimes carry an exec bit by accident (older sync runs chmod 0o755'd
+ * everything) but they are not scripts.
+ */
+const NON_SCRIPT_EXTENSIONS = new Set([
+    '.md', '.markdown', '.rst', '.txt',
+    '.yaml', '.yml', '.json', '.toml', '.ini', '.conf',
+]);
 const SCRIPT_EXTENSIONS = new Set([
     '.sh',
     '.bash',
@@ -140,9 +152,15 @@ export function listHookEntriesFromDir(dir) {
     const entries = [];
     for (const [base, group] of grouped) {
         group.sort((a, b) => a.name.localeCompare(b.name));
-        const script = group.find((f) => f.isExec) ||
-            group.find((f) => SCRIPT_EXTENSIONS.has(f.ext.toLowerCase())) ||
-            group[0];
+        // A group is a hook only if it has an actual script: a script extension,
+        // OR an executable bit on a file whose extension is not a known data /
+        // docs type. Files like `README.md` (docs) or `promptcuts.yaml` (data
+        // the expand-promptcuts hook reads directly) sit alongside hooks but
+        // are NOT hooks themselves and must not surface in the hooks list
+        // anywhere — doctor, sync, view, or otherwise. Older sync runs may have
+        // chmod 0o755'd these files; an exec bit alone is not enough.
+        const script = group.find((f) => SCRIPT_EXTENSIONS.has(f.ext.toLowerCase())) ||
+            group.find((f) => f.isExec && !NON_SCRIPT_EXTENSIONS.has(f.ext.toLowerCase()));
         if (!script)
             continue;
         const data = group.find((f) => f !== script);

package/dist/lib/migrate.js

@@ -58,14 +58,14 @@ function deleteSystemPromptsJson() {
  * The teams persistence layer already reads the legacy path as a fallback;
  * moving it here keeps the canonical location consistent.
  */
+// Delete the legacy ~/.agents-system/config.json. This was the teams agent
+// registry, which no longer exists — `agents teams` discovers agents through
+// `listInstalledVersions` and invokes them through `agents run`.
 function migrateSystemConfigJson() {
     const src = path.join(SYSTEM_DIR, 'config.json');
-    const dest = path.join(USER_DIR, 'teams', 'config.json');
-    if (!fs.existsSync(src) || fs.existsSync(dest))
+    if (!fs.existsSync(src))
         return;
     try {
-        fs.mkdirSync(path.dirname(dest), { recursive: true, mode: 0o700 });
-        fs.copyFileSync(src, dest);
         fs.unlinkSync(src);
     }
     catch { /* best-effort */ }
@@ -375,20 +375,41 @@ function deleteUserPromptsJson() {
     catch { /* best-effort */ }
 }
 /**
- * Delete ~/.agents/config.json. The canonical teams config is at
- * ~/.agents/teams/config.json (teams/persistence.ts). If the canonical
- * file exists we just unlink the legacy copy; otherwise migrate first.
+ * Delete ~/.agents/teams/config.json. The teams subsystem no longer carries
+ * its own agent registry — agent discovery flows through `listInstalledVersions`
+ * (the same source `agents view` uses) and invocation flows through
+ * `agents run`. The on-disk file is pure dead state on existing installs.
+ */
+function deleteTeamsConfigJson() {
+    const f = path.join(USER_DIR, 'teams', 'config.json');
+    if (!fs.existsSync(f))
+        return;
+    try {
+        fs.unlinkSync(f);
+    }
+    catch { /* best-effort */ }
+}
+/**
+ * Move ~/.agents/teams/registry.json → ~/.agents/.history/teams/registry.json.
+ * The registry is per-machine runtime state (timestamps + absolute worktree
+ * paths) and belongs in the durable-runtime bucket, not at the user-root
+ * where `agents repo push` would sync it across machines.
+ */
+function moveTeamsRegistryToHistory() {
+    const src = path.join(USER_DIR, 'teams', 'registry.json');
+    const dest = path.join(HISTORY_DIR, 'teams', 'registry.json');
+    moveFileOnce(src, dest);
+}
+/**
+ * Delete ~/.agents/config.json. This was the legacy teams config location;
+ * the teams subsystem no longer carries a config file at all, so the legacy
+ * copy is simply removed.
  */
 function cleanupUserConfigJson() {
     const legacy = path.join(USER_DIR, 'config.json');
     if (!fs.existsSync(legacy))
         return;
-    const canonical = path.join(USER_DIR, 'teams', 'config.json');
     try {
-        if (!fs.existsSync(canonical)) {
-            fs.mkdirSync(path.dirname(canonical), { recursive: true, mode: 0o700 });
-            fs.copyFileSync(legacy, canonical);
-        }
         fs.unlinkSync(legacy);
     }
     catch { /* best-effort */ }
@@ -1455,6 +1476,8 @@ export async function runMigration() {
     migratePermissionSetsToPresets();
     deleteUserLinearJson();
     deleteUserPromptsJson();
+    deleteTeamsConfigJson();
+    moveTeamsRegistryToHistory();
     cleanupUserConfigJson();
     cleanupEmptyTopLevelRuns();
     foldUserHooksYamlIntoAgentsYaml();

package/dist/lib/plugin-marketplace.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Native plugin marketplace install path for Claude / OpenClaw.
+ *
+ * Plugins managed by agents-cli are exposed as a synthetic local marketplace
+ * named "agents-cli" under each version's plugin directory:
+ *
+ *   <versionHome>/.{claude,openclaw}/plugins/
+ *     known_marketplaces.json            # registers the "agents-cli" marketplace
+ *     marketplaces/agents-cli/
+ *       .claude-plugin/marketplace.json  # synthesized catalog
+ *       plugins/<plugin>/                # copied plugin source
+ *
+ * Plus the version's settings.json gets `enabledPlugins["<plugin>@agents-cli"] = true`.
+ *
+ * This produces native `/plugin:skill` slash namespacing, visibility in `/plugins`,
+ * and `/plugin enable|disable` support — matching the Claude Code spec at
+ * https://code.claude.com/docs/en/plugins and /plugin-marketplaces.
+ */
+import type { AgentId, DiscoveredPlugin } from './types.js';
+export declare const MARKETPLACE_NAME = "agents-cli";
+interface MarketplacePluginEntry {
+    name: string;
+    source: string;
+    description?: string;
+    version?: string;
+    author?: {
+        name: string;
+        email?: string;
+    };
+}
+interface MarketplaceManifest {
+    $schema?: string;
+    name: string;
+    description?: string;
+    owner: {
+        name: string;
+        email?: string;
+    };
+    plugins: MarketplacePluginEntry[];
+}
+export declare function marketplaceRoot(agent: AgentId, versionHome: string): string;
+export declare function marketplaceManifestPath(agent: AgentId, versionHome: string): string;
+export declare function pluginInstallDir(plugin: DiscoveredPlugin, agent: AgentId, versionHome: string): string;
+export declare function knownMarketplacesPath(agent: AgentId, versionHome: string): string;
+/**
+ * Copy plugin source into marketplace install dir.
+ * Source of truth remains ~/.agents/plugins/<name>/ — this is a per-version snapshot.
+ */
+export declare function copyPluginToMarketplace(plugin: DiscoveredPlugin, agent: AgentId, versionHome: string): string;
+/**
+ * Re-synthesize <marketplace>/.claude-plugin/marketplace.json from the list of
+ * plugins installed under <marketplace>/plugins/. Always run after add or remove
+ * so the manifest stays in lockstep with on-disk contents.
+ */
+export declare function syncMarketplaceManifest(agent: AgentId, versionHome: string): MarketplaceManifest | null;
+/**
+ * Register the agents-cli marketplace in known_marketplaces.json so Claude Code
+ * discovers it on startup. Idempotent: re-running just refreshes lastUpdated.
+ */
+export declare function registerMarketplace(agent: AgentId, versionHome: string): void;
+/**
+ * Drop the agents-cli marketplace entry from known_marketplaces.json.
+ * Called when the last plugin under it is removed.
+ */
+export declare function unregisterMarketplace(agent: AgentId, versionHome: string): void;
+/**
+ * Mark a plugin as enabled in <versionHome>/.{agent}/settings.json under
+ * enabledPlugins["<plugin>@agents-cli"]: true. Reads, mutates, writes —
+ * preserving every other key.
+ */
+export declare function enablePluginInSettings(pluginName: string, agent: AgentId, versionHome: string): void;
+/**
+ * Remove the enabledPlugins key for this plugin. Inverse of enablePluginInSettings.
+ */
+export declare function disablePluginInSettings(pluginName: string, agent: AgentId, versionHome: string): void;
+/**
+ * Remove a plugin's installed marketplace directory. Returns true if the dir
+ * existed and was removed.
+ */
+export declare function removePluginFromMarketplace(pluginName: string, agent: AgentId, versionHome: string): boolean;
+/**
+ * Return true if the marketplace has no plugins left under it.
+ */
+export declare function marketplaceIsEmpty(agent: AgentId, versionHome: string): boolean;
+/**
+ * Drop the entire marketplace directory. Called after the last plugin removal.
+ */
+export declare function removeEmptyMarketplaceDir(agent: AgentId, versionHome: string): void;
+/**
+ * Detect whether a plugin is installed via the native marketplace path.
+ */
+export declare function isInstalledInMarketplace(pluginName: string, agent: AgentId, versionHome: string): boolean;
+export {};