@wenrwa/marketplace-cli 0.7.5 → 0.7.7

package/dist/__tests__/bridge-config-mcp.test.js

@@ -122,3 +122,50 @@ describe('MCP auto-registration', () => {
         expect((0, mcpRegister_1.redactToken)(cmd)).toContain('wm_ct_…<redacted>');
     });
 });
+describe('MCP registration — installed server (fast start)', () => {
+    const token = 'wm_ct_' + 'c'.repeat(64);
+    const server = { command: '/usr/local/bin/node', args: ['/Users/u/.wen-market/mcp/node_modules/@wenrwa/marketplace-mcp/dist/index.js'] };
+    const runner = (listOutput) => {
+        const calls = [];
+        const run = async (cmd, args) => {
+            calls.push([cmd, ...args]);
+            return { stdout: args.includes('list') ? listOutput : '', code: 0 };
+        };
+        return { calls, run };
+    };
+    it('registers the absolute installed command, never npx', async () => {
+        const { calls, run } = runner('');
+        const result = await (0, mcpRegister_1.registerMcpServer)({ connectToken: token, apiUrl: 'https://api.x', run, server });
+        expect(result.action).toBe('registered');
+        const add = calls.find((c) => c.includes('add'));
+        expect(add.slice(add.indexOf('--') + 1)).toEqual([server.command, ...server.args]);
+        expect(add).not.toContain('npx');
+    });
+    it('migrates an OLD `npx @wenrwa/marketplace-mcp` registration: remove then add the installed one', async () => {
+        const { calls, run } = runner('wenrwa-marketplace: npx @wenrwa/marketplace-mcp - ✓ Connected\n');
+        const result = await (0, mcpRegister_1.registerMcpServer)({ connectToken: token, apiUrl: 'https://api.x', run, server });
+        expect(result.action).toBe('migrated');
+        const removeIdx = calls.findIndex((c) => c.includes('remove'));
+        const addIdx = calls.findIndex((c) => c.includes('add'));
+        expect(removeIdx).toBeGreaterThan(-1);
+        expect(addIdx).toBeGreaterThan(removeIdx);
+        expect(calls[addIdx]).toContain(server.args[0]);
+    });
+    it('skips when the installed command is already registered', async () => {
+        const { calls, run } = runner(`wenrwa-marketplace: ${server.command} ${server.args[0]} - ✓ Connected\n`);
+        const result = await (0, mcpRegister_1.registerMcpServer)({ connectToken: token, apiUrl: 'https://api.x', run, server });
+        expect(result.action).toBe('already-registered');
+        expect(calls.some((c) => c.includes('add') || c.includes('remove'))).toBe(false);
+    });
+    it('re-points a registration whose node binary moved', async () => {
+        const { run } = runner(`wenrwa-marketplace: /old/node ${server.args[0]} - ✓ Connected\n`);
+        const result = await (0, mcpRegister_1.registerMcpServer)({ connectToken: token, apiUrl: 'https://api.x', run, server });
+        expect(result.action).toBe('migrated');
+    });
+    it('fallback (no installed server): an existing registration is left alone', async () => {
+        const { calls, run } = runner(`wenrwa-marketplace: ${server.command} ${server.args[0]} - ✓ Connected\n`);
+        const result = await (0, mcpRegister_1.registerMcpServer)({ connectToken: token, apiUrl: 'https://api.x', run });
+        expect(result.action).toBe('already-registered');
+        expect(calls.some((c) => c.includes('add'))).toBe(false);
+    });
+});

package/dist/__tests__/bridge-hiveop-settings.test.js

@@ -114,3 +114,23 @@ describe('resolveHooksDir', () => {
         expect((0, hiveopSettings_1.resolveHooksDir)()).toBe(path.join(__dirname, '..', '..', 'hooks'));
     });
 });
+describe('SessionStart loads .hiveop/context.md (2026-10-04: the local context was written but never read)', () => {
+    it('registers the session-start hook alongside the activity hooks', () => {
+        const json = JSON.parse((0, hiveopSettings_1.buildHiveOpSettingsContent)('/opt/x/hooks'));
+        const cmds = (json.hooks.SessionStart ?? []).flatMap((m) => m.hooks.map(h => h.command));
+        expect(cmds).toEqual(['node "/opt/x/hooks/session-start.js"']);
+    });
+    it('the hook prints the context file for the session cwd, and nothing when absent', () => {
+        const fs = require('fs');
+        const os = require('os');
+        const path = require('path');
+        const cp = require('child_process');
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'hiveop-ss-'));
+        const hook = path.join(__dirname, '..', '..', 'hooks', 'session-start.js');
+        const run = () => cp.execFileSync('node', [hook], { input: JSON.stringify({ cwd: dir }) }).toString();
+        expect(run()).toBe('');
+        fs.mkdirSync(path.join(dir, '.hiveop'));
+        fs.writeFileSync(path.join(dir, '.hiveop', 'context.md'), '## Browser\ncall show_in_browser');
+        expect(run()).toContain('call show_in_browser');
+    });
+});

