@floomhq/floom 1.0.45 → 1.0.47

package/dist/audit.js

@@ -0,0 +1,168 @@
+import ora from "ora";
+import { readConfig, resolveApiUrl } from "./config.js";
+import { getJson } from "./lib/api.js";
+import { FloomError } from "./errors.js";
+import { c, symbols } from "./ui.js";
+const FIXTURE_RE = /\b(?:cli lifecycle audit fixture|launch gate|temp skill|test fixture|audit fixture)\b/i;
+function contentHash(skill) {
+    return skill.content_sha256 ?? skill.content_hash ?? undefined;
+}
+function normalized(value) {
+    return (value ?? "").trim().replace(/\s+/g, " ").toLowerCase();
+}
+function riskFor(score, reasons) {
+    if (score >= 90 || reasons.includes("security_scan_failure"))
+        return "critical";
+    if (score >= 70)
+        return "high";
+    if (score >= 40)
+        return "medium";
+    return "low";
+}
+function scoreSkill(skill, duplicateGroup) {
+    const reasons = [];
+    let score = 0;
+    const title = normalized(skill.title);
+    const description = normalized(skill.description);
+    const body = skill.body_md ?? "";
+    const slug = skill.slug;
+    if (!title) {
+        score += 20;
+        reasons.push("blank_title");
+    }
+    if (!description) {
+        score += 15;
+        reasons.push("blank_description");
+    }
+    if (duplicateGroup) {
+        score += 35;
+        reasons.push("duplicate_content_hash");
+    }
+    if (FIXTURE_RE.test(`${skill.title ?? ""} ${skill.description ?? ""} ${slug}`)) {
+        score += 25;
+        reasons.push("launch_or_test_fixture");
+    }
+    if (title && title === normalized(slug)) {
+        score += 20;
+        reasons.push("slug_only_title");
+    }
+    if (body.trim().length > 0 && body.trim().length < 80) {
+        score += 35;
+        reasons.push("near_empty_body");
+    }
+    if (!/^---\s*\n/.test(body.trimStart())) {
+        score += 30;
+        reasons.push("missing_yaml_frontmatter");
+    }
+    if (/\b(?:api[_-]?key|secret|token)\b/i.test(body) && /\b(?:sk-|AIza|BEGIN PRIVATE KEY)\b/.test(body)) {
+        score += 50;
+        reasons.push("possible_secret");
+    }
+    if (score === 0)
+        return null;
+    const risk = riskFor(score, reasons);
+    const hash = contentHash(skill);
+    return {
+        slug,
+        title: skill.title?.trim() || "",
+        risk,
+        score,
+        reasons,
+        ...(hash ? { content_hash: hash } : {}),
+        ...(duplicateGroup ? { duplicate_group: duplicateGroup } : {}),
+        recommended_action: score >= 70 ? "archive" : "review",
+        safe: !reasons.includes("possible_secret"),
+    };
+}
+async function loadOwnedSkills() {
+    const cfg = await readConfig();
+    if (!cfg)
+        throw new FloomError("Not signed in.", "Run `npx -y @floomhq/floom login` first.");
+    const apiUrl = resolveApiUrl(cfg);
+    const skills = [];
+    let cursor;
+    const seenCursors = new Set();
+    for (let page = 0; page < 1000; page += 1) {
+        const url = new URL(`${apiUrl}/api/v1/me/skills`);
+        url.searchParams.set("limit", "100");
+        url.searchParams.set("scope", "owned");
+        if (cursor)
+            url.searchParams.set("cursor", cursor);
+        const mine = await getJson(url.toString(), "audit your skills", cfg.accessToken);
+        skills.push(...(mine.skills ?? []));
+        if (!mine.next_cursor)
+            break;
+        if (seenCursors.has(mine.next_cursor))
+            throw new FloomError("Invalid skills response.");
+        seenCursors.add(mine.next_cursor);
+        cursor = mine.next_cursor;
+    }
+    return skills;
+}
+function duplicateGroups(skills) {
+    const byHash = new Map();
+    for (const skill of skills) {
+        const hash = contentHash(skill);
+        if (!hash)
+            continue;
+        const group = byHash.get(hash) ?? [];
+        group.push(skill);
+        byHash.set(hash, group);
+    }
+    const out = new Map();
+    let i = 1;
+    for (const [hash, group] of byHash.entries()) {
+        if (group.length < 2)
+            continue;
+        const id = `dup_${i}`;
+        i += 1;
+        for (const skill of group)
+            out.set(`${hash}\0${skill.slug}`, id);
+    }
+    return out;
+}
+function summarize(skills, findings) {
+    return {
+        total: skills.length,
+        findings: findings.length,
+        critical: findings.filter((f) => f.risk === "critical").length,
+        high: findings.filter((f) => f.risk === "high").length,
+        medium: findings.filter((f) => f.risk === "medium").length,
+        low: findings.filter((f) => f.risk === "low").length,
+        blank_titles: skills.filter((s) => !normalized(s.title)).length,
+        blank_descriptions: skills.filter((s) => !normalized(s.description)).length,
+        duplicate_hash_groups: new Set(findings.map((f) => f.duplicate_group).filter(Boolean)).size,
+    };
+}
+export async function auditSkills(opts) {
+    const spinner = opts.json ? null : ora({ text: c.dim("Auditing skills..."), color: "yellow" }).start();
+    let skills;
+    try {
+        skills = await loadOwnedSkills();
+    }
+    finally {
+        spinner?.stop();
+    }
+    const duplicates = duplicateGroups(skills);
+    const findings = skills
+        .map((skill) => scoreSkill(skill, contentHash(skill) ? duplicates.get(`${contentHash(skill)}\0${skill.slug}`) : undefined))
+        .filter((finding) => finding !== null)
+        .sort((a, b) => b.score - a.score || a.slug.localeCompare(b.slug));
+    const summary = summarize(skills, findings);
+    const archivePlan = findings
+        .filter((finding) => finding.recommended_action === "archive")
+        .map((finding) => ({ slug: finding.slug, reasons: finding.reasons, score: finding.score }));
+    if (opts.json || opts.fixPlan) {
+        process.stdout.write(`${JSON.stringify({ summary, findings, ...(opts.fixPlan ? { archive_plan: archivePlan } : {}) }, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write(`\n${symbols.dot}  ${c.bold("Skill audit")} ${c.dim(`(${summary.total} owned skills)`)}\n\n`);
+    process.stdout.write(`   findings: ${summary.findings}  critical: ${summary.critical}  high: ${summary.high}  medium: ${summary.medium}  low: ${summary.low}\n`);
+    process.stdout.write(`   blank titles: ${summary.blank_titles}  blank descriptions: ${summary.blank_descriptions}  duplicate groups: ${summary.duplicate_hash_groups}\n\n`);
+    for (const finding of findings.slice(0, 25)) {
+        process.stdout.write(`   ${c.cyan(finding.slug.padEnd(14))} ${finding.risk.padEnd(8)} ${String(finding.score).padStart(3)}  ${finding.reasons.join(", ")}\n`);
+    }
+    if (findings.length > 25)
+        process.stdout.write(`   ${c.dim(`... ${findings.length - 25} more. Run with --json for full output.`)}\n`);
+    process.stdout.write("\n");
+}

package/dist/cli.js

@@ -12,11 +12,14 @@ 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 { libraryAddSkill, libraryCreate, libraryList, libraryRemoveSkill, librarySubscribe, libraryUnsubscribe, moveSkill, } from "./library.js";
 import { c, symbols } from "./ui.js";
 import { printError, FloomError } from "./errors.js";
@@ -25,6 +28,13 @@ 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("  ________                      ")}
@@ -94,6 +104,7 @@ function commandUsage() {
                        ${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
@@ -111,6 +122,10 @@ function commandUsage() {
                        ${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.bold("Examples")}
    ${c.cyan("npx -y @floomhq/floom add")} ${c.dim("https://floom.dev/s/ffas93ud --setup")}
@@ -229,6 +244,62 @@ function doctorUsage() {
    ${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.bold("Flags")}
+   ${c.cyan("--json")}       Full machine-readable report
+   ${c.cyan("--fix-plan")}   Include archive recommendations, without applying them
+`);
+}
+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";
 }
