@phnx-labs/agents-cli 1.20.33 → 1.20.35

package/dist/lib/picker.js

@@ -197,3 +197,127 @@ export function itemPicker(config) {
     });
     return prompt(config);
 }
+/**
+ * Multi-select variant of {@link itemPicker}. Same searchable, paginated list
+ * and preview pane, but `space` toggles a checkbox on the active row instead of
+ * the preview (preview moves to `tab`), and `enter` confirms every checked row.
+ *
+ * Returns the selected items (in the config's `items` order) or `null` on
+ * cancel. Pressing `enter` with nothing checked confirms just the highlighted
+ * row, so a quick single-pick still works.
+ */
+export function multiItemPicker(config) {
+    const prompt = createPrompt((cfg, done) => {
+        const theme = makeTheme({});
+        const [status, setStatus] = useState('idle');
+        const [searchTerm, setSearchTerm] = useState(cfg.initialSearch ?? '');
+        const [previewOpen, setPreviewOpen] = useState(false);
+        const [selectedKeys, setSelectedKeys] = useState(new Set());
+        const [active, setActive] = useState(0);
+        const prefix = usePrefix({ status, theme });
+        const results = useMemo(() => {
+            const filtered = cfg.filter(searchTerm).slice(0, 200);
+            return filtered.map((item) => ({
+                value: item,
+                label: cfg.labelFor(item, searchTerm),
+            }));
+        }, [searchTerm]);
+        useEffect(() => {
+            if (active >= results.length)
+                setActive(0);
+        }, [results]);
+        const selected = results[active];
+        // Selected items resolved in the original list order for deterministic fan-out.
+        const collectSelected = () => cfg.items.filter((it) => selectedKeys.has(cfg.keyFor(it)));
+        useKeypress((key, rl) => {
+            if (isEnterKey(key)) {
+                const chosen = selectedKeys.size > 0 ? collectSelected() : selected ? [selected.value] : [];
+                if (chosen.length === 0)
+                    return;
+                setStatus('done');
+                done(chosen);
+                return;
+            }
+            // space toggles the active row's checkbox; strip the space from the buffer
+            // so it never leaks into the filter.
+            if (isSpaceKey(key)) {
+                rl.clearLine(0);
+                if (selected) {
+                    const k = cfg.keyFor(selected.value);
+                    const next = new Set(selectedKeys);
+                    if (next.has(k))
+                        next.delete(k);
+                    else
+                        next.add(k);
+                    setSelectedKeys(next);
+                }
+                return;
+            }
+            if (key.name === 'tab' && cfg.buildPreview) {
+                rl.clearLine(0);
+                setPreviewOpen(!previewOpen);
+                return;
+            }
+            if (isUpKey(key)) {
+                rl.clearLine(0);
+                if (results.length > 0)
+                    setActive((active - 1 + results.length) % results.length);
+                return;
+            }
+            if (isDownKey(key)) {
+                rl.clearLine(0);
+                if (results.length > 0)
+                    setActive((active + 1) % results.length);
+                return;
+            }
+            setSearchTerm(rl.line);
+        });
+        const message = theme.style.message(cfg.message, status);
+        const count = selectedKeys.size;
+        if (status === 'done') {
+            return `${prefix} ${message} ${chalk.cyan(`${count || 1} session${(count || 1) === 1 ? '' : 's'}`)}`;
+        }
+        const placeholder = '(type to filter · space to toggle · enter to resume)';
+        const searchStr = searchTerm ? chalk.cyan(searchTerm) : chalk.gray(placeholder);
+        const header = [prefix, message, searchStr].filter(Boolean).join(' ');
+        const page = usePagination({
+            items: results,
+            active,
+            renderItem({ item, isActive }) {
+                if (Separator.isSeparator(item))
+                    return ` ${item.separator}`;
+                const checked = selectedKeys.has(cfg.keyFor(item.value));
+                const box = checked ? chalk.green('[x]') : chalk.gray('[ ]');
+                const cursor = isActive ? chalk.cyan('>') : ' ';
+                const row = isActive ? chalk.bold(item.label) : item.label;
+                return `${cursor} ${box} ${row}`;
+            },
+            pageSize: cfg.pageSize ?? 10,
+            loop: false,
+        });
+        const enter = cfg.enterHint ?? 'resume';
+        const countStr = count > 0 ? chalk.green(`${count} selected`) : chalk.gray('0 selected');
+        const help = chalk.gray(`${countStr}${chalk.gray(' · ↑↓ navigate · space toggle')}${cfg.buildPreview ? chalk.gray(' · tab preview') : ''}${chalk.gray(` · ⏎ ${enter} · esc cancel`)}`);
+        const parts = [header, page];
+        if (results.length === 0) {
+            parts.push(chalk.gray(`  ${cfg.emptyMessage ?? 'No matches.'}`));
+        }
+        if (previewOpen && selected && cfg.buildPreview) {
+            const width = terminalWidth();
+            const separator = chalk.gray('─'.repeat(Math.min(width, 80)));
+            const fixedRows = renderedRows(header, width) +
+                renderedRows(parts.slice(1).join('\n'), width) +
+                renderedRows(separator, width) +
+                renderedRows(help, width);
+            const availablePreviewRows = terminalRows() - fixedRows;
+            const preview = limitPreviewHeight(cfg.buildPreview(selected.value), availablePreviewRows, width);
+            if (preview) {
+                parts.push(separator);
+                parts.push(preview);
+            }
+        }
+        parts.push(help);
+        return [header, parts.slice(1).join('\n')];
+    });
+    return prompt(config);
+}