package/dist/__tests__/bridge-launch-gate.test.d.ts

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

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

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const launchGate_1 = require("../bridge/launchGate");
+const sessionManager_1 = require("../bridge/sessionManager");
+class FakePty {
+    spawnOpts;
+    written = [];
+    resizes = [];
+    killed = false;
+    dataCbs = [];
+    exitCbs = [];
+    constructor(spawnOpts) {
+        this.spawnOpts = spawnOpts;
+    }
+    write(d) { this.written.push(d); }
+    resize(c, r) { this.resizes.push([c, r]); }
+    kill() { this.killed = true; }
+    onData(cb) { this.dataCbs.push(cb); }
+    onExit(cb) { this.exitCbs.push(cb); }
+    emitData(d) { for (const cb of this.dataCbs)
+        cb(d); }
+    emitExit(c) { for (const cb of this.exitCbs)
+        cb(c); }
+}
+/** Fake clock: timers fire only when advanced. */
+const fakeClock = () => {
+    let t = 0;
+    let nextId = 1;
+    const timers = new Map();
+    return {
+        scheduleTimeout: (cb, ms) => { const id = nextId++; timers.set(id, { at: t + ms, cb }); return id; },
+        cancelTimeout: (h) => { timers.delete(h); },
+        advance(ms) {
+            t += ms;
+            for (const [id, timer] of [...timers]) {
+                if (timer.at <= t && timers.has(id)) {
+                    timers.delete(id);
+                    timer.cb();
+                }
+            }
+        },
+    };
+};
+const spawner = () => {
+    const ptys = [];
+    const spawn = (size) => { const p = new FakePty(size); ptys.push(p); return p; };
+    return { ptys, spawn };
+};
+const collect = (pty) => {
+    const out = [];
+    pty.onData((d) => out.push(d));
+    return out;
+};
+describe('LaunchGate', () => {
+    it('starts two at once; the third queues with "Starting… (2 ahead)" visible immediately', () => {
+        const clock = fakeClock();
+        const gate = new launchGate_1.LaunchGate({ ...clock, log: () => { } });
+        const { ptys, spawn } = spawner();
+        gate.launch(spawn, { cols: 80, rows: 24 });
+        gate.launch(spawn, { cols: 80, rows: 24 });
+        const third = gate.launch(spawn, { cols: 80, rows: 24 });
+        const out = collect(third); // subscribed AFTER launch, as SessionManager does
+        expect(ptys).toHaveLength(2);
+        expect(gate.queuedCount()).toBe(1);
+        expect(out.join('')).toContain('Starting… (2 ahead)');
+    });
+    it('a starting launch frees its slot on FIRST OUTPUT, and the queue drains FIFO', () => {
+        const clock = fakeClock();
+        const gate = new launchGate_1.LaunchGate({ ...clock, log: () => { } });
+        const { ptys, spawn } = spawner();
+        const a = gate.launch(spawn, { cols: 80, rows: 24 });
+        gate.launch(spawn, { cols: 80, rows: 24 });
+        const c = gate.launch(spawn, { cols: 100, rows: 30 });
+        const d = gate.launch(spawn, { cols: 80, rows: 24 });
+        const outA = collect(a);
+        const outC = collect(c);
+        const outD = collect(d);
+        expect(outD.join('')).toContain('Starting… (3 ahead)');
+        ptys[0].emitData('hello');
+        expect(outA).toEqual(['hello']);
+        expect(ptys).toHaveLength(3);
+        expect(ptys[2].spawnOpts).toMatchObject({ cols: 100, rows: 30 }); // c went first
+        expect(outD[outD.length - 1]).toBe((0, launchGate_1.queuedLine)(2)); // renumbered in place
+        ptys[2].emitData('claude ui');
+        expect(outC[outC.length - 1]).toBe('claude ui');
+        expect(ptys).toHaveLength(4);
+    });
+    it('a launch that prints nothing frees its slot after 8s', () => {
+        const clock = fakeClock();
+        const gate = new launchGate_1.LaunchGate({ ...clock, log: () => { } });
+        const { ptys, spawn } = spawner();
+        for (let i = 0; i < 3; i++)
+            gate.launch(spawn, { cols: 80, rows: 24 });
+        clock.advance(7_999);
+        expect(ptys).toHaveLength(2);
+        clock.advance(1);
+        expect(ptys).toHaveLength(3);
+    });
+    it('an exit frees the slot too', () => {
+        const clock = fakeClock();
+        const gate = new launchGate_1.LaunchGate({ ...clock, log: () => { } });
+        const { ptys, spawn } = spawner();
+        for (let i = 0; i < 3; i++)
+            gate.launch(spawn, { cols: 80, rows: 24 });
+        ptys[1].emitExit(1);
+        expect(ptys).toHaveLength(3);
+    });
+    it('killing a queued launch removes it without spawning; the ones behind move up', () => {
+        const clock = fakeClock();
+        const gate = new launchGate_1.LaunchGate({ ...clock, log: () => { } });
+        const { ptys, spawn } = spawner();
+        gate.launch(spawn, { cols: 80, rows: 24 });
+        gate.launch(spawn, { cols: 80, rows: 24 });
+        const q1 = gate.launch(spawn, { cols: 80, rows: 24 });
+        const q2 = gate.launch(spawn, { cols: 80, rows: 24 });
+        const out2 = collect(q2);
+        q1.kill();
+        expect(gate.queuedCount()).toBe(1);
+        expect(out2[out2.length - 1]).toBe((0, launchGate_1.queuedLine)(2));
+        ptys[0].emitData('x');
+        expect(ptys).toHaveLength(3);
+        clock.advance(10_000);
+        expect(ptys).toHaveLength(3); // the killed one never spawns
+    });
+    it('input typed while queued is delivered once the process starts; resize is applied', () => {
+        const clock = fakeClock();
+        const gate = new launchGate_1.LaunchGate({ ...clock, log: () => { } });
+        const { ptys, spawn } = spawner();
+        gate.launch(spawn, { cols: 80, rows: 24 });
+        gate.launch(spawn, { cols: 80, rows: 24 });
+        const q = gate.launch(spawn, { cols: 80, rows: 24 });
+        q.write('hi');
+        q.resize(120, 40);
+        ptys[0].emitData('x');
+        expect(ptys[2].spawnOpts).toMatchObject({ cols: 120, rows: 40 });
+        expect(ptys[2].written).toEqual(['hi']);
+    });
+    it('a queued spawn that throws prints a line and exits instead of hanging the pane', () => {
+        const clock = fakeClock();
+        const gate = new launchGate_1.LaunchGate({ ...clock, log: () => { } });
+        const { ptys, spawn } = spawner();
+        gate.launch(spawn, { cols: 80, rows: 24 });
+        gate.launch(spawn, { cols: 80, rows: 24 });
+        const q = gate.launch(() => { throw new Error('EAGAIN'); }, { cols: 80, rows: 24 });
+        const out = collect(q);
+        const exits = [];
+        q.onExit((c) => exits.push(c));
+        ptys[0].emitData('x');
+        expect(out.join('')).toContain("Claude couldn't start: EAGAIN");
+        expect(exits).toEqual([1]);
+        expect(gate.startingCount()).toBe(1);
+    });
+    it('an immediate spawn that throws propagates and frees the slot', () => {
+        const gate = new launchGate_1.LaunchGate({ ...fakeClock(), log: () => { } });
+        expect(() => gate.launch(() => { throw new Error('ENOMEM'); }, { cols: 80, rows: 24 })).toThrow('ENOMEM');
+        expect(gate.startingCount()).toBe(0);
+    });
+});
+describe('SessionManager staggers agent launches, never shells', () => {
+    const snapshot = () => ({
+        write: () => Promise.resolve(),
+        resize: () => { },
+        serialize: () => Promise.resolve(''),
+        dispose: () => { },
+    });
+    const setup = (everyOpenIsAgentLaunch = false) => {
+        const clock = fakeClock();
+        const ptys = [];
+        const factory = { spawn: (o) => { const p = new FakePty(o); ptys.push(p); return p; } };
+        const sm = new sessionManager_1.SessionManager(factory, {
+            snapshotFactory: snapshot,
+            launchGate: { ...clock, log: () => { } },
+            launchSupervisor: { settle: (fn) => fn(), log: () => { } },
+            everyOpenIsAgentLaunch,
+        });
+        return { sm, ptys, clock };
+    };
+    it('seven claude opens → two processes now, all seven sessions registered, the rest follow as output arrives', () => {
+        const { sm, ptys } = setup();
+        const ids = Array.from({ length: 7 }, () => sm.open({ cols: 80, rows: 24, command: 'claude', args: [] }));
+        expect(sm.list()).toEqual(ids);
+        expect(ptys).toHaveLength(2);
+        ptys[0].emitData('ready');
+        ptys[1].emitData('ready');
+        expect(ptys).toHaveLength(4);
+    });
+    it('a queued pane is never blank: its snapshot (what an attach replays) holds the Starting line', () => {
+        const writes = [];
+        const recording = () => {
+            const mine = [];
+            writes.push(mine);
+            return { write: (d) => { mine.push(d); return Promise.resolve(); }, resize: () => { }, serialize: () => Promise.resolve(mine.join('')), dispose: () => { } };
+        };
+        const factory = { spawn: (o) => new FakePty(o) };
+        const sm = new sessionManager_1.SessionManager(factory, { snapshotFactory: recording, launchGate: { ...fakeClock(), log: () => { } } });
+        for (let i = 0; i < 3; i++)
+            sm.open({ cols: 80, rows: 24, command: 'claude', args: [] });
+        expect(writes[2].join('')).toContain('Starting… (2 ahead)');
+        expect(writes[0].join('')).toBe('');
+    });
+    it('plain shells are never delayed, even with claude launches queued', () => {
+        const { sm, ptys } = setup();
+        for (let i = 0; i < 4; i++)
+            sm.open({ cols: 80, rows: 24, command: 'claude', args: [] });
+        expect(ptys).toHaveLength(2);
+        sm.open({ cols: 80, rows: 24 });
+        expect(ptys).toHaveLength(3);
+        expect(ptys[2].spawnOpts.command).toBeUndefined();
+    });
+    it('hosted lane (everyOpenIsAgentLaunch): shell opens are gated, since autolaunch turns each into claude', () => {
+        const { sm, ptys, clock } = setup(true);
+        for (let i = 0; i < 3; i++)
+            sm.open({ cols: 80, rows: 24 });
+        expect(ptys).toHaveLength(2);
+        clock.advance(8_000);
+        expect(ptys).toHaveLength(3);
+    });
+});

