@wenrwa/marketplace-cli 0.6.6 → 0.7.0

package/dist/__tests__/bridge-checkout-inventory.test.js

@@ -29,23 +29,40 @@ function makeDeps(opts) {
             runCalls.push({ path: id, args });
             const fixture = opts.git?.[id] ?? {};
             const sub = args[2];
+            const fail = (msg) => {
+                if (fixture.rejectOnFailure)
+                    throw new Error(`Command failed: git ${args.join(' ')}\n${msg}`);
+                return { stdout: '', code: 128 };
+            };
             if (sub === 'status') {
                 if (fixture.failStatus)
-                    return { stdout: '', code: 128 };
+                    return fail('fatal: not a git repository');
                 return { stdout: fixture.status ?? '', code: 0 };
             }
             if (sub === 'stash') {
                 if (fixture.failStash)
-                    return { stdout: '', code: 128 };
+                    return fail('fatal: not a git repository');
                 return { stdout: fixture.stash ?? '', code: 0 };
             }
             if (sub === 'rev-list') {
+                expect(args.slice(3)).toEqual(['HEAD', '--not', '--remotes', '--count']);
                 if (fixture.ahead === undefined)
-                    return { stdout: '', code: 128 }; // no upstream
+                    return fail("fatal: ambiguous argument 'HEAD'");
                 return { stdout: fixture.ahead, code: 0 };
             }
+            if (sub === 'rev-parse') {
+                if (fixture.upstream === false)
+                    return fail("fatal: no upstream configured for branch 'backup/x'");
+                return { stdout: 'origin/main\n', code: 0 };
+            }
+            if (sub === 'show') {
+                if (fixture.headClaudeMd === undefined)
+                    return fail("fatal: path 'CLAUDE.md' does not exist in 'HEAD'");
+                return { stdout: fixture.headClaudeMd, code: 0 };
+            }
             throw new Error(`unexpected git call: ${args.join(' ')}`);
         },
+        readText: (p) => opts.files?.[p] ?? null,
     };
     return { deps, runCalls, sizeCalls };
 }
@@ -57,7 +74,10 @@ describe('scanCheckoutInventory — dirty detection (independent conditions)', (
             git: { 'ws-clean': { status: '', stash: '', ahead: '0' } },
         });
         const [entry] = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps);
