@floomhq/floom 1.0.25 → 1.0.27

package/dist/push-watch.js

@@ -0,0 +1,245 @@
+import { constants } from "node:fs";
+import { mkdir, open, readdir, rename } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { CONFIG_DIR } from "./config.js";
+import { FloomError } from "./errors.js";
+import { publishSkillPath } from "./publish.js";
+import { readSkillPackage } from "./package.js";
+import { manifestKey, markSynced, readSyncManifest, writeSyncManifest } from "./sync-manifest.js";
+import { c, symbols } from "./ui.js";
+import { targetSkillsDir } from "./targets.js";
+const MANIFEST_VERSION = 1;
+const PUSH_MANIFEST_PATH = join(CONFIG_DIR, "push-manifest.json");
+const MAX_SCAN_DEPTH = 8;
+const SKIP_DIRS = new Set([".cache", ".git", ".next", ".pytest_cache", "__pycache__", "build", "coverage", "dist", "node_modules", "out"]);
+const SLUG_RE = /^[A-Za-z0-9_-]{1,128}$/;
+function emptyManifest() {
+    return { version: MANIFEST_VERSION, files: {} };
+}
+async function readPushManifest() {
+    try {
+        const handle = await open(PUSH_MANIFEST_PATH, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const parsed = JSON.parse(await handle.readFile("utf8"));
+            if (parsed.version !== MANIFEST_VERSION || !parsed.files || typeof parsed.files !== "object")
+                return emptyManifest();
+            return parsed;
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return emptyManifest();
+        if (err instanceof SyntaxError)
+            return emptyManifest();
+        throw err;
+    }
+}
+async function writePushManifest(manifest) {
+    await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    const tmp = join(CONFIG_DIR, `.push-manifest.${process.pid}.${Date.now()}.tmp`);
+    const handle = await open(tmp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    try {
+        await handle.writeFile(JSON.stringify(manifest, null, 2));
+    }
+    finally {
+        await handle.close();
+    }
+    await rename(tmp, PUSH_MANIFEST_PATH);
+}
+function hashPackage(skillPath, body, files) {
+    const hash = createHash("sha256");
+    hash.update(skillPath);
+    hash.update("\0");
+    hash.update(body);
+    for (const file of files) {
+        hash.update("\0");
+        hash.update(file.path);
+        hash.update("\0");
+        hash.update(file.sha256);
+    }
+    return hash.digest("hex");
+}
+async function findSkillPackages(root) {
+    const out = [];
+    async function walk(dir, depth) {
+        if (depth > MAX_SCAN_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return;
+            throw err;
+        }
+        if (entries.some((entry) => entry.isFile() && entry.name === "SKILL.md")) {
+            out.push(dir);
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith(".") || SKIP_DIRS.has(entry.name))
+                continue;
+            if (entry.isSymbolicLink())
+                continue;
+            await walk(join(dir, entry.name), depth + 1);
+        }
+    }
+    await walk(root, 0);
+    return out.sort();
+}
+function safeRootRelative(root, path) {
+    const relativePath = relative(resolve(root), resolve(path));
+    if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+        throw new FloomError("Invalid watched skill path.");
+    }
+    return relativePath.split(sep).join("/");
+}
+function slugFromSyncManifest(root, skillFilePath, syncManifest) {
+    const key = manifestKey(root, skillFilePath);
+    const entry = syncManifest.files[key];
+    return entry?.slug ?? null;
+}
+function slugFromPushManifest(key, pushManifest) {
+    return pushManifest.files[key]?.slug ?? null;
+}
+function pushManifestKey(target, relativeSkillPath) {
+    return `${target}:${relativeSkillPath}`;
+}
+function isUnchangedSyncedPackage(root, skillPackage, syncManifest) {
+    const files = [
+        { target: skillPackage.skillPath, hash: createHash("sha256").update(skillPackage.skillBody).digest("hex") },
+        ...skillPackage.packageFiles.map((file) => ({
+            target: join(dirname(skillPackage.skillPath), ...file.path.split("/")),
+            hash: file.sha256,
+        })),
+    ];
+    return files.every((file) => syncManifest.files[manifestKey(root, file.target)]?.hash === file.hash);
+}
+function markPackageSynced(root, skillPackage, syncManifest, slug) {
+    markSynced(syncManifest, manifestKey(root, skillPackage.skillPath), slug, createHash("sha256").update(skillPackage.skillBody).digest("hex"));
+    for (const file of skillPackage.packageFiles) {
+        markSynced(syncManifest, manifestKey(root, join(dirname(skillPackage.skillPath), ...file.path.split("/"))), slug, file.sha256);
+    }
+}
+function fallbackSlugFromPath(packagePath) {
+    const slug = packagePath.split(/[\\/]/).filter(Boolean).at(-1);
+    return slug && SLUG_RE.test(slug) ? slug : null;
+}
+export async function pushWatchOnce(opts) {
+    const root = targetSkillsDir(opts.target);
+    const pushManifest = await readPushManifest();
+    const syncManifest = await readSyncManifest();
+    const packages = await findSkillPackages(root);
+    let published = 0;
+    let updated = 0;
+    let adopted = 0;
+    let skipped = 0;
+    for (const packagePath of packages) {
+        let skillPackage;
+        try {
+            skillPackage = await readSkillPackage(packagePath);
+        }
+        catch (err) {
+            skipped += 1;
+            if (!opts.quiet) {
+                process.stderr.write(`[floom] skipped ${packagePath}: ${err instanceof Error ? err.message : String(err)}\n`);
+            }
+            continue;
+        }
+        const key = safeRootRelative(root, skillPackage.skillPath);
+        const pushKey = pushManifestKey(opts.target, key);
+        const hash = hashPackage(key, skillPackage.skillBody, skillPackage.packageFiles);
+        const pushed = pushManifest.files[pushKey];
+        if (pushed?.hash === hash) {
+            skipped += 1;
+            continue;
+        }
+        if (!opts.yolo) {
+            const syncedSlug = slugFromSyncManifest(root, skillPackage.skillPath, syncManifest);
+            const pushedSlug = slugFromPushManifest(pushKey, pushManifest);
+            const fallbackSlug = fallbackSlugFromPath(packagePath);
+            pushManifest.files[pushKey] = {
+                hash,
+                slug: pushedSlug ?? syncedSlug ?? fallbackSlug ?? key,
+                path: key,
+                pushedAt: new Date().toISOString(),
+            };
+            adopted += 1;
+            continue;
+        }
+        const syncedSlug = slugFromSyncManifest(root, skillPackage.skillPath, syncManifest);
+        const pushedSlug = slugFromPushManifest(pushKey, pushManifest);
+        const fallbackSlug = fallbackSlugFromPath(packagePath);
+        const slug = pushedSlug ?? syncedSlug ?? fallbackSlug;
+        if (!pushed && syncedSlug && isUnchangedSyncedPackage(root, skillPackage, syncManifest)) {
+            pushManifest.files[pushKey] = {
+                hash,
+                slug: syncedSlug,
+                path: key,
+                pushedAt: new Date().toISOString(),
+            };
+            adopted += 1;
+            continue;
+        }
+        if (pushed || syncedSlug) {
+            if (!slug) {
+                skipped += 1;
+                continue;
+            }
+            try {
+                await publishSkillPath({ file: packagePath, update: true, updateSlug: slug, quiet: true });
+                updated += 1;
+                pushManifest.files[pushKey] = { hash, slug, path: key, pushedAt: new Date().toISOString() };
+                markPackageSynced(root, skillPackage, syncManifest, slug);
+                await writeSyncManifest(syncManifest);
+            }
+            catch (err) {
+                if (err instanceof Error && /Skill not found/i.test(err.message)) {
+                    const result = await publishSkillPath({ file: packagePath, visibility: "unlisted", quiet: true });
+                    published += 1;
+                    pushManifest.files[pushKey] = { hash, slug: result.data.slug, path: key, pushedAt: new Date().toISOString() };
+                    markPackageSynced(root, skillPackage, syncManifest, result.data.slug);
+                    await writeSyncManifest(syncManifest);
+                    continue;
+                }
+                skipped += 1;
+                if (!opts.quiet) {
+                    process.stderr.write(`[floom] skipped ${packagePath}: ${err instanceof Error ? err.message : String(err)}\n`);
+                }
+            }
+            continue;
+        }
+        try {
+            const result = await publishSkillPath({ file: packagePath, visibility: "unlisted", quiet: true });
+            published += 1;
+            pushManifest.files[pushKey] = { hash, slug: result.data.slug, path: key, pushedAt: new Date().toISOString() };
+            markPackageSynced(root, skillPackage, syncManifest, result.data.slug);
+            await writeSyncManifest(syncManifest);
+        }
+        catch (err) {
+            skipped += 1;
+            if (!opts.quiet) {
+                process.stderr.write(`[floom] skipped ${packagePath}: ${err instanceof Error ? err.message : String(err)}\n`);
+            }
+        }
+    }
+    await writePushManifest(pushManifest);
+    if (!opts.quiet && (published > 0 || updated > 0 || adopted > 0)) {
+        process.stdout.write(`${symbols.ok}  Floom push watch: ${packages.length} scanned, ${published} published, ${updated} updated, ${adopted} adopted\n`);
+    }
+    return { scanned: packages.length, published, updated, adopted, skipped };
+}
+export async function watchPush(intervalSeconds, opts) {
+    for (;;) {
+        await pushWatchOnce(opts);
+        if (opts.once)
+            return;
+        await new Promise((resolve) => setTimeout(resolve, intervalSeconds * 1000));
+        if (!opts.quiet)
+            process.stdout.write(c.dim("[floom] push watch tick\n"));
+    }
+}

