@wenrwa/marketplace-cli 0.5.13-hcs.0 → 0.5.23

package/dist/__tests__/bridge-agent-launch.test.js

@@ -68,4 +68,79 @@ describe('resolveAgentLaunch (lws-06)', () => {
             });
         });
     });
+    // psp-01 (production bug, 2026-09-14; supersedes bres-01's `resume`
+    // boolean) — the local bridge's per-AGENT session pin. bres-01's
+    // `resume: boolean` decided --continue off the CWD alone, so two agents
+    // sharing one workspace checkout both resumed whichever conversation was
+    // most recently active for that directory — never their own. `sessionPin`
+    // pins the launch's session id to the AGENT instead: a prior transcript
+    // file for THIS agent → --resume <agentId>; none → --session-id <agentId>
+    // (a clean session PINNED to this agent, never a directory-scoped one).
+    describe('sessionPin (psp-01)', () => {
+        it('sessionPin.exists:false → --session-id <agentId> (first launch, PINS a fresh session)', () => {
+            const launch = (0, agentLaunch_1.resolveAgentLaunch)({ sessionPin: { agentId: 'agent-A', exists: false } });
+            expect(launch.args).toEqual(['--session-id', 'agent-A']);
+        });
+        it('sessionPin.exists:true → --resume <agentId> (a prior session for THIS agent already exists)', () => {
+            const launch = (0, agentLaunch_1.resolveAgentLaunch)({ sessionPin: { agentId: 'agent-A', exists: true } });
+            expect(launch.args).toEqual(['--resume', 'agent-A']);
+        });
+        it('stamps WENRWA_AGENT_ID into env whenever a sessionPin is given', () => {
+            const launch = (0, agentLaunch_1.resolveAgentLaunch)({ sessionPin: { agentId: 'agent-A', exists: true } });
+            expect(launch.env).toEqual({ HIVEOP_CONTEXT_FILE: '.hiveop/context.md', WENRWA_AGENT_ID: 'agent-A' });
+        });
+        it('omitting sessionPin entirely is byte-identical to today\'s bare shape (no args, no WENRWA_AGENT_ID)', () => {
+            expect((0, agentLaunch_1.resolveAgentLaunch)({})).toEqual({
+                command: 'claude',
+                args: [],
+                env: { HIVEOP_CONTEXT_FILE: '.hiveop/context.md' },
+            });
+        });
+        it('composes with autonomous AND activity — the session-pin flag lands LAST', () => {
+            const activity = { settingsPath: '/Users/t/.wen-market/claude-hooks-settings.json', sessionId: 'agent-123', activityFile: '/Users/t/.wen-market/activity.jsonl' };
+            const launch = (0, agentLaunch_1.resolveAgentLaunch)({ autonomous: true, activity, sessionPin: { agentId: 'agent-A', exists: true } });
+            expect(launch.args).toEqual(['--dangerously-skip-permissions', '--settings', activity.settingsPath, '--resume', 'agent-A']);
+        });
+        // THE PRODUCTION REPRO at this layer: two different agents in the same
+        // cwd (a shared workspace checkout) must never resolve to the same argv.
+        it('THE PRODUCTION REPRO: two different agents each get their OWN resume target, not a shared one', () => {
+            const forA = (0, agentLaunch_1.resolveAgentLaunch)({ sessionPin: { agentId: 'agent-A', exists: true } });
+            const forB = (0, agentLaunch_1.resolveAgentLaunch)({ sessionPin: { agentId: 'agent-B', exists: true } });
+            expect(forA.args).not.toEqual(forB.args);
+            expect(forA.env.WENRWA_AGENT_ID).not.toBe(forB.env.WENRWA_AGENT_ID);
+        });
+    });
+    // local-workspace-id-env — the local lane never set WENRWA_WORKSPACE_ID
+    // (unlike the hosted/relay lane, assembleSessionEnv in relayClient.ts),
+    // so the workgraph MCP tools' `workspaceId` parameter stayed a REQUIRED
+    // field the model had to guess a UUID for instead of an auto-pinned one
+    // (mcp-server/src/tools/workgraph-tools.ts's `ws()` helper). The local
+    // bridge's `open` frame already carries a per-session `workspaceId`
+    // (server.ts) — threading it through here stamps the same env var the
+    // hosted lane stamps, closing the gap without inventing a new lookup.
+    describe('workspaceId (local-workspace-id-env)', () => {
+        it('stamps WENRWA_WORKSPACE_ID into env when workspaceId is given', () => {
+            const launch = (0, agentLaunch_1.resolveAgentLaunch)({ workspaceId: 'ws-1' });
+            expect(launch.env).toEqual({ HIVEOP_CONTEXT_FILE: '.hiveop/context.md', WENRWA_WORKSPACE_ID: 'ws-1' });
+        });
+        it('omitting workspaceId is byte-identical to today\'s bare shape (no WENRWA_WORKSPACE_ID)', () => {
+            expect((0, agentLaunch_1.resolveAgentLaunch)({}).env).toEqual({ HIVEOP_CONTEXT_FILE: '.hiveop/context.md' });
+        });
+        it('composes with autonomous, activity, and sessionPin — independent of the other opts', () => {
+            const activity = { settingsPath: '/Users/t/.wen-market/claude-hooks-settings.json', sessionId: 'agent-123', activityFile: '/Users/t/.wen-market/activity.jsonl' };
+            const launch = (0, agentLaunch_1.resolveAgentLaunch)({
+                autonomous: true,
+                activity,
+                sessionPin: { agentId: 'agent-A', exists: true },
+                workspaceId: 'ws-1',
+            });
+            expect(launch.env).toEqual({
+                HIVEOP_CONTEXT_FILE: '.hiveop/context.md',
+                WENRWA_SESSION_ID: 'agent-123',
+                HIVEOP_ACTIVITY_FILE: activity.activityFile,
+                WENRWA_AGENT_ID: 'agent-A',
+                WENRWA_WORKSPACE_ID: 'ws-1',
+            });
+        });
+    });
 });

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

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

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

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * hcs-06 (docs/prd/hosted-container-storage-reclamation.md, ADR-0008) —
+ * checkoutParkAndRemove: the deliberate, user-initiated lever for a DIRTY
+ * checkout that automatic reclamation (hcs-04/hcs-05) will never touch.
+ *
+ * FAILS CLOSED BY CONSTRUCTION: commit -> push -> verify-on-remote -> only
+ * then delete (by reusing hcs-05's own checkoutReclaim executor for the
+ * delete step, never a second `rm` implementation). Every test below proves
+ * one of:
+ *   - a push failure (rejected / unauthenticated / network / unverifiable)
+ *     retains the checkout and deletes nothing;
+ *   - a commit failure retains the checkout and deletes nothing;
+ *   - a genuine success pushes AND removes;
+ *   - untracked files ride the commit;
+ *   - nothing-to-park is reported without deleting anything;
+ *   - a second concurrent park for the same workspace is refused, not raced.
+ *
+ * No real git, no real filesystem, no real network — `run` and the
+ * `reclaimer` are both injected fakes, same DI discipline as
+ * checkoutReclaim.ts's own test suite.
+ */
+const checkoutParkAndRemove_1 = require("../bridge/checkoutParkAndRemove");
+const REPOS = '/data/repos';
+const WS = 'ws-1';
+const TARGET = `${REPOS}/${WS}`;
+/** A scriptable git runner: maps an argv-prefix pattern to a canned result,
+ *  and records every call so a test can assert exactly what was run
+ *  (e.g. that untracked files are staged via `-A`). */
+function makeGitRunner(script) {
+    const calls = [];
+    const run = async (cmd, args) => {
+        calls.push({ cmd, args });
+        const outcome = script(args);
+        if (outcome === 'throw')
+            throw new Error('simulated network failure: getaddrinfo ENOTFOUND github.com');
+        return outcome;
+    };
+    return { run, calls };
+}
+/** Default happy-path script: dirty working tree, clean push, matching
+ *  ls-remote verification. Individual tests override specific branches. */
+function defaultScript(headSha = 'a'.repeat(40)) {
+    return (args) => {
+        if (args.includes('add'))
+            return { stdout: '', code: 0 };
+        if (args.includes('status'))
+            return { stdout: ' M some/file.ts\n?? new/untracked.ts\n', code: 0 };
+        if (args.includes('commit'))
+            return { stdout: '', code: 0 };
+        if (args.includes('rev-list'))
+            return { stdout: '0\n', code: 0 };
+        if (args.includes('rev-parse'))
+            return { stdout: `${headSha}\n`, code: 0 };
+        if (args.includes('push'))
+            return { stdout: '', code: 0 };
+        if (args.includes('ls-remote'))
+            return { stdout: `${headSha}\trefs/heads/park/${WS}\n`, code: 0 };
+        return { stdout: '', code: 0 };
+    };
+}
+function fakeReclaimer(overrides) {
+    const calls = [];
+    return {
+        calls,
+        async reclaim(verdicts) {
+            calls.push(verdicts);
+            if (overrides?.reclaim)
+                return overrides.reclaim(verdicts);
+            return verdicts.map((v) => ({ workspaceId: v.workspaceId, outcome: 'removed', bytesFreed: 4096 }));
+        },
+    };
+}
+function baseDeps(script, reclaimer, exists = () => true) {
+    const g = makeGitRunner(script);
+    return {
+        deps: { reposBaseDir: REPOS, exists, run: g.run, reclaimer },
+        calls: g.calls,
+    };
+}
+describe('checkoutParkAndRemove (hcs-06)', () => {
+    it('parkingBranchName is deterministic from the workspace id', () => {
+        expect((0, checkoutParkAndRemove_1.parkingBranchName)('ws-1')).toBe((0, checkoutParkAndRemove_1.parkingBranchName)('ws-1'));
+        expect((0, checkoutParkAndRemove_1.parkingBranchName)('ws-1')).not.toBe((0, checkoutParkAndRemove_1.parkingBranchName)('ws-2'));
+        expect((0, checkoutParkAndRemove_1.parkingBranchName)('ws-1')).toContain('ws-1');
+    });
+    it('successful park: work is verified on the remote AND the checkout is removed', async () => {
+        const reclaimer = fakeReclaimer();
+        const { deps, calls } = baseDeps(defaultScript(), reclaimer);
+        const parker = (0, checkoutParkAndRemove_1.createCheckoutParker)(deps);
+        const phases = [];
+        const result = await parker.park(WS, (p) => phases.push(p));
+        expect(result).toMatchObject({ workspaceId: WS, outcome: 'removed', bytesFreed: 4096 });
+        expect(result.branch).toBe((0, checkoutParkAndRemove_1.parkingBranchName)(WS));
+        expect(phases).toEqual(['committing', 'pushing', 'removing']);
+        expect(reclaimer.calls).toEqual([[{ workspaceId: WS, verdict: 'RECLAIM', reason: expect.any(String) }]]);
+        // Untracked files are included: `git add -A`, not a narrower add.
+        const addCall = calls.find((c) => c.args.includes('add'));
+        expect(addCall?.args).toEqual(expect.arrayContaining(['-A']));
+    });
+    it('push rejected (non-fast-forward) -> checkout retained, zero deletion, reason surfaced', async () => {
+        const reclaimer = fakeReclaimer();
+        const script = (args) => {
+            if (args.includes('add'))
+                return { stdout: '', code: 0 };
+            if (args.includes('status'))
+                return { stdout: ' M file.ts\n', code: 0 };
+            if (args.includes('commit'))
+                return { stdout: '', code: 0 };
+            if (args.includes('rev-list'))
+                return { stdout: '0\n', code: 0 };
+            if (args.includes('rev-parse'))
+                return { stdout: `${'a'.repeat(40)}\n`, code: 0 };
+            if (args.includes('push')) {
+                return { stdout: '! [rejected]        HEAD -> park/ws-1 (non-fast-forward)\n', code: 1 };
+            }
+            return { stdout: '', code: 0 };
+        };
+        const { deps } = baseDeps(script, reclaimer);
+        const parker = (0, checkoutParkAndRemove_1.createCheckoutParker)(deps);
+        const result = await parker.park(WS);
+        expect(result.outcome).toBe('retained');
+        expect(result.phase).toBe('pushing');
+        expect(result.reason).toMatch(/non-fast-forward|rejected/i);
+        expect(reclaimer.calls).toEqual([]); // removal is NEVER attempted
+    });
+    it('push unauthenticated -> checkout retained, zero deletion, reason surfaced', async () => {
+        const reclaimer = fakeReclaimer();
+        const script = (args) => {
+            if (args.includes('add'))
+                return { stdout: '', code: 0 };
+            if (args.includes('status'))
+                return { stdout: ' M file.ts\n', code: 0 };
+            if (args.includes('commit'))
+                return { stdout: '', code: 0 };
+            if (args.includes('rev-list'))
+                return { stdout: '0\n', code: 0 };
+            if (args.includes('rev-parse'))
+                return { stdout: `${'a'.repeat(40)}\n`, code: 0 };
+            if (args.includes('push')) {
+                return { stdout: 'fatal: could not read Username for \'https://github.com\': terminal prompts disabled\n', code: 1 };
+            }
+            return { stdout: '', code: 0 };
+        };
+        const { deps } = baseDeps(script, reclaimer);
+        const parker = (0, checkoutParkAndRemove_1.createCheckoutParker)(deps);
+        const result = await parker.park(WS);
+        expect(result.outcome).toBe('retained');
+        expect(result.phase).toBe('pushing');
+        expect(result.reason).toMatch(/Username|credentials|auth/i);
+        expect(reclaimer.calls).toEqual([]);
+    });
+    it('network failure during push -> checkout retained, zero deletion, reason surfaced', async () => {
+        const reclaimer = fakeReclaimer();
+        const script = (args) => {
+            if (args.includes('add'))
+                return { stdout: '', code: 0 };
+            if (args.includes('status'))
+                return { stdout: ' M file.ts\n', code: 0 };
+            if (args.includes('commit'))
+                return { stdout: '', code: 0 };
+            if (args.includes('rev-list'))
+                return { stdout: '0\n', code: 0 };
+            if (args.includes('rev-parse'))
+                return { stdout: `${'a'.repeat(40)}\n`, code: 0 };
+            if (args.includes('push'))
+                return 'throw'; // the injected runner rejects — real ECONNREFUSED/ENOTFOUND shape
+            return { stdout: '', code: 0 };
+        };
+        const { deps } = baseDeps(script, reclaimer);
+        const parker = (0, checkoutParkAndRemove_1.createCheckoutParker)(deps);
+        const result = await parker.park(WS);
+        expect(result.outcome).toBe('retained');
+        expect(result.phase).toBe('pushing');
+        expect(result.reason).toMatch(/network|ENOTFOUND|failure/i);
+        expect(reclaimer.calls).toEqual([]);
+    });
+    it('push reports success but the remote ref does not verify -> retained, zero deletion (never trust exit code alone)', async () => {
+        const reclaimer = fakeReclaimer();
+        const script = (args) => {
+            if (args.includes('add'))
+                return { stdout: '', code: 0 };
+            if (args.includes('status'))
+                return { stdout: ' M file.ts\n', code: 0 };
+            if (args.includes('commit'))
+                return { stdout: '', code: 0 };
+            if (args.includes('rev-list'))
+                return { stdout: '0\n', code: 0 };
+            if (args.includes('rev-parse'))
+                return { stdout: `${'a'.repeat(40)}\n`, code: 0 };
+            if (args.includes('push'))
+                return { stdout: '', code: 0 }; // claims success...
+            if (args.includes('ls-remote'))
+                return { stdout: '', code: 0 }; // ...but the ref isn't actually there
+            return { stdout: '', code: 0 };
+        };
+        const { deps } = baseDeps(script, reclaimer);
+        const parker = (0, checkoutParkAndRemove_1.createCheckoutParker)(deps);
+        const result = await parker.park(WS);
+        expect(result.outcome).toBe('retained');
+        expect(result.phase).toBe('pushing');
+        expect(result.reason).toMatch(/verif|remote/i);
+        expect(reclaimer.calls).toEqual([]);
+    });
+    it('push reports success but ls-remote returns a DIFFERENT sha -> retained, zero deletion', async () => {
+        const reclaimer = fakeReclaimer();
+        const localSha = 'a'.repeat(40);
+        const otherSha = 'b'.repeat(40);
+        const script = (args) => {
+            if (args.includes('add'))
+                return { stdout: '', code: 0 };
+            if (args.includes('status'))
+                return { stdout: ' M file.ts\n', code: 0 };
+            if (args.includes('commit'))
+                return { stdout: '', code: 0 };
+            if (args.includes('rev-list'))
+                return { stdout: '0\n', code: 0 };
+            if (args.includes('rev-parse'))
+                return { stdout: `${localSha}\n`, code: 0 };
+            if (args.includes('push'))
+                return { stdout: '', code: 0 };
+            if (args.includes('ls-remote'))
+                return { stdout: `${otherSha}\trefs/heads/park/${WS}\n`, code: 0 };
+            return { stdout: '', code: 0 };
+        };
+        const { deps } = baseDeps(script, reclaimer);
+        const parker = (0, checkoutParkAndRemove_1.createCheckoutParker)(deps);
+        const result = await parker.park(WS);
+        expect(result.outcome).toBe('retained');
+        expect(reclaimer.calls).toEqual([]);
+    });
+    it('commit fails -> checkout retained, zero deletion, reason surfaced, push never attempted', async () => {
+        const reclaimer = fakeReclaimer();
+        const script = (args) => {
+            if (args.includes('add'))
+                return { stdout: '', code: 0 };
+            if (args.includes('status'))
+                return { stdout: ' M file.ts\n', code: 0 };
+            if (args.includes('commit'))
+                return { stdout: 'fatal: unable to create index.lock\n', code: 1 };
+            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('retained');
+        expect(result.phase).toBe('committing');
+        expect(result.reason).toMatch(/index\.lock|commit/i);
+        expect(reclaimer.calls).toEqual([]);
+        expect(calls.some((c) => c.args.includes('push'))).toBe(false);
+    });
+    it('git add fails -> checkout retained, zero deletion, nothing committed or pushed', async () => {
+        const reclaimer = fakeReclaimer();
+        const script = (args) => {
+            if (args.includes('add'))
+                return { stdout: 'fatal: not a git repository\n', code: 128 };
+            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('retained');
+        expect(result.phase).toBe('committing');
+        expect(reclaimer.calls).toEqual([]);
+        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 () => {
+        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
+            if (args.includes('rev-list'))
+                return { stdout: '0\n', code: 0 }; // nothing unpushed either
+            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([]);
+        expect(calls.some((c) => c.args.includes('push'))).toBe(false);
+        expect(calls.some((c) => c.args.includes('commit'))).toBe(false);
+    });
+    it('nothing to commit but there ARE unpushed commits -> still pushes and removes', async () => {
+        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
+            if (args.includes('rev-list'))
+                return { stdout: '2\n', code: 0 }; // but 2 unpushed commits
+            if (args.includes('rev-parse'))
+                return { stdout: `${'a'.repeat(40)}\n`, code: 0 };
+            if (args.includes('push'))
+                return { stdout: '', code: 0 };
+            if (args.includes('ls-remote'))
+                return { stdout: `${'a'.repeat(40)}\trefs/heads/park/${WS}\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('removed');
+        expect(calls.some((c) => c.args.includes('commit'))).toBe(false); // nothing NEW to commit
+        expect(calls.some((c) => c.args.includes('push'))).toBe(true);
+    });
+    it('push succeeds and verifies, but the reuse-hcs-05 removal step aborts (e.g. a stash reappeared) -> retained, work already safe', async () => {
+        const reclaimer = fakeReclaimer({
+            reclaim: async (verdicts) => verdicts.map((v) => ({ workspaceId: v.workspaceId, outcome: 'aborted', reason: 'checkout became dirty between the inventory scan and removal — aborted' })),
+        });
+        const { deps } = baseDeps(defaultScript(), reclaimer);
+        const parker = (0, checkoutParkAndRemove_1.createCheckoutParker)(deps);
+        const result = await parker.park(WS);
+        expect(result.outcome).toBe('retained');
+        expect(result.phase).toBe('removing');
+        expect(result.reason).toMatch(/dirty|abort/i);
+        expect(result.branch).toBe((0, checkoutParkAndRemove_1.parkingBranchName)(WS)); // still findable — the push DID succeed
+    });
+    it('unsafe workspace id is refused before any git command runs', async () => {
+        const reclaimer = fakeReclaimer();
+        const { deps, calls } = baseDeps(defaultScript(), reclaimer);
+        const parker = (0, checkoutParkAndRemove_1.createCheckoutParker)(deps);
+        const result = await parker.park('../escape');
+        expect(result.outcome).toBe('refused');
+        expect(calls.length).toBe(0);
+        expect(reclaimer.calls).toEqual([]);
+    });
+    it('no checkout exists for this workspace id -> refused, not treated as trivially parked', async () => {
+        const reclaimer = fakeReclaimer();
+        const { deps } = baseDeps(defaultScript(), reclaimer, () => false);
+        const parker = (0, checkoutParkAndRemove_1.createCheckoutParker)(deps);
+        const result = await parker.park(WS);
+        expect(result.outcome).toBe('refused');
+        expect(reclaimer.calls).toEqual([]);
+    });
+    it('a second concurrent park for the same checkout is refused, not raced', async () => {
+        const reclaimer = fakeReclaimer();
+        let releasePush;
+        const pushGate = new Promise((r) => { releasePush = r; });
+        let pushCalls = 0;
+        const script = (args) => {
+            if (args.includes('add'))
+                return { stdout: '', code: 0 };
+            if (args.includes('status'))
+                return { stdout: ' M file.ts\n', code: 0 };
+            if (args.includes('commit'))
+                return { stdout: '', code: 0 };
+            if (args.includes('rev-list'))
+                return { stdout: '0\n', code: 0 };
+            if (args.includes('rev-parse'))
+                return { stdout: `${'a'.repeat(40)}\n`, code: 0 };
+            if (args.includes('push')) {
+                pushCalls++;
+                return { stdout: '', code: 0 };
+            }
+            if (args.includes('ls-remote'))
+                return { stdout: `${'a'.repeat(40)}\trefs/heads/park/${WS}\n`, code: 0 };
+            return { stdout: '', code: 0 };
+        };
+        // Wrap the runner so the FIRST push call blocks on pushGate, giving the
+        // second park() call a real window to race in.
+        const g = makeGitRunner(script);
+        const gatedRun = async (cmd, args) => {
+            if (args.includes('push'))
+                await pushGate;
+            return g.run(cmd, args);
+        };
+        const parker = (0, checkoutParkAndRemove_1.createCheckoutParker)({ reposBaseDir: REPOS, exists: () => true, run: gatedRun, reclaimer });
+        const first = parker.park(WS);
+        // Let the first call reach (and block inside) the push phase.
+        await new Promise((r) => setTimeout(r, 10));
+        const second = await parker.park(WS);
+        expect(second.outcome).toBe('refused');
+        expect(second.reason).toMatch(/already.*progress|in progress/i);
+        releasePush();
+        const firstResult = await first;
+        expect(firstResult.outcome).toBe('removed');
+        expect(pushCalls).toBe(1); // never raced into a second push
+    });
+});

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

@@ -329,7 +329,9 @@ describe('checkoutReclaim + repoCheckout — re-clone after reclaim', () => {
         // 1. Before reclaim: the terminal reuses the existing checkout.
         const before = await (0, repoCheckout_1.ensureWorkspaceRepo)({ workspaceId, repoUrl }, repoDeps);
         expect(before).toEqual({ path: dirPath, action: 'existing' });
-        expect(cloneRuns).toHaveLength(0);
+        // grad-04: reuse now also verifies `origin` matches the workspace's repo,
+        // so count CLONES — the invariant this test is named for — not every git call.
+        expect(cloneRuns.filter((r) => r.includes('clone'))).toHaveLength(0);
         // 2. Reclaim removes the checkout directory entirely.
         const reclaimDeps = {
             reposBaseDir: REPOS,
@@ -348,6 +350,6 @@ describe('checkoutReclaim + repoCheckout — re-clone after reclaim', () => {
         //    the repo (action: 'cloned'), never 'failed' (the home-dir degrade).
         const after = await (0, repoCheckout_1.ensureWorkspaceRepo)({ workspaceId, repoUrl }, repoDeps);
         expect(after).toEqual({ path: dirPath, action: 'cloned' });
-        expect(cloneRuns).toHaveLength(1);
+        expect(cloneRuns.filter((r) => r.includes('clone'))).toHaveLength(1);
     });
 });

package/dist/__tests__/bridge-companion-forwarder-env-options.test.d.ts

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

package/dist/__tests__/bridge-companion-forwarder-env-options.test.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * bws-08 — pure resolver for the companion forwarder's env-derived knobs
+ * (buildCompanionForwarderEnvOptions in commands/bridge.ts). Same
+ * "pure helper, thin command shell" pattern as buildBrowserDriverOptions
+ * (bridge-command-browser-options.test.ts) — `buildCompanionForwarder`
+ * itself is thin glue over real `/etc/hosts` + `/proc/net/tcp[6]` reads and
+ * is deliberately left untested here for the same reason the commander
+ * action itself is: the actual decisions (resolveFlyLocal6pnHost,
+ * createCompanionForwarder, createNoopCompanionForwarder) are each unit
+ * tested directly in bridge-companion-forwarder.test.ts.
+ */
+const bridge_1 = require("../commands/bridge");
+describe('buildCompanionForwarderEnvOptions (bws-08)', () => {
+    it('defaults to a 5s poll and no excluded ports', () => {
+        expect((0, bridge_1.buildCompanionForwarderEnvOptions)({})).toEqual({
+            pollMs: 5_000,
+            excludePorts: new Set(),
+        });
+    });
+    it('honors HT_COMPANION_FORWARDER_POLL_MS', () => {
+        expect((0, bridge_1.buildCompanionForwarderEnvOptions)({ HT_COMPANION_FORWARDER_POLL_MS: '2000' })).toEqual({
+            pollMs: 2000,
+            excludePorts: new Set(),
+        });
+    });
+    it('parses a comma-separated HT_COMPANION_FORWARDER_EXCLUDE_PORTS list', () => {
+        expect((0, bridge_1.buildCompanionForwarderEnvOptions)({ HT_COMPANION_FORWARDER_EXCLUDE_PORTS: '9229, 8377,3000' })).toEqual({
+            pollMs: 5_000,
+            excludePorts: new Set([9229, 8377, 3000]),
+        });
+    });
+    it('ignores garbage entries in the exclude-ports list rather than crashing', () => {
+        expect((0, bridge_1.buildCompanionForwarderEnvOptions)({ HT_COMPANION_FORWARDER_EXCLUDE_PORTS: 'nope,,-1,0,8080' })).toEqual({
+            pollMs: 5_000,
+            excludePorts: new Set([8080]),
+        });
+    });
+    it('falls back to the default poll on a non-numeric override', () => {
+        expect((0, bridge_1.buildCompanionForwarderEnvOptions)({ HT_COMPANION_FORWARDER_POLL_MS: 'abc' })).toEqual({
+            pollMs: 5_000,
+            excludePorts: new Set(),
+        });
+    });
+});

package/dist/__tests__/bridge-companion-forwarder.test.d.ts

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