-        expect(entry).toEqual({ workspaceId: 'ws-clean', unparseable: false, bytes: 4096, dirty: false, mtimeMs: 1000 });
+        expect(entry).toEqual({
+            workspaceId: 'ws-clean', unparseable: false, bytes: 4096, dirty: false, mtimeMs: 1000,
+            dirtyKinds: [], noUpstream: false, scanVersion: 2,
+        });
     });
     it('uncommitted changes alone mark the checkout dirty', async () => {
         const { deps } = makeDeps({
@@ -86,15 +106,107 @@ describe('scanCheckoutInventory — dirty detection (independent conditions)', (
         const [entry] = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps);
         expect(entry).toMatchObject({ dirty: true, unparseable: false });
     });
-    it('no upstream configured (rev-list fails) is treated as not-unpushed, not as a parse failure', async () => {
+    it('a repo with no commits (rev-list fails) is not unpushed, and not a parse failure', async () => {
         const { deps } = makeDeps({
-            workspaceIds: ['ws-no-upstream'],
-            sizes: { 'ws-no-upstream': 100 },
-            git: { 'ws-no-upstream': { status: '', stash: '' } }, // ahead undefined -> rev-list fails
+            workspaceIds: ['ws-empty'],
+            sizes: { 'ws-empty': 100 },
+            git: { 'ws-empty': { status: '', stash: '' } }, // ahead undefined -> rev-list fails
         });
         const [entry] = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps);
         expect(entry).toMatchObject({ dirty: false, unparseable: false });
     });
+    it('names WHICH conditions made it dirty', async () => {
+        const { deps } = makeDeps({
+            workspaceIds: ['ws'],
+            git: { ws: { status: ' M a.ts\n', stash: 'stash@{0}: x\n', ahead: '2' } },
+            files: {},
+        });
+        const [entry] = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps);
+        expect(entry).toMatchObject({ dirty: true, dirtyKinds: ['uncommitted', 'unpushed', 'stashed'] });
+    });
+});
+/*
+  Owner report 2026-10-02 — the Storage view said "Could not read this
+  checkout: Command failed: git -C … rev-list @{u}..HEAD --count fatal: no
+  upstream configured for branch 'backup/botsim-swee…'". The production runner
+  REJECTS on a failed command; the old check let that escape.
+*/
+describe('scanCheckoutInventory — a branch with no upstream (production runner rejects)', () => {
+    it('is a readable checkout with unpushed work and noUpstream, never unparseable', async () => {
+        const { deps } = makeDeps({
+            workspaceIds: ['ws-backup'],
+            sizes: { 'ws-backup': 100 },
+            git: { 'ws-backup': { status: '', stash: '', ahead: '3', upstream: false, rejectOnFailure: true } },
+        });
+        const [entry] = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps);
+        expect(entry).toMatchObject({ unparseable: false, dirty: true, dirtyKinds: ['unpushed'], noUpstream: true });
+    });
+    it('with every commit already on a remote, it is clean even without an upstream', async () => {
+        const { deps } = makeDeps({
+            workspaceIds: ['ws-gone'],
+            git: { 'ws-gone': { status: '', stash: '', ahead: '0', upstream: false, rejectOnFailure: true } },
+        });
+        const [entry] = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps);
+        expect(entry).toMatchObject({ unparseable: false, dirty: false, noUpstream: true });
+    });
+    it('a status that rejects is still unparseable (not a git checkout)', async () => {
+        const { deps } = makeDeps({
+            workspaceIds: ['ws-notgit'],
+            git: { 'ws-notgit': { failStatus: true, rejectOnFailure: true } },
+        });
+        const [entry] = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps);
+        expect(entry).toMatchObject({ unparseable: true, reason: 'git status failed — not a usable checkout' });
+    });
+});
+/*
+  Owner report 2026-10-02 — nearly every row, finished match copies that were
+  pushed included, said "Unsaved work". The bridge itself rewrites a managed
+  region of CLAUDE.md whenever a session opens (wmr-07).
+*/
+describe('scanCheckoutInventory — the bridge’s own writes are not unsaved work', () => {
+    const REGION = '<!-- HIVEOP:CONTEXT:START -->\n## Work graph\nstuff\n<!-- HIVEOP:CONTEXT:END -->\n';
+    it('an untracked CLAUDE.md holding only the managed region is clean', async () => {
+        const { deps } = makeDeps({
+            workspaceIds: ['ws'],
+            git: { ws: { status: '?? CLAUDE.md\n', stash: '', ahead: '0' } },
+            files: { [`${BASE}/ws/CLAUDE.md`]: REGION },
+        });
+        const [entry] = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps);
+        expect(entry).toMatchObject({ dirty: false, dirtyKinds: [] });
+    });
+    it('a committed CLAUDE.md that changed only inside the region is clean', async () => {
+        const { deps } = makeDeps({
+            workspaceIds: ['ws'],
+            git: { ws: { status: ' M CLAUDE.md\n', stash: '', ahead: '0', headClaudeMd: '# Project\n\nRules.\n' } },
+            files: { [`${BASE}/ws/CLAUDE.md`]: `# Project\n\nRules.\n\n${REGION}` },
+        });
+        const [entry] = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps);
+        expect(entry).toMatchObject({ dirty: false });
+    });
+    it('user text in CLAUDE.md outside the region IS unsaved work', async () => {
+        const { deps } = makeDeps({
+            workspaceIds: ['ws'],
+            git: { ws: { status: ' M CLAUDE.md\n', stash: '', ahead: '0', headClaudeMd: '# Project\n' } },
+            files: { [`${BASE}/ws/CLAUDE.md`]: `# Project\n\nMy new rule.\n${REGION}` },
+        });
+        const [entry] = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps);
+        expect(entry).toMatchObject({ dirty: true, dirtyKinds: ['uncommitted'] });
+    });
+    it('an untracked CLAUDE.md with user text is unsaved work', async () => {
+        const { deps } = makeDeps({
+            workspaceIds: ['ws'],
+            git: { ws: { status: '?? CLAUDE.md\n', stash: '', ahead: '0' } },
+            files: { [`${BASE}/ws/CLAUDE.md`]: `Notes\n${REGION}` },
+        });
+        const [entry] = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps);
+        expect(entry).toMatchObject({ dirty: true });
+    });
+    it('.hiveop/ is the bridge’s; any other file still counts', async () => {
+        const clean = makeDeps({ workspaceIds: ['ws'], git: { ws: { status: '?? .hiveop/\n', stash: '', ahead: '0' } } });
+        expect((await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, clean.deps))[0]).toMatchObject({ dirty: false });
+        const dirty = makeDeps({ workspaceIds: ['ws'], git: { ws: { status: '?? .hiveop/\n?? view/index.html\n', stash: '', ahead: '0' } } });
+        expect((await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, dirty.deps))[0]).toMatchObject({ dirty: true });
+    });
 });
 describe('scanCheckoutInventory — reporting shape', () => {
     it('one record per checkout, with workspace id, bytes, dirty flag, and mtime', async () => {
@@ -109,8 +221,8 @@ describe('scanCheckoutInventory — reporting shape', () => {
         });
         const entries = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps);
         expect(entries).toEqual([
-            { workspaceId: 'ws-a', unparseable: false, bytes: 1000, dirty: false, mtimeMs: 111 },
-            { workspaceId: 'ws-b', unparseable: false, bytes: 2000, dirty: true, mtimeMs: 222 },
+            { workspaceId: 'ws-a', unparseable: false, bytes: 1000, dirty: false, mtimeMs: 111, dirtyKinds: [], noUpstream: false, scanVersion: 2 },
+            { workspaceId: 'ws-b', unparseable: false, bytes: 2000, dirty: true, mtimeMs: 222, dirtyKinds: ['uncommitted'], noUpstream: false, scanVersion: 2 },
         ]);
     });
     it('an unreadable checkouts root yields an empty inventory, not a crash', async () => {
@@ -162,8 +274,8 @@ describe('scanCheckoutInventory — malformed/unreadable checkouts', () => {
         expect(entries.find((e) => e.workspaceId === 'ws-fine')?.unparseable).toBe(false);
     });
 });
-describe('scanCheckoutInventory — mtime cache (unchanged checkouts are not re-scanned)', () => {
-    it('reuses the cached entry when the mtime has not changed, without calling sizeBytes/run again', async () => {
+describe('scanCheckoutInventory — mtime cache (size only)', () => {
+    it('reuses the cached SIZE when the mtime has not changed, but re-checks dirty every scan', async () => {
         const { deps, runCalls, sizeCalls } = makeDeps({
             workspaceIds: ['ws-a'],
             mtimes: { 'ws-a': 500 },
@@ -176,8 +288,10 @@ describe('scanCheckoutInventory — mtime cache (unchanged checkouts are not re-
         expect(runCalls.length).toBeGreaterThan(0);
         const runCallsAfterFirst = runCalls.length;
         const second = await (0, checkoutInventory_1.scanCheckoutInventory)(BASE, deps, cache);
-        expect(sizeCalls).toEqual(['ws-a']); // not called again
-        expect(runCalls.length).toBe(runCallsAfterFirst); // no new git calls
+        expect(sizeCalls).toEqual(['ws-a']); // du not run again
+        // …but git is: a push lands inside .git and never moves the top-level
+        // mtime, so a cached dirty flag outlived the push that cleared it.
+        expect(runCalls.length).toBeGreaterThan(runCallsAfterFirst);
         expect(second).toEqual(first);
     });
     it('rescans when the mtime has changed', async () => {

package/dist/__tests__/bridge-checkout-park-and-remove.test.js

@@ -266,26 +266,43 @@ describe('checkoutParkAndRemove (hcs-06)', () => {
         expect(calls.some((c) => c.args.includes('commit'))).toBe(false);
         expect(calls.some((c) => c.args.includes('push'))).toBe(false);
     });
-    it('nothing to commit and nothing unpushed -> nothing-to-park, deletes nothing, never pushes', async () => {
+    it('remove with nothing to commit and nothing unpushed -> removed through the reclaimer, never pushes', async () => {
+        // Everything here is already on a remote. Refusing left clean match copies
+        // with no way out but the 14-day automatic sweep; the reclaimer's own
+        // re-check (clean, unattached) still guards the delete.
         const reclaimer = fakeReclaimer();
         const script = (args) => {
             if (args.includes('add'))
                 return { stdout: '', code: 0 };
             if (args.includes('status'))
-                return { stdout: '', code: 0 }; // clean working tree after add
+                return { stdout: '', code: 0 };
             if (args.includes('rev-list'))
-                return { stdout: '0\n', code: 0 }; // nothing unpushed either
+                return { stdout: '0\n', code: 0 };
             return { stdout: '', code: 0 };
         };
         const { deps, calls } = baseDeps(script, reclaimer);
-        const parker = (0, checkoutParkAndRemove_1.createCheckoutParker)(deps);
-        const result = await parker.park(WS);
-        expect(result.outcome).toBe('nothing-to-park');
-        expect(result.branch).toBe((0, checkoutParkAndRemove_1.parkingBranchName)(WS));
-        expect(reclaimer.calls).toEqual([]);
+        const result = await (0, checkoutParkAndRemove_1.createCheckoutParker)(deps).park(WS);
+        expect(result).toEqual({ workspaceId: WS, outcome: 'removed', branch: (0, checkoutParkAndRemove_1.parkingBranchName)(WS), bytesFreed: 4096 });
+        expect(reclaimer.calls).toHaveLength(1);
         expect(calls.some((c) => c.args.includes('push'))).toBe(false);
         expect(calls.some((c) => c.args.includes('commit'))).toBe(false);
     });
+    it('remove with nothing unsaved, but the reclaimer refuses (a session attached) -> retained with its reason', async () => {
+        const reclaimer = fakeReclaimer({
+            reclaim: async (v) => v.map((x) => ({ workspaceId: x.workspaceId, outcome: 'aborted', reason: 'a session attached' })),
+        });
+        const script = (args) => args.includes('rev-list') ? { stdout: '0\n', code: 0 } : { stdout: '', code: 0 };
+        const { deps } = baseDeps(script, reclaimer);
+        const result = await (0, checkoutParkAndRemove_1.createCheckoutParker)(deps).park(WS);
+        expect(result).toMatchObject({ outcome: 'retained', phase: 'removing', reason: 'a session attached' });
+    });
+    it('unpushed is "commits no remote ref contains", not @{u}..HEAD', async () => {
+        const reclaimer = fakeReclaimer();
+        const { deps, calls } = baseDeps(defaultScript(), reclaimer);
+        await (0, checkoutParkAndRemove_1.createCheckoutParker)(deps).park(WS);
+        const revList = calls.find((c) => c.args.includes('rev-list'));
+        expect(revList.args.slice(3)).toEqual(['HEAD', '--not', '--remotes', '--count']);
+    });
     it('nothing to commit but there ARE unpushed commits -> still pushes and removes', async () => {
         const reclaimer = fakeReclaimer();
         const script = (args) => {
@@ -383,4 +400,36 @@ describe('checkoutParkAndRemove (hcs-06)', () => {
         expect(firstResult.outcome).toBe('removed');
         expect(pushCalls).toBe(1); // never raced into a second push
     });
+    describe('Save (park without remove)', () => {
+        it('commits, pushes, verifies, records the tracking ref — and keeps the checkout', async () => {
+            const reclaimer = fakeReclaimer();
+            const sha = 'b'.repeat(40);
+            const { deps, calls } = baseDeps(defaultScript(sha), reclaimer);
+            const phases = [];
+            const result = await (0, checkoutParkAndRemove_1.createCheckoutParker)(deps).park(WS, (p) => phases.push(p), { remove: false });
+            expect(result).toEqual({ workspaceId: WS, outcome: 'saved', branch: (0, checkoutParkAndRemove_1.parkingBranchName)(WS) });
+            expect(phases).toEqual(['committing', 'pushing']);
+            expect(reclaimer.calls).toEqual([]);
+            const updateRef = calls.find((c) => c.args.includes('update-ref'));
+            expect(updateRef.args.slice(2)).toEqual(['update-ref', `refs/remotes/origin/park/${WS}`, sha]);
+        });
+        it('an unverified push is never reported as saved', async () => {
+            const reclaimer = fakeReclaimer();
+            const base = defaultScript();
+            const script = (args) => (args.includes('ls-remote') ? { stdout: '', code: 0 } : base(args));
+            const { deps, calls } = baseDeps(script, reclaimer);
+            const result = await (0, checkoutParkAndRemove_1.createCheckoutParker)(deps).park(WS, undefined, { remove: false });
+            expect(result.outcome).toBe('retained');
+            expect(calls.some((c) => c.args.includes('update-ref'))).toBe(false);
+        });
+        it('nothing unsaved -> nothing-to-park, nothing pushed, nothing removed', async () => {
+            const reclaimer = fakeReclaimer();
+            const script = (args) => args.includes('rev-list') ? { stdout: '0\n', code: 0 } : { stdout: '', code: 0 };
+            const { deps, calls } = baseDeps(script, reclaimer);
+            const result = await (0, checkoutParkAndRemove_1.createCheckoutParker)(deps).park(WS, undefined, { remove: false });
+            expect(result.outcome).toBe('nothing-to-park');
+            expect(reclaimer.calls).toEqual([]);
+            expect(calls.some((c) => c.args.includes('push'))).toBe(false);
+        });
+    });
 });

package/dist/__tests__/bridge-claude-trust.test.d.ts

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

package/dist/__tests__/bridge-claude-trust.test.js

@@ -0,0 +1,137 @@
+"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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const claudeTrust_1 = require("../bridge/claudeTrust");
+/**
+ * Playtest 2026-10-01 (Qubit Forge, hosted lane): Claude Code 2.1.28x shows
+ * its folder-trust dialog even under --dangerously-skip-permissions, on every
+ * fresh /data/repos/<workspaceId> checkout — and its default answer is
+ * "No, exit". The container is ours and the bridge cloned the folder, so the
+ * bridge marks the checkout trusted in the container's Claude config
+ * ($CLAUDE_CONFIG_DIR/.claude.json → projects[<dir>].hasTrustDialogAccepted),
+ * the key Claude Code reads (verified against 2.1.286: the entry suppresses
+ * the dialog; a parent entry does NOT count inside a git repo — Claude only
+ * walks up to the repo root, so the entry must name the checkout itself).
+ *
+ * Real files in a temp dir: the contract is the file Claude reads.
+ */
+describe('trustClaudeProjectDir', () => {
+    let root;
+    let configDir;
+    let reposBaseDir;
+    const configFile = () => path.join(configDir, '.claude.json');
+    const read = () => JSON.parse(fs.readFileSync(configFile(), 'utf-8'));
+    const trust = (dir) => (0, claudeTrust_1.trustClaudeProjectDir)(dir, { configDir, reposBaseDir });
+    beforeEach(() => {
+        root = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-trust-'));
+        configDir = path.join(root, '.claude');
+        reposBaseDir = path.join(root, 'repos');
+        fs.mkdirSync(configDir, { recursive: true });
+        fs.mkdirSync(path.join(reposBaseDir, 'ws-1'), { recursive: true });
+    });
+    afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
+    it('marks a bridge-managed checkout trusted, keeping every other key', () => {
+        const repo = path.join(reposBaseDir, 'ws-1');
+        fs.writeFileSync(configFile(), JSON.stringify({
+            hasCompletedOnboarding: true,
+            bypassPermissionsModeAccepted: true,
+            mcpServers: { x: { command: 'y' } },
+            projects: { '/elsewhere': { allowedTools: ['Bash'], hasTrustDialogAccepted: false } },
+        }));
+        expect(trust(repo)).toBe('trusted');
+        const cfg = read();
+        expect(cfg.projects[repo].hasTrustDialogAccepted).toBe(true);
+        expect(cfg.projects['/elsewhere']).toEqual({ allowedTools: ['Bash'], hasTrustDialogAccepted: false });
+        expect(cfg.hasCompletedOnboarding).toBe(true);
+        expect(cfg.bypassPermissionsModeAccepted).toBe(true);
+        expect(cfg.mcpServers).toEqual({ x: { command: 'y' } });
+    });
+    it("keeps the project's existing entry (allowed tools, history) and only adds the flag", () => {
+        const repo = path.join(reposBaseDir, 'ws-1');
+        fs.writeFileSync(configFile(), JSON.stringify({ projects: { [repo]: { allowedTools: ['Edit'], lastCost: 1 } } }));
+        expect(trust(repo)).toBe('trusted');
+        expect(read().projects[repo]).toEqual({ allowedTools: ['Edit'], lastCost: 1, hasTrustDialogAccepted: true });
+    });
+    it('is idempotent: an already-trusted checkout is not rewritten', () => {
+        const repo = path.join(reposBaseDir, 'ws-1');
+        const raw = JSON.stringify({ projects: { [repo]: { hasTrustDialogAccepted: true } } });
+        fs.writeFileSync(configFile(), raw);
+        expect(trust(repo)).toBe('already');
+        expect(fs.readFileSync(configFile(), 'utf-8')).toBe(raw);
+    });
+    it('creates the config when Claude has not written one yet', () => {
+        const repo = path.join(reposBaseDir, 'ws-1');
+        expect(trust(repo)).toBe('trusted');
+        expect(read()).toEqual({ projects: { [repo]: { hasTrustDialogAccepted: true } } });
+    });
+    it('never clobbers a config it cannot parse (that file holds the login state too)', () => {
+        const repo = path.join(reposBaseDir, 'ws-1');
+        fs.writeFileSync(configFile(), '{ half-written');
+        expect(trust(repo)).toBe('skipped');
+        expect(fs.readFileSync(configFile(), 'utf-8')).toBe('{ half-written');
+    });
+    it('only trusts folders the bridge manages: never the repos root itself, never outside it', () => {
+        expect(trust(reposBaseDir)).toBe('skipped');
+        expect(trust(path.join(root, 'home', 'project'))).toBe('skipped');
+        expect(trust(path.join(reposBaseDir, '..', 'escape'))).toBe('skipped');
+        expect(trust(`${reposBaseDir}-sibling/ws`)).toBe('skipped');
+        expect(fs.existsSync(configFile())).toBe(false);
+    });
+    it('leaves no temp file behind', () => {
+        trust(path.join(reposBaseDir, 'ws-1'));
+        expect(fs.readdirSync(configDir)).toEqual(['.claude.json']);
+    });
+});
+/**
+ * Wiring: the HOSTED bridge's clone-on-demand path (resolveWorkspaceCwd in
+ * commands/bridge.ts) pre-trusts the checkout, gated on CLAUDE_CONFIG_DIR.
+ * Code only (comments stripped) so prose cannot satisfy it.
+ */
+describe('hosted bridge wiring', () => {
+    const code = fs
+        .readFileSync(path.join(__dirname, '..', 'commands', 'bridge.ts'), 'utf-8')
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/^\s*\/\/.*$/gm, '');
+    it('resolveWorkspaceCwd trusts the checkout it returns, only with CLAUDE_CONFIG_DIR set', () => {
+        const body = code.match(/resolveWorkspaceCwd: async[\s\S]*?return result\.path \?\? null;/)?.[0] ?? '';
+        expect(body).toMatch(/if \(result\.path && process\.env\.CLAUDE_CONFIG_DIR\)[\s\S]*?trustClaudeProjectDir\(result\.path, \{ configDir: process\.env\.CLAUDE_CONFIG_DIR, reposBaseDir \}\)/);
+    });
+    it('is wired exactly once — never into the local BYO bridge', () => {
+        expect(code.match(/trustClaudeProjectDir\(/g)).toHaveLength(1);
+    });
+});

package/dist/__tests__/bridge-command-browser-options.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * cbs-07 — pure resolver for the Chromium options the `wen-market bridge`
+ * cbs-07 — pure resolver for the Chromium options the `hiveop bridge`
  * (relay mode) command wires into `createBrowserDriver`. Mirrors
  * resolveRelayMode's existing pattern in bridge.ts: the command shell itself
  * is thin/untested, so the actual decision logic lives in a pure,

package/dist/__tests__/bridge-command-install-env.test.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Autostart PATH/command fix (2026-08-13, live bug) — pure resolver for
- * `wen-market bridge install`. Mirrors buildBrowserDriverOptions'/
+ * `hiveop bridge install`. Mirrors buildBrowserDriverOptions'/
  * resolveRelayMode's existing pattern in bridge.ts: the actual decision
  * (which PATH, which command) lives in a pure, inputs-in/options-out
  * helper, unit-tested directly instead of forcing a harness onto the

package/dist/__tests__/bridge-device-registration.test.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * TDD — lws-03: bridge/deviceRegistration.ts. "Connect this machine" — on
- * first `wen-market bridge` run with a Connect Token configured, auto-
+ * first `hiveop bridge` run with a Connect Token configured, auto-
  * register the device; idempotent thereafter (persisted deviceId short-
  * circuits re-registration).
  */

package/dist/__tests__/bridge-folder-registry.test.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * TDD — lws-03: bridge/folderRegistry.ts. Persisted path→workspaceId map
  * (`~/.wen-market/local-workspaces.json`), survives daemon restart, backs
- * `wen-market local add/list/remove` and the discovery advertisement.
+ * `hiveop local add/list/remove` and the discovery advertisement.
  */
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));

package/dist/__tests__/bridge-local-add-core.test.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * TDD — lws-05: shared idempotent-add core behind POST /local/add (the
- * bridge-side twin of `wen-market local add`, PRD D3). Deps-injected — no
+ * bridge-side twin of `hiveop local add`, PRD D3). Deps-injected — no
  * real fs/network — server.ts wires the real folderRegistry + apiClient.
  */
 const localAdd_1 = require("../bridge/localAdd");

package/dist/__tests__/bridge-match-pointer.test.d.ts

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

package/dist/__tests__/bridge-match-pointer.test.js

@@ -0,0 +1,136 @@
+"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 });
+/**
+ * Qubit Forge playtest 2026-10-02 — in a MATCH workspace an agent said
+ * "CLAUDE.md says work should go through the HiveOp queue" and went looking
+ * for issues. A match has no queue to work: missions are scored when the
+ * pilot presses Submit on the committed, pushed code. The bridge learns a
+ * workspace is a match from the memory brief reply (`match: true`) and writes
+ * match guidance IN PLACE of the work-queue pointer, on both lanes. Ordinary
+ * workspaces are byte-identical to before.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const contextWriter_1 = require("../bridge/contextWriter");
+const localContextWriter_1 = require("../bridge/localContextWriter");
+const workGraphPointer_1 = require("../bridge/workGraphPointer");
+const memoryBrief_1 = require("../bridge/memoryBrief");
+const fakeFs = () => {
+    const files = new Map();
+    return {
+        files,
+        deps: {
+            reposBaseDir: '/data/repos',
+            exists: (p) => files.has(p),
+            readFile: (p) => files.get(p) ?? '',
+            writeFile: (p, c) => { files.set(p, c); },
+            mkdirp: () => { },
+        },
+    };
+};
+describe('MATCH_POINTER', () => {
+    it('says how a match is scored and what not to do — the runtime value', () => {
+        expect(workGraphPointer_1.MATCH_POINTER).toMatch(/^## Match\n/);
+        expect(workGraphPointer_1.MATCH_POINTER).toMatch(/scored when the pilot presses Submit/);
+        expect(workGraphPointer_1.MATCH_POINTER).toMatch(/[Cc]ommit and push/);
+        expect(workGraphPointer_1.MATCH_POINTER).toMatch(/list_ready_issues/);
+        expect(workGraphPointer_1.MATCH_POINTER).toMatch(/do not use/i);
+        expect(workGraphPointer_1.MATCH_POINTER).not.toMatch(/claim_issue` before starting/);
+    });
+});
+describe('hosted lane — writeContext', () => {
+    it('a match workspace gets the match guidance and NOT the work-queue pointer', () => {
+        const { files, deps } = fakeFs();
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-m', pointersOnly: true, workGraphAvailable: true, match: true }, deps);
+        const out = files.get('/data/repos/ws-m/CLAUDE.md') ?? '';
+        expect(out).toContain(workGraphPointer_1.MATCH_POINTER);
+        expect(out).not.toContain(workGraphPointer_1.WORK_GRAPH_POINTER);
+    });
+    it('an ordinary workspace is unchanged', () => {
+        const { files, deps } = fakeFs();
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-n', pointersOnly: true, workGraphAvailable: true }, deps);
+        const out = files.get('/data/repos/ws-n/CLAUDE.md') ?? '';
+        expect(out).toContain(workGraphPointer_1.WORK_GRAPH_POINTER);
+        expect(out).not.toContain(workGraphPointer_1.MATCH_POINTER);
+    });
+    it('a workspace that was a match and is kept loses the match guidance on the next write', () => {
+        const { files, deps } = fakeFs();
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-k', pointersOnly: true, workGraphAvailable: true, match: true }, deps);
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-k', pointersOnly: true, workGraphAvailable: true }, deps);
+        const out = files.get('/data/repos/ws-k/CLAUDE.md') ?? '';
+        expect(out).not.toContain(workGraphPointer_1.MATCH_POINTER);
+        expect(out).toContain(workGraphPointer_1.WORK_GRAPH_POINTER);
+    });
+});
+describe('local lane — writeLocalContext', () => {
+    it('a match workspace gets the match guidance and NOT the work-queue pointer', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'match-ptr-'));
+        try {
+            (0, localContextWriter_1.writeLocalContext)({ projectRoot: root, pointersOnly: true, workGraphAvailable: true, match: true }, {
+                exists: (p) => fs.existsSync(p),
+                readFile: (p) => fs.readFileSync(p, 'utf8'),
+                writeFileAtomic: (p, c) => fs.writeFileSync(p, c),
+                mkdirp: (d) => fs.mkdirSync(d, { recursive: true }),
+                remove: (p) => fs.rmSync(p, { force: true }),
+            });
+            const out = fs.readFileSync(path.join(root, localContextWriter_1.LOCAL_CONTEXT_RELATIVE_PATH), 'utf8');
+            expect(out).toContain(workGraphPointer_1.MATCH_POINTER);
+            expect(out).not.toContain(workGraphPointer_1.WORK_GRAPH_POINTER);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});
+describe('fetchWorkspaceBrief — the match flag rides the brief reply', () => {
+    const ENV = { ...process.env };
+    beforeEach(() => { process.env.WENRWA_CONNECT_TOKEN = 'wm_ct_' + 'a'.repeat(32); });
+    afterEach(() => { process.env = { ...ENV }; });
+    const reply = (body) => async () => ({ ok: true, status: 200, json: async () => body });
+    it('match: true → match', async () => {
+        await expect((0, memoryBrief_1.fetchWorkspaceBrief)('ws', { fetchImpl: reply({ success: true, brief: 'B', match: true }) }))
+            .resolves.toEqual({ brief: 'B', match: true });
+    });
+    it('no flag → not a match; an empty brief is still a reply', async () => {
+        await expect((0, memoryBrief_1.fetchWorkspaceBrief)('ws', { fetchImpl: reply({ success: true, brief: '' }) }))
+            .resolves.toEqual({ brief: null, match: false });
+    });
+    it('any failure → null (unknown), and fetchMemoryBrief keeps its contract', async () => {
+        await expect((0, memoryBrief_1.fetchWorkspaceBrief)('ws', { fetchImpl: async () => { throw new Error('down'); } })).resolves.toBeNull();
+        await expect((0, memoryBrief_1.fetchMemoryBrief)('ws', { fetchImpl: reply({ success: true, brief: 'B', match: true }) })).resolves.toBe('B');
+    });
+});

package/dist/__tests__/bridge-pairing-api.test.js

@@ -52,7 +52,7 @@ describe('bridge apiClient — pairing', () => {
         catch (err) {
             expect(err).toBeInstanceOf(apiClient_1.BridgeApiError);
             expect(err.code).toBe('PAT_FORBIDDEN');
-            expect(err.message).toBe('your pairing is out of date — run `wen-market pair` again');
+            expect(err.message).toBe('your pairing is out of date — run `hiveop pair` again');
             expect(err.message).not.toContain('Allowed:');
         }
     });

package/dist/__tests__/bridge-pairing-core.test.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * TDD — lws-14: bridge/pairing.ts pairCore. Orchestrates request → poll →
  * config write as a pure core (network + fs both injected), mirroring
  * addLocalWorkspaceCore / ensureDeviceRegistered's "pure core, thin command
- * shell" shape so `wen-market pair` itself stays a thin wrapper.
+ * shell" shape so `hiveop pair` itself stays a thin wrapper.
  */
 const pairing_1 = require("../bridge/pairing");
 describe('pairCore', () => {