@genspark/cli 1.0.24 → 1.0.25

package/dist/commands/skills-sync.js

@@ -0,0 +1,329 @@
+/**
+ * `gsk skills sync` — client-side materializer for the backend `skills_sync`
+ * action.
+ *
+ * Why client-side: `skills_sync` returns a digest-diffed bundle (base64 file
+ * bytes for changed skills, a removal list, per-slug errors); this module
+ * applies one such response to disk. Deliberately NOT parity with
+ * `setup.sh` (which unconditionally `rm -rf`s then `ln -sfn`s over the mount
+ * path — the synced skill always wins): here a pre-existing REAL directory
+ * under `mountDir` (an inline-tar builtin, or user content) is never
+ * clobbered by a same-named synced skill; the real dir wins and the slug is
+ * reported failed instead. Chosen because this materializer runs on a
+ * user's laptop, not a disposable sandbox — never `rm -rf`ing directories we
+ * didn't create is worth a failed sync entry. Index.ts (Task 6) drives the
+ * poll-until-`complete` loop and owns `--check`; this module only ever
+ * applies (never diffs) a response.
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { error as logError } from '../logger.js';
+import { safeJoin, SLUG_RE } from './skills-pull.js';
+/**
+ * Folds the per-batch results of the multi-batch sync loop into single deduped
+ * totals. A slug can recur across batches — a server `error` row carries no
+ * recordable sha, so the server re-emits it in EVERY batch — and concatenating
+ * per-batch arrays would multi-count it, making the summary counts and the
+ * exit-4 gate wrong. Each category is a Set (dedup by slug); a slug's outcome
+ * in a later batch supersedes an earlier one. It also aggregates the echoed
+ * skill rows so `-o json` reflects every batch, not just the final one.
+ *
+ * Generic over the echoed-row type so the CLI can pass its own row shape
+ * without a cast (only `slug` is required here).
+ */
+export class SyncAggregator {
+    _applied = new Set();
+    _removed = new Set();
+    _failed = new Set();
+    _rows = new Map();
+    /** Fold one batch's apply result and its echoed skill rows into the totals. */
+    add(result, rows) {
+        for (const slug of result.applied)
+            this.categorize(slug, this._applied);
+        for (const slug of result.removed)
+            this.categorize(slug, this._removed);
+        for (const slug of result.failed)
+            this.categorize(slug, this._failed);
+        for (const row of rows)
+            this._rows.set(row.slug, row);
+    }
+    categorize(slug, into) {
+        this._applied.delete(slug);
+        this._removed.delete(slug);
+        this._failed.delete(slug);
+        into.add(slug);
+    }
+    get appliedCount() {
+        return this._applied.size;
+    }
+    get removedCount() {
+        return this._removed.size;
+    }
+    get failedCount() {
+        return this._failed.size;
+    }
+    /** Aggregated echoed rows (deduped by slug, last-wins). */
+    get skills() {
+        return Array.from(this._rows.values());
+    }
+}
+export const STATE_FILENAME = 'skills-sync-state.json';
+function expandHome(p) {
+    return p.replace(/^~(?=\/|$)/, os.homedir());
+}
+export function defaultStoreDir() {
+    return expandHome('~/.gsk/skills-store');
+}
+export function defaultMountDir() {
+    return expandHome('~/.opencode/skills');
+}
+/** Load the persisted `{slug: sha}` digest map. Both unparseable JSON AND a
+ * valid-JSON-but-wrong-shape file self-heal to `{}` — a dirty state file
+ * forces a full re-diff on the next sync rather than risk skipping a change
+ * against a state we can't trust. The shape check matters because the server
+ * verb rejects the WHOLE sync (`bad state digest map`) on a single bad key,
+ * so without validating here a corrupt map would wedge every sync forever;
+ * resetting to `{}` lets it recover on the next run. */
+export function loadState(storeDir) {
+    try {
+        const raw = fs.readFileSync(path.join(storeDir, STATE_FILENAME), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            const obj = parsed;
+            const wellShaped = Object.entries(obj).every(([k, v]) => SLUG_RE.test(k) && typeof v === 'string');
+            if (wellShaped)
+                return obj;
+        }
+    }
+    catch {
+        // absent or unparseable → treated as empty state
+    }
+    return {};
+}
+/** True when `<slug>`'s files are downloaded on disk. The STORE dir is the
+ * single source of truth for "materialized" — NOT the mount symlink. The mount
+ * is a best-effort, separately-reconciled concern (see `reconcileMount`): on a
+ * filesystem that can't hold a symlink (Windows without Developer Mode,
+ * exFAT/FAT/SMB — `symlinkSync` throws EPERM/ENOSYS) the mount is never created,
+ * yet the store IS. Keying materialization on the mount would then read the
+ * slug as "not materialized" on every `unchanged` re-sync, drop its sha, and
+ * re-download the whole store forever. `writeSlugAtomic` renames the tree into
+ * place in one step, so a present store dir is a complete one. A hand-deleted
+ * store dir (store missing) still reads false → the caller drops the sha and
+ * the next sync re-fetches (the F3 self-heal). */
+function isSlugMaterialized(storeDir, slug) {
+    return fs.existsSync(path.join(storeDir, slug));
+}
+/** Best-effort reconcile of the mount symlink for an already-stored slug, run
+ * every sync (never touches the store, so it can't trigger a re-download):
+ *   - `'mounted'`     — the symlink now points at (or already pointed at) the
+ *     live store dir.
+ *   - `'blocked'`     — a REAL dir/file occupies the mount path; the builtin /
+ *     user content wins and we never clobber it (the module's core deviation
+ *     from setup.sh). A benign, terminal state — not retried into a symlink.
+ *   - `'unsupported'` — `symlinkSync` threw (filesystem can't hold a symlink),
+ *     or the mount path can't be stat'd (a non-ENOENT fault). The store is
+ *     intact; the caller keeps the sha but reports the slug not-mounted.
+ * The whole body is guarded: the initial `lstatSync` can itself throw a
+ * non-ENOENT error (e.g. ENOTDIR when `mountDir` is a file), which must be
+ * caught here rather than escape the batch before `saveState`. */
+function reconcileMount(storeDir, mountDir, slug) {
+    const linkPath = path.join(mountDir, slug);
+    const targetPath = path.join(storeDir, slug);
+    try {
+        const stat = fs.lstatSync(linkPath, { throwIfNoEntry: false });
+        if (stat && !stat.isSymbolicLink())
+            return 'blocked';
+        if (stat &&
+            path.resolve(mountDir, fs.readlinkSync(linkPath)) === targetPath) {
+            return 'mounted'; // already our symlink → no churn
+        }
+        fs.mkdirSync(mountDir, { recursive: true });
+        if (stat)
+            fs.unlinkSync(linkPath); // stale / foreign symlink → repoint
+        fs.symlinkSync(targetPath, linkPath, 'dir');
+        return 'mounted';
+    }
+    catch {
+        return 'unsupported';
+    }
+}
+/** Human-facing reason a stored slug isn't mounted, per `reconcileMount`. */
+function mountFailureMessage(slug, result) {
+    const why = result === 'blocked'
+        ? 'a real directory occupies the mount path (builtin/user content wins)'
+        : 'the filesystem does not support symlinks (Windows without Developer Mode, exFAT/FAT/SMB)';
+    return `skills sync: ${slug} stored but not mounted — ${why}`;
+}
+/** Sweep orphan `.tmp-<slug>-<pid>` staging dirs left by a killed run. Each
+ * `writeSlugAtomic` only clears its OWN pid's tmp dir, so a process killed
+ * mid-write leaks one; this best-effort sweep runs once per apply. Guarded to
+ * the exact tmp-dir shape so it can never touch a real skill dir. */
+function sweepStaleTmpDirs(storeDir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(storeDir);
+    }
+    catch {
+        return;
+    }
+    const tmpRe = /^\.tmp-[A-Za-z0-9][A-Za-z0-9_-]*-\d+$/;
+    for (const name of entries) {
+        if (!tmpRe.test(name))
+            continue;
+        try {
+            fs.rmSync(path.join(storeDir, name), { recursive: true, force: true });
+        }
+        catch {
+            // best-effort — a concurrent writer or locked dir just stays
+        }
+    }
+}
+function saveState(storeDir, state) {
+    fs.mkdirSync(storeDir, { recursive: true });
+    fs.writeFileSync(path.join(storeDir, STATE_FILENAME), JSON.stringify(state, null, 2) + '\n');
+}
+/**
+ * Write one `update` entry's files into `<storeDir>/<slug>` atomically: build
+ * the tree in a sibling `.tmp-` dir first, then remove any existing target
+ * and `renameSync` the tmp dir over it. A crash or crafted traversal path
+ * partway through the write leaves the tmp dir orphaned but the previous
+ * (or absent) target untouched — never a half-written skill on disk.
+ */
+function writeSlugAtomic(storeDir, slug, files) {
+    const tmpDir = path.join(storeDir, `.tmp-${slug}-${process.pid}`);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs.mkdirSync(tmpDir, { recursive: true });
+    try {
+        for (const file of files) {
+            const target = safeJoin(tmpDir, file.path);
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            fs.writeFileSync(target, Buffer.from(file.content_base64, 'base64'));
+        }
+        const finalDir = path.join(storeDir, slug);
+        fs.rmSync(finalDir, { recursive: true, force: true });
+        fs.renameSync(tmpDir, finalDir);
+    }
+    catch (e) {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        throw e;
+    }
+}
+/** Remove a slug's store dir and mount symlink. Only unlinks the symlink
+ * when it actually points into `storeDir` — a repointed or foreign symlink
+ * (or a real directory) is left alone rather than risk deleting user data. */
+function removeSlug(storeDir, mountDir, slug) {
+    const linkPath = path.join(mountDir, slug);
+    const stat = fs.lstatSync(linkPath, { throwIfNoEntry: false });
+    if (stat?.isSymbolicLink()) {
+        const resolved = path.resolve(mountDir, fs.readlinkSync(linkPath));
+        const storeSlugDir = path.join(storeDir, slug);
+        if (resolved === storeSlugDir) {
+            fs.unlinkSync(linkPath);
+        }
+    }
+    fs.rmSync(path.join(storeDir, slug), { recursive: true, force: true });
+}
+/**
+ * Apply one `skills_sync` response to disk. Never called in `--check` mode
+ * (Task 6's caller diffs against `loadState` output itself for that path).
+ */
+export function applySyncResponse(data, opts = {}) {
+    // Absolutize (mirrors resolvePullDest in skills-pull.ts): a relative
+    // storeDir/mountDir would otherwise reach safeJoin's containment check as
+    // a relative `dest` while its computed `target` is always absolute
+    // (path.resolve), so `target.startsWith(dest + sep)` could never match
+    // and every `update` entry would be rejected as an unsafe path.
+    const storeDir = path.resolve(expandHome(opts.storeDir ?? defaultStoreDir()));
+    const mountDir = path.resolve(expandHome(opts.mountDir ?? defaultMountDir()));
+    fs.mkdirSync(storeDir, { recursive: true });
+    sweepStaleTmpDirs(storeDir);
+    const state = loadState(storeDir);
+    const applied = [];
+    const removed = [];
+    const failed = [];
+    for (const entry of data.skills) {
+        if (!SLUG_RE.test(entry.slug)) {
+            failed.push(entry.slug);
+            continue;
+        }
+        if (entry.action === 'update') {
+            try {
+                writeSlugAtomic(storeDir, entry.slug, entry.files ?? []);
+            }
+            catch (e) {
+                logError(`skills sync: ${entry.slug} failed: ${e instanceof Error ? e.message : String(e)}`);
+                failed.push(entry.slug);
+                continue;
+            }
+            // Record the synced sha the moment the STORE write succeeds — the content
+            // is materialized and sha-addressed regardless of whether the mount step
+            // then succeeds. The mount is reconciled separately (best-effort); its
+            // failure must never drop the sha, or the server would re-send this slug
+            // every sync (on a symlink-unsupported filesystem that re-downloads
+            // everything each run, and a large re-sent skill sorting early could
+            // starve later slugs out of the byte budget until the batch guard bailed).
+            if (entry.sha)
+                state[entry.slug] = entry.sha;
+            const mount = reconcileMount(storeDir, mountDir, entry.slug);
+            if (mount === 'mounted') {
+                applied.push(entry.slug);
+            }
+            else {
+                // Store is materialized and the sha recorded (no re-download); only the
+                // mount could not be made. Surface it once for this content change.
+                logError(mountFailureMessage(entry.slug, mount));
+                failed.push(entry.slug);
+            }
+        }
+        else if (entry.action === 'unchanged') {
+            // The server said "unchanged" only because our digest matched — but the
+            // store may be gone from disk (dir hand-deleted, or a state file restored
+            // from backup without its store). Trust the STORE, not the state file:
+            // carry the sha forward only when the store dir is present; otherwise DROP
+            // it so the next sync sees a digest miss and re-fetches (self-heal). The
+            // mount symlink is NOT part of this decision — see isSlugMaterialized.
+            if (entry.sha && isSlugMaterialized(storeDir, entry.slug)) {
+                state[entry.slug] = entry.sha;
+                // Retry the mount every sync (a transient/absent mount can recover),
+                // but never let it drop the sha or re-download. A real dir winning the
+                // mount ('blocked') is benign and self-heals to exit 0; a
+                // symlink-unsupported filesystem ('unsupported') keeps the slug failed
+                // (persistent exit 4 — the store is downloaded but can't be mounted).
+                if (reconcileMount(storeDir, mountDir, entry.slug) === 'unsupported') {
+                    logError(mountFailureMessage(entry.slug, 'unsupported'));
+                    failed.push(entry.slug);
+                }
+            }
+            else {
+                delete state[entry.slug];
+            }
+        }
+        else if (entry.action === 'removed') {
+            try {
+                removeSlug(storeDir, mountDir, entry.slug);
+                delete state[entry.slug];
+                removed.push(entry.slug);
+            }
+            catch (e) {
+                // Keep the state entry so the next sync retries this removal —
+                // a failed delete here (e.g. a locked store dir) must not be
+                // reported as done, and the batch's already-applied updates
+                // still need saveState() below to land.
+                logError(`skills sync: ${entry.slug} failed: ${e instanceof Error ? e.message : String(e)}`);
+                failed.push(entry.slug);
+            }
+        }
+        else if (entry.action === 'error') {
+            // Surface the server's per-slug code (NOT_FOUND / TOO_LARGE) like the
+            // update/removed branches log their failures — otherwise a server-side
+            // sync error was silently swallowed into the failed count with no reason.
+            logError(`skills sync: ${entry.slug} failed${entry.code ? ` (${entry.code})` : ''}`);
+            failed.push(entry.slug);
+        }
+    }
+    saveState(storeDir, state);
+    return { state, applied, removed, failed };
+}
+//# sourceMappingURL=skills-sync.js.map

