@sweny-ai/core 0.1.66 → 0.1.67

package/dist/cli/__tests__/upgrade.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/__tests__/upgrade.test.js

@@ -0,0 +1,306 @@
+import { describe, it, expect, vi } from "vitest";
+import { compareVersions, detectPackageManager, resolveInstallRoot, installCommandFor, runUpgrade, fetchLatestFromNpm, } from "../upgrade.js";
+// In-memory writable stream for pure assertions on output. Cheaper and
+// simpler than a real Node stream and identical to the helper used by
+// diagram.test.ts — keeps test utilities consistent across the cli/ dir.
+function captureStream() {
+    const chunks = [];
+    const stream = {
+        write: (chunk) => {
+            chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+            return true;
+        },
+    };
+    return {
+        stream,
+        get text() {
+            return chunks.join("");
+        },
+    };
+}
+/**
+ * Build an UpgradeDeps object with sensible defaults. Tests override only
+ * the bits relevant to the behavior they're asserting — keeps each case
+ * focused on its condition rather than plumbing.
+ */
+function makeDeps(over = {}) {
+    const stdout = captureStream();
+    const stderr = captureStream();
+    const exit = vi.fn();
+    const runInstall = vi.fn(() => 0);
+    const deps = {
+        currentVersion: "0.1.65",
+        installPath: "/Users/x/.nvm/versions/node/v22/lib/node_modules/@sweny-ai/core/dist/cli/main.js",
+        fetchLatestVersion: vi.fn(async () => "0.1.66"),
+        runInstall,
+        canWrite: () => true,
+        stdout: stdout.stream,
+        stderr: stderr.stream,
+        exit,
+        ...over,
+    };
+    return { deps, stdout, stderr, exit, runInstall };
+}
+describe("compareVersions", () => {
+    it("ranks by numeric core segments", () => {
+        expect(compareVersions("0.1.10", "0.1.9")).toBeGreaterThan(0);
+        expect(compareVersions("0.1.9", "0.1.10")).toBeLessThan(0);
+        expect(compareVersions("1.0.0", "0.9.999")).toBeGreaterThan(0);
+        expect(compareVersions("0.1.65", "0.1.65")).toBe(0);
+    });
+    it("handles missing segments as zero", () => {
+        expect(compareVersions("1", "1.0.0")).toBe(0);
+        expect(compareVersions("1.0", "1.0.1")).toBeLessThan(0);
+    });
+    it("ranks pre-releases below their release", () => {
+        expect(compareVersions("1.0.0-alpha.1", "1.0.0")).toBeLessThan(0);
+        expect(compareVersions("1.0.0", "1.0.0-beta.3")).toBeGreaterThan(0);
+        expect(compareVersions("1.0.0-alpha", "1.0.0-beta")).toBeLessThan(0);
+    });
+    it("treats non-numeric core segments as zero (defensive)", () => {
+        // Malformed numeric segments shouldn't throw or return NaN — they
+        // collapse to 0 so the comparison still returns a deterministic ordering.
+        expect(compareVersions("1.x.0", "1.0.0")).toBe(0);
+        expect(compareVersions("1.0.y", "1.0.0")).toBe(0);
+    });
+});
+describe("detectPackageManager", () => {
+    it("detects npm from nvm-style layout", () => {
+        expect(detectPackageManager("/Users/x/.nvm/versions/node/v22.22.0/lib/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("npm");
+    });
+    it("detects npm from fnm / asdf / vanilla Node paths", () => {
+        expect(detectPackageManager("/usr/lib/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("npm");
+        expect(detectPackageManager("/home/x/.fnm/node-versions/v22/installation/lib/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("npm");
+    });
+    it("detects pnpm global installs", () => {
+        expect(detectPackageManager("/Users/x/.local/share/pnpm/global/5/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("pnpm");
+        expect(detectPackageManager("/Users/x/Library/pnpm-global/5/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("pnpm");
+    });
+    it("detects homebrew", () => {
+        expect(detectPackageManager("/opt/homebrew/Cellar/sweny/0.1.65/libexec/bin/sweny")).toBe("brew");
+        expect(detectPackageManager("/usr/local/Cellar/sweny/0.1.65/libexec/bin/sweny")).toBe("brew");
+    });
+    it("detects volta-managed installs", () => {
+        expect(detectPackageManager("/Users/x/.volta/tools/image/packages/@sweny-ai/core/bin/sweny")).toBe("volta");
+    });
+    it("detects bun global installs", () => {
+        expect(detectPackageManager("/Users/x/.bun/install/global/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("bun");
+    });
+    it("detects yarn global", () => {
+        expect(detectPackageManager("/Users/x/.yarn/global/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("yarn");
+    });
+    it("normalizes Windows paths (forward-slash rules)", () => {
+        const win = "C:\\Users\\x\\AppData\\Roaming\\npm\\node_modules\\@sweny-ai\\core\\dist\\cli\\main.js";
+        expect(detectPackageManager(win)).toBe("npm");
+    });
+    it("returns 'unknown' for paths that don't look like a package-manager install", () => {
+        expect(detectPackageManager("/tmp/some-random-path/main.js")).toBe("unknown");
+    });
+});
+describe("resolveInstallRoot", () => {
+    it("returns the prefix above node_modules for a typical npm layout", () => {
+        const p = "/Users/x/.nvm/versions/node/v22/lib/node_modules/@sweny-ai/core/dist/cli/main.js";
+        expect(resolveInstallRoot(p)).toBe("/Users/x/.nvm/versions/node/v22/lib");
+    });
+    it("returns null when @sweny-ai is not in the parent chain", () => {
+        expect(resolveInstallRoot("/tmp/random/main.js")).toBeNull();
+    });
+});
+describe("installCommandFor", () => {
+    it("emits the correct CLI invocation per package manager", () => {
+        expect(installCommandFor("npm", "latest")).toEqual({
+            cmd: "npm",
+            args: ["install", "-g", "@sweny-ai/core@latest"],
+        });
+        expect(installCommandFor("pnpm", "latest")).toEqual({ cmd: "pnpm", args: ["add", "-g", "@sweny-ai/core@latest"] });
+        expect(installCommandFor("yarn", "latest")).toEqual({
+            cmd: "yarn",
+            args: ["global", "add", "@sweny-ai/core@latest"],
+        });
+        expect(installCommandFor("bun", "latest")).toEqual({ cmd: "bun", args: ["add", "-g", "@sweny-ai/core@latest"] });
+        expect(installCommandFor("volta", "latest")).toEqual({ cmd: "volta", args: ["install", "@sweny-ai/core@latest"] });
+    });
+    it("passes through non-default tags", () => {
+        expect(installCommandFor("npm", "beta")).toEqual({ cmd: "npm", args: ["install", "-g", "@sweny-ai/core@beta"] });
+    });
+    it("returns null for brew / unknown (can't drive automatically)", () => {
+        expect(installCommandFor("brew", "latest")).toBeNull();
+        expect(installCommandFor("unknown", "latest")).toBeNull();
+    });
+});
+describe("runUpgrade — no-op paths", () => {
+    it("reports already-latest and exits 0", async () => {
+        const { deps, stdout, exit, runInstall } = makeDeps({
+            currentVersion: "0.1.66",
+            fetchLatestVersion: vi.fn(async () => "0.1.66"),
+        });
+        await runUpgrade({}, deps);
+        expect(stdout.text).toMatch(/already the latest/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+    it("reports when running ahead of the registry (local build) and exits 0", async () => {
+        const { deps, stdout, exit, runInstall } = makeDeps({
+            currentVersion: "0.2.0",
+            fetchLatestVersion: vi.fn(async () => "0.1.66"),
+        });
+        await runUpgrade({}, deps);
+        expect(stdout.text).toMatch(/newer than the published/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+    it("installs anyway when --force is set even if already latest", async () => {
+        const { deps, runInstall, exit } = makeDeps({
+            currentVersion: "0.1.66",
+            fetchLatestVersion: vi.fn(async () => "0.1.66"),
+        });
+        await runUpgrade({ force: true }, deps);
+        expect(runInstall).toHaveBeenCalledWith("npm", ["install", "-g", "@sweny-ai/core@latest"]);
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+});
+describe("runUpgrade — install dispatch", () => {
+    it("invokes the detected package manager and exits 0 on success", async () => {
+        const { deps, stdout, runInstall, exit } = makeDeps();
+        await runUpgrade({}, deps);
+        expect(runInstall).toHaveBeenCalledWith("npm", ["install", "-g", "@sweny-ai/core@latest"]);
+        expect(stdout.text).toMatch(/Upgrading sweny 0\.1\.65 → 0\.1\.66/);
+        expect(stdout.text).toMatch(/✓ Upgraded sweny to 0\.1\.66/);
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+    it("uses pnpm when the install path is a pnpm global root", async () => {
+        const { deps, runInstall } = makeDeps({
+            installPath: "/Users/x/.local/share/pnpm/global/5/node_modules/@sweny-ai/core/dist/cli/main.js",
+        });
+        await runUpgrade({}, deps);
+        expect(runInstall).toHaveBeenCalledWith("pnpm", ["add", "-g", "@sweny-ai/core@latest"]);
+    });
+    it("forwards a non-default --tag to the install command", async () => {
+        const { deps, runInstall } = makeDeps({
+            fetchLatestVersion: vi.fn(async (tag) => (tag === "beta" ? "0.2.0-beta.1" : "0.1.66")),
+        });
+        await runUpgrade({ tag: "beta" }, deps);
+        expect(runInstall).toHaveBeenCalledWith("npm", ["install", "-g", "@sweny-ai/core@beta"]);
+    });
+    it("propagates a non-zero install exit code", async () => {
+        const { deps, stderr, exit } = makeDeps({
+            runInstall: vi.fn(() => 42),
+        });
+        await runUpgrade({}, deps);
+        expect(stderr.text).toMatch(/exited with code 42/);
+        expect(exit).toHaveBeenCalledWith(42);
+    });
+});
+describe("runUpgrade — permissions + platform edges", () => {
+    it("prints sudo hint and exits 1 when the install prefix isn't writable", async () => {
+        const { deps, stderr, exit, runInstall } = makeDeps({
+            canWrite: () => false,
+        });
+        await runUpgrade({}, deps);
+        expect(stderr.text).toMatch(/no write permission/);
+        expect(stderr.text).toMatch(/sudo npm install -g @sweny-ai\/core@latest/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(1);
+    });
+    it("defers to brew for homebrew installs (doesn't try to npm-install over it)", async () => {
+        const { deps, stdout, stderr, exit, runInstall } = makeDeps({
+            installPath: "/opt/homebrew/Cellar/sweny/0.1.65/libexec/bin/sweny",
+        });
+        await runUpgrade({}, deps);
+        expect(stdout.text).toMatch(/0\.1\.66 is available/);
+        expect(stderr.text).toMatch(/brew upgrade sweny/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(1);
+    });
+    it("prints a manual-install hint for unknown layouts", async () => {
+        const { deps, stdout, stderr, exit, runInstall } = makeDeps({
+            installPath: "/tmp/some-random-path/main.js",
+        });
+        await runUpgrade({}, deps);
+        expect(stdout.text).toMatch(/0\.1\.66 is available/);
+        expect(stderr.text).toMatch(/npm install -g @sweny-ai\/core@latest/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(1);
+    });
+});
+describe("runUpgrade — --check (dry run)", () => {
+    it("reports the command without running it", async () => {
+        const { deps, stdout, runInstall, exit } = makeDeps();
+        await runUpgrade({ check: true }, deps);
+        expect(stdout.text).toMatch(/0\.1\.66 is available/);
+        expect(stdout.text).toMatch(/npm install -g @sweny-ai\/core@latest/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+    it("still short-circuits on already-latest under --check", async () => {
+        const { deps, stdout, exit } = makeDeps({
+            currentVersion: "0.1.66",
+            fetchLatestVersion: vi.fn(async () => "0.1.66"),
+        });
+        await runUpgrade({ check: true }, deps);
+        expect(stdout.text).toMatch(/already the latest/);
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+});
+describe("runUpgrade — error handling", () => {
+    it("exits 1 with a helpful message when the registry fetch fails", async () => {
+        const { deps, stderr, exit, runInstall } = makeDeps({
+            fetchLatestVersion: vi.fn(async () => {
+                throw new Error("ENETDOWN");
+            }),
+        });
+        await runUpgrade({}, deps);
+        expect(stderr.text).toMatch(/couldn't reach the npm registry/);
+        expect(stderr.text).toMatch(/ENETDOWN/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(1);
+    });
+});
+describe("fetchLatestFromNpm", () => {
+    it("parses the dist-tag JSON and returns the version", async () => {
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockImplementation(async () => new Response(JSON.stringify({ version: "9.9.9" }), { status: 200 }));
+        try {
+            expect(await fetchLatestFromNpm("latest")).toBe("9.9.9");
+            expect(fetchSpy).toHaveBeenCalledWith("https://registry.npmjs.org/@sweny-ai/core/latest", expect.objectContaining({ headers: expect.objectContaining({ accept: "application/json" }) }));
+        }
+        finally {
+            fetchSpy.mockRestore();
+        }
+    });
+    it("throws a clear error when the registry returns non-2xx", async () => {
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockImplementation(async () => new Response("not found", { status: 404, statusText: "Not Found" }));
+        try {
+            await expect(fetchLatestFromNpm("bogus-tag")).rejects.toThrow(/404/);
+        }
+        finally {
+            fetchSpy.mockRestore();
+        }
+    });
+    it("throws when the registry payload is missing `version`", async () => {
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockImplementation(async () => new Response(JSON.stringify({}), { status: 200 }));
+        try {
+            await expect(fetchLatestFromNpm("latest")).rejects.toThrow(/version/);
+        }
+        finally {
+            fetchSpy.mockRestore();
+        }
+    });
+    it("URL-encodes the tag so custom tags don't break the path", async () => {
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockImplementation(async () => new Response(JSON.stringify({ version: "1.0.0" }), { status: 200 }));
+        try {
+            await fetchLatestFromNpm("next beta");
+            expect(fetchSpy).toHaveBeenCalledWith("https://registry.npmjs.org/@sweny-ai/core/next%20beta", expect.anything());
+        }
+        finally {
+            fetchSpy.mockRestore();
+        }
+    });
+});

package/dist/cli/__tests__/version-check.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/__tests__/version-check.test.js

@@ -0,0 +1,192 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { shouldSkip, readCache, writeCache, isCacheFresh, formatNudge, defaultCachePath, maybeNudge, CACHE_TTL_MS, } from "../version-check.js";
+function captureStream() {
+    const chunks = [];
+    const stream = {
+        write: (chunk) => {
+            chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+            return true;
+        },
+    };
+    return {
+        stream,
+        get text() {
+            return chunks.join("");
+        },
+    };
+}
+describe("shouldSkip", () => {
+    it("skips in CI", () => {
+        expect(shouldSkip({ CI: "1" }, true, "run")).toBe(true);
+    });
+    it("skips when SWENY_NO_UPDATE_CHECK is set", () => {
+        expect(shouldSkip({ SWENY_NO_UPDATE_CHECK: "1" }, true, "run")).toBe(true);
+    });
+    it("skips when SWENY_OFFLINE is set", () => {
+        expect(shouldSkip({ SWENY_OFFLINE: "1" }, true, "run")).toBe(true);
+    });
+    it("skips non-TTY invocations (pipes, scripts)", () => {
+        expect(shouldSkip({}, false, "run")).toBe(true);
+    });
+    it("skips the upgrade command itself to avoid double-printing", () => {
+        expect(shouldSkip({}, true, "upgrade")).toBe(true);
+        expect(shouldSkip({}, true, "update")).toBe(true);
+    });
+    it("allows the nudge in an interactive TTY with no opt-out", () => {
+        expect(shouldSkip({}, true, "run")).toBe(false);
+    });
+});
+describe("cache I/O", () => {
+    let tmpdir;
+    let cachePath;
+    beforeEach(() => {
+        tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-version-check-"));
+        cachePath = path.join(tmpdir, "sub", "version-check.json");
+    });
+    afterEach(() => {
+        fs.rmSync(tmpdir, { recursive: true, force: true });
+    });
+    it("round-trips a valid cache entry", () => {
+        writeCache(cachePath, { latest: "0.1.66", checkedAt: 12345 });
+        expect(readCache(cachePath)).toEqual({ latest: "0.1.66", checkedAt: 12345 });
+    });
+    it("creates parent directories as needed", () => {
+        writeCache(cachePath, { latest: "0.1.66", checkedAt: 12345 });
+        expect(fs.existsSync(cachePath)).toBe(true);
+    });
+    it("returns null for a missing cache file", () => {
+        expect(readCache(cachePath)).toBeNull();
+    });
+    it("returns null when the cache is malformed JSON", () => {
+        fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+        fs.writeFileSync(cachePath, "{{{not json");
+        expect(readCache(cachePath)).toBeNull();
+    });
+    it("returns null when required fields are missing or wrong type", () => {
+        fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+        fs.writeFileSync(cachePath, JSON.stringify({ latest: "0.1.66" }));
+        expect(readCache(cachePath)).toBeNull();
+        fs.writeFileSync(cachePath, JSON.stringify({ checkedAt: 1 }));
+        expect(readCache(cachePath)).toBeNull();
+        fs.writeFileSync(cachePath, JSON.stringify({ latest: "", checkedAt: 1 }));
+        expect(readCache(cachePath)).toBeNull();
+    });
+    it("never throws on unwritable cache directories (degrades silently)", () => {
+        // Point at a path where the parent is a file — mkdirSync will throw,
+        // and writeCache must swallow it.
+        const blocker = path.join(tmpdir, "blocker");
+        fs.writeFileSync(blocker, "im-a-file");
+        expect(() => writeCache(path.join(blocker, "cache.json"), { latest: "0.1.66", checkedAt: 1 })).not.toThrow();
+    });
+});
+describe("isCacheFresh", () => {
+    it("returns true within TTL", () => {
+        expect(isCacheFresh({ latest: "x", checkedAt: 1000 }, 1000 + CACHE_TTL_MS - 1)).toBe(true);
+    });
+    it("returns false at or past TTL", () => {
+        expect(isCacheFresh({ latest: "x", checkedAt: 1000 }, 1000 + CACHE_TTL_MS)).toBe(false);
+        expect(isCacheFresh({ latest: "x", checkedAt: 1000 }, 1000 + CACHE_TTL_MS + 1)).toBe(false);
+    });
+});
+describe("formatNudge", () => {
+    it("includes both versions and the upgrade command", () => {
+        const out = formatNudge("0.1.65", "0.1.66");
+        expect(out).toContain("0.1.65");
+        expect(out).toContain("0.1.66");
+        expect(out).toContain("sweny upgrade");
+    });
+});
+describe("defaultCachePath", () => {
+    it("honors XDG_CACHE_HOME when set", () => {
+        const p = defaultCachePath({ XDG_CACHE_HOME: "/custom/cache" }, "/home/x");
+        expect(p).toBe(path.join("/custom/cache", "sweny", "version-check.json"));
+    });
+    it("falls back to ~/.cache when XDG_CACHE_HOME is unset", () => {
+        expect(defaultCachePath({}, "/home/x")).toBe(path.join("/home/x/.cache", "sweny", "version-check.json"));
+    });
+    it("treats empty XDG_CACHE_HOME as unset (defensive)", () => {
+        expect(defaultCachePath({ XDG_CACHE_HOME: "" }, "/home/x")).toBe(path.join("/home/x/.cache", "sweny", "version-check.json"));
+    });
+});
+describe("maybeNudge", () => {
+    let tmpdir;
+    let cachePath;
+    let stderr;
+    const fetchOk = vi.fn(async () => "9.9.9");
+    beforeEach(() => {
+        tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-nudge-"));
+        cachePath = path.join(tmpdir, "version-check.json");
+        stderr = captureStream();
+        fetchOk.mockClear();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpdir, { recursive: true, force: true });
+    });
+    function baseDeps(over = {}) {
+        return {
+            currentVersion: "0.1.65",
+            cachePath,
+            now: 1_000_000,
+            env: {},
+            isTty: true,
+            commandName: "run",
+            stderr: stderr.stream,
+            fetchLatestVersion: fetchOk,
+            ...over,
+        };
+    }
+    it("prints nudge when cache shows a newer release", async () => {
+        writeCache(cachePath, { latest: "0.1.66", checkedAt: 1_000_000 });
+        await maybeNudge(baseDeps());
+        expect(stderr.text).toMatch(/0\.1\.66 is available/);
+        expect(stderr.text).toMatch(/sweny upgrade/);
+    });
+    it("stays silent when cache is equal or lower than current", async () => {
+        writeCache(cachePath, { latest: "0.1.65", checkedAt: 1_000_000 });
+        await maybeNudge(baseDeps());
+        expect(stderr.text).toBe("");
+    });
+    it("refreshes the cache when stale and writes the fetched version", async () => {
+        writeCache(cachePath, { latest: "0.1.64", checkedAt: 0 });
+        await maybeNudge(baseDeps({ now: CACHE_TTL_MS + 10 }));
+        expect(fetchOk).toHaveBeenCalledWith("latest");
+        const after = readCache(cachePath);
+        expect(after?.latest).toBe("9.9.9");
+        expect(after?.checkedAt).toBe(CACHE_TTL_MS + 10);
+    });
+    it("refreshes when cache is missing and does not crash when fetch fails", async () => {
+        const fetchFail = vi.fn(async () => {
+            throw new Error("ENETDOWN");
+        });
+        await maybeNudge(baseDeps({ fetchLatestVersion: fetchFail }));
+        expect(fetchFail).toHaveBeenCalled();
+        expect(readCache(cachePath)).toBeNull(); // fetch failed, nothing written
+        expect(stderr.text).toBe(""); // silent on error
+    });
+    it("does not refresh when cache is fresh (saves bandwidth)", async () => {
+        writeCache(cachePath, { latest: "0.1.65", checkedAt: 1_000_000 });
+        await maybeNudge(baseDeps({ now: 1_000_000 + 1 }));
+        expect(fetchOk).not.toHaveBeenCalled();
+    });
+    it("skips entirely in CI — no nudge, no fetch", async () => {
+        writeCache(cachePath, { latest: "0.1.66", checkedAt: 1_000_000 });
+        await maybeNudge(baseDeps({ env: { CI: "1" } }));
+        expect(stderr.text).toBe("");
+        expect(fetchOk).not.toHaveBeenCalled();
+    });
+    it("skips entirely on non-TTY stderr", async () => {
+        writeCache(cachePath, { latest: "0.1.66", checkedAt: 1_000_000 });
+        await maybeNudge(baseDeps({ isTty: false }));
+        expect(stderr.text).toBe("");
+        expect(fetchOk).not.toHaveBeenCalled();
+    });
+    it("suppresses the nudge from within `sweny upgrade` itself", async () => {
+        writeCache(cachePath, { latest: "0.1.66", checkedAt: 1_000_000 });
+        await maybeNudge(baseDeps({ commandName: "upgrade" }));
+        expect(stderr.text).toBe("");
+        expect(fetchOk).not.toHaveBeenCalled();
+    });
+});

package/dist/cli/main.js

@@ -31,6 +31,9 @@ import { checkProviderConnectivity } from "./check.js";
 import { registerSetupCommand } from "./setup.js";
 import { registerPublishCommand } from "./publish.js";
 import { reportToCloud } from "./cloud-report.js";
+import { runUpgrade, fetchLatestFromNpm } from "./upgrade.js";
+import { maybeNudge, defaultCachePath } from "./version-check.js";
+import { spawnSync } from "node:child_process";
 // ── Stream observer (NDJSON) ────────────────────────────────────────
 /**
  * Create an observer that writes NDJSON ExecutionEvents to stdout.
@@ -961,4 +964,65 @@ workflowCmd
     }
     console.log();
 });
-program.parse();
+// ── sweny upgrade / update ────────────────────────────────────────────
+// Self-update the globally-installed @sweny-ai/core. Mirrors the UX of
+// `bun upgrade`, `deno upgrade`, `rustup update`, etc.
+const upgradeCmd = program
+    .command("upgrade")
+    .alias("update")
+    .description("Upgrade sweny to the latest published version")
+    .option("--check", "Report what would be installed without running the installer")
+    .option("--force", "Reinstall even if the current version is already latest")
+    .option("--tag <tag>", "npm dist-tag to install (default: latest)", "latest")
+    .action(async (options) => {
+    // process.argv[1] is the CLI entrypoint — resolve through any symlinks
+    // (nvm, homebrew, etc. symlink the bin into a PATH dir) so PM detection
+    // looks at the real install location.
+    const argv1 = process.argv[1] ?? "";
+    let installPath = argv1;
+    try {
+        installPath = fs.realpathSync(argv1);
+    }
+    catch {
+        // Fall through with the unresolved path; detection degrades gracefully.
+    }
+    await runUpgrade(options, {
+        currentVersion: version,
+        installPath,
+        fetchLatestVersion: fetchLatestFromNpm,
+        runInstall: (cmd, args) => {
+            const res = spawnSync(cmd, args, { stdio: "inherit" });
+            if (res.error) {
+                process.stderr.write(chalk.red(`  Error: couldn't run ${cmd} — ${res.error.message}`) + "\n");
+                return 127;
+            }
+            return typeof res.status === "number" ? res.status : 1;
+        },
+        canWrite: (dir) => {
+            try {
+                fs.accessSync(dir, fs.constants.W_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    });
+});
+// Touch upgradeCmd so TS/ESLint don't flag it unused if someone tightens rules.
+void upgradeCmd;
+// ── Passive "new version available" nudge ─────────────────────────────
+// Runs after every command. Non-blocking, bounded to 1.5s, silent on any
+// failure, skipped in CI / non-TTY / opt-out environments.
+program.hook("postAction", async (_thisCommand, actionCommand) => {
+    const topLevel = actionCommand.parent?.name() === "sweny" ? actionCommand.name() : actionCommand.parent?.name();
+    await maybeNudge({
+        currentVersion: version,
+        cachePath: defaultCachePath(),
+        now: Date.now(),
+        env: process.env,
+        isTty: Boolean(process.stderr.isTTY),
+        commandName: topLevel,
+    });
+});
+await program.parseAsync();

package/dist/cli/upgrade.d.ts

@@ -0,0 +1,74 @@
+/**
+ * `sweny upgrade` — self-update the globally-installed `@sweny-ai/core` CLI.
+ *
+ * The hard parts are detection (which package manager owns this install?) and
+ * permissions (global node_modules often require sudo). We keep the runtime
+ * surface tiny via dependency injection so the whole flow is testable.
+ */
+export type PackageManager = "npm" | "pnpm" | "yarn" | "bun" | "volta" | "brew" | "unknown";
+export interface UpgradeOptions {
+    /** Skip the "already latest" short-circuit. */
+    force?: boolean;
+    /** Don't install — just report what would happen. */
+    check?: boolean;
+    /** Override the tag pulled from the registry. Defaults to "latest". */
+    tag?: string;
+}
+export interface UpgradeDeps {
+    /** Version currently running (from `package.json`). */
+    currentVersion: string;
+    /** Absolute path to the current CLI entrypoint — used for PM detection. */
+    installPath: string;
+    /** Fetch latest version for `@sweny-ai/core@<tag>`. */
+    fetchLatestVersion: (tag: string) => Promise<string>;
+    /** Run the resolved install command. Returns the process exit code. */
+    runInstall: (cmd: string, args: string[]) => number;
+    /** Writable-dir probe for EACCES detection. */
+    canWrite: (dir: string) => boolean;
+    stdout?: NodeJS.WritableStream;
+    stderr?: NodeJS.WritableStream;
+    exit?: (code: number) => void;
+}
+/**
+ * Detect the package manager that owns this install by walking the parent
+ * chain of the CLI entrypoint. The rules are ordered by specificity — more
+ * distinctive roots (bun, volta, pnpm, homebrew) beat the generic
+ * `lib/node_modules` npm layout.
+ */
+export declare function detectPackageManager(installPath: string): PackageManager;
+/**
+ * Resolve the install-root directory for writability checks. For npm-style
+ * layouts, walk up until we find `node_modules/@sweny-ai/core` and return
+ * the parent of `node_modules` (the writable prefix). Returns null if the
+ * install path doesn't look like a package-manager install.
+ */
+export declare function resolveInstallRoot(installPath: string): string | null;
+/** Build the (cmd, args) pair for a given package manager + tag. */
+export declare function installCommandFor(pm: PackageManager, tag: string): {
+    cmd: string;
+    args: string[];
+} | null;
+/**
+ * Compare two semver-ish version strings. Returns:
+ *  - `>0` when `a > b`
+ *  - `<0` when `a < b`
+ *  - `0` when equal
+ *
+ * Handles numeric core (`major.minor.patch`) and pre-release strings
+ * conservatively: any pre-release (`-alpha.1`) is treated as *lower* than
+ * the same core without one, matching npm's semver ordering at the level
+ * of precision we need for "is the registry newer than me."
+ */
+export declare function compareVersions(a: string, b: string): number;
+/**
+ * Fetch the latest published version of `@sweny-ai/core` from the npm
+ * registry. Uses the dist-tag endpoint which returns a small, cacheable JSON
+ * document — no tarball download.
+ */
+export declare function fetchLatestFromNpm(tag: string): Promise<string>;
+/**
+ * Main `sweny upgrade` entrypoint. Resolves the latest version, decides
+ * whether an install is needed, dispatches to the right package manager,
+ * and surfaces permission problems as actionable copy-paste commands.
+ */
+export declare function runUpgrade(options: UpgradeOptions, deps: UpgradeDeps): Promise<void>;

package/dist/cli/upgrade.js

@@ -0,0 +1,219 @@
+import * as path from "node:path";
+import chalk from "chalk";
+/**
+ * Detect the package manager that owns this install by walking the parent
+ * chain of the CLI entrypoint. The rules are ordered by specificity — more
+ * distinctive roots (bun, volta, pnpm, homebrew) beat the generic
+ * `lib/node_modules` npm layout.
+ */
+export function detectPackageManager(installPath) {
+    // Normalize to forward slashes so Windows paths match the same patterns.
+    const p = installPath.replace(/\\/g, "/").toLowerCase();
+    if (p.includes("/homebrew/") || p.includes("/cellar/"))
+        return "brew";
+    if (p.includes("/.volta/"))
+        return "volta";
+    if (p.includes("/.bun/"))
+        return "bun";
+    // pnpm global store lives under ~/.local/share/pnpm or ~/Library/pnpm, and
+    // the actual binary is a symlink — the resolved path typically contains
+    // either `/pnpm/` or the global store marker `/pnpm-global/`.
+    if (p.includes("/pnpm/") || p.includes("/pnpm-global/") || p.includes("/.pnpm-store/"))
+        return "pnpm";
+    // Yarn's global install folder is ~/.config/yarn/global or
+    // ~/.yarn/global — check for both.
+    if (p.includes("/.yarn/") || p.includes("/yarn/global/"))
+        return "yarn";
+    // Default: assume npm if we see node_modules — covers nvm, fnm, asdf,
+    // vanilla Node, and every CI runner.
+    if (p.includes("/node_modules/"))
+        return "npm";
+    return "unknown";
+}
+/**
+ * Resolve the install-root directory for writability checks. For npm-style
+ * layouts, walk up until we find `node_modules/@sweny-ai/core` and return
+ * the parent of `node_modules` (the writable prefix). Returns null if the
+ * install path doesn't look like a package-manager install.
+ */
+export function resolveInstallRoot(installPath) {
+    let cur = path.dirname(installPath);
+    const visited = new Set();
+    while (cur && !visited.has(cur) && path.dirname(cur) !== cur) {
+        visited.add(cur);
+        if (path.basename(cur) === "@sweny-ai") {
+            // cur = .../node_modules/@sweny-ai — parent of node_modules is the root
+            const nodeModules = path.dirname(cur);
+            if (path.basename(nodeModules) === "node_modules") {
+                return path.dirname(nodeModules);
+            }
+        }
+        cur = path.dirname(cur);
+    }
+    return null;
+}
+/** Build the (cmd, args) pair for a given package manager + tag. */
+export function installCommandFor(pm, tag) {
+    const ref = `@sweny-ai/core@${tag}`;
+    switch (pm) {
+        case "npm":
+            return { cmd: "npm", args: ["install", "-g", ref] };
+        case "pnpm":
+            return { cmd: "pnpm", args: ["add", "-g", ref] };
+        case "yarn":
+            return { cmd: "yarn", args: ["global", "add", ref] };
+        case "bun":
+            return { cmd: "bun", args: ["add", "-g", ref] };
+        case "volta":
+            return { cmd: "volta", args: ["install", `@sweny-ai/core@${tag}`] };
+        case "brew":
+        case "unknown":
+            return null;
+    }
+}
+/**
+ * Compare two semver-ish version strings. Returns:
+ *  - `>0` when `a > b`
+ *  - `<0` when `a < b`
+ *  - `0` when equal
+ *
+ * Handles numeric core (`major.minor.patch`) and pre-release strings
+ * conservatively: any pre-release (`-alpha.1`) is treated as *lower* than
+ * the same core without one, matching npm's semver ordering at the level
+ * of precision we need for "is the registry newer than me."
+ */
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const [core, pre] = v.split("-", 2);
+        const nums = core.split(".").map((n) => {
+            const parsed = Number.parseInt(n, 10);
+            return Number.isFinite(parsed) ? parsed : 0;
+        });
+        return { nums, pre: pre ?? "" };
+    };
+    const pa = parse(a);
+    const pb = parse(b);
+    const len = Math.max(pa.nums.length, pb.nums.length);
+    for (let i = 0; i < len; i++) {
+        const av = pa.nums[i] ?? 0;
+        const bv = pb.nums[i] ?? 0;
+        if (av !== bv)
+            return av - bv;
+    }
+    // Core equal — a pre-release ranks lower than a release.
+    if (pa.pre && !pb.pre)
+        return -1;
+    if (!pa.pre && pb.pre)
+        return 1;
+    if (pa.pre < pb.pre)
+        return -1;
+    if (pa.pre > pb.pre)
+        return 1;
+    return 0;
+}
+/**
+ * Fetch the latest published version of `@sweny-ai/core` from the npm
+ * registry. Uses the dist-tag endpoint which returns a small, cacheable JSON
+ * document — no tarball download.
+ */
+export async function fetchLatestFromNpm(tag) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+        const res = await fetch(`https://registry.npmjs.org/@sweny-ai/core/${encodeURIComponent(tag)}`, {
+            signal: controller.signal,
+            headers: { accept: "application/json" },
+        });
+        if (!res.ok) {
+            throw new Error(`npm registry returned ${res.status} ${res.statusText}`);
+        }
+        const body = (await res.json());
+        if (typeof body.version !== "string" || body.version.length === 0) {
+            throw new Error("npm registry response missing `version` field");
+        }
+        return body.version;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+const BREW_HINT = "This CLI looks like it was installed via Homebrew. Run `brew upgrade sweny` or `brew update && brew upgrade sweny`.";
+const UNKNOWN_HINT = "Couldn't detect your package manager. Install the latest manually with:\n    npm install -g @sweny-ai/core@latest";
+/**
+ * Main `sweny upgrade` entrypoint. Resolves the latest version, decides
+ * whether an install is needed, dispatches to the right package manager,
+ * and surfaces permission problems as actionable copy-paste commands.
+ */
+export async function runUpgrade(options, deps) {
+    const stdout = deps.stdout ?? process.stdout;
+    const stderr = deps.stderr ?? process.stderr;
+    const exit = deps.exit ?? ((code) => process.exit(code));
+    const tag = options.tag && options.tag.length > 0 ? options.tag : "latest";
+    let latest;
+    try {
+        latest = await deps.fetchLatestVersion(tag);
+    }
+    catch (err) {
+        stderr.write(chalk.red(`  Error: couldn't reach the npm registry — ${err instanceof Error ? err.message : String(err)}`) +
+            "\n");
+        stderr.write(chalk.dim("  Check your network connection and try again.") + "\n");
+        exit(1);
+        return;
+    }
+    const current = deps.currentVersion;
+    const cmp = compareVersions(current, latest);
+    if (cmp >= 0 && !options.force) {
+        if (cmp === 0) {
+            stdout.write(chalk.green(`  ✓ sweny ${current} is already the latest.`) + "\n");
+        }
+        else {
+            stdout.write(chalk.yellow(`  You're running sweny ${current}, which is newer than the published ${latest}. Nothing to do.`) +
+                "\n");
+        }
+        exit(0);
+        return;
+    }
+    const pm = detectPackageManager(deps.installPath);
+    // Homebrew has its own update cadence — we don't try to drive it from here.
+    if (pm === "brew") {
+        stdout.write(chalk.cyan(`  sweny ${latest} is available (you have ${current}).`) + "\n");
+        stderr.write(chalk.dim(`  ${BREW_HINT}`) + "\n");
+        exit(options.check ? 0 : 1);
+        return;
+    }
+    const installCmd = installCommandFor(pm, tag);
+    if (!installCmd) {
+        stdout.write(chalk.cyan(`  sweny ${latest} is available (you have ${current}).`) + "\n");
+        stderr.write(chalk.dim(`  ${UNKNOWN_HINT}`) + "\n");
+        exit(options.check ? 0 : 1);
+        return;
+    }
+    const fullCmd = [installCmd.cmd, ...installCmd.args].join(" ");
+    if (options.check) {
+        stdout.write(chalk.cyan(`  sweny ${latest} is available (you have ${current}).`) + "\n");
+        stdout.write(chalk.dim(`  Run: ${fullCmd}`) + "\n");
+        exit(0);
+        return;
+    }
+    // Permissions probe — for npm-style layouts, the user needs write access to
+    // the prefix. If not, we print the exact sudo-prefixed command so they can
+    // copy-paste without guessing.
+    const root = resolveInstallRoot(deps.installPath);
+    if (root && !deps.canWrite(root)) {
+        stderr.write(chalk.red(`  Error: no write permission on ${root}`) + "\n");
+        stderr.write(chalk.dim(`  Try: sudo ${fullCmd}`) + "\n");
+        stderr.write(chalk.dim(`  Or reinstall Node with a user-writable prefix (nvm, fnm, volta) to avoid sudo.`) + "\n");
+        exit(1);
+        return;
+    }
+    stdout.write(chalk.cyan(`  Upgrading sweny ${current} → ${latest} via ${pm}…`) + "\n");
+    stdout.write(chalk.dim(`  $ ${fullCmd}`) + "\n");
+    const code = deps.runInstall(installCmd.cmd, installCmd.args);
+    if (code !== 0) {
+        stderr.write(chalk.red(`  Error: ${installCmd.cmd} exited with code ${code}`) + "\n");
+        exit(code);
+        return;
+    }
+    stdout.write(chalk.green(`  ✓ Upgraded sweny to ${latest}.`) + "\n");
+    exit(0);
+}

package/dist/cli/version-check.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Passive "a new sweny is out" nudge. Runs as a commander `postAction` hook
+ * so every command prints at most one dim footer line when behind.
+ *
+ * Design goals:
+ *   1. Never block the user's command. Cache reads are sync; network refresh
+ *      happens inline but bounded to a tight budget — if the registry is slow
+ *      we swallow the error silently and try again in 24h.
+ *   2. Never nag in contexts where nobody's watching — CI, pipes, or when the
+ *      user has explicitly opted out.
+ *   3. Never fire from inside `sweny upgrade` itself (would double-print the
+ *      upgrade hint right before/after running the install).
+ */
+export declare const CACHE_TTL_MS: number;
+/** Budget for the background registry refresh. Short on purpose. */
+export declare const REFRESH_BUDGET_MS = 1500;
+export interface CacheEntry {
+    latest: string;
+    checkedAt: number;
+}
+export interface VersionCheckDeps {
+    currentVersion: string;
+    cachePath: string;
+    now: number;
+    env: NodeJS.ProcessEnv;
+    isTty: boolean;
+    /** The command the user ran, so we can suppress the nudge for self-referential commands. */
+    commandName?: string;
+    stderr?: NodeJS.WritableStream;
+    fetchLatestVersion?: (tag: string) => Promise<string>;
+    /** Injected so tests can make the refresh synchronous + deterministic. */
+    now_fn?: () => number;
+}
+/**
+ * Decide whether any version-check work should run at all. We bail early for:
+ *   - `CI=1`: noise in pipelines and reads tokens
+ *   - `SWENY_NO_UPDATE_CHECK=1`: explicit opt-out
+ *   - `SWENY_OFFLINE=1`: users behind airgaps
+ *   - Non-TTY stderr: scripts and pipes
+ *   - `upgrade` / `update` commands: the command itself handles the hint
+ */
+export declare function shouldSkip(env: NodeJS.ProcessEnv, isTty: boolean, commandName: string | undefined): boolean;
+export declare function readCache(cachePath: string): CacheEntry | null;
+export declare function writeCache(cachePath: string, entry: CacheEntry): void;
+export declare function isCacheFresh(entry: CacheEntry, now: number, ttl?: number): boolean;
+export declare function formatNudge(current: string, latest: string): string;
+/**
+ * Resolve the cache path on disk. Honors `XDG_CACHE_HOME` and falls back to
+ * `~/.cache/sweny/version-check.json`. We isolate this so tests can inject a
+ * tmpdir without touching the real cache.
+ */
+export declare function defaultCachePath(env?: NodeJS.ProcessEnv, home?: string): string;
+/**
+ * Run the check. Prints a nudge if the cache shows a newer version, then
+ * refreshes the cache in the background if it's stale or missing.
+ *
+ * The refresh is awaited with a short timeout so we don't hang the CLI, but
+ * we also don't surface its result on *this* run — that keeps the code paths
+ * simple and avoids "first run after install" printing a nudge before the
+ * user's command finishes rendering.
+ */
+export declare function maybeNudge(deps: VersionCheckDeps): Promise<void>;

package/dist/cli/version-check.js

@@ -0,0 +1,123 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import chalk from "chalk";
+import { compareVersions, fetchLatestFromNpm } from "./upgrade.js";
+/**
+ * Passive "a new sweny is out" nudge. Runs as a commander `postAction` hook
+ * so every command prints at most one dim footer line when behind.
+ *
+ * Design goals:
+ *   1. Never block the user's command. Cache reads are sync; network refresh
+ *      happens inline but bounded to a tight budget — if the registry is slow
+ *      we swallow the error silently and try again in 24h.
+ *   2. Never nag in contexts where nobody's watching — CI, pipes, or when the
+ *      user has explicitly opted out.
+ *   3. Never fire from inside `sweny upgrade` itself (would double-print the
+ *      upgrade hint right before/after running the install).
+ */
+export const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+/** Budget for the background registry refresh. Short on purpose. */
+export const REFRESH_BUDGET_MS = 1500;
+/**
+ * Decide whether any version-check work should run at all. We bail early for:
+ *   - `CI=1`: noise in pipelines and reads tokens
+ *   - `SWENY_NO_UPDATE_CHECK=1`: explicit opt-out
+ *   - `SWENY_OFFLINE=1`: users behind airgaps
+ *   - Non-TTY stderr: scripts and pipes
+ *   - `upgrade` / `update` commands: the command itself handles the hint
+ */
+export function shouldSkip(env, isTty, commandName) {
+    if (env.CI)
+        return true;
+    if (env.SWENY_NO_UPDATE_CHECK)
+        return true;
+    if (env.SWENY_OFFLINE)
+        return true;
+    if (!isTty)
+        return true;
+    if (commandName === "upgrade" || commandName === "update")
+        return true;
+    return false;
+}
+export function readCache(cachePath) {
+    try {
+        const raw = fs.readFileSync(cachePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.latest !== "string" || typeof parsed.checkedAt !== "number") {
+            return null;
+        }
+        if (parsed.latest.length === 0)
+            return null;
+        return { latest: parsed.latest, checkedAt: parsed.checkedAt };
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCache(cachePath, entry) {
+    try {
+        fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+        fs.writeFileSync(cachePath, JSON.stringify(entry));
+    }
+    catch {
+        // Cache-write failures are non-fatal — we'll just retry next run.
+    }
+}
+export function isCacheFresh(entry, now, ttl = CACHE_TTL_MS) {
+    return now - entry.checkedAt < ttl;
+}
+export function formatNudge(current, latest) {
+    return chalk.dim(`  › sweny ${latest} is available (you have ${current}). Run \`sweny upgrade\``);
+}
+/**
+ * Resolve the cache path on disk. Honors `XDG_CACHE_HOME` and falls back to
+ * `~/.cache/sweny/version-check.json`. We isolate this so tests can inject a
+ * tmpdir without touching the real cache.
+ */
+export function defaultCachePath(env = process.env, home = os.homedir()) {
+    const xdg = env.XDG_CACHE_HOME && env.XDG_CACHE_HOME.length > 0 ? env.XDG_CACHE_HOME : path.join(home, ".cache");
+    return path.join(xdg, "sweny", "version-check.json");
+}
+/**
+ * Run the check. Prints a nudge if the cache shows a newer version, then
+ * refreshes the cache in the background if it's stale or missing.
+ *
+ * The refresh is awaited with a short timeout so we don't hang the CLI, but
+ * we also don't surface its result on *this* run — that keeps the code paths
+ * simple and avoids "first run after install" printing a nudge before the
+ * user's command finishes rendering.
+ */
+export async function maybeNudge(deps) {
+    if (shouldSkip(deps.env, deps.isTty, deps.commandName))
+        return;
+    const stderr = deps.stderr ?? process.stderr;
+    const cache = readCache(deps.cachePath);
+    if (cache && compareVersions(deps.currentVersion, cache.latest) < 0) {
+        stderr.write(formatNudge(deps.currentVersion, cache.latest) + "\n");
+    }
+    if (cache && isCacheFresh(cache, deps.now))
+        return;
+    // Stale or missing — refresh in the background with a hard timeout. We
+    // race the fetch against a timer so the process can exit promptly even if
+    // the registry hangs.
+    const fetchFn = deps.fetchLatestVersion ?? fetchLatestFromNpm;
+    try {
+        const latest = await Promise.race([
+            fetchFn("latest").catch(() => null),
+            new Promise((resolve) => {
+                const t = setTimeout(() => resolve(null), REFRESH_BUDGET_MS);
+                // Don't keep the event loop alive purely for this timer.
+                if (typeof t.unref === "function") {
+                    t.unref();
+                }
+            }),
+        ]);
+        if (latest) {
+            writeCache(deps.cachePath, { latest, checkedAt: deps.now });
+        }
+    }
+    catch {
+        // Swallow — network hiccups shouldn't be user-visible here.
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.66",
+  "version": "0.1.67",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"