@poolzin/pool-bot 2026.2.17 → 2026.2.18

package/dist/cli/program/routes.js

@@ -0,0 +1,233 @@
+import { defaultRuntime } from "../../runtime.js";
+import { getFlagValue, getPositiveIntFlagValue, getVerboseFlag, hasFlag } from "../argv.js";
+const routeHealth = {
+    match: (path) => path[0] === "health",
+    loadPlugins: true,
+    run: async (argv) => {
+        const json = hasFlag(argv, "--json");
+        const verbose = getVerboseFlag(argv, { includeDebug: true });
+        const timeoutMs = getPositiveIntFlagValue(argv, "--timeout");
+        if (timeoutMs === null) {
+            return false;
+        }
+        const { healthCommand } = await import("../../commands/health.js");
+        await healthCommand({ json, timeoutMs, verbose }, defaultRuntime);
+        return true;
+    },
+};
+const routeStatus = {
+    match: (path) => path[0] === "status",
+    loadPlugins: true,
+    run: async (argv) => {
+        const json = hasFlag(argv, "--json");
+        const deep = hasFlag(argv, "--deep");
+        const all = hasFlag(argv, "--all");
+        const usage = hasFlag(argv, "--usage");
+        const verbose = getVerboseFlag(argv, { includeDebug: true });
+        const timeoutMs = getPositiveIntFlagValue(argv, "--timeout");
+        if (timeoutMs === null) {
+            return false;
+        }
+        const { statusCommand } = await import("../../commands/status.js");
+        await statusCommand({ json, deep, all, usage, timeoutMs, verbose }, defaultRuntime);
+        return true;
+    },
+};
+const routeSessions = {
+    match: (path) => path[0] === "sessions",
+    run: async (argv) => {
+        const json = hasFlag(argv, "--json");
+        const store = getFlagValue(argv, "--store");
+        if (store === null) {
+            return false;
+        }
+        const active = getFlagValue(argv, "--active");
+        if (active === null) {
+            return false;
+        }
+        const { sessionsCommand } = await import("../../commands/sessions.js");
+        await sessionsCommand({ json, store, active }, defaultRuntime);
+        return true;
+    },
+};
+const routeAgentsList = {
+    match: (path) => path[0] === "agents" && path[1] === "list",
+    run: async (argv) => {
+        const json = hasFlag(argv, "--json");
+        const bindings = hasFlag(argv, "--bindings");
+        const { agentsListCommand } = await import("../../commands/agents.js");
+        await agentsListCommand({ json, bindings }, defaultRuntime);
+        return true;
+    },
+};
+const routeMemoryStatus = {
+    match: (path) => path[0] === "memory" && path[1] === "status",
+    run: async (argv) => {
+        const agent = getFlagValue(argv, "--agent");
+        if (agent === null) {
+            return false;
+        }
+        const json = hasFlag(argv, "--json");
+        const deep = hasFlag(argv, "--deep");
+        const index = hasFlag(argv, "--index");
+        const verbose = hasFlag(argv, "--verbose");
+        const { runMemoryStatus } = await import("../memory-cli.js");
+        await runMemoryStatus({ agent, json, deep, index, verbose });
+        return true;
+    },
+};
+function getCommandPositionals(argv) {
+    const out = [];
+    const args = argv.slice(2);
+    for (const arg of args) {
+        if (!arg || arg === "--") {
+            break;
+        }
+        if (arg.startsWith("-")) {
+            continue;
+        }
+        out.push(arg);
+    }
+    return out;
+}
+function getFlagValues(argv, name) {
+    const values = [];
+    const args = argv.slice(2);
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (!arg || arg === "--") {
+            break;
+        }
+        if (arg === name) {
+            const next = args[i + 1];
+            if (!next || next === "--" || next.startsWith("-")) {
+                return null;
+            }
+            values.push(next);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith(`${name}=`)) {
+            const value = arg.slice(name.length + 1).trim();
+            if (!value) {
+                return null;
+            }
+            values.push(value);
+        }
+    }
+    return values;
+}
+const routeConfigGet = {
+    match: (path) => path[0] === "config" && path[1] === "get",
+    run: async (argv) => {
+        const positionals = getCommandPositionals(argv);
+        const pathArg = positionals[2];
+        if (!pathArg) {
+            return false;
+        }
+        const json = hasFlag(argv, "--json");
+        const { runConfigGet } = await import("../config-cli.js");
+        await runConfigGet({ path: pathArg, json });
+        return true;
+    },
+};
+const routeConfigUnset = {
+    match: (path) => path[0] === "config" && path[1] === "unset",
+    run: async (argv) => {
+        const positionals = getCommandPositionals(argv);
+        const pathArg = positionals[2];
+        if (!pathArg) {
+            return false;
+        }
+        const { runConfigUnset } = await import("../config-cli.js");
+        await runConfigUnset({ path: pathArg });
+        return true;
+    },
+};
+const routeModelsList = {
+    match: (path) => path[0] === "models" && path[1] === "list",
+    run: async (argv) => {
+        const provider = getFlagValue(argv, "--provider");
+        if (provider === null) {
+            return false;
+        }
+        const all = hasFlag(argv, "--all");
+        const local = hasFlag(argv, "--local");
+        const json = hasFlag(argv, "--json");
+        const plain = hasFlag(argv, "--plain");
+        const { modelsListCommand } = await import("../../commands/models.js");
+        await modelsListCommand({ all, local, provider, json, plain }, defaultRuntime);
+        return true;
+    },
+};
+const routeModelsStatus = {
+    match: (path) => path[0] === "models" && path[1] === "status",
+    run: async (argv) => {
+        const probeProvider = getFlagValue(argv, "--probe-provider");
+        if (probeProvider === null) {
+            return false;
+        }
+        const probeTimeout = getFlagValue(argv, "--probe-timeout");
+        if (probeTimeout === null) {
+            return false;
+        }
+        const probeConcurrency = getFlagValue(argv, "--probe-concurrency");
+        if (probeConcurrency === null) {
+            return false;
+        }
+        const probeMaxTokens = getFlagValue(argv, "--probe-max-tokens");
+        if (probeMaxTokens === null) {
+            return false;
+        }
+        const agent = getFlagValue(argv, "--agent");
+        if (agent === null) {
+            return false;
+        }
+        const probeProfileValues = getFlagValues(argv, "--probe-profile");
+        if (probeProfileValues === null) {
+            return false;
+        }
+        const probeProfile = probeProfileValues.length === 0
+            ? undefined
+            : probeProfileValues.length === 1
+                ? probeProfileValues[0]
+                : probeProfileValues;
+        const json = hasFlag(argv, "--json");
+        const plain = hasFlag(argv, "--plain");
+        const check = hasFlag(argv, "--check");
+        const probe = hasFlag(argv, "--probe");
+        const { modelsStatusCommand } = await import("../../commands/models.js");
+        await modelsStatusCommand({
+            json,
+            plain,
+            check,
+            probe,
+            probeProvider,
+            probeProfile,
+            probeTimeout,
+            probeConcurrency,
+            probeMaxTokens,
+            agent,
+        }, defaultRuntime);
+        return true;
+    },
+};
+const routes = [
+    routeHealth,
+    routeStatus,
+    routeSessions,
+    routeAgentsList,
+    routeMemoryStatus,
+    routeConfigGet,
+    routeConfigUnset,
+    routeModelsList,
+    routeModelsStatus,
+];
+export function findRoutedCommand(path) {
+    for (const route of routes) {
+        if (route.match(path)) {
+            return route;
+        }
+    }
+    return null;
+}

