@phnx-labs/agents-cli 1.20.34 → 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/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;

package/dist/lib/plugins.js

@@ -18,7 +18,7 @@ import { listInstalledVersions, getVersionHomePath } from './versions.js';
 import { AGENTS, agentConfigDirName } from './agents.js';
 import { capableAgents, isCapable } from './capabilities.js';
 import { shouldInstallCommandAsSkill, installCommandSkillToVersion } from './command-skills.js';
-import { copyPluginToMarketplace, syncMarketplaceManifest, registerMarketplace, unregisterMarketplace, addPluginToSettings, removePluginFromSettings, removePluginFromMarketplace, marketplaceIsEmpty, removeEmptyMarketplaceDir, isInstalledInMarketplace, marketplaceRoot, discoverMarketplaces, marketplaceNameFor, MARKETPLACE_NAME, PROJECT_MARKETPLACE_NAME, SYSTEM_MARKETPLACE_NAME, } from './plugin-marketplace.js';
+import { copyPluginToMarketplace, syncMarketplaceManifest, registerMarketplace, unregisterMarketplace, addPluginToSettings, removePluginFromSettings, removePluginFromMarketplace, registerDroidInstalledPlugin, unregisterDroidInstalledPlugin, isDroidPluginInstalled, registerCopilotInstalledPlugin, unregisterCopilotInstalledPlugin, marketplaceIsEmpty, removeEmptyMarketplaceDir, isInstalledInMarketplace, marketplaceRoot, discoverMarketplaces, marketplaceNameFor, MARKETPLACE_NAME, PROJECT_MARKETPLACE_NAME, SYSTEM_MARKETPLACE_NAME, } from './plugin-marketplace.js';
 const PLUGIN_MANIFEST_DIR = '.claude-plugin';
 const PLUGIN_MANIFEST_FILE = 'plugin.json';
 const USER_CONFIG_FILE = '.user-config.json';
