@zhijiewang/openharness 1.0.0 → 1.3.0

package/dist/agents/roles.d.ts

@@ -16,9 +16,11 @@ export type AgentRole = {
     /** Suggested tools to include (empty = all tools) */
     suggestedTools?: string[];
 };
-/** Get a role by ID */
+/** Discover markdown agent roles from .oh/agents/ and ~/.oh/agents/ */
+export declare function discoverMarkdownAgents(): AgentRole[];
+/** Get a role by ID (checks built-in first, then markdown agents) */
 export declare function getRole(id: string): AgentRole | undefined;
-/** List all available roles */
+/** List all available roles (built-in + markdown) */
 export declare function listRoles(): AgentRole[];
 /** Get role IDs */
 export declare function getRoleIds(): string[];

package/dist/agents/roles.js

@@ -157,16 +157,80 @@ Work methodically: search exhaustively, change incrementally, test after each ba
         suggestedTools: ['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash'],
     },
 ];
-/** Get a role by ID */
+// ── Markdown Agent Discovery ──
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+const PROJECT_AGENTS_DIR = join('.oh', 'agents');
+const GLOBAL_AGENTS_DIR = join(homedir(), '.oh', 'agents');
+/**
+ * Parse a markdown agent file into an AgentRole.
+ *
+ * Format:
+ * ---
+ * name: My Agent
+ * description: What it does
+ * tools: [Read, Grep, Bash]
+ * ---
+ *
+ * System prompt content...
+ */
+function parseAgentMarkdown(raw, filePath) {
+    const fmMatch = raw.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch)
+        return null;
+    const fm = fmMatch[1];
+    const nameMatch = fm.match(/^name:\s*(.+)$/m);
+    const descMatch = fm.match(/^description:\s*(.+)$/m);
+    const toolsMatch = fm.match(/^tools:\s*\[(.+)\]$/m);
+    const fmEnd = raw.indexOf('---', raw.indexOf('---') + 3);
+    const content = fmEnd > 0 ? raw.slice(fmEnd + 3).trim() : '';
+    const id = basename(filePath, '.md').toLowerCase().replace(/[^a-z0-9]+/g, '-');
+    return {
+        id,
+        name: nameMatch?.[1]?.trim() ?? id,
+        description: descMatch?.[1]?.trim() ?? '',
+        systemPromptSupplement: content,
+        suggestedTools: toolsMatch
+            ? toolsMatch[1].split(',').map(t => t.trim())
+            : undefined,
+    };
+}
+/** Load agent roles from a directory of .md files */
+function loadAgentsFromDir(dir) {
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter(f => f.endsWith('.md'))
+        .map(f => {
+        try {
+            const raw = readFileSync(join(dir, f), 'utf-8');
+            return parseAgentMarkdown(raw, f);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((r) => r !== null);
+}
+/** Discover markdown agent roles from .oh/agents/ and ~/.oh/agents/ */
+export function discoverMarkdownAgents() {
+    return [
+        ...loadAgentsFromDir(PROJECT_AGENTS_DIR),
+        ...loadAgentsFromDir(GLOBAL_AGENTS_DIR),
+    ];
+}
+/** Get a role by ID (checks built-in first, then markdown agents) */
 export function getRole(id) {
-    return roles.find(r => r.id === id);
+    return roles.find(r => r.id === id)
+        ?? discoverMarkdownAgents().find(r => r.id === id);
 }
-/** List all available roles */
+/** List all available roles (built-in + markdown) */
 export function listRoles() {
-    return [...roles];
+    return [...roles, ...discoverMarkdownAgents()];
 }
 /** Get role IDs */
 export function getRoleIds() {
-    return roles.map(r => r.id);
+    return listRoles().map(r => r.id);
 }
 //# sourceMappingURL=roles.js.map

package/dist/commands/index.js

@@ -29,7 +29,7 @@ register("help", "Show available commands", () => {
         'Git': ['diff', 'undo', 'rewind', 'commit', 'log'],
         'Info': ['help', 'cost', 'status', 'config', 'files', 'model', 'memory', 'doctor', 'context', 'mcp', 'mcp-registry'],
         'Settings': ['theme', 'vim', 'companion', 'fast', 'keys'],
-        'AI': ['plan', 'review', 'roles'],
+        'AI': ['plan', 'review', 'roles', 'agents', 'plugins'],
         'Pet': ['cybergotchi'],
     };
     const lines = [];
@@ -354,6 +354,27 @@ register("roles", "List available agent specialization roles", () => {
     lines.push("Usage: Agent({ subagent_type: 'code-reviewer', prompt: '...' })");
     return { output: lines.join("\n"), handled: true };
 });
+register("agents", "Discover running openHarness agents on this machine", () => {
+    const { discoverAgents } = require('../services/a2a.js');
+    const agents = discoverAgents();
+    if (agents.length === 0) {
+        return { output: "No other openHarness agents running on this machine.\n\nOther oh sessions will appear here automatically via the A2A protocol.", handled: true };
+    }
+    const lines = [`Running Agents (${agents.length}):\n`];
+    for (const agent of agents) {
+        const age = Math.round((Date.now() - agent.registeredAt) / 60_000);
+        lines.push(`  ${agent.name}`);
+        lines.push(`    ID:       ${agent.id}`);
+        lines.push(`    Provider: ${agent.provider ?? 'unknown'} / ${agent.model ?? 'unknown'}`);
+        lines.push(`    Dir:      ${agent.workingDir ?? 'unknown'}`);
+        lines.push(`    Endpoint: ${agent.endpoint.type}${agent.endpoint.port ? ':' + agent.endpoint.port : ''}`);
+        lines.push(`    Uptime:   ${age}m`);
+        lines.push(`    Caps:     ${agent.capabilities.map((c) => c.name).join(', ')}`);
+        lines.push('');
+    }
+    lines.push("Send messages with: Agent({ prompt: 'ask the other agent...', allowed_tools: ['SendMessage'] })");
+    return { output: lines.join("\n"), handled: true };
+});
 register("fast", "Toggle fast mode (optimized for speed)", () => {
     return { output: "", handled: true, toggleFastMode: true };
 });
@@ -614,51 +635,88 @@ function setPinned(args, ctx, pinned) {
 }
 register("pin", "Pin a message (survives /compact)", (args, ctx) => setPinned(args, ctx, true));
 register("unpin", "Unpin a message", (args, ctx) => setPinned(args, ctx, false));
-register("plugins", "List installed plugins and discover new ones", (args) => {
+register("plugins", "Manage plugins: list, search, install, uninstall, marketplace", (args) => {
     const { discoverPlugins, discoverSkills } = require('../harness/plugins.js');
-    const query = args.trim();
-    if (query === 'search' || query.startsWith('search ')) {
-        // npm registry search
-        const keyword = query.replace(/^search\s*/, '').trim() || 'openharness-plugin';
-        return {
-            output: `To discover plugins, search npm:\n\n  npm search openharness-plugin${keyword !== 'openharness-plugin' ? ' ' + keyword : ''}\n\nInstall with:\n  npm install <package-name>\n\nPlugins are auto-discovered from node_modules/ if they contain openharness-plugin.json.`,
-            handled: true,
-        };
+    const { searchMarketplace, installPlugin, uninstallPlugin, getInstalledPlugins, listMarketplaces, addMarketplace, removeMarketplace, formatMarketplaceSearch, formatInstalledPlugins, } = require('../harness/marketplace.js');
+    const parts = args.trim().split(/\s+/);
+    const subcommand = parts[0] ?? '';
+    const rest = parts.slice(1).join(' ');
+    // /plugins marketplace add <source>
+    if (subcommand === 'marketplace') {
+        const action = parts[1];
+        const source = parts.slice(2).join(' ');
+        if (action === 'add' && source) {
+            const mp = addMarketplace(source);
+            if (mp)
+                return { output: `Added marketplace "${mp.name}" (${mp.plugins.length} plugins)`, handled: true };
+            return { output: `Failed to add marketplace from "${source}"`, handled: true };
+        }
+        if (action === 'remove' && source) {
+            return { output: removeMarketplace(source) ? `Removed marketplace "${source}"` : `Marketplace "${source}" not found`, handled: true };
+        }
+        // List marketplaces
+        const mps = listMarketplaces();
+        if (mps.length === 0) {
+            return { output: 'No marketplaces configured.\n\nAdd one:\n  /plugins marketplace add owner/repo\n  /plugins marketplace add https://example.com/plugins', handled: true };
+        }
+        const lines = [`Marketplaces (${mps.length}):\n`];
+        for (const mp of mps) {
+            lines.push(`  ${mp.name} — ${mp.plugins.length} plugins`);
+        }
+        return { output: lines.join('\n'), handled: true };
+    }
+    // /plugins search <query>
+    if (subcommand === 'search') {
+        const query = rest || 'all';
+        const results = searchMarketplace(query === 'all' ? '' : query);
+        return { output: formatMarketplaceSearch(results), handled: true };
+    }
+    // /plugins install <name>
+    if (subcommand === 'install' && rest) {
+        const [name, marketplace] = rest.split('@');
+        const result = installPlugin(name, marketplace);
+        if (result) {
+            return { output: `Installed ${result.name}@${result.version} from ${result.marketplace}\nCached at: ${result.cachePath}`, handled: true };
+        }
+        return { output: `Failed to install "${rest}". Is it listed in a marketplace?\nRun /plugins search ${name} to check.`, handled: true };
     }
-    // List installed
+    // /plugins uninstall <name>
+    if (subcommand === 'uninstall' && rest) {
+        return { output: uninstallPlugin(rest) ? `Uninstalled "${rest}"` : `Plugin "${rest}" not found`, handled: true };
+    }
+    // /plugins (no args) — show everything
     const plugins = discoverPlugins();
     const skills = discoverSkills();
+    const marketplacePlugins = getInstalledPlugins();
     const lines = [];
+    if (marketplacePlugins.length > 0) {
+        lines.push(formatInstalledPlugins(marketplacePlugins));
+        lines.push('');
+    }
     if (plugins.length > 0) {
-        lines.push(`Installed Plugins (${plugins.length}):`);
+        lines.push(`Local Plugins (${plugins.length}):`);
         for (const p of plugins) {
             lines.push(`  ${p.name}@${p.version} — ${p.description || 'no description'}`);
-            if (p.skills?.length)
-                lines.push(`    Skills: ${p.skills.length}`);
-            if (p.mcpServers?.length)
-                lines.push(`    MCP servers: ${p.mcpServers.map((s) => s.name).join(', ')}`);
         }
         lines.push('');
     }
     if (skills.length > 0) {
-        lines.push(`Available Skills (${skills.length}):`);
-        const bySource = {};
+        lines.push(`Skills (${skills.length}):`);
         for (const s of skills) {
-            (bySource[s.source] ??= []).push(s);
-        }
-        for (const [source, sourceSkills] of Object.entries(bySource)) {
-            lines.push(`  ${source}:`);
-            for (const s of sourceSkills) {
-                lines.push(`    ${s.name} — ${s.description}${s.trigger ? ` (trigger: "${s.trigger}")` : ''}`);
-            }
+            lines.push(`  ${s.source}:${s.name} — ${s.description || ''}`);
         }
+        lines.push('');
     }
-    else if (plugins.length === 0) {
+    if (lines.length === 0) {
         lines.push('No plugins or skills installed.');
-        lines.push('');
-        lines.push('Create skills in .oh/skills/ or ~/.oh/skills/');
-        lines.push('Run /plugins search to find npm packages.');
     }
+    lines.push('');
+    lines.push('Commands:');
+    lines.push('  /plugins search <query>          Search marketplaces');
+    lines.push('  /plugins install <name>          Install from marketplace');
+    lines.push('  /plugins uninstall <name>        Remove a plugin');
+    lines.push('  /plugins marketplace add <src>   Add a marketplace');
+    lines.push('  /plugins marketplace             List marketplaces');
     return { output: lines.join('\n'), handled: true };
 });
 // ── Command Parser ──

package/dist/harness/config.d.ts

@@ -51,6 +51,23 @@ export type OhConfig = {
     memory?: {
         consolidateOnExit?: boolean;
     };
+    /** Multi-model router — use different models for different task types */
+    modelRouter?: {
+        fast?: string;
+        balanced?: string;
+        powerful?: string;
+    };
+    /** Opt-in telemetry (default: off) */
+    telemetry?: {
+        enabled?: boolean;
+        endpoint?: string;
+    };
+    /** Remote server security settings */
+    remote?: {
+        tokens?: string[];
+        rateLimit?: number;
+        allowedTools?: string[];
+    };
 };
 /** Clear cached config (call after writes or to force re-read) */
 export declare function invalidateConfigCache(): void;

package/dist/harness/marketplace.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Plugin Marketplace — discover, install, and manage plugins from curated registries.
+ *
+ * Marketplaces are JSON files listing available plugins with versions and sources.
+ * Plugins are downloaded and cached to ~/.oh/plugins/cache/ for security and versioning.
+ *
+ * Inspired by Claude Code's marketplace model.
+ */
+export type MarketplaceEntry = {
+    name: string;
+    description: string;
+    version: string;
+    author?: string;
+    source: MarketplaceSource;
+    keywords?: string[];
+};
+export type MarketplaceSource = {
+    type: 'github';
+    repo: string;
+} | {
+    type: 'npm';
+    package: string;
+} | {
+    type: 'url';
+    url: string;
+};
+export type Marketplace = {
+    name: string;
+    version: number;
+    description?: string;
+    plugins: MarketplaceEntry[];
+};
+export type InstalledPlugin = {
+    name: string;
+    version: string;
+    marketplace: string;
+    installedAt: number;
+    cachePath: string;
+};
+/** Add a marketplace from a URL, GitHub repo, or local path */
+export declare function addMarketplace(nameOrUrl: string): Marketplace | null;
+/** Remove a marketplace */
+export declare function removeMarketplace(name: string): boolean;
+/** List all configured marketplaces */
+export declare function listMarketplaces(): Marketplace[];
+/** Search all marketplaces for plugins matching a query */
+export declare function searchMarketplace(query: string): Array<MarketplaceEntry & {
+    marketplace: string;
+}>;
+/** Install a plugin from a marketplace */
+export declare function installPlugin(pluginName: string, marketplaceName?: string): InstalledPlugin | null;
+/** Uninstall a plugin */
+export declare function uninstallPlugin(name: string): boolean;
+/** Get all installed plugins */
+export declare function getInstalledPlugins(): InstalledPlugin[];
+/** Format marketplace entries for display */
+export declare function formatMarketplaceSearch(results: Array<MarketplaceEntry & {
+    marketplace: string;
+}>): string;
+/** Format installed plugins for display */
+export declare function formatInstalledPlugins(plugins: InstalledPlugin[]): string;
+//# sourceMappingURL=marketplace.d.ts.map

package/dist/harness/marketplace.js

@@ -0,0 +1,242 @@
+/**
+ * Plugin Marketplace — discover, install, and manage plugins from curated registries.
+ *
+ * Marketplaces are JSON files listing available plugins with versions and sources.
+ * Plugins are downloaded and cached to ~/.oh/plugins/cache/ for security and versioning.
+ *
+ * Inspired by Claude Code's marketplace model.
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, rmSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { execSync } from 'node:child_process';
+const MARKETPLACE_DIR = join(homedir(), '.oh', 'marketplaces');
+const PLUGIN_CACHE_DIR = join(homedir(), '.oh', 'plugins', 'cache');
+const INSTALLED_PLUGINS_FILE = join(homedir(), '.oh', 'plugins', 'installed.json');
+// ── Marketplace Management ──
+/** Add a marketplace from a URL, GitHub repo, or local path */
+export function addMarketplace(nameOrUrl) {
+    mkdirSync(MARKETPLACE_DIR, { recursive: true });
+    // Fetch marketplace.json
+    let data;
+    let marketplaceName;
+    if (nameOrUrl.startsWith('http')) {
+        // URL
+        try {
+            data = execSync(`curl -sL "${nameOrUrl}/marketplace.json"`, { encoding: 'utf-8', timeout: 10_000 });
+            marketplaceName = new URL(nameOrUrl).hostname;
+        }
+        catch {
+            return null;
+        }
+    }
+    else if (nameOrUrl.includes('/') && !nameOrUrl.startsWith('.')) {
+        // GitHub repo (owner/repo format)
+        try {
+            const url = `https://raw.githubusercontent.com/${nameOrUrl}/main/marketplace.json`;
+            data = execSync(`curl -sL "${url}"`, { encoding: 'utf-8', timeout: 10_000 });
+            marketplaceName = nameOrUrl.replace('/', '-');
+        }
+        catch {
+            return null;
+        }
+    }
+    else if (existsSync(join(nameOrUrl, 'marketplace.json'))) {
+        // Local path
+        data = readFileSync(join(nameOrUrl, 'marketplace.json'), 'utf-8');
+        marketplaceName = basename(nameOrUrl);
+    }
+    else {
+        return null;
+    }
+    try {
+        const marketplace = JSON.parse(data);
+        if (!marketplace.plugins || !Array.isArray(marketplace.plugins))
+            return null;
+        marketplace.name = marketplace.name ?? marketplaceName;
+        writeFileSync(join(MARKETPLACE_DIR, `${marketplace.name}.json`), JSON.stringify(marketplace, null, 2));
+        return marketplace;
+    }
+    catch {
+        return null;
+    }
+}
+/** Remove a marketplace */
+export function removeMarketplace(name) {
+    const path = join(MARKETPLACE_DIR, `${name}.json`);
+    if (!existsSync(path))
+        return false;
+    try {
+        rmSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** List all configured marketplaces */
+export function listMarketplaces() {
+    if (!existsSync(MARKETPLACE_DIR))
+        return [];
+    return readdirSync(MARKETPLACE_DIR)
+        .filter(f => f.endsWith('.json'))
+        .map(f => {
+        try {
+            return JSON.parse(readFileSync(join(MARKETPLACE_DIR, f), 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((m) => m !== null);
+}
+/** Search all marketplaces for plugins matching a query */
+export function searchMarketplace(query) {
+    const q = query.toLowerCase();
+    const results = [];
+    for (const mp of listMarketplaces()) {
+        for (const plugin of mp.plugins) {
+            if (plugin.name.toLowerCase().includes(q) ||
+                plugin.description.toLowerCase().includes(q) ||
+                plugin.keywords?.some(k => k.toLowerCase().includes(q))) {
+                results.push({ ...plugin, marketplace: mp.name });
+            }
+        }
+    }
+    return results;
+}
+// ── Plugin Installation ──
+/** Install a plugin from a marketplace */
+export function installPlugin(pluginName, marketplaceName) {
+    // Find the plugin in marketplaces
+    const marketplaces = listMarketplaces();
+    let entry = null;
+    let fromMarketplace = '';
+    for (const mp of marketplaces) {
+        if (marketplaceName && mp.name !== marketplaceName)
+            continue;
+        const found = mp.plugins.find(p => p.name === pluginName);
+        if (found) {
+            entry = found;
+            fromMarketplace = mp.name;
+            break;
+        }
+    }
+    if (!entry)
+        return null;
+    // Download to cache
+    const cacheDir = join(PLUGIN_CACHE_DIR, entry.name, entry.version);
+    mkdirSync(cacheDir, { recursive: true });
+    try {
+        switch (entry.source.type) {
+            case 'github': {
+                // Clone the repo to cache
+                execSync(`git clone --depth 1 "https://github.com/${entry.source.repo}.git" "${cacheDir}"`, { stdio: 'pipe', timeout: 30_000 });
+                break;
+            }
+            case 'npm': {
+                // Install npm package to cache
+                execSync(`npm pack "${entry.source.package}" --pack-destination "${cacheDir}"`, { stdio: 'pipe', timeout: 30_000 });
+                // Extract the tarball
+                const tgz = readdirSync(cacheDir).find(f => f.endsWith('.tgz'));
+                if (tgz) {
+                    execSync(`tar xzf "${join(cacheDir, tgz)}" -C "${cacheDir}" --strip-components=1`, { stdio: 'pipe' });
+                }
+                break;
+            }
+            case 'url': {
+                execSync(`curl -sL "${entry.source.url}" -o "${join(cacheDir, 'plugin.tar.gz')}"`, { stdio: 'pipe', timeout: 30_000 });
+                execSync(`tar xzf "${join(cacheDir, 'plugin.tar.gz')}" -C "${cacheDir}"`, { stdio: 'pipe' });
+                break;
+            }
+        }
+    }
+    catch {
+        // Clean up failed install
+        try {
+            rmSync(cacheDir, { recursive: true });
+        }
+        catch { /* ignore */ }
+        return null;
+    }
+    // Record installation
+    const installed = {
+        name: entry.name,
+        version: entry.version,
+        marketplace: fromMarketplace,
+        installedAt: Date.now(),
+        cachePath: cacheDir,
+    };
+    saveInstalledPlugin(installed);
+    return installed;
+}
+/** Uninstall a plugin */
+export function uninstallPlugin(name) {
+    const installed = getInstalledPlugins();
+    const plugin = installed.find(p => p.name === name);
+    if (!plugin)
+        return false;
+    // Remove from cache
+    try {
+        rmSync(plugin.cachePath, { recursive: true });
+    }
+    catch { /* ignore */ }
+    // Remove from installed list
+    const remaining = installed.filter(p => p.name !== name);
+    saveInstalledPluginList(remaining);
+    return true;
+}
+/** Get all installed plugins */
+export function getInstalledPlugins() {
+    if (!existsSync(INSTALLED_PLUGINS_FILE))
+        return [];
+    try {
+        return JSON.parse(readFileSync(INSTALLED_PLUGINS_FILE, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}
+function saveInstalledPlugin(plugin) {
+    const installed = getInstalledPlugins();
+    // Replace existing version
+    const idx = installed.findIndex(p => p.name === plugin.name);
+    if (idx >= 0)
+        installed[idx] = plugin;
+    else
+        installed.push(plugin);
+    saveInstalledPluginList(installed);
+}
+function saveInstalledPluginList(plugins) {
+    const dir = join(homedir(), '.oh', 'plugins');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(INSTALLED_PLUGINS_FILE, JSON.stringify(plugins, null, 2));
+}
+// ── Formatting ──
+/** Format marketplace entries for display */
+export function formatMarketplaceSearch(results) {
+    if (results.length === 0)
+        return 'No plugins found.';
+    const lines = [`Found ${results.length} plugin(s):\n`];
+    for (const r of results) {
+        lines.push(`  ${r.name}@${r.version}  [${r.marketplace}]`);
+        lines.push(`    ${r.description}`);
+        if (r.author)
+            lines.push(`    by ${r.author}`);
+        lines.push('');
+    }
+    lines.push('Install with: /plugin install <name>');
+    return lines.join('\n');
+}
+/** Format installed plugins for display */
+export function formatInstalledPlugins(plugins) {
+    if (plugins.length === 0)
+        return 'No plugins installed from marketplaces.';
+    const lines = [`Installed Plugins (${plugins.length}):\n`];
+    for (const p of plugins) {
+        const age = Math.round((Date.now() - p.installedAt) / (1000 * 60 * 60 * 24));
+        lines.push(`  ${p.name}@${p.version}  [${p.marketplace}]  ${age}d ago`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=marketplace.js.map

package/dist/harness/plugins.d.ts

@@ -42,7 +42,7 @@ export type AgentTeamConfig = {
         tools?: string[];
     }>;
 };
-/** Discover all available skills from project + global dirs */
+/** Discover all available skills from project + global dirs + installed plugins */
 export declare function discoverSkills(): SkillMetadata[];
 /** Find a skill by name (case-insensitive) */
 export declare function findSkill(name: string): SkillMetadata | null;

package/dist/harness/plugins.js

@@ -67,11 +67,25 @@ function loadSkillsFromDir(dir, source) {
     })
         .filter((s) => s !== null);
 }
-/** Discover all available skills from project + global dirs */
+/** Discover all available skills from project + global dirs + installed plugins */
 export function discoverSkills() {
     const skills = [];
     skills.push(...loadSkillsFromDir(PROJECT_SKILLS_DIR, 'project'));
     skills.push(...loadSkillsFromDir(GLOBAL_SKILLS_DIR, 'global'));
+    // Load skills from installed marketplace plugins (namespaced as plugin-name:skill-name)
+    try {
+        const { getInstalledPlugins } = require('./marketplace.js');
+        for (const plugin of getInstalledPlugins()) {
+            const pluginSkillsDir = join(plugin.cachePath, 'skills');
+            const pluginSkills = loadSkillsFromDir(pluginSkillsDir, 'plugin');
+            // Namespace: prefix skill name with plugin name
+            for (const skill of pluginSkills) {
+                skill.name = `${plugin.name}:${skill.name}`;
+            }
+            skills.push(...pluginSkills);
+        }
+    }
+    catch { /* marketplace module may not be loaded yet */ }
     return skills;
 }
 /** Find a skill by name (case-insensitive) */