skillmaxxing 0.1.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,11 @@
+{
+  "name": "skillmaxxing",
+  "owner": { "name": "Benny Jiang", "url": "https://github.com/Bennyoooo" },
+  "plugins": [
+    {
+      "name": "skillmaxxing",
+      "source": "./",
+      "description": "Self-evolving skills for your coding agent — auto-create and auto-improve skills as you work, no trigger needed."
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "skillmaxxing",
+  "version": "0.1.0",
+  "description": "Self-evolving skills for your coding agent. Auto-creates and auto-improves skills as you work — no trigger needed.",
+  "author": { "name": "Benny Jiang" },
+  "homepage": "https://github.com/Bennyoooo/skillmaxxing",
+  "license": "MIT",
+  "keywords": ["skills", "self-improving", "agent", "hooks", "claude-code"]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Benny Jiang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,152 @@
+<p align="center">
+  <img src="assets/hero.svg" alt="SKILLMAXXING" width="760">
+</p>
+
+<h1 align="center">SkillMaxxing</h1>
+
+<p align="center">
+  <b>Self-evolving skills for your coding agent.</b><br>
+  Your agent auto-creates and auto-improves its own skills as it works — no command, no trigger, no babysitting.
+</p>
+
+<p align="center">
+  <a href="#-install-in-one-line"><img alt="install" src="https://img.shields.io/badge/install-one%20line-ff4d4d"></a>
+  <img alt="node" src="https://img.shields.io/badge/node-%E2%89%A520-2ec27e">
+  <img alt="deps" src="https://img.shields.io/badge/runtime%20deps-1-22b8cf">
+  <img alt="license" src="https://img.shields.io/badge/license-MIT-9b5de5">
+</p>
+
+---
+
+## Why
+
+Every coding agent starts every task from zero. It solves the same gnarly migration, re-derives the same release flow, re-learns the same repo quirk — and forgets it the moment the session ends.
+
+**Skill Maxing makes the forgetting stop.** It hooks into your agent so that, after real work, the agent reflects on what it just did and crystallizes the reusable parts into a **skill** — or improves a skill it already has. Over days, your agent gets measurably better at *your* codebase. That's a self-evolving agent, and it takes one line to turn on.
+
+Inspired by the [Hermes Agent](https://github.com/NousResearch/hermes-agent) self-improvement loop, adapted to run on the hooks that Claude Code, Codex, and other agents already expose.
+
+## ⚡ Install in one line
+
+```bash
+npx skillmaxxing@latest plugin install
+```
+
+That's it. Restart your agent session and Skill Maxing is live — **you never have to invoke anything.**
+
+<details>
+<summary>Claude Code, the native way</summary>
+
+```bash
+/plugin marketplace add Bennyoooo/skillmaxxing
+/plugin install skillmaxxing
+```
+</details>
+
+<details>
+<summary>Codex / other agents</summary>
+
+```bash
+npx skillmaxxing@latest plugin install --agent codex
+```
+
+Codex has no programmatic stop hook, so self-evolution runs **in-session** via standing guidance written to `AGENTS.md`. Claude Code gets the full background loop below.
+</details>
+
+Turn it off any time:
+
+```bash
+npx skillmaxxing plugin uninstall      # check state with: plugin status
+```
+
+## 🧠 How it works
+
+Skill Maxing installs three hooks. You do nothing — the loop runs itself.
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│  SessionStart   →  inject standing guidance                    │
+│                    "crystallize reusable work; fix stale skills"│
+│                                                                │
+│  PostToolUse    →  count substantive tool calls this session   │
+│                                                                │
+│  Stop (task done) → enough work? fork a background reflector:   │
+│                     review the transcript and, if warranted,    │
+│                     create ONE new skill or improve an existing │
+│                     one — autonomously, trusted:false           │
+└──────────────────────────────────────────────────────────────┘
+```
+
+This mirrors Hermes' three layers:
+
+| Hermes | Skill Maxing |
+|--------|--------------|
+| Always-on system-prompt nudge | **SessionStart** hook injects skill-creation guidance |
+| Background review every N iterations | **PostToolUse** counter + **Stop** hook fork a headless reflector after a threshold of real work |
+| Provenance-gated curation | New/changed skills are recorded **`trusted: false`** until you approve them |
+
+Two key Hermes ideas carry straight over: the reflector **prefers updating an existing skill over creating a near-duplicate**, and it is **conservative** — most sessions produce no skill at all.
+
+### Two modes
+
+| Mode | What happens on a substantial session | Pick it when |
+|------|----------------------------------------|--------------|
+| `auto` *(default)* | A **background** agent (`claude -p`, restricted to skill tools) reflects and writes/updates a skill while you keep working | You want truly hands-off self-evolution |
+| `nudge` | The agent is reminded to crystallize the workflow itself, in-session | You want zero extra processes / full visibility |
+
+```bash
+npx skillmaxxing plugin install --mode nudge --threshold 12
+```
+
+The background reflector is **recursion-guarded** (it can never trigger itself) and **detached** (it never blocks your session). Every skill it writes is `trusted: false` and never auto-executes until you grant trust.
+
+## 🔧 The two superpowers
+
+Everything above is built on two CLI primitives the reflector (or you) can call directly. The CLI is **model-agnostic** — it does the deterministic work; your agent supplies the reasoning.
+
+**Create** — turn a workflow into a tested skill:
+
+```bash
+skillmaxxing skillify --draft draft.json    # stage → smoke-test → review → --commit
+```
+
+**Improve** — make an existing skill measurably better, safely:
+
+```bash
+skillmaxxing optimize <score|apply|gate|promote|revert>
+```
+
+`optimize` is an **eval-gated** loop (rollout → reflect → bounded edit → validate): a candidate is promoted only on a strict score win with no regression, every version is retained, and any change is reversible.
+
+## 🛟 Trust & safety
+
+- **Untrusted by default.** Auto-created and improved skills are `trusted: false`; the sandbox refuses to run their code without your explicit `--allow-exec`.
+- **Reversible.** Promotions are atomic and every prior version is retained — revert any time.
+- **No surprise execution.** The background reflector writes skills; it does not run untrusted code or touch your project source.
+
+## 🗺️ Roadmap
+
+| Capability | Status |
+|------------|--------|
+| Auto-create skills (hook-driven) | ✅ v1 |
+| Auto-improve skills (eval-gated) | ✅ v1 |
+| Cross-agent install (Claude Code, Codex) | ✅ v1 |
+| Discover skills from public sources | 🧰 CLI ready — landing in the plugin next |
+| Team workspace: share + collaboratively optimize | 🧰 CLI ready — landing in the plugin next |
+
+Discovery and team sharing already exist as CLI commands (`skillmaxxing discover`, `skillmaxxing workspace`); they're intentionally held out of the v1 plugin surface to keep the install dead-simple.
+
+## 🛠️ Develop
+
+```bash
+npm install
+npm run build      # tsc -> dist/
+npm test           # node:test, ~90 tests
+node scripts/gen-hero.mjs   # regenerate the hero
+```
+
+Zero runtime dependencies beyond `yaml`. ESM, Node ≥ 20.
+
+## License
+
+MIT

package/dist/agents/claude.js

@@ -0,0 +1,12 @@
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { fileExists } from '../util/fs.js';
+const claude = {
+    name: 'claude',
+    displayName: 'Claude Code',
+    cliCommand: 'claude',
+    globalSkillsDir: path.join(os.homedir(), '.claude', 'skills'),
+    projectSkillsDir: '.claude/skills',
+    detectInstalled: async () => fileExists(path.join(os.homedir(), '.claude')),
+};
+export default claude;

package/dist/agents/codex.js

@@ -0,0 +1,12 @@
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { fileExists } from '../util/fs.js';
+const codex = {
+    name: 'codex',
+    displayName: 'OpenAI Codex CLI',
+    cliCommand: 'codex',
+    globalSkillsDir: path.join(os.homedir(), '.codex', 'skills'),
+    projectSkillsDir: '.agents/skills',
+    detectInstalled: async () => fileExists(path.join(os.homedir(), '.codex')),
+};
+export default codex;

package/dist/agents/cursor.js

@@ -0,0 +1,12 @@
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { fileExists } from '../util/fs.js';
+const cursor = {
+    name: 'cursor',
+    displayName: 'Cursor',
+    cliCommand: 'cursor',
+    globalSkillsDir: path.join(os.homedir(), '.cursor', 'skills'),
+    projectSkillsDir: '.cursor/skills',
+    detectInstalled: async () => fileExists(path.join(os.homedir(), '.cursor')),
+};
+export default cursor;

package/dist/agents/hermes.js

@@ -0,0 +1,12 @@
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { fileExists } from '../util/fs.js';
+const hermes = {
+    name: 'hermes',
+    displayName: 'Hermes Agent',
+    cliCommand: 'hermes',
+    globalSkillsDir: path.join(os.homedir(), '.hermes', 'skills'),
+    projectSkillsDir: '.hermes/skills',
+    detectInstalled: async () => fileExists(path.join(os.homedir(), '.hermes')),
+};
+export default hermes;

package/dist/agents/opencode.js

@@ -0,0 +1,12 @@
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { fileExists } from '../util/fs.js';
+const opencode = {
+    name: 'opencode',
+    displayName: 'OpenCode',
+    cliCommand: 'opencode',
+    globalSkillsDir: path.join(os.homedir(), '.config', 'opencode', 'skills'),
+    projectSkillsDir: '.opencode/skills',
+    detectInstalled: async () => fileExists(path.join(os.homedir(), '.config', 'opencode')),
+};
+export default opencode;

package/dist/agents/registry.js

@@ -0,0 +1,22 @@
+import claude from './claude.js';
+import codex from './codex.js';
+import cursor from './cursor.js';
+import opencode from './opencode.js';
+import hermes from './hermes.js';
+export const ALL_AGENTS = [claude, codex, cursor, opencode, hermes];
+const AGENT_MAP = new Map(ALL_AGENTS.map(a => [a.name, a]));
+export function getAgent(name) {
+    return AGENT_MAP.get(name);
+}
+export function getAgentOrThrow(name) {
+    const agent = AGENT_MAP.get(name);
+    if (!agent) {
+        throw new Error(`Unknown agent '${name}'. Available: ${ALL_AGENTS.map(a => a.name).join(', ')}`);
+    }
+    return agent;
+}
+export async function detectInstalledAgents() {
+    const results = await Promise.all(ALL_AGENTS.map(async (a) => ({ agent: a, installed: await a.detectInstalled() })));
+    return results.filter(r => r.installed).map(r => r.agent);
+}
+export const ALL_AGENT_NAMES = ALL_AGENTS.map(a => a.name);

package/dist/agents/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+import { install } from './commands/install.js';
+import { discover } from './commands/discover.js';
+import { skillify } from './commands/skillify.js';
+import { optimize } from './commands/optimize.js';
+import { workspace } from './commands/workspace.js';
+import { plugin } from './commands/plugin.js';
+import { list } from './commands/list.js';
+import { remove } from './commands/remove.js';
+import { update } from './commands/update.js';
+import { init } from './commands/init.js';
+import { doctor } from './commands/doctor.js';
+import * as log from './util/log.js';
+const VERSION = '0.1.0';
+function parseFlags(argv) {
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--') {
+            positional.push(...argv.slice(i + 1));
+            break;
+        }
+        if (arg.startsWith('--')) {
+            const eq = arg.indexOf('=');
+            if (eq !== -1) {
+                flags[arg.substring(2, eq)] = arg.substring(eq + 1);
+            }
+            else {
+                const next = argv[i + 1];
+                if (next && !next.startsWith('-')) {
+                    flags[arg.substring(2)] = next;
+                    i++;
+                }
+                else {
+                    flags[arg.substring(2)] = true;
+                }
+            }
+        }
+        else if (arg.startsWith('-') && arg.length === 2) {
+            const shortMap = { g: 'global', a: 'agent', s: 'scope', y: 'yes', h: 'help' };
+            const long = shortMap[arg[1]] ?? arg[1];
+            const next = argv[i + 1];
+            if (next && !next.startsWith('-')) {
+                flags[long] = next;
+                i++;
+            }
+            else {
+                flags[long] = true;
+            }
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    return { positional, flags };
+}
+function printHelp() {
+    console.log(`skill-maxing v${VERSION}
+
+A stack for installing, creating, improving, and governing AI agent skills.
+
+Usage:
+  skill-maxing <command> [options]
+
+Commands:
+  plugin <action>     Self-evolving plugin: install|uninstall|status (hooks, no trigger)
+  install <source>    Install skills from GitHub, URL, or local path
+  discover <query>    Find skills by intent (curated index, repos, local)
+  skillify            Create a skill from a draft (--draft/--commit/--list-drafts)
+  optimize <action>   Eval-gated optimize: score|apply|gate|promote|revert
+  workspace <action>  Team registry: publish|sync|list|pool|promote
+  list                List installed skills
+  remove <names...>   Remove installed skills
+  update [names...]   Update installed skills to latest
+  init [name]         Create a new skill template
+  doctor              Check agent integrations and skill health
+
+Options:
+  -g, --global        Install/operate at global scope (default: project)
+  -a, --agent <name>  Target specific agent (claude, codex, cursor, opencode, hermes)
+  --copy              Force copy instead of symlink
+  --force             Overwrite an existing unmanaged skill of the same name
+  --repo <owner/repo> Extra repo source(s) to scan during discover (comma-sep)
+  --limit <n>         Max discover results (default 20)
+  --install <name>    Install a named result (discover command)
+  --json              Output as JSON (list/discover commands)
+  -y, --yes           Skip confirmation prompts
+  -h, --help          Show help
+  --version           Show version
+
+Examples:
+  skill-maxing install owner/repo              Install skills from GitHub
+  skill-maxing install ./my-skills -g          Install local skills globally
+  skill-maxing install owner/repo -a claude    Install for Claude Code only
+  skill-maxing list                            List all installed skills
+  skill-maxing list -g                         List global skills only
+  skill-maxing remove my-skill                 Remove a skill
+  skill-maxing update                          Update all installed skills
+  skill-maxing init my-new-skill               Create a skill template
+  skill-maxing doctor                          Check health
+`);
+}
+async function main() {
+    const { positional, flags } = parseFlags(process.argv.slice(2));
+    const command = positional[0];
+    if (flags.version === true) {
+        console.log(VERSION);
+        return;
+    }
+    if (!command || flags.help) {
+        printHelp();
+        return;
+    }
+    const scope = flags.global === true ? 'global' : 'project';
+    const agentFlag = typeof flags.agent === 'string' ? flags.agent : undefined;
+    const agents = agentFlag ? agentFlag.split(',') : undefined;
+    try {
+        switch (command) {
+            case 'install':
+            case 'add':
+            case 'i': {
+                const source = positional[1];
+                if (!source) {
+                    log.error('Usage: skill-maxing install <source>');
+                    process.exit(1);
+                }
+                await install({ source, agents, scope, copy: flags.copy === true, force: flags.force === true });
+                break;
+            }
+            case 'discover':
+            case 'search':
+            case 'find': {
+                const query = positional.slice(1).join(' ');
+                if (!query) {
+                    log.error('Usage: skill-maxing discover "<what you want>" [--repo owner/repo] [--install <name>]');
+                    process.exit(1);
+                }
+                const repos = typeof flags.repo === 'string' ? flags.repo.split(',') : undefined;
+                const limit = typeof flags.limit === 'string' ? parseInt(flags.limit, 10) : undefined;
+                await discover({
+                    query,
+                    repos,
+                    json: flags.json === true,
+                    limit: Number.isNaN(limit) ? undefined : limit,
+                    install: typeof flags.install === 'string' ? flags.install : undefined,
+                    scope,
+                    agents,
+                    copy: flags.copy === true,
+                    force: flags.force === true,
+                });
+                break;
+            }
+            case 'skillify':
+            case 'create': {
+                await skillify({
+                    draftPath: typeof flags.draft === 'string' ? flags.draft : undefined,
+                    commit: typeof flags.commit === 'string' ? flags.commit : undefined,
+                    listDrafts: flags['list-drafts'] === true,
+                    discard: typeof flags.discard === 'string' ? flags.discard : undefined,
+                    allowExec: flags['allow-exec'] === true,
+                    forceNew: flags.new === true,
+                    scope,
+                    agents,
+                    copy: flags.copy === true,
+                    force: flags.force === true,
+                });
+                break;
+            }
+            case 'optimize':
+            case 'opt': {
+                const action = positional[1];
+                if (!action) {
+                    log.error('Usage: skill-maxing optimize <score|apply|gate|promote|revert> [options]');
+                    process.exit(1);
+                }
+                const num = (k) => {
+                    if (typeof flags[k] !== 'string')
+                        return undefined;
+                    const n = Number(flags[k]);
+                    return Number.isNaN(n) ? undefined : n; // a non-numeric flag is not a silent 0/NaN
+                };
+                const str = (k) => typeof flags[k] === 'string' ? flags[k] : undefined;
+                await optimize({
+                    action,
+                    skillName: str('skill'),
+                    skillDir: str('skill-dir'),
+                    editsPath: str('edits'),
+                    evalPath: str('eval'),
+                    rolloutsPath: str('rollouts'),
+                    liveDir: str('live'),
+                    candidateDir: str('candidate'),
+                    version: str('version'),
+                    step: num('step'),
+                    total: num('total'),
+                    base: num('base'),
+                    min: num('min'),
+                    scheduler: str('scheduler'),
+                    current: num('current'),
+                    candidate: num('candidate'),
+                    best: num('best'),
+                    score: num('score'),
+                    allowExec: flags['allow-exec'] === true,
+                    json: flags.json === true,
+                });
+                break;
+            }
+            case 'workspace':
+            case 'ws': {
+                const action = positional[1];
+                if (!action) {
+                    log.error('Usage: skill-maxing workspace <publish|sync|list|pool|promote> --registry <dir> [options]');
+                    process.exit(1);
+                }
+                const str = (k) => typeof flags[k] === 'string' ? flags[k] : undefined;
+                await workspace({
+                    action,
+                    registryDir: str('registry'),
+                    skillDir: str('skill-dir'),
+                    skillName: str('skill'),
+                    channel: str('channel'),
+                    by: str('by'),
+                    approver: str('approver'),
+                    approve: flags.approve === true,
+                    score: typeof flags.score === 'string' && !Number.isNaN(Number(flags.score))
+                        ? Number(flags.score)
+                        : undefined,
+                    json: flags.json === true,
+                });
+                break;
+            }
+            case 'plugin': {
+                const action = positional[1];
+                if (!action) {
+                    log.error('Usage: skill-maxing plugin <install|uninstall|status> [--agent claude|codex] [--mode auto|nudge] [--threshold N] [--project]');
+                    process.exit(1);
+                }
+                const pAgent = agentFlag === 'codex' ? 'codex' : agentFlag === 'claude' ? 'claude' : undefined;
+                const pMode = flags.mode === 'nudge' ? 'nudge' : flags.mode === 'auto' ? 'auto' : undefined;
+                const pThreshold = typeof flags.threshold === 'string' && !Number.isNaN(Number(flags.threshold))
+                    ? Number(flags.threshold)
+                    : undefined;
+                await plugin({
+                    action,
+                    agent: pAgent,
+                    mode: pMode,
+                    threshold: pThreshold,
+                    project: flags.project === true,
+                });
+                break;
+            }
+            case 'list':
+            case 'ls':
+                await list({ agent: agentFlag, scope: flags.global === true ? 'global' : undefined, json: flags.json === true });
+                break;
+            case 'remove':
+            case 'rm': {
+                const names = positional.slice(1);
+                if (names.length === 0) {
+                    log.error('Usage: skill-maxing remove <skill-name> [skill-name...]');
+                    process.exit(1);
+                }
+                await remove({ names, agent: agentFlag, scope: flags.global === true ? 'global' : undefined });
+                break;
+            }
+            case 'update':
+            case 'upgrade': {
+                const names = positional.slice(1);
+                await update({ names: names.length > 0 ? names : undefined, scope: flags.global === true ? 'global' : undefined });
+                break;
+            }
+            case 'init': {
+                const name = positional[1];
+                await init({ name });
+                break;
+            }
+            case 'doctor':
+                await doctor();
+                break;
+            default:
+                log.error(`Unknown command: ${command}`);
+                printHelp();
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        log.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+main();

package/dist/commands/discover.js

@@ -0,0 +1,76 @@
+import { collectSources } from '../discover/collect.js';
+import { rankCandidates } from '../discover/rank.js';
+import { install } from './install.js';
+import * as log from '../util/log.js';
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n - 1) + '…' : s;
+}
+export async function discover(args) {
+    const { candidates, errors } = await collectSources({
+        repos: args.repos,
+        projectDir: process.cwd(),
+    });
+    for (const e of errors)
+        log.warn(`Source '${e.source}' unavailable: ${e.message}`);
+    let ranked = rankCandidates(args.query, candidates);
+    if (args.query.trim())
+        ranked = ranked.filter((r) => r.score > 0);
+    const limited = ranked.slice(0, args.limit ?? 20);
+    if (limited.length === 0) {
+        log.warn(`No skills matched "${args.query}".`);
+        process.exitCode = 1; // explicit non-empty contract (review I2)
+        return;
+    }
+    // Discover → install handoff.
+    if (args.install) {
+        const pick = limited.find((r) => r.name.toLowerCase() === args.install.toLowerCase());
+        if (!pick) {
+            log.error(`"${args.install}" is not in the results.`);
+            process.exitCode = 1;
+            return;
+        }
+        if (!pick.source) {
+            if (pick.installed) {
+                log.info(`${pick.name} is already installed locally.`);
+                return;
+            }
+            log.error(`${pick.name} has no installable source.`);
+            process.exitCode = 1;
+            return;
+        }
+        // NOTE: install re-resolves the source to HEAD. Exact pinned-commit install
+        // (using pick.commitSha) needs a fetch-by-SHA path the depth-1 clone can't
+        // do today — tracked as a known gap (review F2). We surface the resolved
+        // commit for provenance.
+        if (pick.commitSha) {
+            log.info(`${pick.name} discovered at ${pick.commitSha.slice(0, 10)}; installing from ${pick.source}.`);
+        }
+        else {
+            log.info(`Installing ${pick.name} from ${pick.source}...`);
+        }
+        await install({
+            source: pick.source,
+            scope: args.scope,
+            agents: args.agents,
+            copy: args.copy,
+            force: args.force,
+        });
+        return;
+    }
+    if (args.json) {
+        console.log(JSON.stringify(limited, null, 2));
+        return;
+    }
+    log.heading(`Skills matching "${args.query}" (${limited.length})`);
+    log.table([
+        ['', 'name', 'origin', 'source', 'description'],
+        ...limited.map((r) => [
+            r.installed ? '✓' : ' ',
+            r.name,
+            r.origin,
+            r.source || '(local)',
+            truncate(r.description, 50),
+        ]),
+    ]);
+    log.info(`Install one with: skill-maxing discover "${args.query}" --install <name>`);
+}