@wenrwa/marketplace-cli 0.7.3 → 0.7.5

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

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

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

@@ -0,0 +1,135 @@
+"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 });
+/**
+ * cvt-09 — the managed region tells agents WHEN to call `show_in_browser`.
+ * Both lanes: hosted (contextWriter → fenced region of CLAUDE.md) and local
+ * (localContextWriter → bridge-owned .hiveop/context.md). Asserts on runtime
+ * output, never source text.
+ */
+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 LINE = 'Your pilot watches a Browser pane on their HiveOp canvas. After you start a dev server or finish a deploy, confirm the URL is live (fetch it), then call `show_in_browser` with that URL. It reloads their tab if open, otherwise opens it in a background tab — it never touches their other tabs.';
+const count = (hay, needle) => hay.split(needle).length - 1;
+describe('BROWSER_POINTER (cvt-09)', () => {
+    it('is the heading plus the exact line, ≤3 lines', () => {
+        expect(workGraphPointer_1.BROWSER_POINTER).toBe(`## Browser\n${LINE}`);
+        expect(workGraphPointer_1.BROWSER_POINTER.split('\n').length).toBeLessThanOrEqual(3);
+    });
+    it('is silent when the MCP tools are not registered', () => {
+        expect((0, workGraphPointer_1.browserSection)({ workGraphAvailable: false })).toBeNull();
+        expect((0, workGraphPointer_1.browserSection)({})).toBeNull();
+        expect((0, workGraphPointer_1.browserSection)({ workGraphAvailable: true })).toBe(workGraphPointer_1.BROWSER_POINTER);
+    });
+});
+describe('hosted lane — CLAUDE.md fenced region', () => {
+    const CLAUDE = '/data/repos/ws-7/CLAUDE.md';
+    const makeFs = (seed) => {
+        const files = new Map(Object.entries(seed));
+        return {
+            files,
+            deps: {
+                reposBaseDir: '/data/repos',
+                exists: (p) => files.has(p),
+                readFile: (p) => files.get(p) ?? '',
+                writeFile: (p, c) => { files.set(p, c); },
+                mkdirp: () => { },
+            },
+        };
+    };
+    it('carries the line exactly once inside the pointer markers after two writes; user content untouched', () => {
+        const userTop = '# My project\n\nHand-written rules.\n\n';
+        const userBottom = '\n\n## Mine\nkeep me\n';
+        const { files, deps } = makeFs({ [CLAUDE]: userTop + userBottom });
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'pushed', workGraphAvailable: true, memoryAvailable: true }, deps);
+        const first = files.get(CLAUDE);
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', pointersOnly: true, workGraphAvailable: true, memoryAvailable: true }, deps);
+        const out = files.get(CLAUDE);
+        expect(out).toBe(first);
+        expect(count(out, LINE)).toBe(1);
+        expect(count(out, '## Browser')).toBe(1);
+        const ps = out.indexOf(contextWriter_1.POINTERS_START_MARKER);
+        const pe = out.indexOf(contextWriter_1.POINTERS_END_MARKER);
+        const at = out.indexOf(LINE);
+        expect(ps).toBeGreaterThan(-1);
+        expect(at).toBeGreaterThan(ps);
+        expect(at).toBeLessThan(pe);
+        const rs = out.indexOf(contextWriter_1.CONTEXT_START_MARKER);
+        const re = out.indexOf(contextWriter_1.CONTEXT_END_MARKER) + contextWriter_1.CONTEXT_END_MARKER.length;
+        const outside = out.slice(0, rs) + out.slice(re);
+        expect(outside).toContain('# My project\n\nHand-written rules.');
+        expect(outside).toContain('## Mine\nkeep me');
+        expect(outside).not.toContain('show_in_browser');
+    });
+    it('carries the line in a match workspace too', () => {
+        const { files, deps } = makeFs({});
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: '', workGraphAvailable: true, match: true }, deps);
+        expect(count(files.get(CLAUDE), LINE)).toBe(1);
+    });
+    it('omits it when the MCP tools are not registered', () => {
+        const { files, deps } = makeFs({});
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'pushed' }, deps);
+        expect(files.get(CLAUDE)).not.toContain('show_in_browser');
+    });
+});
+describe('local lane — .hiveop/context.md', () => {
+    let projectRoot;
+    beforeEach(() => { projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cvt09-')); });
+    afterEach(() => { fs.rmSync(projectRoot, { recursive: true, force: true }); });
+    const deps = () => ({
+        exists: (p) => fs.existsSync(p),
+        readFile: (p) => fs.readFileSync(p, 'utf-8'),
+        mkdirp: (d) => fs.mkdirSync(d, { recursive: true }),
+        writeFileAtomic: (p, c) => fs.writeFileSync(p, c, 'utf-8'),
+        remove: (p) => fs.rmSync(p, { force: true }),
+    });
+    it('carries the line exactly once inside the pointer markers after two writes; CLAUDE.md untouched', () => {
+        const claudeMd = path.join(projectRoot, 'CLAUDE.md');
+        fs.writeFileSync(claudeMd, '# user rules\n');
+        (0, localContextWriter_1.writeLocalContext)({ projectRoot, content: '## files\n- a.ts', workGraphAvailable: true, memoryAvailable: true }, deps());
+        (0, localContextWriter_1.writeLocalContext)({ projectRoot, pointersOnly: true, workGraphAvailable: true, memoryAvailable: true }, deps());
+        const out = fs.readFileSync(path.join(projectRoot, localContextWriter_1.LOCAL_CONTEXT_RELATIVE_PATH), 'utf-8');
+        expect(count(out, LINE)).toBe(1);
+        const at = out.indexOf(LINE);
+        expect(at).toBeGreaterThan(out.indexOf(contextWriter_1.POINTERS_START_MARKER));
+        expect(at).toBeLessThan(out.indexOf(contextWriter_1.POINTERS_END_MARKER));
+        expect(out).toContain('## files\n- a.ts');
+        expect(fs.readFileSync(claudeMd, 'utf-8')).toBe('# user rules\n');
+    });
+});

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

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

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

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const launchSupervisor_1 = require("../bridge/launchSupervisor");
+const sessionManager_1 = require("../bridge/sessionManager");
+const ID = '445be432-0000-4000-8000-000000000001';
+// Verbatim shapes from Claude Code 2.1.289 (stderr is red-wrapped; the resume
+// miss is drawn by the TUI with a truecolor escape).
+const IN_USE = `\x1b[31mError: Session ID ${ID} is already in use.\x1b[39m\r\n`;
+const NO_CONVO = `\x1b[?2026h\x1b[38;2;255;107;128mNo conversation found with session ID: ${ID}\x1b[39m\r\r\n`;
+class FakePty {
+    args;
+    written = [];
+    killed = false;
+    dataCb = null;
+    exitCb = null;
+    constructor(args) {
+        this.args = args;
+    }
+    write(d) { this.written.push(d); }
+    resize() { }
+    kill() { this.killed = true; }
+    onData(cb) { this.dataCb = cb; }
+    onExit(cb) { this.exitCb = cb; }
+    emit(d) { this.dataCb?.(d); }
+    exit(code) { this.exitCb?.(code); }
+}
+function harness(args) {
+    const spawned = [];
+    const factory = {
+        spawn: (o) => {
+            const p = new FakePty(o.args ?? []);
+            spawned.push(p);
+            return p;
+        },
+    };
+    let t = 0;
+    const logs = [];
+    const pty = (0, launchSupervisor_1.superviseLaunch)(factory, { cols: 80, rows: 24, command: 'claude', args }, { now: () => t, log: (m) => logs.push(m), settle: (fn) => fn(), windowMs: 10_000 });
+    const out = [];
+    const exits = [];
+    pty.onData((d) => out.push(d));
+    pty.onExit((c) => exits.push(c));
+    return { pty, spawned, out, exits, logs, advance: (ms) => { t += ms; } };
+}
+describe('launchSupervisor — pure helpers', () => {
+    it('session-in-use on --session-id → swap to --resume, keeping every other arg', () => {
+        expect((0, launchSupervisor_1.retryArgsFor)(['--dangerously-skip-permissions', '--settings', '/s.json', '--session-id', ID], IN_USE))
+            .toEqual(['--dangerously-skip-permissions', '--settings', '/s.json', '--resume', ID]);
+    });
+    it('no-conversation on --resume → swap to --session-id', () => {
+        expect((0, launchSupervisor_1.retryArgsFor)(['--resume', ID], NO_CONVO)).toEqual(['--session-id', ID]);
+    });
+    it('no session flag, or an unrelated error → no retry', () => {
+        expect((0, launchSupervisor_1.retryArgsFor)([], IN_USE)).toBeNull();
+        expect((0, launchSupervisor_1.retryArgsFor)(['--session-id', ID], 'Error: Invalid session ID. Must be a valid UUID.')).toBeNull();
+        expect((0, launchSupervisor_1.retryArgsFor)(['--resume', ID], IN_USE)).toBeNull();
+    });
+    it('firstMeaningfulLine strips ANSI, "Error:" and stack frames', () => {
+        expect((0, launchSupervisor_1.firstMeaningfulLine)(IN_USE)).toBe(`Session ID ${ID} is already in use`);
+        expect((0, launchSupervisor_1.firstMeaningfulLine)('\r\n\x1b[1m\x1b[0m\r\nError: boom.\n    at foo (x.js:1:1)\n')).toBe('boom');
+        expect((0, launchSupervisor_1.firstMeaningfulLine)('\x1b[?25h\r\n')).toBeNull();
+    });
+    it('friendly line is one short sentence with no stack trace', () => {
+        const line = (0, launchSupervisor_1.friendlyStartFailure)('Error: kaput\n    at a (b.js:1:1)\n    at c (d.js:2:2)', 1);
+        expect(line).toContain("Claude couldn't start: kaput. Reopen the pane to try again.");
+        expect(line).not.toContain('at a (');
+        expect((0, launchSupervisor_1.friendlyStartFailure)('', 3)).toContain("Claude couldn't start: it exited with code 3.");
+    });
+});
+describe('launchSupervisor — supervised PTY', () => {
+    it('session-in-use → exactly one relaunch with --resume; the healthy retry is passed through', () => {
+        const h = harness(['--session-id', ID]);
+        h.spawned[0].emit(IN_USE);
+        h.advance(800);
+        h.spawned[0].exit(1);
+        expect(h.spawned).toHaveLength(2);
+        expect(h.spawned[1].args).toEqual(['--resume', ID]);
+        expect(h.exits).toEqual([]); // the pane never sees the first exit
+        expect(h.out.join('')).not.toContain("couldn't start");
+        h.pty.write('hi');
+        expect(h.spawned[1].written).toEqual(['hi']);
+        h.spawned[1].emit('welcome back');
+        expect(h.out[h.out.length - 1]).toBe('welcome back');
+        expect(h.logs.join('\n')).toMatch(/already in use/);
+    });
+    it('resume-missing → exactly one relaunch with --session-id', () => {
+        const h = harness(['--dangerously-skip-permissions', '--resume', ID]);
+        h.spawned[0].emit(NO_CONVO);
+        h.spawned[0].exit(1);
+        expect(h.spawned).toHaveLength(2);
+        expect(h.spawned[1].args).toEqual(['--dangerously-skip-permissions', '--session-id', ID]);
+        expect(h.exits).toEqual([]);
+    });
+    it('never loops: a retry that fails the same way gets the friendly line and the exit, no third spawn', () => {
+        const h = harness(['--session-id', ID]);
+        h.spawned[0].emit(IN_USE);
+        h.spawned[0].exit(1);
+        h.spawned[1].emit(NO_CONVO);
+        h.spawned[1].exit(1);
+        expect(h.spawned).toHaveLength(2);
+        expect(h.exits).toEqual([1]);
+        expect(h.out.join('')).toContain(`Claude couldn't start: No conversation found with session ID: ${ID}. Reopen the pane to try again.`);
+    });
+    it('generic fast non-zero exit → friendly line, then the exit; raw error kept in the log', () => {
+        const h = harness(['--session-id', ID]);
+        h.spawned[0].emit('\x1b[31mError: Invalid session ID. Must be a valid UUID.\x1b[39m\r\n');
+        h.advance(300);
+        h.spawned[0].exit(1);
+        expect(h.spawned).toHaveLength(1);
+        expect(h.exits).toEqual([1]);
+        const last = h.out[h.out.length - 1];
+        expect(last).toContain("Claude couldn't start: Invalid session ID. Must be a valid UUID. Reopen the pane to try again.");
+        expect(h.logs.join('\n')).toContain('Error: Invalid session ID. Must be a valid UUID.');
+    });
+    it('a long-running session that exits later is untouched — no retry, no friendly line', () => {
+        const h = harness(['--session-id', ID]);
+        h.spawned[0].emit('working...');
+        h.advance(60_000);
+        h.spawned[0].emit(IN_USE); // even matching text, outside the window
+        h.spawned[0].exit(1);
+        expect(h.spawned).toHaveLength(1);
+        expect(h.exits).toEqual([1]);
+        expect(h.out.join('')).not.toContain("couldn't start");
+        expect(h.logs).toEqual([]);
+    });
+    it('a fast clean exit (code 0) passes straight through', () => {
+        const h = harness(['--resume', ID]);
+        h.spawned[0].exit(0);
+        expect(h.spawned).toHaveLength(1);
+        expect(h.exits).toEqual([0]);
+        expect(h.out).toEqual([]);
+    });
+    it('a bridge kill is never retried or annotated', () => {
+        const h = harness(['--session-id', ID]);
+        h.spawned[0].emit(IN_USE);
+        h.pty.kill();
+        expect(h.spawned[0].killed).toBe(true);
+        h.spawned[0].exit(1);
+        expect(h.spawned).toHaveLength(1);
+        expect(h.exits).toEqual([1]);
+        expect(h.out.join('')).not.toContain("couldn't start");
+    });
+});
+describe('launchSupervisor — wired through SessionManager', () => {
+    const fakeSnapshot = () => ({
+        write: () => Promise.resolve(),
+        resize: () => { },
+        serialize: () => Promise.resolve(''),
+        dispose: () => { },
+    });
+    function manager() {
+        const spawned = [];
+        const factory = { spawn: (o) => { const p = new FakePty(o.args ?? []); spawned.push(p); return p; } };
+        const mgr = new sessionManager_1.SessionManager(factory, {
+            snapshotFactory: fakeSnapshot,
+            launchSupervisor: { now: () => 0, log: () => { }, settle: (fn) => fn() },
+        });
+        const exits = [];
+        mgr.setOnSessionExit((id, code) => exits.push([id, code]));
+        return { mgr, spawned, exits };
+    }
+    it('a claude launch self-heals inside one session: same id, one exit only when the retry dies', async () => {
+        const { mgr, spawned, exits } = manager();
+        const id = mgr.open({ cols: 80, rows: 24, id: ID, command: 'claude', args: ['--session-id', ID] });
+        const seen = [];
+        await mgr.attach(id, (f) => { if (f.t === 'data')
+            seen.push(f.data); });
+        spawned[0].emit(IN_USE);
+        spawned[0].exit(1);
+        expect(spawned).toHaveLength(2);
+        expect(mgr.list()).toEqual([ID]);
+        expect(exits).toEqual([]);
+        spawned[1].emit('boom\r\n');
+        spawned[1].exit(2);
+        expect(exits).toEqual([[ID, 2]]);
+        expect(seen.join('')).toContain("Claude couldn't start: boom. Reopen the pane to try again.");
+    });
+    it('a shell launch (no command) is not supervised', () => {
+        const { mgr, spawned, exits } = manager();
+        mgr.open({ cols: 80, rows: 24 });
+        spawned[0].emit('Error: nope\r\n');
+        spawned[0].exit(1);
+        expect(spawned).toHaveLength(1);
+        expect(exits).toHaveLength(1);
+    });
+});

package/dist/bridge/contextWriter.js

@@ -153,6 +153,9 @@ function writeContext(input, deps) {
         pointers.push(work);
     if (input.memoryAvailable)
         pointers.push((0, memoryPointer_1.memorySection)(input.memoryBrief));
+    const browser = (0, workGraphPointer_1.browserSection)(input);
+    if (browser)
+        pointers.push(browser);
     // wmr-07: a pointers-only refresh keeps the region's existing file content
     // rather than replacing it with the (absent) `content` argument.
     const fileContent = input.pointersOnly

package/dist/bridge/launchSupervisor.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Launch supervisor — makes a `claude` that dies at startup either heal
+ * itself or say so in plain words, instead of leaving its raw stderr as the
+ * last thing in the pane.
+ *
+ * Wraps ONE agent launch (SessionManager.open with `command: 'claude'`) in a
+ * PtyLike that the session manager cannot tell apart from a plain PTY. Inside,
+ * it watches the first `windowMs` of the process's life:
+ *
+ *  - `--session-id <id>` exits early with "Session ID <id> is already in use"
+ *    → the conversation already exists (e.g. it was recorded under a project
+ *    dir the existence check missed), so relaunch ONCE with `--resume <id>`.
+ *  - `--resume <id>` exits early with "No conversation found with session ID"
+ *    → there is nothing to resume, so relaunch ONCE with `--session-id <id>`.
+ *  - any other early non-zero exit (or a retry that also fails) → write one
+ *    short line into the stream ("Claude couldn't start: …") and let the exit
+ *    through. The raw output goes to the bridge log, not into a second copy.
+ *
+ * At most one retry per open — the retry itself is never retried, so no loop.
+ * A process that outlives the window, exits 0, or was killed by the bridge is
+ * passed through untouched.
+ *
+ * Wording checked against Claude Code 2.1.289: the session-in-use error is
+ * `Error: Session ID <uuid> is already in use.` (stderr); the resume miss is
+ * `No conversation found with session ID: <uuid>` (rendered by the TUI).
+ * Both arrive on the PTY, so matching the combined output catches both.
+ *
+ * Both lanes: the local bridge (loopback + crew relay on a laptop) spawns
+ * `claude` through here. The hosted container does NOT — it spawns $SHELL and
+ * infra/terminal-image/autolaunch.sh runs `claude`, so the same rules live
+ * there too.
+ */
+import { PtyFactory, PtyLike } from './sessionManager';
+/** How long after launch an exit still counts as "couldn't start". */
+export declare const DEFAULT_LAUNCH_WINDOW_MS = 10000;
+export declare const SESSION_IN_USE_RE: RegExp;
+export declare const RESUME_MISSING_RE: RegExp;
+export declare function stripAnsi(s: string): string;
+/**
+ * The first line of `output` worth showing a person: ANSI stripped, blank
+ * lines and stack frames skipped, a leading "Error:" dropped, trailing period
+ * dropped (the caller adds its own punctuation), clipped to ~160 chars.
+ */
+export declare function firstMeaningfulLine(output: string): string | null;
+/**
+ * Pure decision for an EARLY exit (caller has already checked the window and
+ * the retry budget): the argv to relaunch with, or null for "don't retry".
+ */
+export declare function retryArgsFor(args: string[], output: string): string[] | null;
+export declare function friendlyStartFailure(output: string, code: number): string;
+export interface LaunchSupervisorOptions {
+    windowMs?: number;
+    now?: () => number;
+    log?: (msg: string) => void;
+    /** node-pty can report exit before the last output chunk is read; an early
+     *  failure is judged after this short settle. Tests pass a synchronous one. */
+    settle?: (fn: () => void) => void;
+}
+type SpawnOpts = Parameters<PtyFactory['spawn']>[0];
+export declare function superviseLaunch(factory: PtyFactory, spawnOpts: SpawnOpts, opts?: LaunchSupervisorOptions): PtyLike;
+export {};

package/dist/bridge/launchSupervisor.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESUME_MISSING_RE = exports.SESSION_IN_USE_RE = exports.DEFAULT_LAUNCH_WINDOW_MS = void 0;
+exports.stripAnsi = stripAnsi;
+exports.firstMeaningfulLine = firstMeaningfulLine;
+exports.retryArgsFor = retryArgsFor;
+exports.friendlyStartFailure = friendlyStartFailure;
+exports.superviseLaunch = superviseLaunch;
+/** How long after launch an exit still counts as "couldn't start". */
+exports.DEFAULT_LAUNCH_WINDOW_MS = 10_000;
+/** Cap on how much early output is kept for matching/logging. */
+const MAX_CAPTURE = 16 * 1024;
+exports.SESSION_IN_USE_RE = /Session ID \S+ is already in use/i;
+exports.RESUME_MISSING_RE = /No conversation found/i;
+// CSI, OSC (BEL- or ST-terminated), and lone two-char escapes.
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_()#%][0-9A-Za-z]?/g;
+function stripAnsi(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(ANSI_RE, '').replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '');
+}
+/**
+ * The first line of `output` worth showing a person: ANSI stripped, blank
+ * lines and stack frames skipped, a leading "Error:" dropped, trailing period
+ * dropped (the caller adds its own punctuation), clipped to ~160 chars.
+ */
+function firstMeaningfulLine(output) {
+    const lines = stripAnsi(output).split(/\r?\n|\r/);
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        if (/^at\s+\S/.test(line))
+            continue;
+        if (/^[-─━═_=*·•\s]+$/.test(line))
+            continue;
+        let msg = line.replace(/^(?:error|fatal)\s*:\s*/i, '').replace(/[.\s]+$/, '');
+        if (!msg)
+            continue;
+        if (msg.length > 160)
+            msg = `${msg.slice(0, 157)}...`;
+        return msg;
+    }
+    return null;
+}
+/** Where `--resume`/`--session-id` sits in argv, or null. */
+function sessionFlagIndex(args) {
+    for (let i = 0; i < args.length - 1; i++) {
+        if (args[i] === '--resume' || args[i] === '--session-id')
+            return i;
+    }
+    return null;
+}
+/**
+ * Pure decision for an EARLY exit (caller has already checked the window and
+ * the retry budget): the argv to relaunch with, or null for "don't retry".
+ */
+function retryArgsFor(args, output) {
+    const i = sessionFlagIndex(args);
+    if (i === null)
+        return null;
+    const text = stripAnsi(output);
+    const flag = args[i];
+    if (flag === '--session-id' && exports.SESSION_IN_USE_RE.test(text)) {
+        const next = [...args];
+        next[i] = '--resume';
+        return next;
+    }
+    if (flag === '--resume' && exports.RESUME_MISSING_RE.test(text)) {
+        const next = [...args];
+        next[i] = '--session-id';
+        return next;
+    }
+    return null;
+}
+function friendlyStartFailure(output, code) {
+    const reason = firstMeaningfulLine(output) ?? `it exited with code ${code}`;
+    return `\r\n\x1b[33mClaude couldn't start: ${reason}. Reopen the pane to try again.\x1b[0m\r\n`;
+}
+/** Clears the pane before the retry so the raw error from the first attempt
+ *  doesn't sit above the healthy session. */
+const RETRY_CLEAR = '\x1b[2J\x1b[3J\x1b[H';
+function superviseLaunch(factory, spawnOpts, opts = {}) {
+    const windowMs = opts.windowMs ?? exports.DEFAULT_LAUNCH_WINDOW_MS;
+    const now = opts.now ?? Date.now;
+    const log = opts.log ?? ((m) => console.error(m));
+    const settle = opts.settle ?? ((fn) => { setTimeout(fn, 100); });
+    const dataListeners = [];
+    const exitListeners = [];
+    const emitData = (d) => { for (const cb of dataListeners)
+        cb(d); };
+    const emitExit = (code) => { for (const cb of exitListeners)
+        cb(code); };
+    let cols = spawnOpts.cols;
+    let rows = spawnOpts.rows;
+    let args = spawnOpts.args ?? [];
+    let retried = false;
+    let killed = false;
+    let current;
+    const start = () => {
+        const startedAt = now();
+        let captured = '';
+        const pty = factory.spawn({ ...spawnOpts, cols, rows, args });
+        current = pty;
+        pty.onData((d) => {
+            if (pty !== current)
+                return;
+            if (captured.length < MAX_CAPTURE && now() - startedAt < windowMs)
+                captured += d;
+            emitData(d);
+        });
+        pty.onExit((code) => {
+            if (pty !== current)
+                return;
+            const early = now() - startedAt < windowMs;
+            if (killed || !early || code === 0) {
+                emitExit(code);
+                return;
+            }
+            settle(() => onEarlyFailure(code));
+        });
+        const onEarlyFailure = (code) => {
+            if (pty !== current)
+                return;
+            if (killed) {
+                emitExit(code);
+                return;
+            }
+            const raw = stripAnsi(captured).trim();
+            log(`[bridge] claude exited at startup (code ${code}, args: ${args.join(' ')}): ${raw || '(no output)'}`);
+            const nextArgs = retried ? null : retryArgsFor(args, captured);
+            if (nextArgs) {
+                retried = true;
+                log(`[bridge] relaunching claude once with: ${nextArgs.join(' ')}`);
+                args = nextArgs;
+                emitData(RETRY_CLEAR);
+                try {
+                    start();
+                    return;
+                }
+                catch (err) {
+                    log(`[bridge] claude relaunch failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            emitData(friendlyStartFailure(captured, code));
+            emitExit(code);
+        };
+    };
+    start();
+    return {
+        write: (d) => current.write(d),
+        resize: (c, r) => { cols = c; rows = r; current.resize(c, r); },
+        kill: () => { killed = true; current.kill(); },
+        onData: (cb) => { dataListeners.push(cb); },
+        onExit: (cb) => { exitListeners.push(cb); },
+    };
+}

package/dist/bridge/localContextWriter.js

@@ -94,6 +94,9 @@ function writeLocalContext(input, deps) {
         pointers.push(work);
     if (input.memoryAvailable)
         pointers.push((0, memoryPointer_1.memorySection)(input.memoryBrief));
+    const browser = (0, workGraphPointer_1.browserSection)(input);
+    if (browser)
+        pointers.push(browser);
     // wmr-07 — the whole local file is bridge-owned, so "preserve the pushed
     // content" means keeping what is already on disk below the pointer fence.
     const existingBody = existed ? deps.readFile(contextPath) : '';

package/dist/bridge/sessionManager.d.ts

@@ -1,4 +1,5 @@
 import { TermSnapshot } from './termSnapshot';
+import { LaunchSupervisorOptions } from './launchSupervisor';
 export interface PtyLike {
     write(data: string): void;
     resize(cols: number, rows: number): void;
@@ -83,6 +84,10 @@ export interface SessionManagerOptions {
     snapshotFactory?: (cols: number, rows: number, opts?: {
         scrollback?: number;
     }) => TermSnapshot;
+    /** Startup supervision for `claude` launches (launchSupervisor.ts): one
+     *  self-healing retry for a session-id/resume mismatch, else a plain
+     *  "Claude couldn't start" line. Injectable clock/settle for tests. */
+    launchSupervisor?: LaunchSupervisorOptions;
 }
 /**
  * lws-07 (ADR-0033 port): validates a client-supplied size pair for the
@@ -106,6 +111,7 @@ export declare class SessionManager {
     private scheduleTimeout;
     private cancelTimeout;
     private snapshotFactory;
+    private launchSupervisor;
     /** 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

@@ -21,6 +21,7 @@ exports.validSize = validSize;
  */
 const crypto_1 = __importDefault(require("crypto"));
 const termSnapshot_1 = require("./termSnapshot");
+const launchSupervisor_1 = require("./launchSupervisor");
 /** 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
@@ -73,6 +74,7 @@ class SessionManager {
     scheduleTimeout;
     cancelTimeout;
     snapshotFactory;
+    launchSupervisor;
     /** 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
@@ -89,6 +91,7 @@ class SessionManager {
         this.scheduleTimeout = opts.scheduleTimeout ?? ((cb, ms) => setTimeout(cb, ms));
         this.cancelTimeout = opts.cancelTimeout ?? ((h) => clearTimeout(h));
         this.snapshotFactory = opts.snapshotFactory ?? termSnapshot_1.createTermSnapshot;
+        this.launchSupervisor = opts.launchSupervisor ?? {};
     }
     /** twr-16: see attachFailureCount. */
     attachFailures() {
@@ -123,7 +126,12 @@ class SessionManager {
             prior.snapshot.dispose();
             this.sessions.delete(id);
         }
-        const pty = this.factory.spawn(opts);
+        // 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);
         const snapshot = this.snapshotFactory(opts.cols, opts.rows, { scrollback: this.snapshotScrollback });
         const session = {
             pty,

package/dist/bridge/workGraphPointer.d.ts

@@ -51,3 +51,19 @@ export declare function workSection(input: {
     workGraphAvailable?: boolean;
     match?: boolean;
 }): string | null;
+/**
+ * cvt-09 (amended by the 2026-10-04 show-in-browser-tabs change) — tells the
+ * agent its pilot watches a Browser pane and WHEN to call `show_in_browser`:
+ * after starting a dev server or finishing a deploy, once the URL is confirmed
+ * live. Without this, agents only showed a site when asked.
+ *
+ * Gated on the same signal as the work-queue pointer (`workGraphAvailable` =
+ * the HiveOp MCP tools are registered for this process) — `show_in_browser`
+ * rides that same registration, and a pointer to an unregistered tool is
+ * worse than silence. Carried in matches too: a match agent runs dev servers.
+ */
+export declare const BROWSER_POINTER: string;
+/** cvt-09 — the browser section, one function so the hosted and local writers cannot diverge. */
+export declare function browserSection(input: {
+    workGraphAvailable?: boolean;
+}): string | null;

package/dist/bridge/workGraphPointer.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MATCH_POINTER = exports.WORK_GRAPH_POINTER = void 0;
+exports.BROWSER_POINTER = exports.MATCH_POINTER = exports.WORK_GRAPH_POINTER = void 0;
 exports.workSection = workSection;
+exports.browserSection = browserSection;
 /**
  * wgcp-01 — the one piece of guidance that tells an agent the workspace work
  * graph exists at all. Nothing today does: the MCP tools (`list_ready_issues`,
@@ -64,3 +65,22 @@ function workSection(input) {
         return exports.MATCH_POINTER;
     return input.workGraphAvailable ? exports.WORK_GRAPH_POINTER : null;
 }
+/**
+ * cvt-09 (amended by the 2026-10-04 show-in-browser-tabs change) — tells the
+ * agent its pilot watches a Browser pane and WHEN to call `show_in_browser`:
+ * after starting a dev server or finishing a deploy, once the URL is confirmed
+ * live. Without this, agents only showed a site when asked.
+ *
+ * Gated on the same signal as the work-queue pointer (`workGraphAvailable` =
+ * the HiveOp MCP tools are registered for this process) — `show_in_browser`
+ * rides that same registration, and a pointer to an unregistered tool is
+ * worse than silence. Carried in matches too: a match agent runs dev servers.
+ */
+exports.BROWSER_POINTER = [
+    '## Browser',
+    'Your pilot watches a Browser pane on their HiveOp canvas. After you start a dev server or finish a deploy, confirm the URL is live (fetch it), then call `show_in_browser` with that URL. It reloads their tab if open, otherwise opens it in a background tab — it never touches their other tabs.',
+].join('\n');
+/** cvt-09 — the browser section, one function so the hosted and local writers cannot diverge. */
+function browserSection(input) {
+    return input.workGraphAvailable ? exports.BROWSER_POINTER : null;
+}

package/package.json

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