@@ -247,9 +318,18 @@ function subcommandUsage(cmd) {
         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 "library":
         case "lib":
             libraryUsage();
@@ -458,6 +538,54 @@ function parseInfoFlags(argv) {
     }
     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;
@@ -550,6 +678,8 @@ function parseSetupFlags(argv) {
             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);
@@ -588,6 +718,103 @@ function parseDoctorFlags(argv) {
     }
     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 };
+    for (const a of rest) {
+        if (a === "--json")
+            out.json = true;
+        else if (a === "--fix-plan")
+            out.fixPlan = 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 === ".")
@@ -944,6 +1171,17 @@ async function main() {
                 });
                 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 "add":
             case "install": {
                 const flags = parseAddArgs(rest);
@@ -979,6 +1217,9 @@ async function main() {
                 await watch(flags.intervalSeconds, flags.target, flags.once);
                 return;
             }
+            case "daemon":
+                await daemon(parseDaemonFlags(rest));
+                return;
             case "delete":
             case "rm": {
                 const flags = parseDeleteFlags(rest);
@@ -989,6 +1230,9 @@ async function main() {
             case "lib":
                 await runLibrary(rest);
                 return;
+            case "audit":
+                await auditSkills(parseAuditFlags(rest));
+                return;
             case "move": {
                 const flags = parseFolderTagFlags(rest);
                 const slug = flags.rest[0];

package/dist/daemon.js

@@ -0,0 +1,413 @@
+import { spawn } from "node:child_process";
+import { access, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { homedir, hostname, platform } from "node:os";
+import { dirname, join } from "node:path";
+import { CONFIG_DIR } from "./config.js";
+import { CLI_VERSION } from "./version.js";
+import { FloomError } from "./errors.js";
+import { c, symbols } from "./ui.js";
+import { AGENT_TARGETS, isAgentTarget, targetSkillsDirEnv } from "./targets.js";
+const SERVICE_NAME = "floom-sync.service";
+const LAUNCHD_LABEL = "dev.floom.sync";
+const LOG_PATH = join(CONFIG_DIR, "daemon.log");
+const STATUS_PATH = join(CONFIG_DIR, "daemon-status.json");
+const MIN_INTERVAL_SECONDS = 30;
+const MIN_TIMEOUT_SECONDS = 30;
+function targetsFor(value) {
+    return value === "all" ? [...AGENT_TARGETS] : [value];
+}
+function cliInvocation() {
+    const node = JSON.stringify(process.execPath);
+    const entry = JSON.stringify(process.argv[1] ?? "floom");
+    return `${node} ${entry}`;
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function runCommand(args, extraEnv = {}) {
+    const timeoutMs = Math.max(MIN_TIMEOUT_SECONDS, Number(args[0]) || MIN_TIMEOUT_SECONDS) * 1000;
+    const commandArgs = args.slice(1);
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, [process.argv[1] ?? "", ...commandArgs], {
+            env: {
+                ...process.env,
+                ...extraEnv,
+                NO_UPDATE_NOTIFIER: "1",
+                npm_config_update_notifier: "false",
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            setTimeout(() => child.kill("SIGKILL"), 5000).unref();
+        }, timeoutMs);
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => { stdout += chunk; });
+        child.stderr.on("data", (chunk) => { stderr += chunk; });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({ code: code ?? 1, stdout, stderr, timedOut });
+        });
+    });
+}
+async function appendLog(message) {
+    await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    const existing = await readFile(LOG_PATH, "utf8").catch((err) => {
+        if (err.code === "ENOENT")
+            return "";
+        throw err;
+    });
+    await writeFile(LOG_PATH, `${existing}${message}`, { mode: 0o600 });
+}
+async function writeStatus(status) {
+    await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    await writeFile(STATUS_PATH, `${JSON.stringify(status, null, 2)}\n`, { mode: 0o600 });
+}
+async function readStatus() {
+    try {
+        return JSON.parse(await readFile(STATUS_PATH, "utf8"));
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+function parseSyncResult(output) {
+    const match = output.match(/synced\s+(\d+)\s+skills\s+\((\d+)\s+unchanged,\s+(\d+)\s+updated(?:,\s+(\d+)\s+conflicts?\s+skipped)?/i);
+    if (!match)
+        return {};
+    return {
+        synced: Number(match[1]),
+        updated: Number(match[3]),
+        conflicts: Number(match[4] ?? "0"),
+    };
+}
+async function runTarget(target, opts) {
+    const started = Date.now();
+    const cacheDir = join(CONFIG_DIR, "skill-cache", target);
+    const nativeManifestPath = join(CONFIG_DIR, "native-sync-manifests", `${target}.json`);
+    const syncResult = await runCommand([String(opts.timeoutSeconds), "sync", "--target", target], {
+        [targetSkillsDirEnv(target)]: cacheDir,
+        FLOOM_SYNC_MANIFEST_PATH: join(cacheDir, ".floom-cli-sync-manifest.json"),
+    });
+    const combined = `${syncResult.stdout}\n${syncResult.stderr}`;
+    let ok = syncResult.code === 0 && !syncResult.timedOut;
+    let error = syncResult.timedOut ? "sync timed out" : syncResult.code === 0 ? undefined : combined.trim() || "sync failed";
+    if (ok) {
+        const setupResult = await runCommand([String(opts.timeoutSeconds), "setup", "--target", target, "--yes", "--global"]);
+        if (setupResult.code !== 0 || setupResult.timedOut) {
+            ok = false;
+            error = setupResult.timedOut ? "instruction setup timed out" : `${setupResult.stdout}\n${setupResult.stderr}`.trim() || "instruction setup failed";
+        }
+    }
+    if (opts.push && ok) {
+        if (opts.yolo && !(await fileExists(nativeManifestPath))) {
+            const baselineResult = await runCommand([String(opts.timeoutSeconds), "watch", "--push", "--once", "--target", target, "--no-yolo"], { FLOOM_SYNC_MANIFEST_PATH: nativeManifestPath });
+            if (baselineResult.code !== 0 || baselineResult.timedOut) {
+                ok = false;
+                error = baselineResult.timedOut ? "native baseline timed out" : `${baselineResult.stdout}\n${baselineResult.stderr}`.trim() || "native baseline failed";
+            }
+        }
+    }
+    if (opts.push && ok) {
+        const pushArgs = ["watch", "--push", "--once", "--target", target];
+        if (!opts.yolo)
+            pushArgs.push("--no-yolo");
+        const pushResult = await runCommand([String(opts.timeoutSeconds), ...pushArgs], { FLOOM_SYNC_MANIFEST_PATH: nativeManifestPath });
+        if (pushResult.code !== 0 || pushResult.timedOut) {
+            ok = false;
+            error = pushResult.timedOut ? "push timed out" : `${pushResult.stdout}\n${pushResult.stderr}`.trim() || "push failed";
+        }
+    }
+    await appendLog([
+        `${new Date().toISOString()} target=${target} ok=${ok}`,
+        combined.trim(),
+        error && !combined.includes(error) ? error : "",
+        "",
+    ].filter(Boolean).join("\n"));
+    return {
+        ok,
+        ...parseSyncResult(combined),
+        ...(error ? { error } : {}),
+        duration_ms: Date.now() - started,
+    };
+}
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return false;
+        throw err;
+    }
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function runDaemonForeground(opts) {
+    const targets = targetsFor(opts.target);
+    process.stdout.write(`${symbols.bullet}  Floom daemon running for ${targets.join(", ")} every ${opts.intervalSeconds}s.\n`);
+    for (;;) {
+        const now = new Date();
+        const status = {
+            running: true,
+            manager: "foreground",
+            service: "foreground",
+            pid: process.pid,
+            version: CLI_VERSION,
+            hostname: hostname(),
+            interval_seconds: opts.intervalSeconds,
+            timeout_seconds: opts.timeoutSeconds,
+            targets,
+            push: opts.push,
+            yolo: opts.yolo,
+            last_started_at: now.toISOString(),
+            last_run: {},
+        };
+        await writeStatus(status);
+        for (const target of targets) {
+            status.last_run[target] = await runTarget(target, opts);
+            await writeStatus(status);
+        }
+        const completed = new Date();
+        status.last_completed_at = completed.toISOString();
+        status.next_run_at = new Date(completed.getTime() + opts.intervalSeconds * 1000).toISOString();
+        await writeStatus(status);
+        await appendLog(`${completed.toISOString()} daemon cycle complete\n`);
+        if (!opts.foreground)
+            return;
+        await sleep(opts.intervalSeconds * 1000);
+    }
+}
+function serviceCommand(opts) {
+    const args = [
+        "daemon",
+        "run",
+        "--foreground",
+        "--target",
+        opts.target,
+        "--interval",
+        String(opts.intervalSeconds),
+        "--timeout",
+        String(opts.timeoutSeconds),
+        opts.push ? "--push" : "--no-push",
+        opts.yolo ? "--yolo" : "--no-yolo",
+    ];
+    return `exec ${cliInvocation()} ${args.map(shellQuote).join(" ")}`;
+}
+function systemdUnit(opts, user) {
+    return `[Unit]
+Description=Floom always-on skill sync
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=/bin/sh -lc ${shellQuote(serviceCommand(opts))}
+Restart=always
+RestartSec=15
+Environment=NO_UPDATE_NOTIFIER=1
+Environment=npm_config_update_notifier=false
+
+[Install]
+WantedBy=${user ? "default.target" : "multi-user.target"}
+`;
+}
+function launchdPlist(opts) {
+    const command = serviceCommand(opts);
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/sh</string>
+    <string>-lc</string>
+    <string>${escapePlist(command)}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${LOG_PATH}</string>
+  <key>StandardErrorPath</key>
+  <string>${LOG_PATH}</string>
+</dict>
+</plist>
+`;
+}
+function escapePlist(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+function manager() {
+    return platform() === "darwin" ? "launchd" : "systemd";
+}
+function systemdPath() {
+    const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
+    if (isRoot)
+        return { path: `/etc/systemd/system/${SERVICE_NAME}`, user: false };
+    return { path: join(homedir(), ".config", "systemd", "user", SERVICE_NAME), user: true };
+}
+async function installDaemon(opts) {
+    if (manager() === "launchd") {
+        const plistPath = join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+        const body = launchdPlist(opts);
+        if (opts.dryRun) {
+            process.stdout.write(body);
+            return;
+        }
+        await mkdir(dirname(plistPath), { recursive: true });
+        await writeFile(plistPath, body, "utf8");
+        process.stdout.write(`${symbols.ok}  Installed ${plistPath}\n`);
+        await runManagerCommand("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? ""}`, plistPath], true);
+        await runManagerCommand("launchctl", ["kickstart", "-k", `gui/${process.getuid?.() ?? ""}/${LAUNCHD_LABEL}`], true);
+        return;
+    }
+    const target = systemdPath();
+    const body = systemdUnit(opts, target.user);
+    if (opts.dryRun) {
+        process.stdout.write(body);
+        return;
+    }
+    await mkdir(dirname(target.path), { recursive: true });
+    await writeFile(target.path, body, "utf8");
+    process.stdout.write(`${symbols.ok}  Installed ${target.path}\n`);
+    await runSystemctl(["daemon-reload"], target.user, true);
+    await runSystemctl(["enable", "--now", SERVICE_NAME], target.user, true);
+}
+async function showStatus(opts) {
+    const status = await readStatus();
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(status ?? { running: false }, null, 2)}\n`);
+        return;
+    }
+    if (!status) {
+        process.stdout.write(`${symbols.bullet}  Floom daemon has no status yet.\n`);
+        return;
+    }
+    process.stdout.write(`${symbols.ok}  Floom daemon ${status.running ? "status" : "last status"}\n`);
+    process.stdout.write(`   ${c.dim("manager:")} ${status.manager}\n`);
+    process.stdout.write(`   ${c.dim("targets:")} ${status.targets.join(", ")}\n`);
+    if (status.last_completed_at)
+        process.stdout.write(`   ${c.dim("last completed:")} ${status.last_completed_at}\n`);
+    for (const [target, run] of Object.entries(status.last_run)) {
+        process.stdout.write(`   ${run.ok ? symbols.ok : symbols.fail} ${target}: ${run.ok ? "ok" : run.error ?? "failed"}\n`);
+    }
+}
+async function showLogs(opts) {
+    const body = await readFile(LOG_PATH, "utf8").catch((err) => {
+        if (err.code === "ENOENT")
+            return "";
+        throw err;
+    });
+    const lines = body.split(/\r?\n/);
+    process.stdout.write(`${lines.slice(Math.max(0, lines.length - opts.tail)).join("\n")}\n`);
+}
+function execManager(command, args) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: ["ignore", "ignore", "pipe"] });
+        let stderr = "";
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => { stderr += chunk; });
+        child.on("error", (err) => resolve({ code: 127, stderr: err.message }));
+        child.on("close", (code) => resolve({ code: code ?? 1, stderr }));
+    });
+}
+async function runManagerCommand(command, args, soft) {
+    const result = await execManager(command, args);
+    if (result.code === 0)
+        return;
+    const rendered = `${command} ${args.join(" ")}`;
+    if (soft) {
+        process.stdout.write(`   ${c.dim(`Run manually if needed: ${rendered}`)}\n`);
+        return;
+    }
+    throw new FloomError(`Failed to run ${rendered}.`, result.stderr.trim() || "Service manager command failed.");
+}
+async function runSystemctl(args, user, soft) {
+    await runManagerCommand("systemctl", user ? ["--user", ...args] : args, soft);
+}
+async function restartDaemon() {
+    if (manager() === "launchd") {
+        await runManagerCommand("launchctl", ["kickstart", "-k", `gui/${process.getuid?.() ?? ""}/${LAUNCHD_LABEL}`], false);
+        process.stdout.write(`${symbols.ok}  Restarted ${LAUNCHD_LABEL}\n`);
+        return;
+    }
+    const target = systemdPath();
+    await runSystemctl(["restart", SERVICE_NAME], target.user, false);
+    process.stdout.write(`${symbols.ok}  Restarted ${SERVICE_NAME}\n`);
+}
+async function uninstallDaemon() {
+    if (manager() === "launchd") {
+        const plistPath = join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+        await runManagerCommand("launchctl", ["bootout", `gui/${process.getuid?.() ?? ""}/${LAUNCHD_LABEL}`], true);
+        await unlink(plistPath).catch((err) => {
+            if (err.code !== "ENOENT")
+                throw err;
+        });
+        process.stdout.write(`${symbols.ok}  Uninstalled ${LAUNCHD_LABEL}\n`);
+        return;
+    }
+    const target = systemdPath();
+    await runSystemctl(["disable", "--now", SERVICE_NAME], target.user, true);
+    await unlink(target.path).catch((err) => {
+        if (err.code !== "ENOENT")
+            throw err;
+    });
+    await runSystemctl(["daemon-reload"], target.user, true);
+    process.stdout.write(`${symbols.ok}  Uninstalled ${SERVICE_NAME}\n`);
+}
+export async function daemon(opts) {
+    switch (opts.command) {
+        case "install":
+            await installDaemon(opts);
+            return;
+        case "status":
+            await showStatus(opts);
+            return;
+        case "logs":
+            await showLogs(opts);
+            return;
+        case "run":
+            await runDaemonForeground(opts);
+            return;
+        case "restart":
+            await restartDaemon();
+            return;
+        case "uninstall":
+            await uninstallDaemon();
+            return;
+        default:
+            throw new FloomError("Missing daemon command.", "Use install, status, logs, restart, uninstall, or run.");
+    }
+}
+export function normalizeDaemonOptions(opts) {
+    if (opts.intervalSeconds < MIN_INTERVAL_SECONDS) {
+        throw new FloomError("Invalid --interval.", `Use an integer number of seconds, minimum ${MIN_INTERVAL_SECONDS}.`);
+    }
+    if (opts.timeoutSeconds < MIN_TIMEOUT_SECONDS) {
+        throw new FloomError("Invalid --timeout.", `Use an integer number of seconds, minimum ${MIN_TIMEOUT_SECONDS}.`);
+    }
+    return opts;
+}
+export function parseDaemonTarget(value) {
+    if (value === "all")
+        return "all";
+    if (isAgentTarget(value))
+        return value;
+    throw new FloomError("Invalid --target.", "Use claude|codex|cursor|opencode|kimi|all.");
+}

package/dist/feedback.js

@@ -0,0 +1,34 @@
+import ora from "ora";
+import { readConfig, resolveApiUrl } from "./config.js";
+import { floomFetch } from "./lib/api.js";
+import { c, symbols } from "./ui.js";
+export async function feedback(opts) {
+    const cfg = await readConfig();
+    const apiUrl = resolveApiUrl(cfg);
+    const payload = {
+        event_name: "feedback.submitted",
+        source: "cli",
+        props: {
+            kind: opts.kind,
+            message: opts.message,
+            ...(opts.target ? { target: opts.target } : {}),
+            ...(opts.skill ? { skill: opts.skill } : {}),
+        },
+    };
+    const spinner = opts.json ? null : ora({ text: c.dim("Sending feedback..."), color: "yellow" }).start();
+    try {
+        await floomFetch(`${apiUrl}/api/v1/events`, "send feedback", {
+            method: "POST",
+            ...(cfg?.accessToken ? { token: cfg.accessToken } : {}),
+            body: payload,
+        });
+    }
+    finally {
+        spinner?.stop();
+    }
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify({ ok: true }, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write(`\n${symbols.ok}  Feedback sent\n\n`);
+}

package/dist/list.js

@@ -47,6 +47,7 @@ export async function list(opts) {
         for (let page = 0; page < 1000; page += 1) {
             const url = new URL(`${apiUrl}/api/v1/me/skills`);
             url.searchParams.set("limit", "100");
+            url.searchParams.set("scope", "owned");
             if (cursor)
                 url.searchParams.set("cursor", cursor);
             const mine = await getJson(url.toString(), "load your skills", cfg.accessToken);

package/dist/publish.js

@@ -20,6 +20,7 @@ const INSTALL_TARGETS = new Set([
 ]);
 const VERSION_RE = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,63}$/;
 const SLUG_RE = /^[A-Za-z0-9_-]{1,128}$/;
+const YAML_MAX_ALIAS_COUNT = 50;
 function parseFrontmatter(input) {
     const trimmed = input.replace(/^/, "");
     if (!trimmed.startsWith("---"))
@@ -37,7 +38,7 @@ function parseFrontmatter(input) {
     const meta = {};
     let parsed;
     try {
-        parsed = headerBlock ? parseYaml(headerBlock) : {};
+        parsed = headerBlock ? parseYaml(headerBlock, { maxAliasCount: YAML_MAX_ALIAS_COUNT }) : {};
     }
     catch (err) {
         return {

package/dist/setup.js

@@ -6,15 +6,36 @@ import { stdin as input, stdout as output } from "node:process";
 import { FloomError } from "./errors.js";
 import { c, symbols } from "./ui.js";
 import { targetLabel } from "./targets.js";
+import { readConfig, resolveApiUrl } from "./config.js";
+import { getJson } from "./lib/api.js";
 const START_MARKER = "<!-- FLOOM SETUP START -->";
 const END_MARKER = "<!-- FLOOM SETUP END -->";
+const CLOUD_START_MARKER = "<!-- FLOOM CLOUD INSTRUCTIONS START -->";
+const CLOUD_END_MARKER = "<!-- FLOOM CLOUD INSTRUCTIONS END -->";
 const CLI_COMMAND = "npx -y @floomhq/floom";
 const INSTRUCTION_FILES = {
     claude: { filename: "CLAUDE.md" },
     codex: { filename: "AGENTS.md" },
 };
-function floomAgentInstructions(target) {
+function cloudInstructionBody(target, profile) {
+    if (!profile)
+        return "";
+    const base = profile.body_md.trim();
+    const override = profile.target_overrides?.[target]?.trim();
+    const body = [base, override].filter(Boolean).join("\n\n");
+    if (!body)
+        return "";
+    return [
+        CLOUD_START_MARKER,
+        `<!-- Floom profile version ${profile.version}; updated ${profile.updated_at} -->`,
+        "",
+        body,
+        CLOUD_END_MARKER,
+    ].join("\n");
+}
+function floomAgentInstructions(target, profile) {
     const addCommand = `${CLI_COMMAND} add <slug-or-url> --target ${target}`;
+    const cloudBody = cloudInstructionBody(target, profile);
     return `${START_MARKER}
 ## Floom
 