package/dist/commands/skills-sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills-sync.js","sourceRoot":"","sources":["../../src/commands/skills-sync.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -22,6 +22,7 @@ import { Command } from 'commander';
 import * as fs from 'fs';
 import * as http from 'http';
 import * as https from 'https';
+import * as os from 'os';
 import * as pathModule from 'path';
 import { createRequire } from 'module';
 import { spawn } from 'child_process';
@@ -30,7 +31,7 @@ import { setDebugEnabled, setOutputFormat, debug, info, error as logError, outpu
 import { loadConfigFile, saveConfigFile, getConfigPath, loadToolsCache, saveToolsCache, setConfigPathOverride, } from './config.js';
 import { checkForUpdates } from './updater.js';
 import { registerDesignCommand } from './commands/design.js';
-import { registerMeshCommand, getMeshInvocation, runMesh } from './commands/mesh.js';
+import { registerMeshCommand, getMeshInvocation, runMesh, } from './commands/mesh.js';
 import { executeCloneUrl, normalizeCloneUrlForGit, } from './commands/sb-git-clone.js';
 const require = createRequire(import.meta.url);
 const { version: VERSION } = require('../package.json');
@@ -74,6 +75,12 @@ const program = new Command();
 program
     .name('gsk')
     .description('Genspark Tool CLI - Search, crawl, analyze, and generate media')
+    // Agents drive this CLI blind (no schema in context): on a bad invocation,
+    // print the full usage + a did-you-mean hint so the caller can self-correct
+    // on the next attempt instead of burning a round on `--help`. Subcommands
+    // inherit both settings via Commander's copyInheritedSettings.
+    .showHelpAfterError()
+    .showSuggestionAfterError()
     .version(VERSION, '-v, --version')
     .option('--api-key <key>', 'API key (or set GSK_API_KEY env var)')
     .option('--base-url <url>', `Base URL for API (default: ${DEFAULT_BASE_URL})`, DEFAULT_BASE_URL)
@@ -451,6 +458,16 @@ function extractFileUrl(data, keys) {
 function resolveVdProjectId() {
     return process.env.GSK_VD_PROJECT_ID || fileConfig.vd_project_id;
 }
+/**
+ * Expand a leading `~` to the user's home directory. `skills-sync.ts`
+ * applies this same expansion internally on the paths it defaults to, but
+ * a user-supplied `--store-dir`/`--mount-dir` needs it applied here too —
+ * `loadState()` is called from this file before the sync response comes
+ * back, and it does no expansion of its own.
+ */
+function expandHome(p) {
+    return p.replace(/^~(?=\/|$)/, os.homedir());
+}
 /**
  * Register a dynamic tool command from a server-provided schema.
  *
@@ -506,8 +523,15 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
         if (name === tool.cli.primary_arg)
             continue;
         // For create_task, make params optional so --acp mode works without them.
-        // Validation of required params happens in the action handler.
-        const isRequired = tool.name === 'create_task' ? false : required.includes(name);
+        // Validation of required params happens in the action handler. Likewise
+        // skills_save's `files` is server-required but CLI-populated (from the
+        // [path] directory collector, never typed by hand) — a Commander
+        // requiredOption would block every invocation before the action handler
+        // (and its collector) ever runs.
+        const isRequired = tool.name === 'create_task' ||
+            (tool.name === 'skills_save' && name === 'files')
+            ? false
+            : required.includes(name);
         const paramType = Array.isArray(param.type) ? param.type[0] : param.type;
         // Single-char aliases are short flags (-n); multi-char aliases must be
         // long flags (--page) — commander treats `-page` as a literal short flag,
@@ -594,6 +618,27 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
     if (tool.name === 'sb-git') {
         cmd.option('--execute [dest]', 'For action=clone-url: run `git clone` locally to [dest] (default: ./<repo>) instead of just printing the snippet');
     }
+    // For skills pull: `--out [dir]` writes the returned skill files to disk.
+    // Client-side because an HTTP/JSON tool can't materialise a tree on the
+    // user's machine — same shape as sb-git's `--execute`. Default dest is
+    // ./<slug>. The option is CLI-only and is stripped before the API call.
+    if (tool.name === 'skills_pull') {
+        cmd.option('--out [dir]', 'Directory to write the skill files into (default: ./<slug>)');
+    }
+    // For skills sync: the digest-diff materializer loop lives entirely on
+    // the client (Task 5's skills-sync.ts), so these are CLI-only knobs —
+    // stripped before the API call, never forwarded to the server.
+    if (tool.name === 'skills_sync') {
+        cmd.option('--check', 'report differences without writing');
+        cmd.option('--mount-dir <dir>', 'symlink mount directory (default ~/.opencode/skills)');
+        cmd.option('--store-dir <dir>', 'content store directory (default ~/.gsk/skills-store)');
+    }
+    // For skills save: the server's `files` param is an inline array with no
+    // `primary_arg`, so add our own positional for the local directory to
+    // read — same shape as `skills pull <ref> --out <dir>` in reverse.
+    if (tool.name === 'skills_save') {
+        cmd.argument('[path]', 'Local skill directory to save (default: current directory)');
+    }
     // Generic action handler
     cmd.action(async (primaryArgValue, opts) => {
         // Commander passes opts as second arg when there's an argument,
@@ -738,6 +783,56 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
                 }
                 delete args.execute;
             }
+            // skills pull --out is client-side only; never forward. `pull` always
+            // materialises to disk (default ./<slug>); --out just overrides where.
+            let skillsPullOut;
+            if (tool.name === 'skills_pull') {
+                const outVal = args.out;
+                skillsPullOut =
+                    typeof outVal === 'string' && outVal.length > 0 ? outVal : undefined;
+                delete args.out;
+            }
+            // skills sync: --check/--mount-dir/--store-dir are CLI-only. The
+            // digest `state` sent to the server is always computed here (from
+            // the on-disk state file the materializer loop owns), never
+            // accepted as user input.
+            let skillsSyncCheck = false;
+            let skillsSyncStoreDir = '';
+            let skillsSyncMountDir = '';
+            if (tool.name === 'skills_sync') {
+                const { loadState, defaultStoreDir, defaultMountDir } = await import('./commands/skills-sync.js');
+                skillsSyncCheck = !!args.check;
+                skillsSyncStoreDir = args.storeDir
+                    ? expandHome(args.storeDir)
+                    : defaultStoreDir();
+                skillsSyncMountDir = args.mountDir
+                    ? expandHome(args.mountDir)
+                    : defaultMountDir();
+                delete args.check;
+                delete args.storeDir;
+                delete args.mountDir;
+                args.state = JSON.stringify(loadState(skillsSyncStoreDir));
+            }
+            // skills save: read the local directory (default cwd) and ship its
+            // files inline — the inverse of `skills pull`. Client-side because
+            // only the local machine can walk a directory tree.
+            if (tool.name === 'skills_save') {
+                const { collectSkillDir } = await import('./commands/skills-save.js');
+                const dir = pathModule.resolve(primaryArgValue || '.');
+                let collected;
+                try {
+                    collected = collectSkillDir(dir);
+                }
+                catch (e) {
+                    logError(`skills save: ${e.message}`);
+                    process.exit(1);
+                }
+                if (collected.sidecarOwner) {
+                    info(`Warning: ${dir} carries provenance for ${collected.sidecarOwner} — ` +
+                        `saving will fork this skill into your own catalog.`);
+                }
+                args.files = collected.files;
+            }
             // aidrive: handle --local_file for the upload action.
             // Stream the file directly to AI Drive via the dedicated tool_cli
             // endpoint (POST /api/tool_cli/aidrive/upload) — no blob middleman.
@@ -809,7 +904,7 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
                     const after = normalizeCloneUrlForGit(before);
                     data.url = after;
                     if (Array.isArray(data.commands)) {
-                        data.commands = data.commands.map((cmd) => typeof cmd === 'string' ? cmd.replace(before, after) : cmd);
+                        data.commands = data.commands.map(cmd => typeof cmd === 'string' ? cmd.replace(before, after) : cmd);
                     }
                 }
             }
@@ -833,6 +928,96 @@ function registerToolCommand(parentProgram, tool, clientFactory, vdProjectIdDefa
                     process.exit(code);
                 return;
             }
+            // skills pull: decode the returned file rows + write the skill tree to
+            // disk (default ./<slug>, or --out <dir>). Client-side because the
+            // backend returns JSON, not a filesystem. Pull always materialises;
+            // the base64 blobs are dropped from the echoed result below.
+            if (tool.name === 'skills_pull' &&
+                result.status === 'ok' &&
+                result.data &&
+                typeof result.data === 'object') {
+                const { writeSkillFiles } = await import('./commands/skills-pull.js');
+                const code = writeSkillFiles(result.data, skillsPullOut);
+                if (code !== 0)
+                    process.exit(code);
+                // Drop the (large, base64) file blobs from the echoed result — the
+                // user asked to write to disk, not to dump bytes to stdout.
+                const data = result.data;
+                delete data.files;
+                output(result);
+                return;
+            }
+            // skills sync: `--check` reports a diff without writing. Otherwise
+            // materialize the response via applySyncResponse (Task 5), looping
+            // while the server signals a truncated bundle (`complete: false`) —
+            // only the local machine holds the digest state across calls and
+            // can write the resulting file tree / symlinks.
+            if (tool.name === 'skills_sync' &&
+                result.status === 'ok' &&
+                result.data &&
+                typeof result.data === 'object') {
+                if (skillsSyncCheck) {
+                    const data = result.data;
+                    for (const entry of data.skills) {
+                        const suffix = entry.code ? ` (${entry.code})` : '';
+                        info(`${entry.slug}: ${entry.action}${suffix}`);
+                    }
+                    const dirty = data.skills.some(entry => entry.action !== 'unchanged');
+                    for (const entry of data.skills)
+                        delete entry.files;
+                    output(result);
+                    if (dirty)
+                        process.exit(3);
+                    return;
+                }
+                const { applySyncResponse, SyncAggregator } = await import('./commands/skills-sync.js');
+                const syncOpts = {
+                    storeDir: skillsSyncStoreDir,
+                    mountDir: skillsSyncMountDir,
+                };
+                let current = result;
+                // Fold every batch's outcome into deduped totals (see SyncAggregator):
+                // a server `error` row re-appears each batch, so concatenating would
+                // multi-count it and the summary + exit code would lie.
+                const agg = new SyncAggregator();
+                let iterations = 0;
+                for (;;) {
+                    const data = current.data;
+                    const applyResult = applySyncResponse(data, syncOpts);
+                    agg.add(applyResult, current.data.skills);
+                    if (data.complete !== false)
+                        break;
+                    iterations += 1;
+                    if (iterations >= 20) {
+                        logError('skills sync: exceeded 20 batches without completing — aborting');
+                        process.exit(1);
+                    }
+                    current = await client.executeTool('skills_sync', {
+                        state: JSON.stringify(applyResult.state),
+                    });
+                    if (current.status !== 'ok' || !current.data) {
+                        logError(`skills sync: batch ${iterations} failed — ${current.message}`);
+                        process.exit(1);
+                    }
+                }
+                info(`synced ${agg.appliedCount} updated / ${agg.removedCount} removed / ${agg.failedCount} failed`);
+                // Emit the aggregated (all-batch, deduped) skill rows rather than only
+                // the final batch's, stripping the base64 file blobs first.
+                const aggregatedSkills = agg.skills;
+                for (const entry of aggregatedSkills)
+                    delete entry.files;
+                current.data.skills = aggregatedSkills;
+                output(current);
+                // A boot script runs `sync` every startup and keys off the exit
+                // code; a per-slug failure (mount refused, write error, server
+                // `error` row) must not read as success. Exit 4 (distinct from 3 =
+                // `--check` found a diff, and 1 = the sync loop itself aborted) so
+                // the caller can tell "some skills didn't materialize" from a clean
+                // run. Exit 0 stays reserved for fully-clean.
+                if (agg.failedCount > 0)
+                    process.exit(4);
+                return;
+            }
             // If -o was specified and tool succeeded, download the output file.
             // Skip for create_task — it has its own export logic below.
             if (tool.name !== 'create_task' &&