@@ -416,7 +416,7 @@ export function marketplaceSpecForName(name, cwd = process.cwd()) {
  * carries, not just the user one.
  */
 function listVersionMarketplaceNames(agent, versionHome) {
-    const dir = path.join(versionHome, `.${agent}`, 'plugins', 'marketplaces');
+    const dir = path.join(versionHome, agentConfigDirName(agent), 'plugins', 'marketplaces');
     if (!fs.existsSync(dir))
         return [];
     try {
@@ -444,6 +444,11 @@ function listVersionMarketplaceNames(agent, versionHome) {
  * 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 function syncPluginToVersion(plugin, agent, versionHome, options = {}) {
     const result = {
@@ -491,9 +496,25 @@ export function syncPluginToVersion(plugin, agent, versionHome, options = {}) {
     // .mcp.json, settings.json, permissions/) are only auto-enabled when the
     // caller explicitly opts in. addPluginToSettings does no gating — that moved
     // here, where plugin capabilities are inspected.
-    if (options.allowExecSurfaces === true || !hasPluginExecSurfaces(inspectPluginCapabilities(plugin.root))) {
+    const enablePlugin = options.allowExecSurfaces === true || !hasPluginExecSurfaces(inspectPluginCapabilities(plugin.root));
+    if (enablePlugin) {
         addPluginToSettings(plugin.name, marketplaceName, agent, versionHome);
     }
+    // 5c. Droid diverges from Claude's marketplace+enabledPlugins model: it only
+    //     "sees" a plugin that also has an entry in installed_plugins.json (with
+    //     the marketplace registered as source "local"). Register the install so
+    //     `droid plugin list` shows it — Active when enabled, Inactive otherwise.
+    if (agent === 'droid') {
+        registerDroidInstalledPlugin(plugin.name, marketplaceName, installDir, plugin.manifest.version, agent, versionHome);
+    }
+    // 5d. Copilot, like Droid, only "sees" a plugin that also has an entry in its
+    //     auto-managed config.json#installedPlugins (registerMarketplace already
+    //     wrote settings.json#extraKnownMarketplaces, and addPluginToSettings the
+    //     enabledPlugins flag). cache_path points at the marketplace copy; the
+    //     `enabled` flag mirrors the exec-surface trust gate above.
+    if (agent === 'copilot') {
+        registerCopilotInstalledPlugin(plugin.name, marketplaceName, installDir, plugin.manifest.version, enablePlugin, agent, versionHome);
+    }
     // 5b. Convert plugin commands/ to skills for agents that dropped command support
     //     (Codex >= 0.117.0). Skill name is prefixed with plugin name to avoid
     //     collision with standalone command skills.
@@ -718,7 +739,15 @@ function migrateLegacyFlatLayout(plugin, agent, versionHome) {
 export function isPluginSynced(plugin, agent, versionHome) {
     if (!isCapable(agent, 'plugins'))
         return false;
-    return isInstalledInMarketplace(plugin.name, marketplaceSpecForName(plugin.marketplace), agent, versionHome);
+    const spec = marketplaceSpecForName(plugin.marketplace);
+    if (!isInstalledInMarketplace(plugin.name, spec, agent, versionHome))
+        return false;
+    // Droid additionally requires its installed_plugins.json registry entry —
+    // without it the marketplace copy is invisible to `droid plugin list`.
+    if (agent === 'droid') {
+        return isDroidPluginInstalled(plugin.name, marketplaceNameFor(spec), agent, versionHome);
+    }
+    return true;
 }
 // ─── Removal ─────────────────────────────────────────────────────────────────
 /**
@@ -746,6 +775,12 @@ export function removePluginFromVersion(pluginName, pluginRoot, agent, versionHo
             removedAny = true;
         }
         removePluginFromSettings(pluginName, name, agent, versionHome);
+        if (agent === 'droid') {
+            unregisterDroidInstalledPlugin(pluginName, name, agent, versionHome);
+        }
+        if (agent === 'copilot') {
+            unregisterCopilotInstalledPlugin(pluginName, name, agent, versionHome);
+        }
         // Refresh marketplace.json so it reflects what's left under plugins/.
         syncMarketplaceManifest(spec, agent, versionHome);
         // If we just removed the last plugin, drop the marketplace dir and the
@@ -930,6 +965,12 @@ export function cleanOrphanedPluginSkills(agent, versionHome, activePluginNames,
                 fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
                 fs.renameSync(path.join(mktPluginsDir, entry.name), trashDest);
                 removePluginFromSettings(entry.name, name, agent, versionHome);
+                if (agent === 'droid') {
+                    unregisterDroidInstalledPlugin(entry.name, name, agent, versionHome);
+                }
+                if (agent === 'copilot') {
+                    unregisterCopilotInstalledPlugin(entry.name, name, agent, versionHome);
+                }
                 removed.push(entry.name);
                 trashedHere = true;
             }

package/dist/lib/session/active.d.ts

@@ -38,6 +38,13 @@ export interface ActiveSession {
      * Absent for cloud sessions (no local pid) and any pid whose env is unreadable.
      */
     provenance?: SessionProvenance;
+    /**
+     * The machine this session runs on, as a normalized device id (machineId()
+     * form). Set when merging cross-machine results so the grouped `--active`
+     * view can bucket by computer. Absent for a purely local query (the renderer
+     * falls back to provenance.host, then the local machine).
+     */
+    machine?: string;
     teamName?: string;
     agentId?: string;
     cloudProvider?: string;

package/dist/lib/session/active.js

@@ -24,6 +24,7 @@ import { promisify } from 'util';
 import { listActiveTasks } from '../cloud/store.js';
 import { AgentManager } from '../teams/agents.js';
 import { getTerminalsDir } from '../state.js';
+import { readPidSessionEntry, prunePidSessionRegistry } from './pid-registry.js';
 import { buildClaudeLabelMap } from './discover.js';
 import { latestSessionFileForCwd } from './db.js';
 import { extractSessionTopic } from './prompt.js';
@@ -499,8 +500,13 @@ export async function listUnattributedActive(attributed) {
     const out = [];
     for (let i = 0; i < candidates.length; i++) {
         const { pid, kind } = candidates[i];
-        const cwd = cwds[i];
-        const sessionFile = findSessionFileForKind(kind, cwd);
+        // The per-pid registry (written by `ag run`) gives the EXACT session id this
+        // pid was launched with — so N agents in one cwd resolve to N distinct
+        // sessions instead of all collapsing onto the newest .jsonl. Absent (agent
+        // not launched via `ag run`, or one that takes no session id) → heuristic.
+        const entry = readPidSessionEntry(pid);
+        const cwd = cwds[i] ?? entry?.cwd ?? undefined;
+        const sessionFile = findSessionFileForKind(kind, cwd, entry?.sessionId);
         const topic = sessionFile ? quickExtractTopic(sessionFile) : undefined;
         const host = detectHost(pid, procByPid);
         const context = host && UI_HOSTS.has(host) ? 'terminal' : 'headless';
@@ -511,11 +517,13 @@ export async function listUnattributedActive(attributed) {
             host,
             pid,
             cwd,
-            sessionId: sessionIdFromFile(sessionFile),
+            sessionId: entry?.sessionId ?? sessionIdFromFile(sessionFile),
             topic,
             sessionFile,
         }, state, sessionFile));
     }
+    // Housekeeping: drop registry files for pids that have since died.
+    prunePidSessionRegistry(isPidAlive);
     return out;
 }
 /**