package/dist/__tests__/bridge-mcp-install.test.d.ts

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

package/dist/__tests__/bridge-mcp-install.test.js

@@ -0,0 +1,100 @@
+"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 path = __importStar(require("path"));
+const mcpInstall_1 = require("../bridge/mcpInstall");
+const BASE = '/home/u/.wen-market/mcp';
+const PKG = path.join(BASE, 'node_modules', '@wenrwa', 'marketplace-mcp', 'package.json');
+const ENTRY = (0, mcpInstall_1.mcpEntryPath)(BASE);
+/** In-memory fs; `npmInstalls` (if given) is what a successful npm run leaves behind. */
+const fakeDeps = (opts = {}) => {
+    const files = { ...(opts.files ?? {}) };
+    const npmCalls = [];
+    const deps = {
+        runNpm: async (args) => {
+            npmCalls.push(args);
+            if (opts.npm === 'throw')
+                throw new Error('ENOTFOUND registry.npmjs.org');
+            if (opts.npm === 'fail')
+                return { code: 1 };
+            files[PKG] = JSON.stringify({ version: opts.installs ?? mcpInstall_1.MCP_PINNED_VERSION });
+            files[ENTRY] = '// server';
+            return { code: 0 };
+        },
+        exists: (p) => p in files,
+        readFile: (p) => { if (!(p in files))
+            throw new Error('ENOENT'); return files[p]; },
+        writeFile: (p, c) => { files[p] = c; },
+        mkdirp: () => { },
+        now: () => opts.now ?? 1_000_000_000,
+        nodePath: '/usr/local/bin/node',
+    };
+    return { deps, files, npmCalls };
+};
+const installed = (version) => ({ [PKG]: JSON.stringify({ version }), [ENTRY]: '// server' });
+describe('ensureMcpInstalled', () => {
+    it('already at the pinned version → no npm run, absolute node + entry', async () => {
+        const { deps, npmCalls } = fakeDeps({ files: installed(mcpInstall_1.MCP_PINNED_VERSION) });
+        const r = await (0, mcpInstall_1.ensureMcpInstalled)({ baseDir: BASE }, deps);
+        expect(npmCalls).toHaveLength(0);
+        expect(r).toMatchObject({ ok: true, action: 'present', command: '/usr/local/bin/node', args: [ENTRY] });
+    });
+    it('missing → npm install --prefix <baseDir> of the pinned version', async () => {
+        const { deps, npmCalls, files } = fakeDeps();
+        const r = await (0, mcpInstall_1.ensureMcpInstalled)({ baseDir: BASE }, deps);
+        expect(r).toMatchObject({ ok: true, action: 'installed', version: mcpInstall_1.MCP_PINNED_VERSION });
+        expect(npmCalls[0]).toEqual(expect.arrayContaining(['install', '--prefix', BASE, `@wenrwa/marketplace-mcp@${mcpInstall_1.MCP_PINNED_VERSION}`]));
+        expect(files[path.join(BASE, 'package.json')]).toBeDefined();
+    });
+    it('offline with nothing installed → not ok (caller falls back to npx), and records the failure', async () => {
+        const { deps, files } = fakeDeps({ npm: 'throw' });
+        const r = await (0, mcpInstall_1.ensureMcpInstalled)({ baseDir: BASE }, deps);
+        expect(r).toMatchObject({ ok: false, action: 'failed' });
+        expect(files[path.join(BASE, '.last-failed-install')]).toBe('1000000000');
+    });
+    it('a recent failure is not retried for INSTALL_RETRY_MS; after that it is', async () => {
+        const stamp = { [path.join(BASE, '.last-failed-install')]: '1000000000' };
+        const soon = fakeDeps({ files: stamp, now: 1_000_000_000 + mcpInstall_1.INSTALL_RETRY_MS - 1 });
+        expect(await (0, mcpInstall_1.ensureMcpInstalled)({ baseDir: BASE }, soon.deps)).toMatchObject({ ok: false, action: 'skipped-recent-failure' });
+        expect(soon.npmCalls).toHaveLength(0);
+        const later = fakeDeps({ files: stamp, now: 1_000_000_000 + mcpInstall_1.INSTALL_RETRY_MS });
+        expect(await (0, mcpInstall_1.ensureMcpInstalled)({ baseDir: BASE }, later.deps)).toMatchObject({ ok: true, action: 'installed' });
+    });
+    it('upgrade fails but an older copy is installed → keep using it', async () => {
+        const { deps } = fakeDeps({ files: installed('0.8.0'), npm: 'fail' });
+        const r = await (0, mcpInstall_1.ensureMcpInstalled)({ baseDir: BASE }, deps);
+        expect(r).toMatchObject({ ok: true, action: 'stale-copy', version: '0.8.0', args: [ENTRY] });
+    });
+});