package/dist/lib/platform/winpath.d.ts

@@ -4,12 +4,41 @@ export interface WinPathResult {
     alreadyPresent?: boolean;
     error?: string;
 }
+/**
+ * Compute the new User PATH from the RAW (unexpanded) current value. Pure and
+ * OS-independent — the single source of truth for the prepend/dedup logic.
+ *
+ * Idempotent: returns `{ changed: false }` (value unchanged, verbatim) when
+ * `dir` is already the first `;`-split entry. Otherwise removes every existing
+ * occurrence of `dir` and prepends it, dropping empty segments — matching POSIX
+ * `export PATH="${dir}:$PATH"`. `%VAR%` segments are preserved verbatim (never
+ * expanded), which is the #308 regression this fix targets.
+ */
+export declare function computeNewUserPath(currentRaw: string, dir: string): {
+    changed: boolean;
+    value: string;
+};
+/**
+ * Decide whether to write the User PATH back as REG_EXPAND_SZ (ExpandString) vs
+ * REG_SZ (String). Pure — testable on any host.
+ *
+ * True (expandable) when the original value was already ExpandString, when the
+ * raw value contains a `%VAR%` reference, or when `Path` was absent (default to
+ * ExpandString — Windows' native Path type). Only a plain String value with no
+ * `%` stays REG_SZ. `originalKind` is the .NET RegistryValueKind name
+ * (`ExpandString`/`String`/…) or `null`/`Absent` when `Path` had no value.
+ */
+export declare function shouldWriteExpandable(originalKind: string | null, rawValue: string): boolean;
 /**
  * Prepend `dir` to the Windows User PATH. Idempotent: a no-op when `dir` is
  * already first; moves it to the front when it exists but is positioned later
  * (e.g. appended by an older install) so it overrides conflicting entries.
- * `dir` is passed via an env var so it is never interpolated into the script
- * text.
+ *
+ * Reads the RAW registry value (preserving `%VAR%` and the REG_EXPAND_SZ type),
+ * computes the new value in TS via `computeNewUserPath`, and only writes when
+ * the value actually changes — preserving the original value type and
+ * broadcasting WM_SETTINGCHANGE. `dir` and the computed value are passed via env
+ * vars so they are never interpolated into the script text.
  */
 export declare function prependToWindowsUserPath(dir: string): WinPathResult;
 /**

package/dist/lib/platform/winpath.js

@@ -1,9 +1,16 @@
 /**
  * Windows User PATH + execution-policy primitives.
  *
- * The single place that mutates the Windows User PATH via the .NET environment
- * API (which writes the registry AND broadcasts WM_SETTINGCHANGE — the correct
- * analog of editing a shell rc file: no `setx` truncation, no manual step).
+ * The single place that mutates the Windows User PATH. It reads and writes the
+ * RAW registry value via `Microsoft.Win32.Registry` (NOT the .NET
+ * `[Environment]::*Environment*Variable` API, which expands `%VAR%` references
+ * on read and downgrades REG_EXPAND_SZ to REG_SZ on write — issue #308,
+ * dotnet/runtime#89695 / #1442). The prepend/dedup itself is computed in TS
+ * (`computeNewUserPath`, the single source of truth) so it has unit coverage on
+ * every OS; PowerShell is used only for the registry primitives. Because a raw
+ * `SetValue` does NOT broadcast the change (the old `[Environment]` API did), the
+ * write script broadcasts WM_SETTINGCHANGE itself so a new terminal picks up the
+ * PATH without re-login.
  * Consumers: `shims.ts` (shims dir) and `scripts/postinstall.js` (npm global-bin
  * dir, so the `agents` command itself resolves).
  *
@@ -12,34 +19,136 @@
  */
 import { execFileSync } from 'child_process';
 import * as path from 'path';