@@ -23,6 +44,7 @@ function floomAgentInstructions(target) {
 - Add shared skills with \`${addCommand}\`; public and unlisted links do not require a Floom account.
 - Use the installed \`floom-find-skills\` router skill, Floom search, or MCP lookup before loading local files. Do not enumerate every cached skill into model context.
 - \`${CLI_COMMAND} sync --target ${target}\`, \`${CLI_COMMAND} watch --push --target ${target}\`, and \`@floomhq/floom-mcp-sync\` keep saved, published, and subscribed library skills current in the Floom cache; review conflicts before relying on synced output.
+${cloudBody ? `\n${cloudBody}` : ""}
 ${END_MARKER}`;
 }
 async function fileExists(path) {
@@ -86,6 +108,20 @@ async function detectTarget(opts) {
         };
     }
     if (agent) {
+        if (opts.global && agent === "claude") {
+            return {
+                agent,
+                label: targetLabel(agent),
+                path: join(homedir(), ".claude", "CLAUDE.md"),
+            };
+        }
+        if (opts.global && agent === "codex") {
+            return {
+                agent,
+                label: targetLabel(agent),
+                path: join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "AGENTS.md"),
+            };
+        }
         if (agent === "cursor") {
             return {
                 agent,
@@ -125,7 +161,7 @@ async function detectTarget(opts) {
         return { agent: "codex", label: targetLabel("codex"), path: codex };
     throw new FloomError("No agent instruction file found.", `Run \`${CLI_COMMAND} setup --target claude --yes\`, \`${CLI_COMMAND} setup --target codex --yes\`, \`${CLI_COMMAND} setup --target cursor --yes\`, \`${CLI_COMMAND} setup --target opencode --yes\`, or \`${CLI_COMMAND} setup --target kimi --yes\`.`);
 }
-function renderPreview(target, existing) {
+function renderPreview(target, existing, profile) {
     const action = existing === null ? "create" : "append";
     return [
         "",
@@ -133,14 +169,14 @@ function renderPreview(target, existing) {
         `   ${c.dim("Target:")} ${target.path}`,
         `   ${c.dim("Action:")} ${action}`,
         "",
-        floomAgentInstructions(target.agent),
+        floomAgentInstructions(target.agent, profile),
         "",
         `${c.dim("MCP setup guidance:")} run ${c.cyan(`${CLI_COMMAND} mcp`)} to print local agent commands.`,
         "",
     ].join("\n");
 }
-function renderInstructions(target, existing) {
-    const body = floomAgentInstructions(target);
+function renderInstructions(target, existing, profile) {
+    const body = floomAgentInstructions(target, profile);
     if (target === "cursor" && existing === null) {
         return [
             "---",
@@ -154,6 +190,29 @@ function renderInstructions(target, existing) {
     }
     return body;
 }
+function replaceExistingBlock(existing, instructions) {
+    const start = existing.indexOf(START_MARKER);
+    const end = existing.indexOf(END_MARKER, start);
+    if (start < 0 || end < 0)
+        return null;
+    const afterEnd = end + END_MARKER.length;
+    const prefix = existing.slice(0, start).replace(/\s*$/, "");
+    const suffix = existing.slice(afterEnd).replace(/^\s*/, "").replace(/\s*$/, "");
+    return [...(prefix ? [prefix] : []), instructions, ...(suffix ? [suffix] : [])].join("\n\n").replace(/\s*$/, "\n");
+}
+async function loadCloudProfile() {
+    const cfg = await readConfig();
+    if (!cfg)
+        return null;
+    try {
+        const apiUrl = resolveApiUrl(cfg);
+        const payload = await getJson(`${apiUrl}/api/v1/me/instructions`, "load cloud instruction profile", cfg.accessToken);
+        return payload.profile;
+    }
+    catch {
+        return null;
+    }
+}
 async function ensureOpencodeInstructionReference(instructionPath) {
     const configPath = join(homedir(), ".config", "opencode", "opencode.json");
     const reference = `{file:${instructionPath.replace(homedir(), "~")}}`;
@@ -191,16 +250,28 @@ async function confirmWrite(target, existing) {
 export async function setupAgent(opts) {
     const target = await detectTarget(opts);
     const existing = await readIfExists(target.path);
+    const profile = opts.global ? await loadCloudProfile() : null;
+    const instructions = renderInstructions(target.agent, existing, profile);
     if (existing?.includes(START_MARKER) && existing.includes(END_MARKER)) {
-        process.stdout.write(`\n${symbols.ok}  Floom instructions already present in ${c.bold(target.path)}\n\n`);
+        const replaced = replaceExistingBlock(existing, instructions);
+        if (replaced === null || replaced === existing) {
+            process.stdout.write(`\n${symbols.ok}  Floom instructions already present in ${c.bold(target.path)}\n\n`);
+            return;
+        }
+        if (opts.dryRun) {
+            process.stdout.write(renderPreview(target, existing, profile));
+            return;
+        }
+        await writeFile(target.path, replaced, "utf8");
+        process.stdout.write(`\n${symbols.ok}  Updated Floom instructions in ${c.bold(target.path)}\n\n`);
         return;
     }
     if (opts.dryRun) {
-        process.stdout.write(renderPreview(target, existing));
+        process.stdout.write(renderPreview(target, existing, profile));
         return;
     }
     if (!opts.yes) {
-        process.stdout.write(renderPreview(target, existing));
+        process.stdout.write(renderPreview(target, existing, profile));
         const ok = await confirmWrite(target, existing);
         if (!ok) {
             process.stdout.write(`\n${c.dim("Cancelled. Nothing was written.")}\n\n`);
@@ -208,7 +279,6 @@ export async function setupAgent(opts) {
         }
     }
     await mkdir(dirname(target.path), { recursive: true });
-    const instructions = renderInstructions(target.agent, existing);
     const next = existing === null
         ? `${instructions}\n`
         : `${existing.replace(/\s*$/, "")}\n\n${instructions}\n`;

package/dist/sync.js

@@ -449,7 +449,7 @@ async function loadSyncPayload(apiUrl, token) {
     const seenCursors = new Set();
     for (let page = 0; page < 1000; page += 1) {
         const url = new URL(`${apiUrl}/api/v1/me/skills`);
-        url.searchParams.set("limit", "10");
+        url.searchParams.set("limit", "100");
         url.searchParams.set("packages", "1");
         if (cursor)
             url.searchParams.set("cursor", cursor);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floomhq/floom",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "description": "Sync AI skills across agents and machines.",
   "license": "MIT",
   "type": "module",