package/dist/bridge/hiveopSettings.js

@@ -88,6 +88,9 @@ function buildHiveOpSettingsContent(hooksDir) {
                 },
             ],
             Stop: [{ hooks: [{ type: 'command', command: hookCommand(hooksDir, 'stop.js') }] }],
+            // Loads `.hiveop/context.md` (the bridge's managed context) into every
+            // local session — without it that file was written but never read.
+            SessionStart: [{ hooks: [{ type: 'command', command: hookCommand(hooksDir, 'session-start.js') }] }],
         },
     };
     return JSON.stringify(obj, null, 2) + '\n';

package/dist/bridge/launchGate.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Launch gate — staggers `claude` start-ups so N agents opened at once don't
+ * all boot in the same second.
+ *
+ * Observed 2026-10-04: seven agents added together spawned seven `claude`
+ * processes, each spawning its MCP server, and the machine's load average hit
+ * 82 — every pane sat blank for one to two minutes. Booting them a couple at
+ * a time finishes sooner for all of them.
+ *
+ * Rules:
+ *  - at most `maxStarting` launches are "starting" at once (default 2);
+ *  - a launch stops "starting" at its FIRST OUTPUT, or after `releaseAfterMs`
+ *    (default 8s), or when it exits/is killed — whichever comes first;
+ *  - further launches queue FIFO; a queued pane immediately shows
+ *    "Starting… (N ahead)" so it is never blank, and the count updates as the
+ *    queue moves.
+ *
+ * Only agent launches go through here (SessionManager decides which); plain
+ * shells are never delayed.
+ *
+ * `gate.launch(spawn)` returns a PtyLike synchronously, so SessionManager can
+ * register the session and a pane can attach before the process exists.
+ * Writes typed while queued are held (capped) and delivered after spawn;
+ * resizes are remembered and applied.
+ */
+import type { PtyLike } from './sessionManager';
+export declare const DEFAULT_MAX_STARTING = 2;
+export declare const DEFAULT_RELEASE_AFTER_MS = 8000;
+export interface LaunchGateOptions {
+    maxStarting?: number;
+    releaseAfterMs?: number;
+    scheduleTimeout?: (cb: () => void, ms: number) => unknown;
+    cancelTimeout?: (handle: unknown) => void;
+    log?: (msg: string) => void;
+}
+/** The line a queued pane shows. `\r\x1b[2K` rewrites it in place as the count moves. */
+export declare function queuedLine(ahead: number): string;
+export declare class LaunchGate {
+    private maxStarting;
+    private releaseAfterMs;
+    private scheduleTimeout;
+    private cancelTimeout;
+    private log;
+    private starting;
+    private queue;
+    constructor(opts?: LaunchGateOptions);
+    /** Launches currently in their start-up window. */
+    startingCount(): number;
+    /** Launches waiting for a slot. */
+    queuedCount(): number;
+    /**
+     * Gate one launch. `spawn` receives the latest geometry. If a slot is free
+     * it runs synchronously (a throw propagates, exactly like an ungated
+     * spawn); otherwise the launch queues and the returned PtyLike stands in.
+     */
+    launch(spawn: (size: {
+        cols: number;
+        rows: number;
+    }) => PtyLike, size: {
+        cols: number;
+        rows: number;
+    }): PtyLike;
+    /** Start queued launches while slots are free. */
+    private drain;
+    /** Tell every queued launch how many are ahead of it now. */
+    private renumber;
+}