+/**
+ * Compute the new User PATH from the RAW (unexpanded) current value. Pure and
+ * OS-independent — the single source of truth for the prepend/dedup logic.
+ *
+ * Idempotent: returns `{ changed: false }` (value unchanged, verbatim) when
+ * `dir` is already the first `;`-split entry. Otherwise removes every existing
+ * occurrence of `dir` and prepends it, dropping empty segments — matching POSIX
+ * `export PATH="${dir}:$PATH"`. `%VAR%` segments are preserved verbatim (never
+ * expanded), which is the #308 regression this fix targets.
+ */
+export function computeNewUserPath(currentRaw, dir) {
+    const parts = currentRaw.split(';').filter((p) => p !== '');
+    if (parts.length > 0 && parts[0] === dir) {
+        return { changed: false, value: currentRaw };
+    }
+    const others = parts.filter((p) => p !== dir);
+    return { changed: true, value: [dir, ...others].join(';') };
+}
+/**
+ * Decide whether to write the User PATH back as REG_EXPAND_SZ (ExpandString) vs
+ * REG_SZ (String). Pure — testable on any host.
+ *
+ * True (expandable) when the original value was already ExpandString, when the
+ * raw value contains a `%VAR%` reference, or when `Path` was absent (default to
+ * ExpandString — Windows' native Path type). Only a plain String value with no
+ * `%` stays REG_SZ. `originalKind` is the .NET RegistryValueKind name
+ * (`ExpandString`/`String`/…) or `null`/`Absent` when `Path` had no value.
+ */
+export function shouldWriteExpandable(originalKind, rawValue) {
+    if (originalKind === null || originalKind === 'Absent')
+        return true;
+    if (originalKind === 'ExpandString')
+        return true;
+    return rawValue.includes('%');
+}
+// Sentinel separating the value kind from the (possibly '%'-laden) raw value in
+// the read script's stdout — PATH entries never contain a newline, so an
+// exclusive line marker parses unambiguously.
+const READ_MARKER = '===AGENTS-PATH-VALUE===';
+// Reads the RAW User PATH preserving REG_EXPAND_SZ: DoNotExpandEnvironmentNames
+// keeps `%VAR%` literal, and GetValueKind reports the original type (throws when
+// 'Path' is absent -> caught, reported as Absent).
+const READ_SCRIPT = [
+    "$key = [Microsoft.Win32.Registry]::CurrentUser.OpenSubKey('Environment', $false)",
+    'if ($null -eq $key) {',
+    "  Write-Output 'KIND:Absent'",
+    `  Write-Output '${READ_MARKER}'`,
+    "  Write-Output ''",
+    '} else {',
+    "  try { $kind = $key.GetValueKind('Path').ToString() } catch { $kind = 'Absent' }",
+    "  $val = $key.GetValue('Path', '', [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)",
+    "  Write-Output ('KIND:' + $kind)",
+    `  Write-Output '${READ_MARKER}'`,
+    '  Write-Output $val',
+    '}',
+].join('\n');
+// Writes the computed value back with the preserved kind and broadcasts
+// WM_SETTINGCHANGE (raw SetValue does not, unlike the old [Environment] API).
+// The value comes in via AGENTS_WINPATH_VALUE so it is never interpolated into
+// the script text (preserves the no-injection property for '%'-laden paths).
+const WRITE_SCRIPT = [
+    "$key = [Microsoft.Win32.Registry]::CurrentUser.OpenSubKey('Environment', $true)",
+    "if ($null -eq $key) { $key = [Microsoft.Win32.Registry]::CurrentUser.CreateSubKey('Environment') }",
+    '$val = $env:AGENTS_WINPATH_VALUE',
+    "if ($env:AGENTS_WINPATH_EXPAND -eq '1') {",
+    '  $kind = [Microsoft.Win32.RegistryValueKind]::ExpandString',
+    '} else {',
+    '  $kind = [Microsoft.Win32.RegistryValueKind]::String',
+    '}',
+    "$key.SetValue('Path', $val, $kind)",
+    'Add-Type @"',
+    'using System;',
+    'using System.Runtime.InteropServices;',
+    'public static class AgentsWinPath {',
+    '  [DllImport("user32.dll", SetLastError=true, CharSet=CharSet.Auto)]',
+    '  public static extern IntPtr SendMessageTimeout(IntPtr hWnd, uint Msg, UIntPtr wParam, string lParam, uint fuFlags, uint uTimeout, out UIntPtr lpdwResult);',
+    '}',
+    '"@',
+    '$res = [UIntPtr]::Zero',
+    // HWND_BROADCAST=0xffff, WM_SETTINGCHANGE=0x1a, SMTO_ABORTIFHUNG=2, 5s timeout
+    "[AgentsWinPath]::SendMessageTimeout([IntPtr]0xffff, 0x1a, [UIntPtr]::Zero, 'Environment', 2, 5000, [ref]$res) | Out-Null",
+    "Write-Output 'written'",
+].join('\n');
+function runPowerShell(script, extraEnv) {
+    return execFileSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', script], {
+        encoding: 'utf-8',
+        env: extraEnv ? { ...process.env, ...extraEnv } : process.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+}
+/** Parse the read script's stdout into the original value kind and RAW value. */
+function parseReadOutput(out) {
+    const idx = out.indexOf(READ_MARKER);
+    if (idx === -1)
+        return { kind: null, raw: '' };
+    const head = out.slice(0, idx);
+    const kindMatch = head.match(/KIND:(\S+)/);
+    const kind = kindMatch ? kindMatch[1] : null;
+    // Everything after the marker line, minus the leading/trailing newline PS adds.
+    const raw = out
+        .slice(idx + READ_MARKER.length)
+        .replace(/^\r?\n/, '')
+        .replace(/\r?\n$/, '');
+    return { kind, raw };
+}
 /**
  * Prepend `dir` to the Windows User PATH. Idempotent: a no-op when `dir` is
  * already first; moves it to the front when it exists but is positioned later
  * (e.g. appended by an older install) so it overrides conflicting entries.
- * `dir` is passed via an env var so it is never interpolated into the script
- * text.
+ *
+ * Reads the RAW registry value (preserving `%VAR%` and the REG_EXPAND_SZ type),
+ * computes the new value in TS via `computeNewUserPath`, and only writes when
+ * the value actually changes — preserving the original value type and
+ * broadcasting WM_SETTINGCHANGE. `dir` and the computed value are passed via env
+ * vars so they are never interpolated into the script text.
  */
 export function prependToWindowsUserPath(dir) {
-    const script = [
-        '$d = $env:AGENTS_WINPATH_DIR',
-        "$u = [Environment]::GetEnvironmentVariable('Path','User')",
-        "if ($null -eq $u) { $u = '' }",
-        "$parts = @($u -split ';' | Where-Object { $_ -ne '' })",
-        // Already first — nothing to do
-        "if ($parts.Count -gt 0 -and $parts[0] -eq $d) { 'present' } else {",
-        // Remove any existing occurrence then prepend, matching POSIX `export PATH="${dir}:$PATH"`
-        "  $newParts = @($d) + @($parts | Where-Object { $_ -ne $d })",
-        "  [Environment]::SetEnvironmentVariable('Path', ($newParts -join ';'), 'User')",
-        "  'added'",
-        '}',
-    ].join('\n');
     try {
-        const out = execFileSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', script], {
-            encoding: 'utf-8',
-            env: { ...process.env, AGENTS_WINPATH_DIR: dir },
-            stdio: ['ignore', 'pipe', 'pipe'],
-        }).trim();
-        return { success: true, alreadyPresent: out.includes('present') };
+        const readOut = runPowerShell(READ_SCRIPT);
+        const { kind, raw } = parseReadOutput(readOut);
+        const { changed, value } = computeNewUserPath(raw, dir);
+        if (!changed) {
+            return { success: true, alreadyPresent: true };
+        }
+        const expandable = shouldWriteExpandable(kind, value);
+        runPowerShell(WRITE_SCRIPT, {
+            AGENTS_WINPATH_VALUE: value,
+            AGENTS_WINPATH_EXPAND: expandable ? '1' : '0',
+        });
+        return { success: true, alreadyPresent: false };
     }
     catch (err) {
         return { success: false, error: `Could not update the Windows user PATH: ${err.message}` };

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

@@ -144,6 +144,36 @@ export declare function syncMarketplaceManifest(spec: MarketplaceSpec, agent: Ag
  * marketplaces' entries are preserved untouched.
  */
 export declare function registerMarketplace(spec: MarketplaceSpec, agent: AgentId, versionHome: string): void;
+/**
+ * Record a plugin in Droid's installed_plugins.json (user scope), pointing
+ * installPath at the marketplace install dir so no second copy is needed. This
+ * is what makes `droid plugin list` show the plugin (Active once enabledPlugins
+ * is set). Idempotent: re-running refreshes lastUpdated and preserves the
+ * original installedAt plus any non-user scope entries.
+ */
+export declare function registerDroidInstalledPlugin(pluginName: string, marketplaceName: string, installDir: string, version: string, agent: AgentId, versionHome: string): void;
+/** True when Droid's installed_plugins.json carries a user-scope entry for the plugin. */
+export declare function isDroidPluginInstalled(pluginName: string, marketplaceName: string, agent: AgentId, versionHome: string): boolean;
+/**
+ * Remove a plugin's user-scope entry from Droid's installed_plugins.json.
+ * Inverse of registerDroidInstalledPlugin. Drops the key when no scopes remain
+ * and deletes the file when the registry is empty.
+ */
+export declare function unregisterDroidInstalledPlugin(pluginName: string, marketplaceName: string, agent: AgentId, versionHome: string): void;
+/**
+ * Record a plugin in Copilot's config.json#installedPlugins (the registry that
+ * makes `copilot plugin list` see it). `cache_path` points at the marketplace
+ * install dir — no separate copy. Idempotent: re-running refreshes the entry and
+ * preserves the original installed_at plus every other config key.
+ */
+export declare function registerCopilotInstalledPlugin(pluginName: string, marketplaceName: string, installDir: string, version: string, enabled: boolean, agent: AgentId, versionHome: string): void;
+/**
+ * Remove a plugin's entry from Copilot's config.json#installedPlugins. Inverse
+ * of registerCopilotInstalledPlugin. Leaves the file (with an empty
+ * installedPlugins) rather than deleting it, since config.json may hold other
+ * Copilot-managed keys.
+ */
+export declare function unregisterCopilotInstalledPlugin(pluginName: string, marketplaceName: string, agent: AgentId, versionHome: string): void;
 /**
  * Drop a marketplace entry from known_marketplaces.json. Called when the last
  * plugin under it is removed. Removes only its own entry; deletes the file only

package/dist/lib/plugin-marketplace.js

@@ -127,7 +127,14 @@ export function marketplaceRoot(specOrName, agent, versionHome) {
     return path.join(pluginsRootForVersion(agent, versionHome), 'marketplaces', nameOf(specOrName));
 }
 export function marketplaceManifestPath(specOrName, agent, versionHome) {
-    return path.join(marketplaceRoot(specOrName, agent, versionHome), '.claude-plugin', 'marketplace.json');
+    const root = marketplaceRoot(specOrName, agent, versionHome);
+    // Copilot resolves a marketplace's catalog from `marketplace.json` at the
+    // marketplace ROOT (also `.plugin/marketplace.json`, `.github/plugin/
+    // marketplace.json`) — NOT `.claude-plugin/marketplace.json`. Verified against
+    // GitHub Copilot CLI 1.0.56 (`plugin marketplace add`).
+    if (agent === 'copilot')
+        return path.join(root, 'marketplace.json');
+    return path.join(root, '.claude-plugin', 'marketplace.json');
 }
 export function pluginInstallDir(plugin, specOrName, agent, versionHome) {
     return path.join(marketplaceRoot(specOrName, agent, versionHome), 'plugins', plugin.name);
@@ -375,6 +382,14 @@ export function syncMarketplaceManifest(spec, agent, versionHome) {
 export function registerMarketplace(spec, agent, versionHome) {
     const name = marketplaceNameFor(spec);
     const root = marketplaceRoot(spec, agent, versionHome);
+    // Copilot diverges from Claude's known_marketplaces.json: it reads registered
+    // marketplaces from settings.json#extraKnownMarketplaces. Verified against
+    // GitHub Copilot CLI 1.0.56 (`plugin marketplace add <dir>` writes exactly
+    // this shape). A "directory"-source entry points at the on-disk catalog root.
+    if (agent === 'copilot') {
+        registerCopilotMarketplace(name, root, agent, versionHome);
+        return;
+    }
     const knownPath = knownMarketplacesPath(agent, versionHome);
     let known = {};
     if (fs.existsSync(knownPath)) {
@@ -385,14 +400,206 @@ export function registerMarketplace(spec, agent, versionHome) {
             known = {};
         }
     }
+    // Droid names the on-disk source type "local" (Claude/OpenClaw use
+    // "directory") and stamps autoUpdate — verified against `droid plugin
+    // marketplace add`. A "directory" entry is silently ignored by the Factory
+    // CLI, so the plugin never resolves.
+    const isDroid = agent === 'droid';
     known[name] = {
-        source: { source: 'directory', path: root },
+        source: { source: isDroid ? 'local' : 'directory', path: root },
         installLocation: root,
         lastUpdated: new Date().toISOString(),
+        ...(isDroid ? { autoUpdate: true } : {}),
     };
     fs.mkdirSync(path.dirname(knownPath), { recursive: true });
     fs.writeFileSync(knownPath, JSON.stringify(known, null, 2) + '\n', 'utf-8');
 }
+// ─── Droid installed-plugins registry ─────────────────────────────────────────
+function installedPluginsPath(agent, versionHome) {
+    return path.join(pluginsRootForVersion(agent, versionHome), 'installed_plugins.json');
+}
+function readInstalledPlugins(agent, versionHome) {
+    const p = installedPluginsPath(agent, versionHome);
+    if (fs.existsSync(p)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(p, 'utf-8'));
+            if (parsed && typeof parsed === 'object' && parsed.plugins && typeof parsed.plugins === 'object') {
+                return { schemaVersion: parsed.schemaVersion ?? 1, plugins: parsed.plugins };
+            }
+        }
+        catch { /* fall through to fresh registry */ }
+    }
+    return { schemaVersion: 1, plugins: {} };
+}
+/**
+ * Record a plugin in Droid's installed_plugins.json (user scope), pointing
+ * installPath at the marketplace install dir so no second copy is needed. This
+ * is what makes `droid plugin list` show the plugin (Active once enabledPlugins
+ * is set). Idempotent: re-running refreshes lastUpdated and preserves the
+ * original installedAt plus any non-user scope entries.
+ */
+export function registerDroidInstalledPlugin(pluginName, marketplaceName, installDir, version, agent, versionHome) {
+    const registry = readInstalledPlugins(agent, versionHome);
+    const key = `${pluginName}@${marketplaceName}`;
+    const now = new Date().toISOString();
+    const existing = registry.plugins[key] ?? [];
+    const priorUser = existing.find(e => e.scope === 'user');
+    const others = existing.filter(e => e.scope !== 'user');
+    registry.plugins[key] = [
+        ...others,
+        {
+            scope: 'user',
+            installPath: installDir,
+            version,
+            installedAt: priorUser?.installedAt ?? now,
+            lastUpdated: now,
+            source: marketplaceName,
+        },
+    ];
+    const p = installedPluginsPath(agent, versionHome);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(registry, null, 2) + '\n', 'utf-8');
+}
+/** True when Droid's installed_plugins.json carries a user-scope entry for the plugin. */
+export function isDroidPluginInstalled(pluginName, marketplaceName, agent, versionHome) {
+    const registry = readInstalledPlugins(agent, versionHome);
+    const entries = registry.plugins[`${pluginName}@${marketplaceName}`];
+    return Array.isArray(entries) && entries.some(e => e.scope === 'user');
+}
+/**
+ * Remove a plugin's user-scope entry from Droid's installed_plugins.json.
+ * Inverse of registerDroidInstalledPlugin. Drops the key when no scopes remain
+ * and deletes the file when the registry is empty.
+ */
+export function unregisterDroidInstalledPlugin(pluginName, marketplaceName, agent, versionHome) {
+    const p = installedPluginsPath(agent, versionHome);
+    if (!fs.existsSync(p))
+        return;
+    const registry = readInstalledPlugins(agent, versionHome);
+    const key = `${pluginName}@${marketplaceName}`;
+    const entries = registry.plugins[key];
+    if (!Array.isArray(entries))
+        return;
+    const kept = entries.filter(e => e.scope !== 'user');
+    if (kept.length > 0) {
+        registry.plugins[key] = kept;
+    }
+    else {
+        delete registry.plugins[key];
+    }
+    if (Object.keys(registry.plugins).length === 0) {
+        try {
+            fs.unlinkSync(p);
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    fs.writeFileSync(p, JSON.stringify(registry, null, 2) + '\n', 'utf-8');
+}
+// ─── Copilot marketplace + installed-plugin registry ──────────────────────────
+function copilotConfigPath(agent, versionHome) {
+    return path.join(versionHome, agentConfigDirName(agent), 'config.json');
+}
+function readCopilotSettings(agent, versionHome) {
+    const p = settingsPath(agent, versionHome);
+    if (fs.existsSync(p)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(p, 'utf-8'));
+            if (parsed && typeof parsed === 'object')
+                return parsed;
+        }
+        catch { /* fall through */ }
+    }
+    return {};
+}
+function writeCopilotSettings(agent, versionHome, settings) {
+    const p = settingsPath(agent, versionHome);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+}
+/** Register a marketplace in Copilot's settings.json#extraKnownMarketplaces. */
+function registerCopilotMarketplace(name, root, agent, versionHome) {
+    const settings = readCopilotSettings(agent, versionHome);
+    const known = (settings.extraKnownMarketplaces && typeof settings.extraKnownMarketplaces === 'object'
+        ? settings.extraKnownMarketplaces
+        : {});
+    known[name] = { source: { source: 'directory', path: root } };
+    settings.extraKnownMarketplaces = known;
+    writeCopilotSettings(agent, versionHome, settings);
+}
+/** Inverse of registerCopilotMarketplace: drop the entry, prune the empty key. */
+function unregisterCopilotMarketplace(name, agent, versionHome) {
+    const p = settingsPath(agent, versionHome);
+    if (!fs.existsSync(p))
+        return;
+    const settings = readCopilotSettings(agent, versionHome);
+    const known = settings.extraKnownMarketplaces;
+    if (!known || !(name in known))
+        return;
+    delete known[name];
+    if (Object.keys(known).length === 0)
+        delete settings.extraKnownMarketplaces;
+    writeCopilotSettings(agent, versionHome, settings);
+}
+function readCopilotConfig(agent, versionHome) {
+    const p = copilotConfigPath(agent, versionHome);
+    if (fs.existsSync(p)) {
+        try {
+            // config.json may carry a leading `//` comment banner written by Copilot;
+            // strip line comments before parsing so we never clobber a real config.
+            const raw = fs.readFileSync(p, 'utf-8').replace(/^\s*\/\/.*$/gm, '');
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === 'object') {
+                return { ...parsed, installedPlugins: Array.isArray(parsed.installedPlugins) ? parsed.installedPlugins : [] };
+            }
+        }
+        catch { /* fall through to fresh config */ }
+    }
+    return { installedPlugins: [] };
+}
+/**
+ * Record a plugin in Copilot's config.json#installedPlugins (the registry that
+ * makes `copilot plugin list` see it). `cache_path` points at the marketplace
+ * install dir — no separate copy. Idempotent: re-running refreshes the entry and
+ * preserves the original installed_at plus every other config key.
+ */
+export function registerCopilotInstalledPlugin(pluginName, marketplaceName, installDir, version, enabled, agent, versionHome) {
+    const config = readCopilotConfig(agent, versionHome);
+    const now = new Date().toISOString();
+    const prior = config.installedPlugins.find(e => e.name === pluginName && e.marketplace === marketplaceName);
+    const others = config.installedPlugins.filter(e => !(e.name === pluginName && e.marketplace === marketplaceName));
+    config.installedPlugins = [
+        ...others,
+        {
+            name: pluginName,
+            marketplace: marketplaceName,
+            version,
+            installed_at: prior?.installed_at ?? now,
+            enabled,
+            cache_path: installDir,
+        },
+    ];
+    const p = copilotConfigPath(agent, versionHome);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+/**
+ * Remove a plugin's entry from Copilot's config.json#installedPlugins. Inverse
+ * of registerCopilotInstalledPlugin. Leaves the file (with an empty
+ * installedPlugins) rather than deleting it, since config.json may hold other
+ * Copilot-managed keys.
+ */
+export function unregisterCopilotInstalledPlugin(pluginName, marketplaceName, agent, versionHome) {
+    const p = copilotConfigPath(agent, versionHome);
+    if (!fs.existsSync(p))
+        return;
+    const config = readCopilotConfig(agent, versionHome);
+    const kept = config.installedPlugins.filter(e => !(e.name === pluginName && e.marketplace === marketplaceName));
+    if (kept.length === config.installedPlugins.length)
+        return;
+    config.installedPlugins = kept;
+    fs.writeFileSync(p, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
 /**
  * Drop a marketplace entry from known_marketplaces.json. Called when the last
  * plugin under it is removed. Removes only its own entry; deletes the file only
@@ -400,6 +607,12 @@ export function registerMarketplace(spec, agent, versionHome) {
  */
 export function unregisterMarketplace(specOrName, agent, versionHome) {
     const name = nameOf(specOrName);
+    // Copilot stores registrations in settings.json#extraKnownMarketplaces, not
+    // known_marketplaces.json. Mirror the branch in registerMarketplace.
+    if (agent === 'copilot') {
+        unregisterCopilotMarketplace(name, agent, versionHome);
+        return;
+    }
     const knownPath = knownMarketplacesPath(agent, versionHome);
     if (!fs.existsSync(knownPath))
         return;

package/dist/lib/plugins.d.ts

@@ -148,6 +148,11 @@ export declare function marketplaceSpecForName(name: string | undefined, cwd?: s
  * MCP servers, bin/, settings.json, and permissions once the plugin lives at the
  * native install path and is marked enabled — see
  * https://code.claude.com/docs/en/plugins.
+ *
+ * Droid (Factory CLI) reuses this same marketplace layout but additionally
+ * requires an installed_plugins.json registry entry and a "local"-source
+ * known_marketplaces.json entry before `droid plugin list` will see the plugin
+ * (steps handled by registerMarketplace's droid branch + step 5c below).
  */
 export declare function syncPluginToVersion(plugin: DiscoveredPlugin, agent: AgentId, versionHome: string, options?: {
     allowExecSurfaces?: boolean;