package/dist/cli/qr-cli.js

@@ -0,0 +1,132 @@
+import qrcode from "qrcode-terminal";
+import { loadConfig } from "../config/config.js";
+import { resolvePairingSetupFromConfig, encodePairingSetupCode } from "../pairing/setup-code.js";
+import { runCommandWithTimeout } from "../process/exec.js";
+import { defaultRuntime } from "../runtime.js";
+import { theme } from "../terminal/theme.js";
+function renderQrAscii(data) {
+    return new Promise((resolve) => {
+        qrcode.generate(data, { small: true }, (output) => {
+            resolve(output);
+        });
+    });
+}
+function readDevicePairPublicUrlFromConfig(cfg) {
+    const value = cfg.plugins?.entries?.["device-pair"]?.config?.["publicUrl"];
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+export function registerQrCli(program) {
+    program
+        .command("qr")
+        .description("Generate an iOS pairing QR code and setup code")
+        .option("--remote", "Use gateway.remote.url and gateway.remote token/password (ignores device-pair publicUrl)", false)
+        .option("--url <url>", "Override gateway URL used in the setup payload")
+        .option("--public-url <url>", "Override gateway public URL used in the setup payload")
+        .option("--token <token>", "Override gateway token for setup payload")
+        .option("--password <password>", "Override gateway password for setup payload")
+        .option("--setup-code-only", "Print only the setup code", false)
+        .option("--no-ascii", "Skip ASCII QR rendering")
+        .option("--json", "Output JSON", false)
+        .action(async (opts) => {
+        try {
+            if (opts.token && opts.password) {
+                throw new Error("Use either --token or --password, not both.");
+            }
+            const loaded = loadConfig();
+            const cfg = {
+                ...loaded,
+                gateway: {
+                    ...loaded.gateway,
+                    auth: {
+                        ...loaded.gateway?.auth,
+                    },
+                },
+            };
+            const token = typeof opts.token === "string" ? opts.token.trim() : "";
+            const password = typeof opts.password === "string" ? opts.password.trim() : "";
+            const wantsRemote = opts.remote === true;
+            if (token) {
+                cfg.gateway.auth.mode = "token";
+                cfg.gateway.auth.token = token;
+            }
+            if (password) {
+                cfg.gateway.auth.mode = "password";
+                cfg.gateway.auth.password = password;
+            }
+            if (wantsRemote && !token && !password) {
+                const remoteToken = typeof cfg.gateway?.remote?.token === "string" ? cfg.gateway.remote.token.trim() : "";
+                const remotePassword = typeof cfg.gateway?.remote?.password === "string"
+                    ? cfg.gateway.remote.password.trim()
+                    : "";
+                if (remoteToken) {
+                    cfg.gateway.auth.mode = "token";
+                    cfg.gateway.auth.token = remoteToken;
+                    cfg.gateway.auth.password = undefined;
+                }
+                else if (remotePassword) {
+                    cfg.gateway.auth.mode = "password";
+                    cfg.gateway.auth.password = remotePassword;
+                    cfg.gateway.auth.token = undefined;
+                }
+            }
+            if (wantsRemote && !opts.url && !opts.publicUrl) {
+                const tailscaleMode = cfg.gateway?.tailscale?.mode ?? "off";
+                const remoteUrl = cfg.gateway?.remote?.url;
+                const hasRemoteUrl = typeof remoteUrl === "string" && remoteUrl.trim().length > 0;
+                const hasTailscaleServe = tailscaleMode === "serve" || tailscaleMode === "funnel";
+                if (!hasRemoteUrl && !hasTailscaleServe) {
+                    throw new Error("qr --remote requires gateway.remote.url (or gateway.tailscale.mode=serve/funnel).");
+                }
+            }
+            const explicitUrl = typeof opts.url === "string" && opts.url.trim()
+                ? opts.url.trim()
+                : typeof opts.publicUrl === "string" && opts.publicUrl.trim()
+                    ? opts.publicUrl.trim()
+                    : undefined;
+            const publicUrl = explicitUrl ?? (wantsRemote ? undefined : readDevicePairPublicUrlFromConfig(cfg));
+            const resolved = await resolvePairingSetupFromConfig(cfg, {
+                publicUrl,
+                preferRemoteUrl: wantsRemote,
+                runCommandWithTimeout: async (argv, runOpts) => await runCommandWithTimeout(argv, {
+                    timeoutMs: runOpts.timeoutMs,
+                }),
+            });
+            if (!resolved.ok) {
+                throw new Error(resolved.error);
+            }
+            const setupCode = encodePairingSetupCode(resolved.payload);
+            if (opts.setupCodeOnly) {
+                defaultRuntime.log(setupCode);
+                return;
+            }
+            if (opts.json) {
+                defaultRuntime.log(JSON.stringify({
+                    setupCode,
+                    gatewayUrl: resolved.payload.url,
+                    auth: resolved.authLabel,
+                    urlSource: resolved.urlSource,
+                }, null, 2));
+                return;
+            }
+            const lines = [
+                theme.heading("Pairing QR"),
+                "Scan this with the OpenClaw iOS app (Onboarding -> Scan QR).",
+                "",
+            ];
+            if (opts.ascii !== false) {
+                const qrAscii = await renderQrAscii(setupCode);
+                lines.push(qrAscii.trimEnd(), "");
+            }
+            lines.push(`${theme.muted("Setup code:")} ${setupCode}`, `${theme.muted("Gateway:")} ${resolved.payload.url}`, `${theme.muted("Auth:")} ${resolved.authLabel}`, `${theme.muted("Source:")} ${resolved.urlSource}`, "", "Approve after scan with:", `  ${theme.command("openclaw devices list")}`, `  ${theme.command("openclaw devices approve <requestId>")}`);
+            defaultRuntime.log(lines.join("\n"));
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+}

package/dist/cli/requirements-test-fixtures.js

@@ -0,0 +1,17 @@
+export function createEmptyRequirements() {
+    return {
+        bins: [],
+        anyBins: [],
+        env: [],
+        config: [],
+        os: [],
+    };
+}
+export function createEmptyInstallChecks() {
+    return {
+        requirements: createEmptyRequirements(),
+        missing: createEmptyRequirements(),
+        configChecks: [],
+        install: [],
+    };
+}

package/dist/cli/respawn-policy.js

@@ -0,0 +1,4 @@
+import { hasHelpOrVersion } from "./argv.js";
+export function shouldSkipRespawnForArgv(argv) {
+    return hasHelpOrVersion(argv);
+}

package/dist/cli/shared/parse-port.js

@@ -0,0 +1,18 @@
+export function parsePort(raw) {
+    if (raw === undefined || raw === null) {
+        return null;
+    }
+    const value = typeof raw === "string"
+        ? raw
+        : typeof raw === "number" || typeof raw === "bigint"
+            ? raw.toString()
+            : null;
+    if (value === null) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return null;
+    }
+    return parsed;
+}

package/dist/cli/skills-cli.format.js

@@ -0,0 +1,241 @@
+import { renderTable } from "../terminal/table.js";
+import { theme } from "../terminal/theme.js";
+import { shortenHomePath } from "../utils.js";
+import { formatCliCommand } from "./command-format.js";
+function appendClawHubHint(output, json) {
+    if (json) {
+        return output;
+    }
+    return `${output}\n\nTip: use \`npx clawhub\` to search, install, and sync skills.`;
+}
+function formatSkillStatus(skill) {
+    if (skill.eligible) {
+        return theme.success("✓ ready");
+    }
+    if (skill.disabled) {
+        return theme.warn("⏸ disabled");
+    }
+    if (skill.blockedByAllowlist) {
+        return theme.warn("🚫 blocked");
+    }
+    return theme.error("✗ missing");
+}
+function formatSkillName(skill) {
+    const emoji = skill.emoji ?? "📦";
+    return `${emoji} ${theme.command(skill.name)}`;
+}
+function formatSkillMissingSummary(skill) {
+    const missing = [];
+    if (skill.missing.bins.length > 0) {
+        missing.push(`bins: ${skill.missing.bins.join(", ")}`);
+    }
+    if (skill.missing.anyBins.length > 0) {
+        missing.push(`anyBins: ${skill.missing.anyBins.join(", ")}`);
+    }
+    if (skill.missing.env.length > 0) {
+        missing.push(`env: ${skill.missing.env.join(", ")}`);
+    }
+    if (skill.missing.config.length > 0) {
+        missing.push(`config: ${skill.missing.config.join(", ")}`);
+    }
+    if (skill.missing.os.length > 0) {
+        missing.push(`os: ${skill.missing.os.join(", ")}`);
+    }
+    return missing.join("; ");
+}
+export function formatSkillsList(report, opts) {
+    const skills = opts.eligible ? report.skills.filter((s) => s.eligible) : report.skills;
+    if (opts.json) {
+        const jsonReport = {
+            workspaceDir: report.workspaceDir,
+            managedSkillsDir: report.managedSkillsDir,
+            skills: skills.map((s) => ({
+                name: s.name,
+                description: s.description,
+                emoji: s.emoji,
+                eligible: s.eligible,
+                disabled: s.disabled,
+                blockedByAllowlist: s.blockedByAllowlist,
+                source: s.source,
+                bundled: s.bundled,
+                primaryEnv: s.primaryEnv,
+                homepage: s.homepage,
+                missing: s.missing,
+            })),
+        };
+        return JSON.stringify(jsonReport, null, 2);
+    }
+    if (skills.length === 0) {
+        const message = opts.eligible
+            ? `No eligible skills found. Run \`${formatCliCommand("openclaw skills list")}\` to see all skills.`
+            : "No skills found.";
+        return appendClawHubHint(message, opts.json);
+    }
+    const eligible = skills.filter((s) => s.eligible);
+    const tableWidth = Math.max(60, (process.stdout.columns ?? 120) - 1);
+    const rows = skills.map((skill) => {
+        const missing = formatSkillMissingSummary(skill);
+        return {
+            Status: formatSkillStatus(skill),
+            Skill: formatSkillName(skill),
+            Description: theme.muted(skill.description),
+            Source: skill.source ?? "",
+            Missing: missing ? theme.warn(missing) : "",
+        };
+    });
+    const columns = [
+        { key: "Status", header: "Status", minWidth: 10 },
+        { key: "Skill", header: "Skill", minWidth: 18, flex: true },
+        { key: "Description", header: "Description", minWidth: 24, flex: true },
+        { key: "Source", header: "Source", minWidth: 10 },
+    ];
+    if (opts.verbose) {
+        columns.push({ key: "Missing", header: "Missing", minWidth: 18, flex: true });
+    }
+    const lines = [];
+    lines.push(`${theme.heading("Skills")} ${theme.muted(`(${eligible.length}/${skills.length} ready)`)}`);
+    lines.push(renderTable({
+        width: tableWidth,
+        columns,
+        rows,
+    }).trimEnd());
+    return appendClawHubHint(lines.join("\n"), opts.json);
+}
+export function formatSkillInfo(report, skillName, opts) {
+    const skill = report.skills.find((s) => s.name === skillName || s.skillKey === skillName);
+    if (!skill) {
+        if (opts.json) {
+            return JSON.stringify({ error: "not found", skill: skillName }, null, 2);
+        }
+        return appendClawHubHint(`Skill "${skillName}" not found. Run \`${formatCliCommand("openclaw skills list")}\` to see available skills.`, opts.json);
+    }
+    if (opts.json) {
+        return JSON.stringify(skill, null, 2);
+    }
+    const lines = [];
+    const emoji = skill.emoji ?? "📦";
+    const status = skill.eligible
+        ? theme.success("✓ Ready")
+        : skill.disabled
+            ? theme.warn("⏸ Disabled")
+            : skill.blockedByAllowlist
+                ? theme.warn("🚫 Blocked by allowlist")
+                : theme.error("✗ Missing requirements");
+    lines.push(`${emoji} ${theme.heading(skill.name)} ${status}`);
+    lines.push("");
+    lines.push(skill.description);
+    lines.push("");
+    lines.push(theme.heading("Details:"));
+    lines.push(`${theme.muted("  Source:")} ${skill.source}`);
+    lines.push(`${theme.muted("  Path:")} ${shortenHomePath(skill.filePath)}`);
+    if (skill.homepage) {
+        lines.push(`${theme.muted("  Homepage:")} ${skill.homepage}`);
+    }
+    if (skill.primaryEnv) {
+        lines.push(`${theme.muted("  Primary env:")} ${skill.primaryEnv}`);
+    }
+    const hasRequirements = skill.requirements.bins.length > 0 ||
+        skill.requirements.anyBins.length > 0 ||
+        skill.requirements.env.length > 0 ||
+        skill.requirements.config.length > 0 ||
+        skill.requirements.os.length > 0;
+    if (hasRequirements) {
+        lines.push("");
+        lines.push(theme.heading("Requirements:"));
+        if (skill.requirements.bins.length > 0) {
+            const binsStatus = skill.requirements.bins.map((bin) => {
+                const missing = skill.missing.bins.includes(bin);
+                return missing ? theme.error(`✗ ${bin}`) : theme.success(`✓ ${bin}`);
+            });
+            lines.push(`${theme.muted("  Binaries:")} ${binsStatus.join(", ")}`);
+        }
+        if (skill.requirements.anyBins.length > 0) {
+            const anyBinsMissing = skill.missing.anyBins.length > 0;
+            const anyBinsStatus = skill.requirements.anyBins.map((bin) => {
+                const missing = anyBinsMissing;
+                return missing ? theme.error(`✗ ${bin}`) : theme.success(`✓ ${bin}`);
+            });
+            lines.push(`${theme.muted("  Any binaries:")} ${anyBinsStatus.join(", ")}`);
+        }
+        if (skill.requirements.env.length > 0) {
+            const envStatus = skill.requirements.env.map((env) => {
+                const missing = skill.missing.env.includes(env);
+                return missing ? theme.error(`✗ ${env}`) : theme.success(`✓ ${env}`);
+            });
+            lines.push(`${theme.muted("  Environment:")} ${envStatus.join(", ")}`);
+        }
+        if (skill.requirements.config.length > 0) {
+            const configStatus = skill.requirements.config.map((cfg) => {
+                const missing = skill.missing.config.includes(cfg);
+                return missing ? theme.error(`✗ ${cfg}`) : theme.success(`✓ ${cfg}`);
+            });
+            lines.push(`${theme.muted("  Config:")} ${configStatus.join(", ")}`);
+        }
+        if (skill.requirements.os.length > 0) {
+            const osStatus = skill.requirements.os.map((osName) => {
+                const missing = skill.missing.os.includes(osName);
+                return missing ? theme.error(`✗ ${osName}`) : theme.success(`✓ ${osName}`);
+            });
+            lines.push(`${theme.muted("  OS:")} ${osStatus.join(", ")}`);
+        }
+    }
+    if (skill.install.length > 0 && !skill.eligible) {
+        lines.push("");
+        lines.push(theme.heading("Install options:"));
+        for (const inst of skill.install) {
+            lines.push(`  ${theme.warn("→")} ${inst.label}`);
+        }
+    }
+    return appendClawHubHint(lines.join("\n"), opts.json);
+}
+export function formatSkillsCheck(report, opts) {
+    const eligible = report.skills.filter((s) => s.eligible);
+    const disabled = report.skills.filter((s) => s.disabled);
+    const blocked = report.skills.filter((s) => s.blockedByAllowlist && !s.disabled);
+    const missingReqs = report.skills.filter((s) => !s.eligible && !s.disabled && !s.blockedByAllowlist);
+    if (opts.json) {
+        return JSON.stringify({
+            summary: {
+                total: report.skills.length,
+                eligible: eligible.length,
+                disabled: disabled.length,
+                blocked: blocked.length,
+                missingRequirements: missingReqs.length,
+            },
+            eligible: eligible.map((s) => s.name),
+            disabled: disabled.map((s) => s.name),
+            blocked: blocked.map((s) => s.name),
+            missingRequirements: missingReqs.map((s) => ({
+                name: s.name,
+                missing: s.missing,
+                install: s.install,
+            })),
+        }, null, 2);
+    }
+    const lines = [];
+    lines.push(theme.heading("Skills Status Check"));
+    lines.push("");
+    lines.push(`${theme.muted("Total:")} ${report.skills.length}`);
+    lines.push(`${theme.success("✓")} ${theme.muted("Eligible:")} ${eligible.length}`);
+    lines.push(`${theme.warn("⏸")} ${theme.muted("Disabled:")} ${disabled.length}`);
+    lines.push(`${theme.warn("🚫")} ${theme.muted("Blocked by allowlist:")} ${blocked.length}`);
+    lines.push(`${theme.error("✗")} ${theme.muted("Missing requirements:")} ${missingReqs.length}`);
+    if (eligible.length > 0) {
+        lines.push("");
+        lines.push(theme.heading("Ready to use:"));
+        for (const skill of eligible) {
+            const emoji = skill.emoji ?? "📦";
+            lines.push(`  ${emoji} ${skill.name}`);
+        }
+    }
+    if (missingReqs.length > 0) {
+        lines.push("");
+        lines.push(theme.heading("Missing requirements:"));
+        for (const skill of missingReqs) {
+            const emoji = skill.emoji ?? "📦";
+            const missing = formatSkillMissingSummary(skill);
+            lines.push(`  ${emoji} ${skill.name} ${theme.muted(`(${missing})`)}`);
+        }
+    }
+    return appendClawHubHint(lines.join("\n"), opts.json);
+}