package/dist/bridge/launchGate.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LaunchGate = exports.DEFAULT_RELEASE_AFTER_MS = exports.DEFAULT_MAX_STARTING = void 0;
+exports.queuedLine = queuedLine;
+exports.DEFAULT_MAX_STARTING = 2;
+exports.DEFAULT_RELEASE_AFTER_MS = 8_000;
+/** Cap on keystrokes held for a queued launch. */
+const MAX_HELD_INPUT = 4 * 1024;
+/** The line a queued pane shows. `\r\x1b[2K` rewrites it in place as the count moves. */
+function queuedLine(ahead) {
+    return `\r\x1b[2K\x1b[2mStarting… (${ahead} ahead)\x1b[0m`;
+}
+/** Wipes the queued line just before the real process starts drawing. */
+const CLEAR_QUEUED_LINE = '\r\x1b[2K';
+class LaunchGate {
+    maxStarting;
+    releaseAfterMs;
+    scheduleTimeout;
+    cancelTimeout;
+    log;
+    starting = 0;
+    queue = [];
+    constructor(opts = {}) {
+        this.maxStarting = Math.max(1, opts.maxStarting ?? exports.DEFAULT_MAX_STARTING);
+        this.releaseAfterMs = opts.releaseAfterMs ?? exports.DEFAULT_RELEASE_AFTER_MS;
+        this.scheduleTimeout = opts.scheduleTimeout ?? ((cb, ms) => {
+            const h = setTimeout(cb, ms);
+            h.unref?.(); // a pending release must never keep the process alive
+            return h;
+        });
+        this.cancelTimeout = opts.cancelTimeout ?? ((h) => clearTimeout(h));
+        this.log = opts.log ?? ((m) => console.error(m));
+    }
+    /** Launches currently in their start-up window. */
+    startingCount() {
+        return this.starting;
+    }
+    /** Launches waiting for a slot. */
+    queuedCount() {
+        return this.queue.length;
+    }
+    /**
+     * Gate one launch. `spawn` receives the latest geometry. If a slot is free
+     * it runs synchronously (a throw propagates, exactly like an ungated
+     * spawn); otherwise the launch queues and the returned PtyLike stands in.
+     */
+    launch(spawn, size) {
+        const dataListeners = [];
+        const exitListeners = [];
+        /** Output emitted before SessionManager subscribed (the queued line). */
+        let unheard = [];
+        const emitData = (d) => {
+            if (dataListeners.length === 0) {
+                unheard.push(d);
+                return;
+            }
+            for (const cb of dataListeners)
+                cb(d);
+        };
+        const emitExit = (code) => { for (const cb of exitListeners)
+            cb(code); };
+        let cols = size.cols;
+        let rows = size.rows;
+        let real = null;
+        let killed = false;
+        let heldInput = '';
+        let queuedEntry = null;
+        // Slot bookkeeping for THIS launch: released exactly once.
+        let holdsSlot = false;
+        let releaseTimer = null;
+        const release = () => {
+            if (!holdsSlot)
+                return;
+            holdsSlot = false;
+            if (releaseTimer !== null)
+                this.cancelTimeout(releaseTimer);
+            releaseTimer = null;
+            this.starting -= 1;
+            this.drain();
+        };
+        const startReal = (fromQueue) => {
+            holdsSlot = true;
+            this.starting += 1;
+            let pty;
+            try {
+                pty = spawn({ cols, rows });
+            }
+            catch (err) {
+                release();
+                if (!fromQueue)
+                    throw err;
+                const msg = err instanceof Error ? err.message : String(err);
+                this.log(`[bridge] queued claude launch failed to spawn: ${msg}`);
+                emitData(`${CLEAR_QUEUED_LINE}\x1b[33mClaude couldn't start: ${msg}. Reopen the pane to try again.\x1b[0m\r\n`);
+                emitExit(1);
+                return;
+            }
+            real = pty;
+            releaseTimer = this.scheduleTimeout(release, this.releaseAfterMs);
+            if (fromQueue)
+                emitData(CLEAR_QUEUED_LINE);
+            pty.onData((d) => {
+                release();
+                emitData(d);
+            });
+            pty.onExit((code) => {
+                release();
+                emitExit(code);
+            });
+            if (fromQueue && heldInput) {
+                const input = heldInput;
+                heldInput = '';
+                pty.write(input);
+            }
+        };
+        if (this.starting < this.maxStarting && this.queue.length === 0) {
+            startReal(false);
+        }
+        else {
+            queuedEntry = {
+                start: () => { queuedEntry = null; if (!killed)
+                    startReal(true); },
+                notify: (ahead) => emitData(queuedLine(ahead)),
+            };
+            this.queue.push(queuedEntry);
+            emitData(queuedLine(this.queue.length - 1 + this.starting));
+        }
+        return {
+            write: (d) => {
+                if (real) {
+                    real.write(d);
+                    return;
+                }
+                if (heldInput.length + d.length <= MAX_HELD_INPUT)
+                    heldInput += d;
+            },
+            resize: (c, r) => {
+                cols = c;
+                rows = r;
+                real?.resize(c, r);
+            },
+            kill: () => {
+                killed = true;
+                if (real) {
+                    real.kill();
+                    return;
+                }
+                // Never started: just leave the queue. No exit is emitted — the caller
+                // killed it and is already tearing the session down, exactly as for a
+                // session closed before its process printed anything.
+                if (queuedEntry) {
+                    const i = this.queue.indexOf(queuedEntry);
+                    if (i >= 0)
+                        this.queue.splice(i, 1);
+                    queuedEntry = null;
+                    this.renumber();
+                }
+            },
+            onData: (cb) => {
+                dataListeners.push(cb);
+                if (unheard.length) {
+                    const pending = unheard;
+                    unheard = [];
+                    for (const d of pending)
+                        cb(d);
+                }
+            },
+            onExit: (cb) => { exitListeners.push(cb); },
+        };
+    }
+    /** Start queued launches while slots are free. */
+    drain() {
+        let moved = false;
+        while (this.starting < this.maxStarting && this.queue.length > 0) {
+            const next = this.queue.shift();
+            moved = true;
+            next.start();
+        }
+        if (moved)
+            this.renumber();
+    }
+    /** Tell every queued launch how many are ahead of it now. */
+    renumber() {
+        this.queue.forEach((entry, i) => entry.notify(i + this.starting));
+    }
+}
+exports.LaunchGate = LaunchGate;

package/dist/bridge/mcpInstall.d.ts

@@ -0,0 +1,39 @@
+export declare const MCP_PACKAGE = "@wenrwa/marketplace-mcp";
+/** Bump on each CLI release that should move to a newer MCP server. */
+export declare const MCP_PINNED_VERSION = "0.9.0";
+/** After a failed install, wait this long before trying again. */
+export declare const INSTALL_RETRY_MS: number;
+export interface McpInstallDeps {
+    /** Run npm. Rejects (or returns non-zero) on failure. */
+    runNpm: (args: string[]) => Promise<{
+        code: number;
+    }>;
+    exists: (p: string) => boolean;
+    readFile: (p: string) => string;
+    writeFile: (p: string, content: string) => void;
+    mkdirp: (dir: string) => void;
+    now: () => number;
+    /** Absolute node binary that runs the server (the bridge's own). */
+    nodePath: string;
+}
+export interface McpInstallOpts {
+    /** e.g. ~/.wen-market/mcp */
+    baseDir: string;
+    version?: string;
+}
+export type McpInstallResult = {
+    ok: true;
+    action: 'present' | 'installed' | 'stale-copy';
+    command: string;
+    args: string[];
+    entry: string;
+    version: string;
+    error?: string;
+} | {
+    ok: false;
+    action: 'failed' | 'skipped-recent-failure';
+    error: string;
+};
+/** Where the installed server's entry point lives under `baseDir`. */
+export declare function mcpEntryPath(baseDir: string): string;
+export declare function ensureMcpInstalled(opts: McpInstallOpts, deps: McpInstallDeps): Promise<McpInstallResult>;

package/dist/bridge/mcpInstall.js