package/dist/setup.js

@@ -5,27 +5,24 @@ import { createInterface } from "node:readline/promises";
 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";
 const START_MARKER = "<!-- FLOOM SETUP START -->";
 const END_MARKER = "<!-- FLOOM SETUP END -->";
 const CLI_COMMAND = "npx -y @floomhq/floom";
-const TARGETS = {
-    claude: { label: "Claude Code", filename: "CLAUDE.md" },
-    codex: { label: "Codex", filename: "AGENTS.md" },
+const INSTRUCTION_FILES = {
+    claude: { filename: "CLAUDE.md" },
+    codex: { filename: "AGENTS.md" },
 };
 function floomAgentInstructions(target) {
-    const addCommand = target === "codex"
-        ? `${CLI_COMMAND} add <slug-or-url> --target codex`
-        : `${CLI_COMMAND} add <slug-or-url> --target claude`;
-    const localSkillsDir = target === "codex" ? "~/.codex/skills" : "~/.claude/skills";
+    const addCommand = `${CLI_COMMAND} add <slug-or-url> --target ${target}`;
     return `${START_MARKER}
-## Floom Skills
+## Floom
 
-- Use Floom skills when they fit the task. Search local skills before recreating behavior from scratch.
-- Local skills live in \`${localSkillsDir}\`.
+- Before recreating agent behavior from scratch, check Floom for reusable skills.
+- Search or inspect skills with \`${CLI_COMMAND} search <query>\`, \`${CLI_COMMAND} info <slug-or-url>\`, and \`${CLI_COMMAND} list\`.
 - Add shared skills with \`${addCommand}\`; public and unlisted links do not require a Floom account.
-- Search or inspect skills with \`${CLI_COMMAND} search <query>\` and \`${CLI_COMMAND} info <slug-or-url>\`.
-- If Floom MCP is available, use it for compact skill search/status and load only the specific skill needed.
-- Do not publish, sync, or subscribe without user approval.
+- Use installed Markdown skills from the local skills folder when they match the task.
+- \`${CLI_COMMAND} sync --target ${target}\`, \`${CLI_COMMAND} watch --push --target ${target}\`, and \`@floomhq/floom-mcp-sync\` keep saved, published, and subscribed library skills current; review conflicts before relying on synced output.
 ${END_MARKER}`;
 }
 async function fileExists(path) {
@@ -55,6 +52,12 @@ function parseTargetFromFile(file) {
         return "claude";
     if (upper.endsWith("AGENTS.MD"))
         return "codex";
+    if (upper.endsWith(".MDC") || upper.includes(`${join(".cursor", "rules").toUpperCase()}`))
+        return "cursor";
+    if (upper.includes(`${join(".config", "opencode").toUpperCase()}`))
+        return "opencode";
+    if (upper.includes(`${join(".kimi", "agents").toUpperCase()}`))
+        return "kimi";
     return undefined;
 }
 async function findUp(filename) {
@@ -74,32 +77,53 @@ async function detectTarget(opts) {
     const agent = opts.target ?? (opts.file ? parseTargetFromFile(opts.file) : undefined);
     if (opts.file) {
         if (!agent) {
-            throw new FloomError("Cannot infer agent target from that file name.", "Pass `--target claude` or `--target codex`, or use CLAUDE.md / AGENTS.md.");
+            throw new FloomError("Cannot infer agent target from that file name.", "Pass `--target claude`, `--target codex`, `--target cursor`, `--target opencode`, or `--target kimi`.");
         }
         return {
             agent,
-            label: TARGETS[agent].label,
+            label: targetLabel(agent),
             path: resolve(process.cwd(), opts.file),
         };
     }
     if (agent) {
-        const existing = await findUp(TARGETS[agent].filename);
+        if (agent === "cursor") {
+            return {
+                agent,
+                label: targetLabel(agent),
+                path: join(homedir(), ".cursor", "rules", "floom.mdc"),
+            };
+        }
+        if (agent === "opencode") {
+            return {
+                agent,
+                label: targetLabel(agent),
+                path: join(homedir(), ".config", "opencode", "floom.md"),
+            };
+        }
+        if (agent === "kimi") {
+            return {
+                agent,
+                label: targetLabel(agent),
+                path: join(homedir(), ".kimi", "agents", "federico-system.md"),
+            };
+        }
+        const existing = await findUp(INSTRUCTION_FILES[agent].filename);
         return {
             agent,
-            label: TARGETS[agent].label,
-            path: existing ?? resolve(process.cwd(), TARGETS[agent].filename),
+            label: targetLabel(agent),
+            path: existing ?? resolve(process.cwd(), INSTRUCTION_FILES[agent].filename),
         };
     }
-    const claude = await findUp(TARGETS.claude.filename);
-    const codex = await findUp(TARGETS.codex.filename);
+    const claude = await findUp(INSTRUCTION_FILES.claude.filename);
+    const codex = await findUp(INSTRUCTION_FILES.codex.filename);
     if (claude && codex) {
-        throw new FloomError("Found both Claude Code and Codex instruction files.", "Pass `--target claude` or `--target codex`.");
+        throw new FloomError("Found both Claude Code and Codex instruction files.", "Pass an explicit `--target`.");
     }
     if (claude)
-        return { agent: "claude", label: TARGETS.claude.label, path: claude };
+        return { agent: "claude", label: targetLabel("claude"), path: claude };
     if (codex)
-        return { agent: "codex", label: TARGETS.codex.label, path: codex };
-    throw new FloomError("No agent instruction file found.", `Run \`${CLI_COMMAND} setup --target claude --yes\` or \`${CLI_COMMAND} setup --target codex --yes\` from the repo root.`);
+        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) {
     const action = existing === null ? "create" : "append";
@@ -115,6 +139,41 @@ function renderPreview(target, existing) {
         "",
     ].join("\n");
 }
+function renderInstructions(target, existing) {
+    const body = floomAgentInstructions(target);
+    if (target === "cursor" && existing === null) {
+        return [
+            "---",
+            "description: Use Floom skills and sync",
+            "alwaysApply: true",
+            "---",
+            "",
+            body,
+            "",
+        ].join("\n");
+    }
+    return body;
+}
+async function ensureOpencodeInstructionReference(instructionPath) {
+    const configPath = join(homedir(), ".config", "opencode", "opencode.json");
+    const reference = `{file:${instructionPath.replace(homedir(), "~")}}`;
+    let parsed = {};
+    const existing = await readIfExists(configPath);
+    if (existing) {
+        try {
+            parsed = JSON.parse(existing);
+        }
+        catch {
+            throw new FloomError("OpenCode config is not valid JSON.", configPath);
+        }
+    }
+    const current = Array.isArray(parsed.instructions) ? parsed.instructions : [];
+    if (current.includes(reference))
+        return;
+    parsed.instructions = [...current.filter((item) => typeof item === "string"), reference];
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
+}
 async function confirmWrite(target, existing) {
     if (!process.stdin.isTTY) {
         throw new FloomError("Refusing to update agent instructions without confirmation in non-interactive mode.", "Pass `--yes` to write, or `--dry-run` to preview.");
@@ -149,7 +208,7 @@ export async function setupAgent(opts) {
         }
     }
     await mkdir(dirname(target.path), { recursive: true });
-    const instructions = floomAgentInstructions(target.agent);
+    const instructions = renderInstructions(target.agent, existing);
     const next = existing === null
         ? `${instructions}\n`
         : `${existing.replace(/\s*$/, "")}\n\n${instructions}\n`;
@@ -164,6 +223,9 @@ export async function setupAgent(opts) {
     else {
         await writeFile(target.path, next, "utf8");
     }
+    if (target.agent === "opencode") {
+        await ensureOpencodeInstructionReference(target.path);
+    }
     process.stdout.write(`\n${symbols.ok}  Added Floom instructions to ${c.bold(target.path)}\n`);
     process.stdout.write(`   ${c.dim("MCP setup guidance:")} ${c.cyan(`${CLI_COMMAND} mcp`)}\n\n`);
 }

package/dist/sync-manifest.js

@@ -9,6 +9,49 @@ const LOCK_TIMEOUT_MS = 15_000;
 const LOCK_STALE_MS = 5 * 60_000;
 const SLUG_RE = /^[A-Za-z0-9_-]{1,128}$/;
 const FD_PATH_ROOT = "/proc/self/fd";
+const SUPPORT_DIRS = new Set([
+    "agents",
+    "assets",
+    "canvas-fonts",
+    "checks",
+    "codex",
+    "core",
+    "cursor",
+    "evidence",
+    "examples",
+    "helpers",
+    "kimi",
+    "opencode",
+    "reference",
+    "references",
+    "scripts",
+    "sdk",
+    "schemas",
+    "templates",
+    "tests",
+    "themes",
+]);
+const ROOT_SUPPORT_FILES = new Set([
+    ".env.example",
+    "ACKNOWLEDGEMENTS.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "LICENSE.md",
+    "LICENSE.txt",
+    "README.md",
+    "SKILL.md.tmpl",
+    "editing.md",
+    "forms.md",
+    "instructions.md",
+    "nanobanana.py",
+    "plan.md",
+    "pptxgenjs.md",
+    "reference.md",
+    "requirements.txt",
+    "skill.md",
+    "style_guidelines.md",
+    "theme-showcase.pdf",
+]);
 function emptyManifest() {
     return { version: MANIFEST_VERSION, files: {} };
 }
@@ -33,10 +76,12 @@ function isEntryForKey(key, value) {
 function isPackageFilePath(packagePath) {
     if (packagePath.length === 1 && packagePath[0] === "SKILL.md")
         return true;
+    if (packagePath.length === 1 && ROOT_SUPPORT_FILES.has(packagePath[0] ?? ""))
+        return true;
     if (packagePath.length < 2)
         return false;
     const first = packagePath[0];
-    if (first === undefined || !["references", "examples", "scripts", "assets"].includes(first))
+    if (first === undefined || !SUPPORT_DIRS.has(first))
         return false;
     return packagePath.every((segment) => segment !== "." && segment !== ".." && segment.length > 0);
 }

package/dist/sync.js

@@ -1,7 +1,6 @@
 import { constants } from "node:fs";
 import { lstat, mkdir, open } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import ora from "ora";
 import { readConfig, resolveApiUrl } from "./config.js";
@@ -10,17 +9,11 @@ import { c, symbols } from "./ui.js";
 import { FloomError } from "./errors.js";
 import { ensureSyncManifestDir, manifestKey, markSynced, readSyncManifest, unmarkSynced, withSyncLock, writeSyncManifest } from "./sync-manifest.js";
 import { normalizeRemotePackageFiles } from "./package.js";
+import { targetSkillsDir } from "./targets.js";
 const SLUG_RE = /^[A-Za-z0-9_-]{1,128}$/;
 const PATH_SEGMENT_RE = /^[a-z0-9._-]{1,128}$/;
 const MANIFEST_SEGMENT_RE = /^[A-Za-z0-9._-]{1,128}$/;
 const FD_PATH_ROOT = "/proc/self/fd";
-function skillsDir(target = "claude") {
-    if (target === "codex") {
-        const codexHome = process.env.CODEX_HOME ?? join(homedir(), ".codex");
-        return process.env.CODEX_SKILLS_DIR ?? join(codexHome, "skills");
-    }
-    return process.env.CLAUDE_SKILLS_DIR ?? join(homedir(), ".claude", "skills");
-}
 function sha256(input) {
     return createHash("sha256").update(input).digest("hex");
 }
@@ -64,7 +57,7 @@ function safePathSegments(value, label) {
 function skillPath(skill, targetAgent) {
     if (!SLUG_RE.test(skill.slug))
         throw new FloomError(`Invalid skill slug: ${skill.slug}`);
-    const root = skillsDir(targetAgent);
+    const root = targetSkillsDir(targetAgent);
     const segments = [root];
     segments.push(...safePathSegments(skill.library_slug, "library slug"));
     segments.push(...safePathSegments(skill.folder, "folder"));
@@ -79,17 +72,6 @@ function skillPath(skill, targetAgent) {
 function syncKey(skill) {
     return `${skill.library_slug ?? ""}\0${skill.folder ?? ""}\0${skill.slug}`;
 }
-function hasStructuredPath(skill) {
-    return Boolean(skill.library_slug || skill.folder);
-}
-function dedupeSyncSkills(skills) {
-    const structuredSlugs = new Set();
-    for (const skill of skills) {
-        if (hasStructuredPath(skill))
-            structuredSlugs.add(skill.slug);
-    }
-    return skills.filter((skill) => !structuredSlugs.has(skill.slug) || hasStructuredPath(skill));
-}
 function validateSyncSkillShape(skill) {
     if (!skill || typeof skill !== "object")
         throw new FloomError("Invalid sync response.");
@@ -195,8 +177,12 @@ async function planPackageSync(root, files, manifest) {
             missing += 1;
             continue;
         }
-        if (!tracked)
-            return { kind: "conflict", target: file.target, reason: "existing file is not tracked by Floom sync" };
+        if (!tracked) {
+            if (state.hash !== file.hash)
+                return { kind: "conflict", target: file.target, reason: "existing file is not tracked by Floom sync" };
+            unchanged += 1;
+            continue;
+        }
         if (state.hash !== tracked.hash)
             return { kind: "conflict", target: file.target, reason: "local file changed since the last Floom sync" };
         if (state.hash !== file.hash)
@@ -292,14 +278,14 @@ export async function sync(opts = {}) {
     }
     try {
         return await withSyncLock(async () => {
-            await mkdir(skillsDir(targetAgent), { recursive: true, mode: 0o700 });
+            await mkdir(targetSkillsDir(targetAgent), { recursive: true, mode: 0o700 });
             if (!Array.isArray(payload.skills)) {
                 throw new FloomError("Invalid sync response.");
             }
             for (const skill of payload.skills)
                 validateSyncSkillShape(skill);
-            // Version 1 syncs published, saved, and subscribed library skills.
-            const all = dedupeSyncSkills(payload.skills);
+            // Version 1 preview syncs published, saved, and subscribed library skills.
+            const all = payload.skills;
             const seen = new Set();
             let unchanged = 0;
             let updated = 0;
@@ -307,7 +293,7 @@ export async function sync(opts = {}) {
             let conflicts = 0;
             const conflictNotes = [];
             const manifest = await readSyncManifest();
-            const root = skillsDir(targetAgent);
+            const root = targetSkillsDir(targetAgent);
             const activeTargetKeys = new Set();
             const pruneBlockedSlugs = new Set();
             let manifestChanged = false;
@@ -354,6 +340,9 @@ export async function sync(opts = {}) {
                         continue;
                     }
                     if (plan.kind === "unchanged") {
+                        for (const file of packageFiles)
+                            markSynced(manifest, manifestKey(root, file.target), skill.slug, file.hash);
+                        await writeSyncManifest(manifest);
                         unchanged += 1;
                         continue;
                     }

package/dist/targets.js

@@ -1,16 +1,49 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
-export function resolveSkillsDir(target) {
-    if (process.env.FLOOM_SKILLS_DIR)
-        return process.env.FLOOM_SKILLS_DIR;
-    if (target === "codex") {
-        const codexHome = process.env.CODEX_HOME ?? join(homedir(), ".codex");
-        return process.env.CODEX_SKILLS_DIR ?? join(codexHome, "skills");
-    }
-    return process.env.CLAUDE_SKILLS_DIR ?? join(homedir(), ".claude", "skills");
+export const AGENT_TARGETS = ["claude", "codex", "cursor", "opencode", "kimi"];
+const TARGETS = {
+    claude: {
+        label: "Claude Code",
+        skillsDirEnv: "CLAUDE_SKILLS_DIR",
+        defaultSkillsDir: () => join(homedir(), ".claude", "skills"),
+    },
+    codex: {
+        label: "Codex",
+        skillsDirEnv: "CODEX_SKILLS_DIR",
+        defaultSkillsDir: () => join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "skills"),
+    },
+    cursor: {
+        label: "Cursor",
+        skillsDirEnv: "CURSOR_SKILLS_DIR",
+        defaultSkillsDir: () => join(homedir(), ".cursor", "skills-cursor"),
+    },
+    opencode: {
+        label: "OpenCode",
+        skillsDirEnv: "OPENCODE_SKILLS_DIR",
+        defaultSkillsDir: () => join(homedir(), ".config", "opencode", "skills"),
+    },
+    kimi: {
+        label: "Kimi",
+        skillsDirEnv: "KIMI_SKILLS_DIR",
+        defaultSkillsDir: () => join(homedir(), ".kimi", "skills"),
+    },
+};
+export const TARGET_HINT = AGENT_TARGETS.join("|");
+export function isAgentTarget(value) {
+    return AGENT_TARGETS.includes(value);
 }
-export function skillsDirHint(target) {
-    if (process.env.FLOOM_SKILLS_DIR)
-        return "FLOOM_SKILLS_DIR";
-    return target === "codex" ? "CODEX_SKILLS_DIR" : "CLAUDE_SKILLS_DIR";
+export function parseAgentTarget(value) {
+    if (isAgentTarget(value))
+        return value;
+    throw new Error(`Invalid agent target: ${value}`);
+}
+export function targetLabel(target) {
+    return TARGETS[target].label;
+}
+export function targetSkillsDir(target) {
+    const info = TARGETS[target];
+    return process.env[info.skillsDirEnv] ?? info.defaultSkillsDir();
+}
+export function targetSkillsDirEnv(target) {
+    return TARGETS[target].skillsDirEnv;
 }

package/package.json

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