@floomhq/floom 1.0.64 → 2.0.1

package/dist/cli.js

@@ -1,1313 +0,0 @@
-#!/usr/bin/env node
-import updateNotifier from "update-notifier";
-import { login } from "./login.js";
-import { publish } from "./publish.js";
-import { whoami } from "./whoami.js";
-import { init, INIT_TEMPLATES } from "./init.js";
-import { deleteConfig, readConfig } from "./config.js";
-import { list } from "./list.js";
-import { install } from "./install.js";
-import { info } from "./info.js";
-import { deleteSkill } from "./delete.js";
-import { doctor } from "./doctor.js";
-import { sync } from "./sync.js";
-import { watchPush } from "./push-watch.js";
-import { daemon, normalizeDaemonOptions, parseDaemonTarget } from "./daemon.js";
-import { printMcpSetup } from "./mcp.js";
-import { setupAgent } from "./setup.js";
-import { search } from "./search.js";
-import { scanSkill } from "./scan.js";
-import { auditSkills } from "./audit.js";
-import { share } from "./share.js";
-import { feedback } from "./feedback.js";
-import { status } from "./status.js";
-import { launchGate } from "./launch.js";
-import { libraryAddSkill, libraryCreate, libraryList, libraryRemoveSkill, librarySubscribe, libraryUnsubscribe, moveSkill, } from "./library.js";
-import { c, symbols } from "./ui.js";
-import { printError, FloomError } from "./errors.js";
-import { CLI_VERSION } from "./version.js";
-import { TARGET_HINT, isAgentTarget } from "./targets.js";
-const PKG = { name: "@floomhq/floom", version: CLI_VERSION };
-const V1_NOT_AVAILABLE = "Not available in Floom Version 1.";
-const CLI_COMMAND = "npx -y @floomhq/floom";
-function exitOnBrokenPipe(err) {
-    if (err.code === "EPIPE")
-        process.exit(0);
-    throw err;
-}
-process.stdout.on("error", exitOnBrokenPipe);
-process.stderr.on("error", exitOnBrokenPipe);
-function usage() {
-    const out = `
- ${c.blue("  ________                      ")}
- ${c.blue(" / ____/ /___  ____  ____ ___  ")} ${c.dim(`v${CLI_VERSION}`)}
- ${c.blue("/ /_  / / __ \\/ __ \\/ __ `__ \\ ")}
- ${c.blue("/ __/ / / /_/ / /_/ / / / / / / ")}
- ${c.blue("/_/   /_/\\____/\\____/_/ /_/ /_/  ")}
-
- ${c.bold("Floom syncs your AI skills across agents and machines.")}
- ${c.dim("A skill is reusable knowledge, instructions, or a workflow for your AI agent.")}
- ${c.dim("Examples: brand voice, PR review checklist, sales research workflow.")}
-
- ${c.bold("Start with one command:")}
-
- ${c.bold("1. I received a Floom link")}
-    ${c.dim("Replace <skill-link> with the full Floom URL someone sent you:")}
-    ${c.cyan("npx -y @floomhq/floom add")} ${c.dim("<skill-link> --setup")}
-    ${c.dim('Then tell Claude Code: "Use my Floom skills when they fit this task."')}
-
- ${c.bold("2. I want my own synced skill library")}
-    ${c.cyan("npx -y @floomhq/floom init")} ${c.dim("my-skill")}
-    ${c.dim("Write what your agent needs to know or do in my-skill/SKILL.md.")}
-    ${c.cyan("npx -y @floomhq/floom login")}
-    ${c.cyan("npx -y @floomhq/floom publish")} ${c.dim("my-skill --public")}
-    ${c.dim("Floom scans it, prints a link, and copies the link when possible.")}
-
- ${c.bold("Good to know")}
-    ${symbols.ok} ${c.dim("No account is needed to add a shared skill.")}
-    ${symbols.ok} ${c.dim("Sign in only when you publish or manage your skills.")}
-    ${symbols.ok} ${c.dim("Every command prints success or the exact problem to fix.")}
-
- ${c.bold("Stuck?")}
-    ${c.cyan("npx -y @floomhq/floom doctor")}        ${c.dim("Find the problem")}
-    ${c.cyan("npx -y @floomhq/floom scan my-skill")} ${c.dim("Check a skill before publishing")}
-    ${c.cyan("npx -y @floomhq/floom commands")}      ${c.dim("See every command")}
-    ${c.dim("Step-by-step guide")}                   https://floom.dev/docs/getting-started
-`;
-    process.stdout.write(out);
-}
-function commandUsage() {
-    const out = `
- ${c.bold("Usage:")} ${c.cyan("npx -y @floomhq/floom")} ${c.dim("<command> [flags]")}
- ${c.dim("After global install:")} ${c.cyan("floom")} ${c.dim("<command> [flags]")}
-
- ${c.bold("Commands")}
-   ${c.dim("Skills")}
-     ${c.cyan("add")} ${c.dim("<url>")}          Install a skill into the local agent skills folder
-                       ${c.dim("Alias: install")}
-                       ${c.dim(`Flags: --target ${TARGET_HINT} (default: claude), --setup, --force`)}
-     ${c.cyan("search")} ${c.dim("<query>")}     Find public skills and libraries
-     ${c.cyan("info")} ${c.dim("<url>")}         Show skill metadata
-
-   ${c.dim("Publishing")}
-     ${c.cyan("init")} ${c.dim("[path]")}        Create a skill scaffold
-                       ${c.dim("Flags: --template generic|brand-voice|pr-review|sales|support|onboarding")}
-     ${c.cyan("scan")} ${c.dim("<path>")}        Check for secrets, injection, exfiltration
-     ${c.cyan("publish")} ${c.dim("<path>")}     Scan, publish, and print a share link
-                       ${c.dim("Flags: --public, --private, --type knowledge|instruction|workflow|skill")}
-                       ${c.dim("       --skill-version <label>")}
-     ${c.cyan("share")} ${c.dim("<slug>")}       Email-share one of your skills
-                       ${c.dim("Flags: --add <email>, --remove <email>, --list")}
-
-   ${c.dim("Account")}
-     ${c.cyan("login")}              Authenticate
-     ${c.cyan("list")}               Your published skills
-     ${c.cyan("delete")} ${c.dim("<url>")}       Delete one of your skills
-                       ${c.dim("Alias: rm")}
-     ${c.cyan("whoami")}             Show the signed-in account
-     ${c.cyan("logout")}             Switch accounts or remove local credentials
-     ${c.cyan("feedback")}           Send agent feedback to Floom
-
-   ${c.dim("Agent setup")}
-     ${c.cyan("setup")}              Configure Claude Code or Codex instructions
-                       ${c.dim("Alias: connect")}
-                       ${c.dim(`Flags: --target ${TARGET_HINT}, --yes, --dry-run`)}
-     ${c.cyan("doctor")}             Troubleshoot auth, API, and local folders
-                       ${c.dim(`Flags: --target ${TARGET_HINT} (default: claude)`)}
-
-   ${c.dim("Advanced")}
-     ${c.cyan("status")}             Show cloud, cache, native projection, and daemon counts
-                       ${c.dim("Flags: --json")}
-     ${c.cyan("library")}            Create, browse, and subscribe to libraries
-                       ${c.dim("Alias: lib")}
-     ${c.cyan("move")} ${c.dim("<slug> --folder <path>")}  Place a saved skill in a relative folder
-     ${c.cyan("mcp")}                Print optional MCP setup guidance
-     ${c.cyan("sync")}               Preview pull of published, saved, and library skills
-                       ${c.dim(`Flags: --target ${TARGET_HINT} (default: claude)`)}
-     ${c.cyan("watch")}              Preview polling sync loop
-                       ${c.dim(`Flags: --push, --no-yolo, --target ${TARGET_HINT}`)}
-     ${c.cyan("daemon")}             Install and inspect always-on Floom sync
-                       ${c.dim(`Flags: install|status|logs|run, --target ${TARGET_HINT}|all`)}
-     ${c.cyan("audit skills")}       Read-only skill quality and duplicate report
-                       ${c.dim("Flags: --json, --fix-plan")}
-     ${c.cyan("launch gate")}        Check pinned release identity for launch evidence
-                       ${c.dim("Flags: --json")}
-
- ${c.bold("Examples")}
-   ${c.cyan("npx -y @floomhq/floom add")} ${c.dim("https://floom.dev/s/ffas93ud --setup")}
-   ${c.cyan("npx -y @floomhq/floom publish")} ${c.dim("support-tone --type instruction --public")}
-   ${c.cyan("npx -y @floomhq/floom setup")} ${c.dim("--target claude --yes")}
-
- ${c.bold("Help")}
-   ${c.cyan("npx -y @floomhq/floom commands")}  Show this reference
-   ${c.cyan("--help")}               Show this reference
-   ${c.cyan("--version")}            Show CLI version
-
- ${c.dim("Run")} ${c.cyan("npx -y @floomhq/floom")} ${c.dim("with no command for the guided start screen.")}
-`;
-    process.stdout.write(out);
-}
-function shareUsage() {
-    process.stdout.write(`
- ${c.bold("Usage:")} ${c.cyan(`${CLI_COMMAND} share`)} ${c.dim("<slug> [flags]")}
-
- ${c.bold("Manage email access for one of your skills.")}
-   ${c.cyan(`${CLI_COMMAND} share support-tone --add person@example.com`)}
-   ${c.cyan(`${CLI_COMMAND} share support-tone --remove person@example.com`)}
-   ${c.cyan(`${CLI_COMMAND} share support-tone --list`)}
-
- ${c.bold("Flags")}
-   ${c.cyan("--add <email>")}       Grant access
-   ${c.cyan("--remove <email>")}    Revoke access
-   ${c.cyan("--list")}              Show who can access the skill
-`);
-}
-function libraryUsage() {
-    process.stdout.write(`
- ${c.bold("Usage:")} ${c.cyan(`${CLI_COMMAND} library`)} ${c.dim("<command> [args] [flags]")}
-
- ${c.bold("Commands")}
-   ${c.cyan("list")}                              Browse public libraries
-   ${c.cyan("create <slug> --name <name>")}       Create a library
-   ${c.cyan("add <library> <skill>")}             Add a skill to a library
-   ${c.cyan("remove <library> <skill>")}          Remove a skill from a library
-   ${c.cyan("subscribe <library>")}               Follow a library
-   ${c.cyan("unsubscribe <library>")}             Stop following a library
-
- ${c.bold("Examples")}
-   ${c.cyan(`${CLI_COMMAND} library list --json`)}
-   ${c.cyan(`${CLI_COMMAND} library create team-onboarding --name "Team onboarding" --public`)}
-   ${c.cyan(`${CLI_COMMAND} library add team-onboarding support-tone --folder support --tags support,tone`)}
-`);
-}
-function moveUsage() {
-    process.stdout.write(`
- ${c.bold("Usage:")} ${c.cyan(`${CLI_COMMAND} move`)} ${c.dim("<slug> --folder <path> [--tag <tag>]")}
-
- ${c.bold("Place a saved or subscribed skill in a portable library folder.")}
-   ${c.cyan(`${CLI_COMMAND} move support-tone --folder support/tone`)}
-   ${c.cyan(`${CLI_COMMAND} move support-tone --root`)}
-   ${c.cyan(`${CLI_COMMAND} move support-tone --folder support --tags support,tone`)}
-
- ${c.bold("Flags")}
-   ${c.cyan("--folder <path>")}     Relative folder path for synced installs
-   ${c.cyan("--root")}              Put the skill at the root
-   ${c.cyan("--tag <tag>")}         Add one tag, repeatable
-   ${c.cyan("--tags a,b")}          Add comma-separated tags
-`);
-}
-function addUsage() {
-    process.stdout.write(`
- ${c.bold("Usage:")} ${c.cyan(`${CLI_COMMAND} add`)} ${c.dim("<slug-or-url> [flags]")}
-
- ${c.bold("Install a shared skill locally.")}
-   ${c.cyan(`${CLI_COMMAND} add https://floom.dev/s/ffas93ud --target claude --setup`)}
-   ${c.cyan(`${CLI_COMMAND} add support-tone --target codex --force`)}
-
- ${c.bold("Flags")}
-   ${c.cyan(`--target ${TARGET_HINT}`)}   Agent target, default claude
-   ${c.cyan("--setup")}                 Add Floom instructions for the target agent
-   ${c.cyan("--force")}                 Replace an existing tracked install
-`);
-}
-function syncUsage() {
-    process.stdout.write(`
- ${c.bold("Usage:")} ${c.cyan(`${CLI_COMMAND} sync`)} ${c.dim("[flags]")}
-
- ${c.bold("Pull published, saved, and subscribed library skills into one target.")}
-   ${c.cyan(`${CLI_COMMAND} sync --target claude`)}
-   ${c.cyan(`${CLI_COMMAND} sync --target codex`)}
-
- ${c.bold("Flags")}
-   ${c.cyan(`--target ${TARGET_HINT}`)}   Agent target, default claude
-`);
-}
-function watchUsage() {
-    process.stdout.write(`
- ${c.bold("Usage:")} ${c.cyan(`${CLI_COMMAND} watch`)} ${c.dim("[flags]")}
-
- ${c.bold("Run a polling loop for one target.")}
-   ${c.cyan(`${CLI_COMMAND} watch --target claude`)}
-   ${c.cyan(`${CLI_COMMAND} watch --push --target codex`)}
-
- ${c.bold("Flags")}
-   ${c.cyan("--push")}                  Publish/update local skill changes
-   ${c.cyan("--no-yolo")}               Adopt local skills without auto-publishing new ones
-   ${c.cyan("--once")}                  Run one cycle and exit
-   ${c.cyan("--interval <seconds>")}     Poll interval, minimum 10
-   ${c.cyan(`--target ${TARGET_HINT}`)}   Agent target, default claude
-`);
-}
-function doctorUsage() {
-    process.stdout.write(`
- ${c.bold("Usage:")} ${c.cyan(`${CLI_COMMAND} doctor`)} ${c.dim("[flags]")}
-
- ${c.bold("Check auth, MCP registration, local folders, and CLI freshness.")}
-   ${c.cyan(`${CLI_COMMAND} doctor --target claude`)}
-   ${c.cyan(`${CLI_COMMAND} doctor --target opencode`)}
-
- ${c.bold("Flags")}
-   ${c.cyan(`--target ${TARGET_HINT}`)}   Agent target, default claude
-`);
-}
-function daemonUsage() {
-    process.stdout.write(`
- ${c.bold("Usage:")} ${c.cyan(`${CLI_COMMAND} daemon`)} ${c.dim("<command> [flags]")}
-
- ${c.bold("Install and inspect always-on Floom sync.")}
-   ${c.cyan(`${CLI_COMMAND} daemon install --target all --interval 300 --timeout 180`)}
-   ${c.cyan(`${CLI_COMMAND} daemon status --json`)}
-   ${c.cyan(`${CLI_COMMAND} daemon logs --tail 100`)}
-   ${c.cyan(`${CLI_COMMAND} daemon run --foreground --target all`)}
-
- ${c.bold("Commands")}
-   ${c.cyan("install")}              Write systemd or launchd service definition
-   ${c.cyan("status")}               Print latest daemon status
-   ${c.cyan("logs")}                 Print daemon log tail
-   ${c.cyan("run")}                  Run the daemon loop in the foreground
-
- ${c.bold("Flags")}
-   ${c.cyan("--target <target|all>")}  claude|codex|cursor|opencode|kimi|all
-   ${c.cyan("--interval <seconds>")}   Poll interval, minimum 30, default 300
-   ${c.cyan("--timeout <seconds>")}    Per-command timeout, minimum 30, default 180
-   ${c.cyan("--push / --no-push")}     Push/adopt local changes, default push
-   ${c.cyan("--yolo / --no-yolo")}     Auto-publish changed local skills, default yolo
-   ${c.cyan("--dry-run")}              Print generated service file without writing
-   ${c.cyan("--json")}                 Machine-readable status output
-`);
-}
-function auditUsage() {
-    process.stdout.write(`
- ${c.bold("Usage:")} ${c.cyan(`${CLI_COMMAND} audit skills`)} ${c.dim("[flags]")}
-
- ${c.bold("Find low-quality, duplicate, fixture, and malformed owned skills.")}
-   ${c.cyan(`${CLI_COMMAND} audit skills`)}
-   ${c.cyan(`${CLI_COMMAND} audit skills --json`)}
-   ${c.cyan(`${CLI_COMMAND} audit skills --fix-plan`)}
-   ${c.cyan(`${CLI_COMMAND} audit skills --archive-plan plan.json`)} ${c.dim("(dry-run)")}
-   ${c.cyan(`${CLI_COMMAND} audit skills --archive-plan plan.json --yes`)}
-
- ${c.bold("Flags")}
-   ${c.cyan("--json")}       Full machine-readable report
-   ${c.cyan("--fix-plan")}   Include archive recommendations, without applying them
-   ${c.cyan("--archive-plan <file>")} Preview or apply a reviewed archive plan
-   ${c.cyan("--yes")}        Apply the archive plan instead of dry-run preview
-`);
-}
-function feedbackUsage() {
-    process.stdout.write(`
- ${c.bold("Usage:")} ${c.cyan(`${CLI_COMMAND} feedback`)} ${c.dim("--kind <kind> --message <message> [flags]")}
-
- ${c.bold("Send agent feedback to Floom.")}
-   ${c.cyan(`${CLI_COMMAND} feedback --kind bug --message "MCP sync missed a file"`)}
-   ${c.cyan(`${CLI_COMMAND} feedback --kind idea --message "Add team defaults" --target codex --skill support-tone`)}
-
- ${c.bold("Flags")}
-   ${c.cyan("--kind <kind>")}       Feedback type, for example bug, idea, friction, praise
-   ${c.cyan("--message <text>")}    Required non-interactive feedback message
-   ${c.cyan("--target <target>")}   Optional agent target
-   ${c.cyan("--skill <slug>")}      Optional related skill slug
-   ${c.cyan("--json")}              Machine-readable success or error
-`);
-}
-function isHelpArg(value) {
-    return value === "--help" || value === "-h" || value === "help";
-}
-function subcommandUsage(cmd) {
-    switch (cmd) {
-        case "add":
-        case "install":
-            addUsage();
-            return true;
-        case "sync":
-            syncUsage();
-            return true;
-        case "watch":
-            watchUsage();
-            return true;
-        case "doctor":
-            doctorUsage();
-            return true;
-        case "daemon":
-            daemonUsage();
-            return true;
-        case "share":
-            shareUsage();
-            return true;
-        case "audit":
-            auditUsage();
-            return true;
-        case "feedback":
-            feedbackUsage();
-            return true;
-        case "launch":
-            commandUsage();
-            return true;
-        case "library":
-        case "lib":
-            libraryUsage();
-            return true;
-        case "move":
-            moveUsage();
-            return true;
-        default:
-            commandUsage();
-            return true;
-    }
-}
-const ASSET_TYPES = new Set(["knowledge", "instruction", "workflow", "skill"]);
-const INSTALL_TARGETS = new Set([
-    "claude_skill",
-    "memory",
-    "rule",
-    "codex_instruction",
-    "opencode_instruction",
-    "cursor_rule",
-    "other",
-]);
-const VERSION_RE = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,63}$/;
-function readFlagValue(argv, index, flag) {
-    const current = argv[index] ?? "";
-    if (current.startsWith(`${flag}=`))
-        return { value: current.slice(flag.length + 1), nextIndex: index };
-    const value = argv[index + 1];
-    if (!value || value.startsWith("--"))
-        throw new FloomError(`Missing value for ${flag}.`);
-    return { value, nextIndex: index + 1 };
-}
-function parseFlags(argv) {
-    const out = { update: false, rest: [] };
-    let visibilityFlag = null;
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i] ?? "";
-        if (a === "--public" || a === "--private" || a === "--unlisted") {
-            const nextVisibility = a.slice(2);
-            if (visibilityFlag && visibilityFlag !== nextVisibility) {
-                throw new FloomError("Conflicting visibility flags.", "Use only one of: --public, --private, or --unlisted.");
-            }
-            visibilityFlag = nextVisibility;
-            out.visibility = nextVisibility;
-        }
-        else if (a === "--update" || a.startsWith("--update=")) {
-            out.update = true;
-            const inline = a.startsWith("--update=") ? a.slice("--update=".length) : undefined;
-            const next = argv[i + 1];
-            const value = inline ?? (next && !next.startsWith("--") ? next : undefined);
-            if (value) {
-                out.updateSlug = value;
-                if (!inline)
-                    i += 1;
-            }
-            else {
-            }
-        }
-        else if (a === "--share" || a.startsWith("--share=")) {
-            throw new FloomError(V1_NOT_AVAILABLE, `\`${CLI_COMMAND} publish --share\` is planned for a later Floom release.`);
-        }
-        else if (a === "--type" || a.startsWith("--type=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--type");
-            if (!ASSET_TYPES.has(value)) {
-                throw new FloomError(`Invalid --type: ${value}`, "Use one of: knowledge, instruction, workflow, skill.");
-            }
-            out.assetType = value;
-            i = nextIndex;
-        }
-        else if (a === "--installs-as" || a.startsWith("--installs-as=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--installs-as");
-            if (!INSTALL_TARGETS.has(value)) {
-                throw new FloomError(`Invalid --installs-as: ${value}`, "Use one of: claude_skill, memory, rule, codex_instruction, opencode_instruction, cursor_rule, other.");
-            }
-            out.installsAs = value;
-            i = nextIndex;
-        }
-        else if (a === "--skill-version" || a.startsWith("--skill-version=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--skill-version");
-            if (!VERSION_RE.test(value)) {
-                throw new FloomError(`Invalid --skill-version: ${value}`, "Use 1-64 characters: letters, numbers, dots, underscores, plus, or hyphen.");
-            }
-            out.version = value;
-            i = nextIndex;
-        }
-        else if (a === "--version" || a.startsWith("--version=")) {
-            throw new FloomError("`--version` prints the Floom CLI version at the top level.", "For skill version labels, use `--skill-version <label>`.");
-        }
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} publish my-skill --type instruction --public\`.`);
-        }
-        else
-            out.rest.push(a);
-    }
-    return out;
-}
-function parseShareFlags(argv) {
-    const out = { list: false, add: [], remove: [] };
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i] ?? "";
-        if (a === "--list") {
-            out.list = true;
-        }
-        else if (a === "--add" || a.startsWith("--add=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--add");
-            out.add.push(value);
-            i = nextIndex;
-        }
-        else if (a === "--remove" || a.startsWith("--remove=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--remove");
-            out.remove.push(value);
-            i = nextIndex;
-        }
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} share <slug> --add person@example.com\`.`);
-        }
-        else if (!out.slug) {
-            out.slug = a;
-        }
-        else {
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} share <slug> --add person@example.com\`.`);
-        }
-    }
-    if (!out.slug)
-        throw new FloomError("Missing skill slug.", `Try \`${CLI_COMMAND} share <slug> --add person@example.com\`.`);
-    if (out.list && (out.add.length > 0 || out.remove.length > 0)) {
-        throw new FloomError("Conflicting share flags.", "Use --list by itself, or use --add/--remove.");
-    }
-    if (!out.list && out.add.length === 0 && out.remove.length === 0) {
-        throw new FloomError("Missing share action.", `Try \`${CLI_COMMAND} share <slug> --add person@example.com\`.`);
-    }
-    return out;
-}
-function parseInitArgs(argv) {
-    let file;
-    let template;
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i] ?? "";
-        if (a === "--template" || a.startsWith("--template=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--template");
-            if (!INIT_TEMPLATES.includes(value)) {
-                throw new FloomError(`Invalid --template: ${value}`, `Use one of: ${INIT_TEMPLATES.join(", ")}.`);
-            }
-            template = value;
-            i = nextIndex;
-            continue;
-        }
-        if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} init my-skill\`.`);
-        }
-        if (file) {
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} init my-skill\`.`);
-        }
-        file = a;
-    }
-    return { ...(file ? { file } : {}), ...(template ? { template } : {}) };
-}
-function parseTargetFlag(value) {
-    if (isAgentTarget(value))
-        return value;
-    throw new FloomError("Invalid --target.", `Use ${TARGET_HINT}.`);
-}
-function parseListFlags(argv) {
-    const out = { json: false };
-    for (const a of argv) {
-        if (a === "--json")
-            out.json = true;
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} list --help\` for usage.`);
-        }
-        else {
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} list --json\`.`);
-        }
-    }
-    return out;
-}
-function parseSyncFlags(argv) {
-    const out = {};
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i] ?? "";
-        if (a === "--target" || a.startsWith("--target=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--target");
-            out.target = parseTargetFlag(value);
-            i = nextIndex;
-        }
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} sync --target claude\`.`);
-        }
-        else {
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} sync --target claude\`.`);
-        }
-    }
-    return out;
-}
-function parseInfoFlags(argv) {
-    const out = { json: false };
-    for (const a of argv) {
-        if (a === "--json")
-            out.json = true;
-        else if (a.startsWith("--"))
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} info <slug> --json\`.`);
-        else if (!out.slug)
-            out.slug = a;
-        else
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} info <slug> --json\`.`);
-    }
-    return out;
-}
-function parseFeedbackFlags(argv) {
-    const out = { json: false };
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i] ?? "";
-        if (a === "--json") {
-            out.json = true;
-        }
-        else if (a === "--kind" || a.startsWith("--kind=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--kind");
-            out.kind = value.trim();
-            i = nextIndex;
-        }
-        else if (a === "--message" || a.startsWith("--message=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--message");
-            out.message = value.trim();
-            i = nextIndex;
-        }
-        else if (a === "--target" || a.startsWith("--target=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--target");
-            out.target = value.trim();
-            i = nextIndex;
-        }
-        else if (a === "--skill" || a.startsWith("--skill=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--skill");
-            out.skill = value.trim();
-            i = nextIndex;
-        }
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} feedback --kind bug --message "What happened"\`.`);
-        }
-        else {
-            throw new FloomError(`Unexpected argument: ${a}`, `Use \`${CLI_COMMAND} feedback --kind bug --message "What happened"\`.`);
-        }
-    }
-    if (!out.kind)
-        throw new FloomError("Missing --kind.", `Try \`${CLI_COMMAND} feedback --kind bug --message "What happened"\`.`);
-    if (!out.message)
-        throw new FloomError("Missing --message.", "Feedback is non-interactive; pass the message with --message.");
-    if (out.kind.length > 64)
-        throw new FloomError("Invalid --kind.", "Use 1-64 characters.");
-    if (out.message.length > 4000)
-        throw new FloomError("Invalid --message.", "Use 1-4000 characters.");
-    if (out.target !== undefined && out.target.length > 128)
-        throw new FloomError("Invalid --target.", "Use at most 128 characters.");
-    if (out.skill !== undefined && out.skill.length > 128)
-        throw new FloomError("Invalid --skill.", "Use at most 128 characters.");
-    return out;
-}
-function parseAddArgs(argv) {
-    let slug;
-    let target;
-    let setup = false;
-    let force = false;
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i] ?? "";
-        if (a === "--target" || a.startsWith("--target=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--target");
-            target = parseTargetFlag(value);
-            i = nextIndex;
-        }
-        else if (a === "--setup") {
-            setup = true;
-        }
-        else if (a === "--force") {
-            force = true;
-        }
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} add <url-or-slug> --setup\`.`);
-        }
-        else if (slug) {
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} add <url-or-slug> --setup\`.`);
-        }
-        else
-            slug = a;
-    }
-    if (!slug) {
-        throw new FloomError("Missing skill slug.", `Try: \`${CLI_COMMAND} add <url-or-slug> --setup\``);
-    }
-    return target ? { slug, target, setup, force } : { slug, setup, force };
-}
-function parseSearchFlags(argv) {
-    const out = { json: false };
-    const terms = [];
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i] ?? "";
-        if (a === "--json")
-            out.json = true;
-        else if (a === "--library" || a.startsWith("--library=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--library");
-            out.library = value;
-            i = nextIndex;
-        }
-        else if (a === "--type" || a.startsWith("--type=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--type");
-            if (!ASSET_TYPES.has(value)) {
-                throw new FloomError(`Invalid --type: ${value}`, "Use one of: knowledge, instruction, workflow, skill.");
-            }
-            out.type = value;
-            i = nextIndex;
-        }
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} search "support tone" --type instruction\`.`);
-        }
-        else {
-            terms.push(a);
-        }
-    }
-    out.query = terms.join(" ").trim();
-    return out;
-}
-function parseDeleteFlags(argv) {
-    const out = { yes: false };
-    for (const a of argv) {
-        if (a === "--yes" || a === "-y")
-            out.yes = true;
-        else if (a.startsWith("--"))
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} delete <slug> --yes\`.`);
-        else if (!out.slug)
-            out.slug = a;
-        else
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} delete <slug> --yes\`.`);
-    }
-    return out;
-}
-function rejectArgs(argv, usageHint) {
-    const arg = argv[0];
-    if (!arg)
-        return;
-    if (arg.startsWith("--"))
-        throw new FloomError(`Unknown flag: ${arg}`, usageHint);
-    throw new FloomError(`Unexpected argument: ${arg}`, usageHint);
-}
-function parseSetupFlags(argv) {
-    const out = { dryRun: false, yes: false };
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i] ?? "";
-        if (a === "--dry-run" || a === "--preview")
-            out.dryRun = true;
-        else if (a === "--yes" || a === "-y")
-            out.yes = true;
-        else if (a === "--global")
-            out.global = true;
-        else if (a === "--target" || a.startsWith("--target=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--target");
-            out.target = parseTargetFlag(value);
-            i = nextIndex;
-        }
-        else if (a === "--file" || a.startsWith("--file=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--file");
-            out.file = value;
-            i = nextIndex;
-        }
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} setup --target codex --dry-run\`.`);
-        }
-        else if (!out.file)
-            out.file = a;
-        else
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} setup --target claude --yes\`.`);
-    }
-    return out;
-}
-function parseDoctorFlags(argv) {
-    const out = {};
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i] ?? "";
-        if (a === "--target" || a.startsWith("--target=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--target");
-            out.target = parseTargetFlag(value);
-            i = nextIndex;
-        }
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} doctor --target codex\`.`);
-        }
-        else {
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} doctor --target claude\`.`);
-        }
-    }
-    return out;
-}
-function parseStatusFlags(argv) {
-    const out = { json: false };
-    for (const a of argv) {
-        if (a === "--json")
-            out.json = true;
-        else if (a.startsWith("--"))
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} status --json\`.`);
-        else
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} status --json\`.`);
-    }
-    return out;
-}
-function parseAuditFlags(argv) {
-    const [subcommand, ...rest] = argv;
-    if (subcommand !== "skills") {
-        throw new FloomError("Unknown audit command.", `Try \`${CLI_COMMAND} audit skills --json\`.`);
-    }
-    const out = { json: false, fixPlan: false, yes: false };
-    for (let i = 0; i < rest.length; i++) {
-        const a = rest[i] ?? "";
-        if (a === "--json")
-            out.json = true;
-        else if (a === "--fix-plan")
-            out.fixPlan = true;
-        else if (a === "--archive-plan" || a.startsWith("--archive-plan=")) {
-            const { value, nextIndex } = readFlagValue(rest, i, "--archive-plan");
-            out.archivePlan = value;
-            i = nextIndex;
-        }
-        else if (a === "--yes")
-            out.yes = true;
-        else if (a.startsWith("--"))
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} audit skills --json\`.`);
-        else
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} audit skills --json\`.`);
-    }
-    return out;
-}
-function parseDaemonFlags(argv) {
-    const [command, ...rest] = argv;
-    const allowedCommands = new Set(["install", "uninstall", "status", "logs", "restart", "run"]);
-    if (!command || !allowedCommands.has(command)) {
-        throw new FloomError("Missing daemon command.", `Try \`${CLI_COMMAND} daemon install --target all\`.`);
-    }
-    const out = {
-        command: command,
-        target: "all",
-        intervalSeconds: 300,
-        timeoutSeconds: 180,
-        push: true,
-        yolo: true,
-        foreground: false,
-        dryRun: false,
-        json: false,
-        tail: 100,
-    };
-    for (let i = 0; i < rest.length; i++) {
-        const a = rest[i] ?? "";
-        if (a === "--target" || a.startsWith("--target=")) {
-            const { value, nextIndex } = readFlagValue(rest, i, "--target");
-            out.target = parseDaemonTarget(value);
-            i = nextIndex;
-        }
-        else if (a === "--interval" || a.startsWith("--interval=")) {
-            const { value, nextIndex } = readFlagValue(rest, i, "--interval");
-            const parsed = Number(value);
-            if (!Number.isInteger(parsed))
-                throw new FloomError("Invalid --interval.", "Use an integer number of seconds.");
-            out.intervalSeconds = parsed;
-            i = nextIndex;
-        }
-        else if (a === "--timeout" || a.startsWith("--timeout=")) {
-            const { value, nextIndex } = readFlagValue(rest, i, "--timeout");
-            const parsed = Number(value);
-            if (!Number.isInteger(parsed))
-                throw new FloomError("Invalid --timeout.", "Use an integer number of seconds.");
-            out.timeoutSeconds = parsed;
-            i = nextIndex;
-        }
-        else if (a === "--push") {
-            out.push = true;
-        }
-        else if (a === "--no-push") {
-            out.push = false;
-        }
-        else if (a === "--yolo") {
-            out.yolo = true;
-        }
-        else if (a === "--no-yolo") {
-            out.yolo = false;
-        }
-        else if (a === "--foreground") {
-            out.foreground = true;
-        }
-        else if (a === "--dry-run") {
-            out.dryRun = true;
-        }
-        else if (a === "--json") {
-            out.json = true;
-        }
-        else if (a === "--tail" || a.startsWith("--tail=")) {
-            const { value, nextIndex } = readFlagValue(rest, i, "--tail");
-            const parsed = Number(value);
-            if (!Number.isInteger(parsed) || parsed < 1)
-                throw new FloomError("Invalid --tail.", "Use a positive integer.");
-            out.tail = parsed;
-            i = nextIndex;
-        }
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} daemon --help\`.`);
-        }
-        else {
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} daemon --help\`.`);
-        }
-    }
-    return normalizeDaemonOptions(out);
-}
-function normalizeFolder(value) {
-    const normalized = value.trim().replace(/\\/g, "/").replace(/\/+/g, "/");
-    if (normalized === "root" || normalized === "/" || normalized === ".")
-        return null;
-    if (normalized.startsWith("/")) {
-        throw new FloomError("Invalid --folder: use a relative sync folder.", "Floom folders are portable library paths like `support/tone`, not absolute filesystem paths like `/tmp/floom-move-target`.");
-    }
-    if (normalized === ".." ||
-        normalized.startsWith("../") ||
-        normalized.includes("/../") ||
-        normalized.endsWith("/..")) {
-        throw new FloomError("Invalid --folder: path traversal is not allowed.", "Use a relative sync folder like `support/tone`, or use `--root`.");
-    }
-    const relative = normalized.startsWith("./") ? normalized.slice(2) : normalized;
-    return relative || null;
-}
-function parseFolderTagFlags(argv) {
-    const out = { tags: [], rest: [] };
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i] ?? "";
-        if (a === "--folder" || a.startsWith("--folder=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--folder");
-            out.folder = normalizeFolder(value);
-            i = nextIndex;
-        }
-        else if (a === "--root") {
-            out.folder = null;
-        }
-        else if (a === "--tag" || a.startsWith("--tag=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--tag");
-            out.tags.push(value);
-            i = nextIndex;
-        }
-        else if (a === "--tags" || a.startsWith("--tags=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--tags");
-            out.tags.push(...value.split(",").map((tag) => tag.trim()).filter(Boolean));
-            i = nextIndex;
-        }
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, "Use --folder <path>, --root, --tag <tag>, or --tags a,b.");
-        }
-        else {
-            out.rest.push(a);
-        }
-    }
-    return out;
-}
-function parseLibraryCreateFlags(argv) {
-    const out = { visibility: "unlisted" };
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i] ?? "";
-        if (a === "--name" || a.startsWith("--name=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--name");
-            out.name = value;
-            i = nextIndex;
-        }
-        else if (a === "--description" || a.startsWith("--description=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--description");
-            out.description = value;
-            i = nextIndex;
-        }
-        else if (a === "--public")
-            out.visibility = "public";
-        else if (a === "--private")
-            out.visibility = "private";
-        else if (a === "--unlisted")
-            out.visibility = "unlisted";
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} library create team-onboarding --name "Team onboarding"\`.`);
-        }
-        else if (!out.slug)
-            out.slug = a;
-        else
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} library create <slug> --name <name>\`.`);
-    }
-    return out;
-}
-async function runLibrary(argv) {
-    const [subcommand, ...rest] = argv;
-    switch (subcommand ?? "list") {
-        case "list": {
-            const flags = parseListFlags(rest);
-            await libraryList(flags);
-            return;
-        }
-        case "create": {
-            const flags = parseLibraryCreateFlags(rest);
-            if (!flags.slug)
-                throw new FloomError("Missing library slug.", `Try \`${CLI_COMMAND} library create team-onboarding --name "Team onboarding"\`.`);
-            if (!flags.name)
-                throw new FloomError("Missing --name.", `Try \`${CLI_COMMAND} library create team-onboarding --name "Team onboarding"\`.`);
-            await libraryCreate({
-                slug: flags.slug,
-                name: flags.name,
-                ...(flags.description !== undefined ? { description: flags.description } : {}),
-                visibility: flags.visibility,
-            });
-            return;
-        }
-        case "add": {
-            const flags = parseFolderTagFlags(rest);
-            const [librarySlug, skillSlug] = flags.rest;
-            if (!librarySlug || !skillSlug) {
-                throw new FloomError("Missing library or skill slug.", `Try \`${CLI_COMMAND} library add team-onboarding support-tone --folder support\`.`);
-            }
-            if (flags.rest.length > 2) {
-                throw new FloomError(`Unexpected argument: ${flags.rest[2]}`, `Try \`${CLI_COMMAND} library add team-onboarding support-tone --folder support\`.`);
-            }
-            await libraryAddSkill({
-                librarySlug,
-                skillSlug,
-                ...(flags.folder !== undefined ? { folder: flags.folder } : {}),
-                tags: flags.tags,
-            });
-            return;
-        }
-        case "remove":
-        case "rm": {
-            const [librarySlug, skillSlug] = rest;
-            if (!librarySlug || !skillSlug) {
-                throw new FloomError("Missing library or skill slug.", `Try \`${CLI_COMMAND} library remove team-onboarding support-tone\`.`);
-            }
-            if (rest.length > 2) {
-                throw new FloomError(`Unexpected argument: ${rest[2]}`, `Try \`${CLI_COMMAND} library remove team-onboarding support-tone\`.`);
-            }
-            await libraryRemoveSkill(librarySlug, skillSlug);
-            return;
-        }
-        case "subscribe": {
-            const slug = rest[0];
-            if (!slug)
-                throw new FloomError("Missing library slug.", `Try \`${CLI_COMMAND} library subscribe superpowers\`.`);
-            if (rest.length > 1) {
-                throw new FloomError(`Unexpected argument: ${rest[1]}`, `Try \`${CLI_COMMAND} library subscribe superpowers\`.`);
-            }
-            await librarySubscribe(slug);
-            return;
-        }
-        case "unsubscribe": {
-            const slug = rest[0];
-            if (!slug)
-                throw new FloomError("Missing library slug.", `Try \`${CLI_COMMAND} library unsubscribe superpowers\`.`);
-            if (rest.length > 1) {
-                throw new FloomError(`Unexpected argument: ${rest[1]}`, `Try \`${CLI_COMMAND} library unsubscribe superpowers\`.`);
-            }
-            await libraryUnsubscribe(slug);
-            return;
-        }
-        default:
-            throw new FloomError(`Unknown library command: ${subcommand}`, "Use: list, create, add, remove, subscribe, unsubscribe.");
-    }
-}
-function parseWatchFlags(argv) {
-    const out = { intervalSeconds: 60, push: false, yolo: true, once: false, target: "claude" };
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i] ?? "";
-        if (a === "--interval" || a.startsWith("--interval=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--interval");
-            const interval = Number(value);
-            if (!Number.isInteger(interval) || interval < 10) {
-                throw new FloomError("Invalid --interval.", "Use an integer number of seconds, minimum 10.");
-            }
-            out.intervalSeconds = interval;
-            i = nextIndex;
-        }
-        else if (a === "--push") {
-            out.push = true;
-        }
-        else if (a === "--no-yolo") {
-            out.yolo = false;
-        }
-        else if (a === "--once") {
-            out.once = true;
-        }
-        else if (a === "--target" || a.startsWith("--target=")) {
-            const { value, nextIndex } = readFlagValue(argv, i, "--target");
-            out.target = parseTargetFlag(value);
-            i = nextIndex;
-        }
-        else if (a.startsWith("--")) {
-            throw new FloomError(`Unknown flag: ${a}`, `Try \`${CLI_COMMAND} watch --push --target claude\`.`);
-        }
-        else {
-            throw new FloomError(`Unexpected argument: ${a}`, `Try \`${CLI_COMMAND} watch --push --target claude\`.`);
-        }
-    }
-    return out;
-}
-function notAvailable(feature) {
-    throw new FloomError(V1_NOT_AVAILABLE, `${feature} is planned for a later Floom release.`);
-}
-function parseSingleFileArg(argv, usageHint) {
-    let file;
-    for (const a of argv) {
-        if (a.startsWith("--"))
-            throw new FloomError(`Unknown flag: ${a}`, usageHint);
-        if (file)
-            throw new FloomError(`Unexpected argument: ${a}`, usageHint);
-        file = a;
-    }
-    if (!file)
-        throw new FloomError("Missing file argument.", usageHint);
-    return file;
-}
-function sleep(ms, signal) {
-    if (signal.aborted)
-        return Promise.resolve();
-    return new Promise((resolve) => {
-        const timer = setTimeout(resolve, ms);
-        signal.addEventListener("abort", () => {
-            clearTimeout(timer);
-            resolve();
-        }, { once: true });
-    });
-}
-async function watch(intervalSeconds, target, once) {
-    const cfg = await readConfig();
-    if (!cfg) {
-        throw new FloomError("Not signed in.", `Run \`${CLI_COMMAND} login\` before \`${CLI_COMMAND} watch\`, or use \`${CLI_COMMAND} add <link>\` without an account.`);
-    }
-    const controller = new AbortController();
-    let stopping = false;
-    const stop = () => {
-        if (stopping)
-            return;
-        stopping = true;
-        controller.abort();
-        process.stdout.write(`\n${symbols.bullet}  Stopping floom watch\n`);
-        process.exit(0);
-    };
-    process.on("SIGINT", stop);
-    process.on("SIGTERM", stop);
-    process.stdout.write(`${symbols.bullet}  Watching Floom sync for ${target} every ${intervalSeconds}s. Press Ctrl-C to stop.\n`);
-    while (!controller.signal.aborted) {
-        await sync({ spinner: false, quietUnchanged: true, target });
-        if (once)
-            return;
-        await sleep(intervalSeconds * 1000, controller.signal);
-    }
-}
-async function main() {
-    const [, , cmd, ...rest] = process.argv;
-    // Update notifier — runs in background, prints at process exit if a newer
-    // version is available. Disabled in CI / non-TTY by default.
-    if (cmd !== "watch") {
-        try {
-            updateNotifier({ pkg: PKG, updateCheckInterval: 1000 * 60 * 60 * 24 }).notify({
-                defer: true,
-                isGlobal: true,
-                message: `${symbols.bullet}  ${c.bold("floom")} v{latestVersion} available — run \`npm i -g {packageName}\` to update.`,
-            });
-        }
-        catch {
-            // never block on update-notifier
-        }
-    }
-    if (rest.some(isHelpArg)) {
-        subcommandUsage(cmd);
-        return;
-    }
-    try {
-        switch (cmd) {
-            case undefined:
-                usage();
-                return;
-            case "--help":
-            case "-h":
-            case "help":
-                commandUsage();
-                return;
-            case "commands":
-                rejectArgs(rest, `Try \`${CLI_COMMAND} commands\`.`);
-                commandUsage();
-                return;
-            case "--version":
-            case "-v":
-                process.stdout.write(`${CLI_VERSION}\n`);
-                return;
-            case "login":
-                rejectArgs(rest, `Try \`${CLI_COMMAND} login\`.`);
-                await login();
-                return;
-            case "logout":
-                rejectArgs(rest, `Try \`${CLI_COMMAND} logout\`.`);
-                await deleteConfig();
-                process.stdout.write(`\n${symbols.ok}  Signed out\n\n`);
-                return;
-            case "whoami":
-                rejectArgs(rest, `Try \`${CLI_COMMAND} whoami\`.`);
-                await whoami();
-                return;
-            case "init": {
-                const flags = parseInitArgs(rest);
-                await init(flags.file, flags.template ? { template: flags.template } : {});
-                return;
-            }
-            case "publish": {
-                const flags = parseFlags(rest);
-                const file = flags.rest[0];
-                if (!file) {
-                    throw new FloomError("Missing file argument.", `Try: \`${CLI_COMMAND} publish my-skill\``);
-                }
-                if (flags.rest.length > 1) {
-                    throw new FloomError(`Unexpected argument: ${flags.rest[1]}`, `Try: \`${CLI_COMMAND} publish my-skill\``);
-                }
-                await publish({
-                    file,
-                    update: flags.update,
-                    ...(flags.visibility ? { visibility: flags.visibility } : {}),
-                    ...(flags.updateSlug ? { updateSlug: flags.updateSlug } : {}),
-                    ...(flags.assetType ? { assetType: flags.assetType } : {}),
-                    ...(flags.installsAs ? { installsAs: flags.installsAs } : {}),
-                    ...(flags.version ? { version: flags.version } : {}),
-                });
-                return;
-            }
-            case "scan": {
-                const file = parseSingleFileArg(rest, `Try \`${CLI_COMMAND} scan my-skill\`.`);
-                await scanSkill(file);
-                return;
-            }
-            case "share":
-                {
-                    const flags = parseShareFlags(rest);
-                    if (flags.list) {
-                        await share({ slug: flags.slug ?? "", kind: "list" });
-                    }
-                    else {
-                        await share({ slug: flags.slug ?? "", kind: "patch", add: flags.add, remove: flags.remove });
-                    }
-                }
-                return;
-            case "list": {
-                const flags = parseListFlags(rest);
-                await list(flags);
-                return;
-            }
-            case "info":
-                {
-                    const flags = parseInfoFlags(rest);
-                    await info({ slug: flags.slug ?? "", json: flags.json });
-                }
-                return;
-            case "search": {
-                const flags = parseSearchFlags(rest);
-                if (!flags.query) {
-                    throw new FloomError("Missing search query.", `Try: \`${CLI_COMMAND} search "support tone"\`.`);
-                }
-                await search({
-                    query: flags.query,
-                    ...(flags.library ? { library: flags.library } : {}),
-                    ...(flags.type ? { type: flags.type } : {}),
-                    json: flags.json,
-                });
-                return;
-            }
-            case "feedback": {
-                const flags = parseFeedbackFlags(rest);
-                await feedback({
-                    kind: flags.kind ?? "",
-                    message: flags.message ?? "",
-                    ...(flags.target ? { target: flags.target } : {}),
-                    ...(flags.skill ? { skill: flags.skill } : {}),
-                    json: flags.json,
-                });
-                return;
-            }
-            case "launch": {
-                const sub = rest[0];
-                if (sub !== "gate")
-                    throw new FloomError("Unknown launch command.", `Try \`${CLI_COMMAND} launch gate --json\`.`);
-                const args = rest.slice(1);
-                const json = args.includes("--json");
-                rejectArgs(args.filter((arg) => arg !== "--json"), `Try \`${CLI_COMMAND} launch gate --json\`.`);
-                await launchGate({ json });
-                return;
-            }
-            case "status":
-                await status(parseStatusFlags(rest));
-                return;
-            case "add":
-            case "install": {
-                const flags = parseAddArgs(rest);
-                await install(flags.slug, {
-                    ...(flags.target ? { target: flags.target } : {}),
-                    setup: flags.setup,
-                    force: flags.force,
-                });
-                if (flags.setup) {
-                    await setupAgent({ target: flags.target ?? "claude", dryRun: false, yes: true });
-                }
-                return;
-            }
-            case "sync":
-                await sync(parseSyncFlags(rest));
-                return;
-            case "setup":
-            case "connect": {
-                const flags = parseSetupFlags(rest);
-                await setupAgent(flags);
-                return;
-            }
-            case "watch": {
-                const flags = parseWatchFlags(rest);
-                if (flags.push) {
-                    await watchPush(flags.intervalSeconds, {
-                        target: flags.target,
-                        yolo: flags.yolo,
-                        once: flags.once,
-                    });
-                    return;
-                }
-                await watch(flags.intervalSeconds, flags.target, flags.once);
-                return;
-            }
-            case "daemon":
-                await daemon(parseDaemonFlags(rest));
-                return;
-            case "delete":
-            case "rm": {
-                const flags = parseDeleteFlags(rest);
-                await deleteSkill({ slug: flags.slug ?? "", yes: flags.yes });
-                return;
-            }
-            case "library":
-            case "lib":
-                await runLibrary(rest);
-                return;
-            case "audit":
-                await auditSkills(parseAuditFlags(rest));
-                return;
-            case "move": {
-                const flags = parseFolderTagFlags(rest);
-                const slug = flags.rest[0];
-                if (!slug) {
-                    throw new FloomError("Missing skill slug.", `Try \`${CLI_COMMAND} move support-tone --folder support/tone\`.`);
-                }
-                if (flags.folder === undefined) {
-                    throw new FloomError("Missing --folder.", "Use --folder <path> or --root. Add --tag or --tags when useful.");
-                }
-                if (flags.rest.length > 1) {
-                    throw new FloomError(`Unexpected argument: ${flags.rest[1]}`, `Try \`${CLI_COMMAND} move support-tone --folder support/tone\`.`);
-                }
-                await moveSkill({ slug, folder: flags.folder, tags: flags.tags });
-                return;
-            }
-            case "mcp":
-                rejectArgs(rest, `Try \`${CLI_COMMAND} mcp\`.`);
-                printMcpSetup();
-                return;
-            case "doctor":
-                await doctor(parseDoctorFlags(rest));
-                return;
-            default:
-                throw new FloomError(`Unknown command: ${cmd}`, `Run \`${CLI_COMMAND} --help\` to see available commands.`);
-        }
-    }
-    catch (e) {
-        printError(e, { json: rest.includes("--json") });
-        process.exit(1);
-    }
-}
-void main();