@@ -0,0 +1,128 @@
+"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.INSTALL_RETRY_MS = exports.MCP_PINNED_VERSION = exports.MCP_PACKAGE = void 0;
+exports.mcpEntryPath = mcpEntryPath;
+exports.ensureMcpInstalled = ensureMcpInstalled;
+/**
+ * A pinned, installed copy of @wenrwa/marketplace-mcp for the LOCAL lane.
+ *
+ * Registering the MCP server as `npx @wenrwa/marketplace-mcp` made every
+ * `claude` launch run `npm exec` — a registry round-trip plus package
+ * resolution per agent. Seven agents opened together meant seven of those at
+ * once (load average 82 on 2026-10-04, panes blank for 1–2 min).
+ *
+ * Instead the bridge installs the server ONCE under ~/.wen-market/mcp and the
+ * registration points at it with an absolute command (`<node> <entry>`), so a
+ * launch just starts node on a file already on disk.
+ *
+ *  - Version: MCP_PINNED_VERSION — what this CLI release was built against,
+ *    bumped with each release (the hosted image pins the same in its
+ *    Dockerfile).
+ *  - Already installed at that version → nothing runs.
+ *  - Install fails (offline, registry down) → an older installed copy is still
+ *    used if one exists; otherwise the caller falls back to npx. A failure is
+ *    not retried for INSTALL_RETRY_MS, so an offline laptop does not pay an
+ *    npm timeout on every bridge start.
+ *
+ * The hosted container never comes through here: its image installs the
+ * server globally and entrypoint.sh registers it.
+ */
+const path = __importStar(require("path"));
+exports.MCP_PACKAGE = '@wenrwa/marketplace-mcp';
+/** Bump on each CLI release that should move to a newer MCP server. */
+exports.MCP_PINNED_VERSION = '0.9.0';
+/** After a failed install, wait this long before trying again. */
+exports.INSTALL_RETRY_MS = 6 * 60 * 60 * 1000;
+/** Where the installed server's entry point lives under `baseDir`. */
+function mcpEntryPath(baseDir) {
+    return path.join(baseDir, 'node_modules', '@wenrwa', 'marketplace-mcp', 'dist', 'index.js');
+}
+function installedVersion(baseDir, deps) {
+    const pkg = path.join(baseDir, 'node_modules', '@wenrwa', 'marketplace-mcp', 'package.json');
+    if (!deps.exists(pkg) || !deps.exists(mcpEntryPath(baseDir)))
+        return null;
+    try {
+        const v = JSON.parse(deps.readFile(pkg)).version;
+        return typeof v === 'string' ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function ensureMcpInstalled(opts, deps) {
+    const version = opts.version ?? exports.MCP_PINNED_VERSION;
+    const entry = mcpEntryPath(opts.baseDir);
+    const ok = (action, v, error) => ({
+        ok: true, action, command: deps.nodePath, args: [entry], entry, version: v, ...(error ? { error } : {}),
+    });
+    const have = installedVersion(opts.baseDir, deps);
+    if (have === version)
+        return ok('present', have);
+    const stampPath = path.join(opts.baseDir, '.last-failed-install');
+    const fallback = (action, error) => have ? ok('stale-copy', have, error) : { ok: false, action, error };
+    try {
+        const last = deps.exists(stampPath) ? Number(deps.readFile(stampPath).trim()) : NaN;
+        if (Number.isFinite(last) && deps.now() - last < exports.INSTALL_RETRY_MS) {
+            return fallback('skipped-recent-failure', 'a recent install attempt failed; retrying later');
+        }
+    }
+    catch { /* unreadable stamp → just try */ }
+    let error;
+    try {
+        deps.mkdirp(opts.baseDir);
+        const pkgJson = path.join(opts.baseDir, 'package.json');
+        // Own package.json so npm never walks up into some other project.
+        if (!deps.exists(pkgJson))
+            deps.writeFile(pkgJson, JSON.stringify({ name: 'wen-market-mcp', private: true }, null, 2) + '\n');
+        const res = await deps.runNpm([
+            'install', '--prefix', opts.baseDir,
+            '--no-audit', '--no-fund', '--omit=dev', '--no-package-lock',
+            `${exports.MCP_PACKAGE}@${version}`,
+        ]);
+        const now = installedVersion(opts.baseDir, deps);
+        if (res.code === 0 && now === version)
+            return ok('installed', now);
+        error = `npm install exited ${res.code}${now ? ` (found ${now})` : ''}`;
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+    }
+    try {
+        deps.writeFile(stampPath, String(deps.now()));
+    }
+    catch { /* best effort */ }
+    return fallback('failed', error);
+}

package/dist/bridge/mcpRegister.d.ts

@@ -17,12 +17,24 @@ export interface McpRegisterOpts {
     /** Set when a fresh token was just provided: an existing registration
      *  carries the OLD token env and must be replaced, not skipped. */
     forceUpdate?: boolean;
+    /** The installed server to register (mcpInstall.ts): an absolute command,
+     *  e.g. `<node> ~/.wen-market/mcp/.../dist/index.js`. Absent → the legacy
+     *  `npx @wenrwa/marketplace-mcp` (install failed / offline). */
+    server?: {
+        command: string;
+        args: string[];
+    };
 }
 export interface McpRegisterResult {
-    action: 'registered' | 're-registered' | 'already-registered' | 'claude-not-found';
+    /** `migrated`: an existing registration used another command (the old
+     *  per-launch npx form) and was replaced with `server`. */
+    action: 'registered' | 're-registered' | 'migrated' | 'already-registered' | 'claude-not-found';
     command?: string;
 }
 export declare const MCP_SERVER_NAME = "wenrwa-marketplace";
 /** Connect Tokens must never appear in output — redact before printing. */
 export declare function redactToken(text: string): string;
 export declare function registerMcpServer(opts: McpRegisterOpts): Promise<McpRegisterResult>;
+/** The `claude mcp list` line for our server, e.g.
+ *  `wenrwa-marketplace: npx @wenrwa/marketplace-mcp - ✓ Connected`. */
+export declare function registrationLine(listOutput: string): string | null;

package/dist/bridge/mcpRegister.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MCP_SERVER_NAME = void 0;
 exports.redactToken = redactToken;
 exports.registerMcpServer = registerMcpServer;
+exports.registrationLine = registrationLine;
 exports.MCP_SERVER_NAME = 'wenrwa-marketplace';
 /** Connect Tokens must never appear in output — redact before printing. */
 function redactToken(text) {
@@ -18,20 +19,39 @@ async function registerMcpServer(opts) {
         return { action: 'claude-not-found' };
     }
     const exists = listOutput.includes(exports.MCP_SERVER_NAME);
-    if (exists && !opts.forceUpdate) {
+    // With an installed server to point at, a registration whose line does not
+    // run exactly that command (the old `npx @wenrwa/marketplace-mcp`, or a
+    // node binary that has since moved) is replaced. Without one (fallback), any existing
+    // registration is kept — never downgrade a working absolute one to npx.
+    const line = registrationLine(listOutput);
+    const wanted = opts.server ? [opts.server.command, ...opts.server.args].join(' ') : null;
+    const stale = wanted !== null && exists && !(line ?? '').includes(wanted);
+    if (exists && !opts.forceUpdate && !stale) {
         return { action: 'already-registered' };
     }
-    if (exists && opts.forceUpdate) {
+    if (exists) {
         await opts.run('claude', ['mcp', 'remove', '--scope', 'user', exports.MCP_SERVER_NAME]).catch(() => { });
         // Also clear a stale default(local)-scope entry from older bridge versions.
         await opts.run('claude', ['mcp', 'remove', exports.MCP_SERVER_NAME]).catch(() => { });
     }
+    const server = opts.server ? [opts.server.command, ...opts.server.args] : ['npx', '@wenrwa/marketplace-mcp'];
     const args = [
         'mcp', 'add', '--scope', 'user', exports.MCP_SERVER_NAME,
         '-e', `WENRWA_CONNECT_TOKEN=${opts.connectToken}`,
         '-e', `MARKETPLACE_API_URL=${opts.apiUrl}`,
-        '--', 'npx', '@wenrwa/marketplace-mcp',
+        '--', ...server,
     ];
     await opts.run('claude', args);
-    return { action: exists ? 're-registered' : 'registered', command: `claude ${args.join(' ')}` };
+    const action = !exists ? 'registered' : opts.forceUpdate ? 're-registered' : 'migrated';
+    return { action, command: `claude ${args.join(' ')}` };
+}
+/** The `claude mcp list` line for our server, e.g.
+ *  `wenrwa-marketplace: npx @wenrwa/marketplace-mcp - ✓ Connected`. */
+function registrationLine(listOutput) {
+    for (const raw of listOutput.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line.startsWith(`${exports.MCP_SERVER_NAME}:`))
+            return line;
+    }
+    return null;
 }

package/dist/bridge/sessionManager.d.ts

@@ -1,5 +1,6 @@
 import { TermSnapshot } from './termSnapshot';
 import { LaunchSupervisorOptions } from './launchSupervisor';
+import { LaunchGateOptions } from './launchGate';
 export interface PtyLike {
     write(data: string): void;
     resize(cols: number, rows: number): void;
@@ -88,6 +89,15 @@ export interface SessionManagerOptions {
      *  self-healing retry for a session-id/resume mismatch, else a plain
      *  "Claude couldn't start" line. Injectable clock/settle for tests. */
     launchSupervisor?: LaunchSupervisorOptions;
+    /** Staggers agent start-ups (launchGate.ts): at most 2 starting at once,
+     *  the rest queue with a "Starting… (N ahead)" line. Options for the
+     *  default gate, or `false` to spawn every launch immediately. */
+    launchGate?: LaunchGateOptions | false;
+    /** Hosted container lane: every PTY is a $SHELL that autolaunch.sh turns
+     *  into `claude`, so every open is an agent launch and goes through the
+     *  gate. Off (laptop) → only an explicit `command: 'claude'` is gated and
+     *  plain shells are never delayed. */
+    everyOpenIsAgentLaunch?: boolean;
 }
 /**
  * lws-07 (ADR-0033 port): validates a client-supplied size pair for the
@@ -112,6 +122,8 @@ export declare class SessionManager {
     private cancelTimeout;
     private snapshotFactory;
     private launchSupervisor;
+    private launchGate;
+    private everyOpenIsAgentLaunch;
     /** twr-16: cumulative count of attach-pipeline wedges (any stage timeout,
      *  or a serialize-wedge whose recovery retry ALSO timed out) since this
      *  SessionManager was created. Surfaced via attachFailures() into the

package/dist/bridge/sessionManager.js

@@ -22,6 +22,7 @@ exports.validSize = validSize;
 const crypto_1 = __importDefault(require("crypto"));
 const termSnapshot_1 = require("./termSnapshot");
 const launchSupervisor_1 = require("./launchSupervisor");
+const launchGate_1 = require("./launchGate");
 /** Default settle window (lws-07): after a resize-on-attach, how long we give
  *  the PTY's SIGWINCH-triggered repaint to land in the snapshot before
  *  serializing. Small — this only needs to cover one render tick, not a
@@ -75,6 +76,8 @@ class SessionManager {
     cancelTimeout;
     snapshotFactory;
     launchSupervisor;
+    launchGate;
+    everyOpenIsAgentLaunch;
     /** twr-16: cumulative count of attach-pipeline wedges (any stage timeout,
      *  or a serialize-wedge whose recovery retry ALSO timed out) since this
      *  SessionManager was created. Surfaced via attachFailures() into the
@@ -92,6 +95,8 @@ class SessionManager {
         this.cancelTimeout = opts.cancelTimeout ?? ((h) => clearTimeout(h));
         this.snapshotFactory = opts.snapshotFactory ?? termSnapshot_1.createTermSnapshot;
         this.launchSupervisor = opts.launchSupervisor ?? {};
+        this.launchGate = opts.launchGate === false ? null : new launchGate_1.LaunchGate(opts.launchGate ?? {});
+        this.everyOpenIsAgentLaunch = opts.everyOpenIsAgentLaunch ?? false;
     }
     /** twr-16: see attachFailureCount. */
     attachFailures() {
@@ -129,9 +134,16 @@ class SessionManager {
         // A `claude` launch (agent panes, crew members) is supervised through its
         // startup window so a fast failure heals or explains itself; a shell is
         // spawned exactly as before.
-        const pty = opts.command === 'claude'
-            ? (0, launchSupervisor_1.superviseLaunch)(this.factory, opts, this.launchSupervisor)
-            : this.factory.spawn(opts);
+        // Agent launches are also staggered (launchGate.ts) so a burst of opens
+        // doesn't boot every `claude` in the same second; a shell never waits.
+        const isClaude = opts.command === 'claude';
+        const spawnOne = (size) => isClaude
+            ? (0, launchSupervisor_1.superviseLaunch)(this.factory, { ...opts, ...size }, this.launchSupervisor)
+            : this.factory.spawn({ ...opts, ...size });
+        const gated = this.launchGate && (isClaude || this.everyOpenIsAgentLaunch);
+        const pty = gated
+            ? this.launchGate.launch(spawnOne, { cols: opts.cols, rows: opts.rows })
+            : spawnOne({ cols: opts.cols, rows: opts.rows });
         const snapshot = this.snapshotFactory(opts.cols, opts.rows, { scrollback: this.snapshotScrollback });
         const session = {
             pty,

package/dist/commands/bridge.js

@@ -69,6 +69,7 @@ const loginStatus_1 = require("../bridge/loginStatus");
 const realPty_1 = require("../bridge/realPty");
 const config_1 = require("../bridge/config");
 const mcpRegister_1 = require("../bridge/mcpRegister");
+const mcpInstall_1 = require("../bridge/mcpInstall");
 const autostart_1 = require("../bridge/autostart");
 const repoCheckout_1 = require("../bridge/repoCheckout");
 const bundleInstaller_1 = require("../bridge/bundleInstaller");
@@ -480,7 +481,9 @@ exports.bridgeCommand = new commander_1.Command('bridge')
         return;
     }
     if (relayMode.mode === 'relay') {
-        const sessions = new sessionManager_1.SessionManager((0, realPty_1.realPtyFactory)());
+        // Every container PTY is a $SHELL that autolaunch.sh turns into
+        // `claude`, so every open is an agent launch and is staggered.
+        const sessions = new sessionManager_1.SessionManager((0, realPty_1.realPtyFactory)(), { everyOpenIsAgentLaunch: true });
         // pucc-03 (ADR-0031 model B): one container, many workspaces. Each
         // workspace's repo lives under /data/repos/<workspaceId> and is cloned
         // on demand the first time a terminal for it opens. The entrypoint can't
@@ -966,6 +969,29 @@ exports.bridgeCommand = new commander_1.Command('bridge')
             console.log(chalk_1.default.green(`✓ Connected this machine as device "${deviceResult.deviceName}" (~/.wen-market/bridge-config.json)`));
         }
     }
+    // 1.9. A pinned, installed MCP server (mcpInstall.ts) so each `claude`
+    // launch starts node on a file on disk instead of running `npx` — seven
+    // agents opened together used to mean seven concurrent `npm exec`s.
+    const mcpDir = path.join(os.homedir(), '.wen-market', 'mcp');
+    const mcpInstall = await (0, mcpInstall_1.ensureMcpInstalled)({ baseDir: mcpDir }, {
+        runNpm: (args) => new Promise((resolve) => {
+            (0, child_process_1.execFile)(process.platform === 'win32' ? 'npm.cmd' : 'npm', args, { timeout: 120_000 }, (err) => {
+                resolve({ code: err ? (typeof err.code === 'number' ? err.code : 1) : 0 });
+            });
+        }),
+        exists: (p) => fs.existsSync(p),
+        readFile: (p) => fs.readFileSync(p, 'utf-8'),
+        writeFile: (p, c) => fs.writeFileSync(p, c),
+        mkdirp: (d) => fs.mkdirSync(d, { recursive: true }),
+        now: Date.now,
+        nodePath: process.execPath,
+    });
+    if (mcpInstall.ok && mcpInstall.action === 'installed')
+        console.log(chalk_1.default.green(`✓ Installed MCP server ${mcpInstall_1.MCP_PINNED_VERSION} (${mcpDir})`));
+    else if (mcpInstall.ok && mcpInstall.action === 'stale-copy')
+        console.log(chalk_1.default.yellow(`! Could not install MCP server ${mcpInstall_1.MCP_PINNED_VERSION} (${mcpInstall.error}) — using installed ${mcpInstall.version}`));
+    else if (!mcpInstall.ok)
+        console.log(chalk_1.default.yellow(`! Could not install MCP server (${mcpInstall.error}) — falling back to npx @wenrwa/marketplace-mcp (slower agent start-up)`));
     // 2. Idempotent MCP registration into the user's Claude Code — loud.
     const mcp = await (0, mcpRegister_1.registerMcpServer)({
         connectToken: config.connectToken,
@@ -973,9 +999,10 @@ exports.bridgeCommand = new commander_1.Command('bridge')
         run: execRunner,
         // A token passed on the command line is fresh — replace any stale registration.
         forceUpdate: Boolean(opts.token),
+        ...(mcpInstall.ok ? { server: { command: mcpInstall.command, args: mcpInstall.args } } : {}),
     });
-    if (mcp.action === 'registered' || mcp.action === 're-registered')
-        console.log(chalk_1.default.green(`✓ ${mcp.action === 're-registered' ? 'Re-registered' : 'Registered'} MCP server: ${(0, mcpRegister_1.redactToken)(mcp.command ?? '')}`));
+    if (mcp.action === 'registered' || mcp.action === 're-registered' || mcp.action === 'migrated')
+        console.log(chalk_1.default.green(`✓ ${mcp.action === 're-registered' ? 'Re-registered' : mcp.action === 'migrated' ? 'Migrated (npx → installed)' : 'Registered'} MCP server: ${(0, mcpRegister_1.redactToken)(mcp.command ?? '')}`));
     else if (mcp.action === 'already-registered')
         console.log(chalk_1.default.dim('• wenrwa-marketplace MCP server already registered — skipped'));
     else

package/hooks/session-start.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/*
+ * HiveOp SessionStart hook — LOCAL bridge lane.
+ *
+ * The local bridge writes HiveOp's managed context (work-queue pointers, the
+ * Browser note, match notes) to `<project>/.hiveop/context.md` and never
+ * edits the user's CLAUDE.md. Nothing made Claude READ that file (2026-10-04:
+ * the "call show_in_browser after a deploy" note went unread). A SessionStart
+ * hook's stdout is added to the session's context, so print the file here.
+ * Silent and non-blocking when the file is absent; never fails the session.
+ */
+const fs = require('fs');
+const path = require('path');
+
+let input = '';
+process.stdin.on('data', (d) => { input += d; });
+process.stdin.on('end', () => {
+  try {
+    let cwd = process.cwd();
+    try { const j = JSON.parse(input || '{}'); if (typeof j.cwd === 'string' && j.cwd) cwd = j.cwd; } catch {}
+    const file = path.join(cwd, '.hiveop', 'context.md');
+    if (fs.existsSync(file)) {
+      const text = fs.readFileSync(file, 'utf8').slice(0, 20000);
+      if (text.trim()) process.stdout.write(`HiveOp workspace context (from .hiveop/context.md):\n\n${text}\n`);
+    }
+  } catch {}
+  process.exit(0);
+});
+process.stdin.on('error', () => process.exit(0));

package/package.json

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