@wenrwa/marketplace-cli 0.8.11 → 0.8.13

package/dist/bridge/storageCleanup.js

@@ -0,0 +1,337 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILD_OUTPUT_DIRS = exports.CLEANUP_VERSION = exports.CLEANUP_CATEGORIES = void 0;
+exports.defaultCacheDirs = defaultCacheDirs;
+exports.createStorageCleaner = createStorageCleaner;
+/**
+ * stc-05 (docs/prd/storage-billed-in-credits.md, ADR-0018; ADR-0008's floor) —
+ * measure and delete ONLY data the box can rebuild by itself:
+ *
+ *   caches            npm / uv / pip caches (the user's home, and the volume)
+ *   previews          Team preview slots (`<previews>/<ws>/{a,b}`) of a preview
+ *                     that is not running, and the shared uv cache under
+ *                     `<previews>/.tools/uv-cache` when no preview runs at all
+ *   removedCheckouts  a `<repos>/<ws>` directory with no repo left in it and
+ *                     nothing but empty dirs / build output — what an
+ *                     interrupted removal leaves behind
+ *   buildOutput       gitignored build directories (node_modules, .next, dist,
+ *                     build, target, .venv, ...) inside a CLEAN checkout
+ *
+ * Never: source, `.env` (or any other file a repo ignores that is not a known
+ * build directory), a checkout with uncommitted / untracked / unpushed /
+ * stashed work (checkoutInventory.ts's inspectDirty — the one dirty
+ * definition), or anything belonging to a workspace with an attached session.
+ * Attachment, dirtiness and preview activity are re-checked IMMEDIATELY before
+ * each delete (after the target is measured), so a session that attaches or a
+ * file written mid-run aborts that target (ADR-0008: "the attachment check
+ * happens immediately before removal").
+ *
+ * The figure the storage view shows ("N.N GB can be freed") is `measure()`;
+ * `clean()` frees exactly the targets it would have counted, each measured
+ * right before its delete, so the two agree unless something changed between.
+ *
+ * Automatic cleanup (stc-06, before a disk grows) is `runAutomaticCleanup()`
+ * and sits behind a kill switch that defaults OFF; when on it touches only the
+ * caches and preview categories. The user's own Clean up button (`clean()`)
+ * works regardless of the switch.
+ *
+ * HOSTED LANE ONLY — the local bridge never constructs one (HiveOp does not
+ * garbage-collect a laptop it does not own).
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const bundleInstaller_1 = require("./bundleInstaller");
+const checkoutInventory_1 = require("./checkoutInventory");
+exports.CLEANUP_CATEGORIES = ['caches', 'previews', 'removedCheckouts', 'buildOutput'];
+/** Stamped on every report so the backend/arena can tell a bridge that can clean. */
+exports.CLEANUP_VERSION = 1;
+/** Directory names that are build output by convention — deleted only when the repo ignores them. */
+exports.BUILD_OUTPUT_DIRS = new Set([
+    'node_modules',
+    '.next',
+    '.nuxt',
+    '.turbo',
+    'dist',
+    'build',
+    'target',
+    '.venv',
+    '__pycache__',
+]);
+/** npm / uv / pip caches under each home-like root, de-duplicated. */
+function defaultCacheDirs(roots) {
+    const out = new Set();
+    for (const r of roots) {
+        if (!r)
+            continue;
+        for (const rel of ['.npm/_cacache', '.npm/_npx', '.cache/pip', '.cache/uv'])
+            out.add(path.join(r, rel));
+    }
+    return [...out];
+}
+function zeros() {
+    return { caches: 0, previews: 0, removedCheckouts: 0, buildOutput: 0 };
+}
+async function walkBytes(p) {
+    let st;
+    try {
+        st = await fs.promises.lstat(p);
+    }
+    catch {
+        return 0;
+    }
+    const own = typeof st.blocks === 'number' ? st.blocks * 512 : st.size;
+    if (!st.isDirectory())
+        return own;
+    let entries = [];
+    try {
+        entries = await fs.promises.readdir(p);
+    }
+    catch {
+        return own;
+    }
+    let total = own;
+    for (const e of entries)
+        total += await walkBytes(path.join(p, e));
+    return total;
+}
+const defaultRm = (p) => fs.promises.rm(p, { recursive: true, force: true });
+/** A real directory (not a symlink to one). */
+function isDir(p) {
+    try {
+        return fs.lstatSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function childDirs(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+/** Nothing in here but directories and build-output directories — no file anyone could need. */
+function holdsOnlyRebuildable(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    for (const e of entries) {
+        if (!e.isDirectory())
+            return false; // a file, symlink, socket... keep
+        if (exports.BUILD_OUTPUT_DIRS.has(e.name))
+            continue;
+        if (!holdsOnlyRebuildable(path.join(dir, e.name)))
+            return false;
+    }
+    return true;
+}
+function createStorageCleaner(deps) {
+    const sizeBytes = deps.sizeBytes ?? walkBytes;
+    const rm = deps.rm ?? defaultRm;
+    let running = false;
+    const activity = () => deps.previewActivity?.() ?? { opInFlight: false, activeWorkspaces: [] };
+    function previewHasPidfile(ws) {
+        return !!deps.previewsBaseDir && fs.existsSync(path.join(deps.previewsBaseDir, ws, 'preview.pid'));
+    }
+    /** Why a preview slot of `ws` (or the shared tools cache, ws=null) must stay — null when it may go. */
+    function previewHold(ws) {
+        const a = activity();
+        if (a.opInFlight)
+            return 'a preview is starting or updating';
+        if (ws === null) {
+            if (a.activeWorkspaces.length > 0)
+                return 'a preview is running';
+            const anyPid = deps.previewsBaseDir ? childDirs(deps.previewsBaseDir).some((d) => previewHasPidfile(d)) : false;
+            return anyPid ? 'a preview may still be running' : null;
+        }
+        if (a.activeWorkspaces.includes(ws))
+            return 'this preview is running';
+        if (previewHasPidfile(ws))
+            return 'this preview may still be running';
+        return null;
+    }
+    async function checkoutIsClean(dir) {
+        try {
+            const d = await (0, checkoutInventory_1.inspectDirty)(dir, deps.run, deps.readText);
+            return d !== 'unparseable' && !d.dirty;
+        }
+        catch {
+            return false; // inconclusive is never clean
+        }
+    }
+    async function ignoredBuildDirs(dir) {
+        let out;
+        try {
+            const r = await deps.run('git', ['-C', dir, 'ls-files', '--others', '--ignored', '--exclude-standard', '--directory', '-z']);
+            if (r.code !== 0)
+                return [];
+            out = r.stdout;
+        }
+        catch {
+            return [];
+        }
+        const root = path.resolve(dir);
+        const found = [];
+        for (const rel of out.split('\0')) {
+            if (!rel.endsWith('/'))
+                continue;
+            const clean = rel.replace(/\/+$/, '');
+            if (!exports.BUILD_OUTPUT_DIRS.has(path.basename(clean)))
+                continue;
+            if (clean.split('/').includes('.git'))
+                continue;
+            const abs = path.resolve(root, clean);
+            if (!abs.startsWith(root + path.sep))
+                continue;
+            if (isDir(abs))
+                found.push(abs);
+        }
+        return found;
+    }
+    async function plan(categories) {
+        const want = new Set(categories);
+        const targets = [];
+        if (want.has('caches')) {
+            for (const c of deps.cacheDirs)
+                if (isDir(c))
+                    targets.push({ category: 'caches', path: c });
+        }
+        if (want.has('previews') && deps.previewsBaseDir) {
+            const base = deps.previewsBaseDir;
+            for (const name of childDirs(base)) {
+                if (name === '.tools') {
+                    const uvCache = path.join(base, '.tools', 'uv-cache');
+                    if (isDir(uvCache) && previewHold(null) === null)
+                        targets.push({ category: 'previews', path: uvCache, workspaceId: null });
+                    continue;
+                }
+                if (!(0, bundleInstaller_1.isSafeWorkspaceId)(name) || previewHold(name) !== null)
+                    continue;
+                for (const slot of ['a', 'b']) {
+                    const p = path.join(base, name, slot);
+                    if (isDir(p))
+                        targets.push({ category: 'previews', path: p, workspaceId: name });
+                }
+            }
+        }
+        if (want.has('removedCheckouts') || want.has('buildOutput')) {
+            for (const ws of childDirs(deps.reposBaseDir)) {
+                if (ws.startsWith('.') || !(0, bundleInstaller_1.isSafeWorkspaceId)(ws) || deps.isAttached(ws))
+                    continue;
+                const dir = path.join(deps.reposBaseDir, ws);
+                if (fs.existsSync(path.join(dir, '.git'))) {
+                    if (!want.has('buildOutput') || !(await checkoutIsClean(dir)))
+                        continue;
+                    for (const p of await ignoredBuildDirs(dir))
+                        targets.push({ category: 'buildOutput', path: p, workspaceId: ws, checkout: dir });
+                }
+                else if (want.has('removedCheckouts') && holdsOnlyRebuildable(dir)) {
+                    targets.push({ category: 'removedCheckouts', path: dir, workspaceId: ws });
+                }
+            }
+        }
+        // Never count (or delete) a path twice: drop any target inside another.
+        return targets.filter((t) => !targets.some((o) => o !== t && t.path.startsWith(o.path + path.sep)));
+    }
+    /** Re-derived right before the delete. null = still safe to remove. */
+    async function hold(t) {
+        switch (t.category) {
+            case 'caches':
+                return null;
+            case 'previews':
+                return previewHold(t.workspaceId);
+            case 'removedCheckouts':
+                if (deps.isAttached(t.workspaceId))
+                    return 'a session attached';
+                if (fs.existsSync(path.join(t.path, '.git')))
+                    return 'a checkout appeared';
+                return holdsOnlyRebuildable(t.path) ? null : 'files appeared';
+            case 'buildOutput':
+                if (deps.isAttached(t.workspaceId))
+                    return 'a session attached';
+                return (await checkoutIsClean(t.checkout)) ? null : 'the checkout has unsaved work';
+        }
+    }
+    async function measure() {
+        const byCategory = zeros();
+        for (const t of await plan(exports.CLEANUP_CATEGORIES))
+            byCategory[t.category] += await sizeBytes(t.path).catch(() => 0);
+        return { reclaimableBytes: exports.CLEANUP_CATEGORIES.reduce((s, c) => s + byCategory[c], 0), byCategory };
+    }
+    async function clean(categories = exports.CLEANUP_CATEGORIES) {
+        if (running)
+            return { busy: true, freedBytes: 0, byCategory: zeros(), skipped: [] };
+        running = true;
+        try {
+            const byCategory = zeros();
+            const skipped = [];
+            for (const t of await plan(categories)) {
+                const bytes = await sizeBytes(t.path).catch(() => 0);
+                const why = await hold(t);
+                if (why) {
+                    skipped.push({ category: t.category, path: t.path, reason: why });
+                    continue;
+                }
+                try {
+                    await rm(t.path);
+                    byCategory[t.category] += bytes;
+                }
+                catch (err) {
+                    skipped.push({ category: t.category, path: t.path, reason: err instanceof Error ? err.message : String(err) });
+                }
+            }
+            return { busy: false, freedBytes: exports.CLEANUP_CATEGORIES.reduce((s, c) => s + byCategory[c], 0), byCategory, skipped };
+        }
+        finally {
+            running = false;
+        }
+    }
+    async function runAutomaticCleanup() {
+        if (!deps.autoCleanupEnabled)
+            return { ran: false, reason: 'disabled' };
+        const r = await clean(['caches', 'previews']);
+        if (r.busy)
+            return { ran: false, reason: 'busy' };
+        return { ran: true, ...r };
+    }
+    return { measure, clean, runAutomaticCleanup };
+}

package/dist/bridge/storageQuotaFetch.js

@@ -7,6 +7,16 @@ function optString(v) {
 function isFiniteNumber(v) {
     return typeof v === 'number' && Number.isFinite(v);
 }
+/** stc-04 — all three numbers finite and positive, or no quote at all. */
+function parseQuote(v) {
+    if (!v || typeof v !== 'object')
+        return null;
+    const q = v;
+    const ok = (n) => isFiniteNumber(n) && n > 0;
+    if (!ok(q.addGb) || !ok(q.newDiskGb) || !isFiniteNumber(q.newCreditsPerDay) || q.newCreditsPerDay < 0)
+        return null;
+    return { addGb: q.addGb, newDiskGb: q.newDiskGb, newCreditsPerDay: q.newCreditsPerDay };
+}
 async function fetchStorageQuotaFact(opts) {
     const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
     if (!fetchImpl)
@@ -39,6 +49,7 @@ async function fetchStorageQuotaFact(opts) {
                 isFiniteNumber(err.capGb) &&
                 isFiniteNumber(err.usedGb) &&
                 isFiniteNumber(err.additionalGb)) {
+                const quote = parseQuote(err.quote);
                 return {
                     allowed: false,
                     tier: err.tier,
@@ -49,6 +60,7 @@ async function fetchStorageQuotaFact(opts) {
                     suggestedCapGb: isFiniteNumber(err.suggestedCapGb) ? err.suggestedCapGb : null,
                     tierName: optString(err.tierName),
                     suggestedTierName: optString(err.suggestedTierName),
+                    ...(quote ? { quote } : {}),
                 };
             }
         }

package/dist/bridge/storageQuotaPreflight.d.ts

@@ -68,6 +68,18 @@ export interface StorageQuotaFact {
      *  Absent from an older backend — the raw id is the fallback. */
     tierName?: string | null;
     suggestedTierName?: string | null;
+    /** stc-04 — the backend's price for growing the disk to fit this clone
+     *  (present only while storage billing is on and growth is possible).
+     *  Carried to the pane untouched; the bridge never grows the disk itself —
+     *  the grow route spends money, so the arena's Grow click makes that call
+     *  with the user's own session. */
+    quote?: GrowQuote;
+}
+/** stc-04 — `POST /me/hive/storage/grow`'s price, quoted by the clone check. */
+export interface GrowQuote {
+    addGb: number;
+    newDiskGb: number;
+    newCreditsPerDay: number;
 }
 /** "about 4.0 GB", or "under 0.1 GB" for a positive sliver — never a raw
  *  float, never "about 0.0 GB" for something real. */

package/dist/commands/bridge.d.ts

@@ -2,6 +2,16 @@ import { Command } from 'commander';
 import { CompanionForwarder } from '../bridge/companionForwarder';
 export declare const DEFAULT_BRIDGE_PORT = 8377;
 export declare function bridgeApiUrl(): string;
+/**
+ * stc-06 — free and total GB of the volume holding `p` (the SAME statfs as
+ * readReposVolumeFreeMb), for the disk-pressure report on the `sessions`
+ * frame. null = unknown (no statfsSync, read failure): the field is omitted
+ * and the backend never acts on a guess.
+ */
+export declare function readVolumeSpaceGb(p: string): {
+    freeGb: number;
+    totalGb: number;
+} | null;
 export type RelayCliOpts = {
     relay?: string;
     relayToken?: string;

package/dist/commands/bridge.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bridgeCommand = exports.DEFAULT_BRIDGE_PORT = void 0;
 exports.bridgeApiUrl = bridgeApiUrl;
+exports.readVolumeSpaceGb = readVolumeSpaceGb;
 exports.resolveRelayMode = resolveRelayMode;
 exports.buildBrowserDriverOptions = buildBrowserDriverOptions;
 exports.buildCompanionForwarderEnvOptions = buildCompanionForwarderEnvOptions;
@@ -63,6 +64,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const sessionManager_1 = require("../bridge/sessionManager");
 const server_1 = require("../bridge/server");
 const relayClient_1 = require("../bridge/relayClient");
+const gitTokenBroker_1 = require("../bridge/gitTokenBroker");
 const browserDriver_1 = require("../bridge/browserDriver");
 const browserHost_1 = require("../bridge/browserHost");
 const browserIdle_1 = require("../bridge/browserIdle");
@@ -124,6 +126,7 @@ const companionForwarder_1 = require("../bridge/companionForwarder");
 const previewForwarder_1 = require("../bridge/previewForwarder");
 // tp-05 — the Team preview checkout runner (hosted lane only, ADR-0014).
 const previewCheckout_1 = require("../bridge/previewCheckout");
+const storageCleanup_1 = require("../bridge/storageCleanup");
 /** lws-12 — real fs binding for writeGitignore.ts: mirrors realLocalContextWriterDeps
  *  above, but a `.gitignore` may already hold user content, so this is a plain
  *  read + overwrite (append), never atomic-rename — there's no concurrent
@@ -320,6 +323,28 @@ function readReposVolumeUsedGb(p) {
         return null;
     }
 }
+/**
+ * stc-06 — free and total GB of the volume holding `p` (the SAME statfs as
+ * readReposVolumeFreeMb), for the disk-pressure report on the `sessions`
+ * frame. null = unknown (no statfsSync, read failure): the field is omitted
+ * and the backend never acts on a guess.
+ */
+function readVolumeSpaceGb(p) {
+    try {
+        const statfsSync = fs.statfsSync;
+        if (!statfsSync)
+            return null;
+        const stats = statfsSync(p);
+        const GB = 1024 * 1024 * 1024;
+        const totalGb = (stats.blocks * stats.bsize) / GB;
+        if (!(totalGb > 0))
+            return null;
+        return { freeGb: (stats.bavail * stats.bsize) / GB, totalGb };
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * hcs-05/hcs-07 — recursive+force removal, shared by checkoutReclaimDeps.rm
  * (removing a RECLAIM-verdict checkout) and resolveWorkspaceCwd's cleanup of
@@ -650,17 +675,28 @@ exports.bridgeCommand = new commander_1.Command('bridge')
         // .env, served on 127.0.0.1:<preview port> (the port the forwarder
         // above targets). Container branch only; the local bridge's relay
         // client answers every preview frame `unsupported / local_lane`.
+        const previewsBaseDir = process.env.WENRWA_PREVIEWS_DIR || path.join(path.dirname(reposBaseDir), 'previews');
         const previewRunner = new previewCheckout_1.PreviewRunner({
-            previewsBaseDir: process.env.WENRWA_PREVIEWS_DIR || path.join(path.dirname(reposBaseDir), 'previews'),
+            previewsBaseDir,
             workingCopyDir: (workspaceId) => path.join(reposBaseDir, workspaceId),
             port: (0, previewForwarder_1.resolvePreviewPorts)(process.env).previewPort,
         });
         // cvt-07: the box's one shared Chromium, created lazily by the first tab.
         let browserHost;
-        (0, relayClient_1.startRelayClient)({
+        // a9be9720 — agents' git credentials stay fresh past the hour the
+        // injected one lives: git-credential-wenrwa asks this socket, the broker
+        // asks the relay. Hosted lane only — a laptop pushes with its own git.
+        const gitTokenSocket = process.env.WENRWA_GIT_TOKEN_SOCKET || path.join(os.homedir(), '.wenrwa', 'git-token.sock');
+        let relayClient = null;
+        const gitTokenBroker = new gitTokenBroker_1.GitTokenBroker((workspaceId) => relayClient
+            ? relayClient.requestGitToken(workspaceId)
+            : Promise.reject(Object.assign(new Error('The bridge is starting'), { code: 'OFFLINE' })));
+        (0, gitTokenBroker_1.startGitTokenSocket)({ path: gitTokenSocket, broker: gitTokenBroker }).catch((err) => console.error(`[bridge] git token socket failed to start — agents fall back to the token from open: ${err instanceof Error ? err.message : String(err)}`));
+        relayClient = (0, relayClient_1.startRelayClient)({
             relayUrl: relayMode.relayUrl,
             relayToken: relayMode.relayToken,
             sessions,
+            gitTokenSocket,
             // Rock-solid sleep/wake: this is the HOSTED container bridge, the only
             // process that knows which agent PTYs are actually running. The backend
             // reconciles claude_code_agents.lifecycle_state against this report —
@@ -743,12 +779,32 @@ exports.bridgeCommand = new commander_1.Command('bridge')
                 exists: (p) => fs.existsSync(p),
                 run: execRunner,
             },
+            // stc-05 — Clean up: measure + delete only rebuildable data (npm/uv/
+            // pip caches in the home dir and on the volume, preview slots not in
+            // use, removed-checkout leftovers, build output in clean repos). The
+            // button always works; AUTOMATIC cleanup (stc-06, before a disk
+            // grows) stays off unless HIVEOP_AUTO_CLEANUP=1 — the ADR-0008 kill
+            // switch. HOSTED LANE ONLY, like enableReclaim.
+            enableStorageCleanup: true,
+            storageCleanupDeps: {
+                previewsBaseDir,
+                cacheDirs: (0, storageCleanup_1.defaultCacheDirs)([os.homedir(), process.env.HOME, path.dirname(reposBaseDir)]),
+                previewActivity: () => previewRunner.activity(),
+                run: execRunner,
+                sizeBytes: duSizeBytes,
+                rm: rmCheckoutDir,
+                autoCleanupEnabled: process.env.HIVEOP_AUTO_CLEANUP === '1',
+            },
             // Rock-solid sleep/wake — refuse a PTY spawn the box can't hold,
             // rather than OOM-killing it behind an indefinite "Waking the
             // machine…" (production 2026-08-14: MemAvailable: 0 kB). Linux-only
             // by nature; a missing /proc/meminfo parses to null, which is UNKNOWN
             // and spawns exactly as before.
             readMemInfo: readContainerMemInfo,
+            // stc-06 — free space on the checkouts' volume rides every `sessions`
+            // frame; the backend grows a nearly-full disk while agents work
+            // (cleanup first, kill switch above). HOSTED LANE ONLY.
+            readDiskSpace: () => readVolumeSpaceGb(reposBaseDir),
             checkLoginValid: () => (0, loginStatus_1.checkClaudeLoginValid)({
                 claudeDir,
                 exists: (p) => fs.existsSync(p),
@@ -776,7 +832,7 @@ exports.bridgeCommand = new commander_1.Command('bridge')
                     // failure here gets. `result.code` is threaded through so the
                     // frame the pane receives carries the RIGHT code — free-space
                     // and quota refusals must never collapse onto the same one.
-                    throw new diskPreflight_1.ClonePreflightRefusalError(result.message, result.code);
+                    throw new diskPreflight_1.ClonePreflightRefusalError(result.message, result.code, result.quote);
                 }
                 // Playtest 2026-10-01 — Claude Code opens a fresh checkout on its
                 // folder-trust dialog (default "No, exit") even in bypass mode. The

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenrwa/marketplace-cli",
-  "version": "0.8.11",
+  "version": "0.8.13",
   "description": "CLI tool for the Wenrwa Agent Marketplace — monitor bounties, agents, workspaces, and treasury from your terminal",
   "author": "Wenrwa <dev@wenrwa.com>",
   "license": "MIT",