@wenrwa/marketplace-cli 0.8.4 → 0.8.6

package/dist/__tests__/term-snapshot.test.js

@@ -1,6 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const termSnapshot_1 = require("../bridge/termSnapshot");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { Terminal } = require('@xterm/headless');
+/** A fresh client terminal at (cols, rows) with `data` replayed into it —
+ *  what a reattaching pane sees. */
+async function replay(data, cols, rows) {
+    const t = new Terminal({ cols, rows, allowProposedApi: true });
+    await new Promise((r) => t.write(data, () => r()));
+    return t;
+}
+function screenRows(t) {
+    const b = t.buffer.active;
+    const out = [];
+    for (let y = b.viewportY; y < b.viewportY + t.rows; y++)
+        out.push(b.getLine(y)?.translateToString(true) ?? '');
+    return out;
+}
 describe('TermSnapshot', () => {
     it('write then immediately serialize includes the written content', async () => {
         const snap = (0, termSnapshot_1.createTermSnapshot)(80, 24);
@@ -77,4 +93,124 @@ describe('TermSnapshot', () => {
         // without callers ever having held a reference to xterm internals).
         expect(Object.keys(snap).sort()).toEqual(['dispose', 'resize', 'serialize', 'write']);
     });
+    describe('reattach after the terminal shrank (OpenCode garble)', () => {
+        /** A full-screen TUI frame on the alt screen, every row full width, with
+         *  a coloured span — then the pane shrinks. */
+        async function wideFrameThenShrink(snap) {
+            await snap.write('\x1b[?1049h\x1b[H');
+            for (let r = 1; r <= 6; r++) {
+                const row = `${r}`.repeat(10) + '\x1b[31m' + 'R'.repeat(10) + '\x1b[0m' + `${r}`.repeat(20);
+                await snap.write(`\x1b[${r};1H${row}`);
+            }
+            snap.resize(20, 4);
+        }
+        it('clips every row to the new cols — no row overflows into the next', async () => {
+            const snap = (0, termSnapshot_1.createTermSnapshot)(40, 6);
+            await wideFrameThenShrink(snap);
+            const out = await snap.serialize();
+            const client = await replay(out, 20, 4);
+            expect(client.buffer.active.type).toBe('alternate');
+            // The live 20x4 screen after the shrink shows rows 3..6, first 20 cells.
+            const live = ['3', '4', '5', '6'].map((d) => d.repeat(10) + 'R'.repeat(10));
+            expect(screenRows(client)).toEqual(live);
+            // SGR state survives the clip: the red span is still red, the digits not.
+            const line = client.buffer.active.getLine(client.buffer.active.viewportY);
+            expect(line.getCell(12).getFgColor()).toBe(1);
+            expect(line.getCell(2).getFgColor()).not.toBe(1);
+            client.dispose();
+            snap.dispose();
+        });
+        it('replays to exactly the live screen of an emulator that saw the same bytes and shrink', async () => {
+            const bytes = ['\x1b[?1049h\x1b[H'];
+            for (let r = 1; r <= 6; r++)
+                bytes.push(`\x1b[${r};1H` + `${r}abcdefghi`.repeat(4));
+            const snap = (0, termSnapshot_1.createTermSnapshot)(40, 6);
+            const live = new Terminal({ cols: 40, rows: 6, allowProposedApi: true });
+            for (const chunk of bytes) {
+                await snap.write(chunk);
+                await new Promise((r) => live.write(chunk, () => r()));
+            }
+            snap.resize(20, 4);
+            live.resize(20, 4);
+            const client = await replay(await snap.serialize(), 20, 4);
+            // What the live pane displays: each row's first `cols` cells.
+            const b = live.buffer.active;
+            const liveScreen = [];
+            for (let y = b.viewportY; y < b.viewportY + live.rows; y++) {
+                liveScreen.push(b.getLine(y).translateToString(true, 0, live.cols));
+            }
+            expect(screenRows(client)).toEqual(liveScreen);
+            expect(client.buffer.active.length).toBe(4);
+            [client, live].forEach((t) => t.dispose());
+            snap.dispose();
+        });
+        it('never splits a wide character that straddles the new right edge', async () => {
+            const snap = (0, termSnapshot_1.createTermSnapshot)(40, 3);
+            await snap.write('\x1b[?1049h\x1b[H');
+            await snap.write('\x1b[1;1H' + 'a'.repeat(19) + '漢' + 'b'.repeat(19));
+            await snap.write('\x1b[2;1H' + 'c'.repeat(40));
+            snap.resize(20, 3);
+            const out = await snap.serialize();
+            const client = await replay(out, 20, 3);
+            const rows = screenRows(client);
+            expect(rows[0]).toBe('a'.repeat(19));
+            expect(rows[1]).toBe('c'.repeat(20));
+            client.dispose();
+            snap.dispose();
+        });
+        it('a soft-wrapped row of the wider frame does not glue onto its clipped predecessor', async () => {
+            const snap = (0, termSnapshot_1.createTermSnapshot)(30, 4);
+            await snap.write('\x1b[?1049h\x1b[H');
+            // 45 chars at 30 cols: row 0 full, row 1 is a soft wrap of it.
+            await snap.write('x'.repeat(30) + 'y'.repeat(15));
+            snap.resize(20, 4);
+            const out = await snap.serialize();
+            const client = await replay(out, 20, 4);
+            expect(screenRows(client).slice(0, 3)).toEqual(['x'.repeat(20), 'y'.repeat(15), '']);
+            client.dispose();
+            snap.dispose();
+        });
+    });
+    describe('terminal modes survive a reattach', () => {
+        it('re-emits mouse tracking + SGR encoding, bracketed paste, app cursor keys, alt screen and a hidden cursor', async () => {
+            const snap = (0, termSnapshot_1.createTermSnapshot)(40, 6);
+            await snap.write('\x1b[?1049h\x1b[?1002h\x1b[?1006h\x1b[?2004h\x1b[?1h\x1b[?25l');
+            await snap.write('\x1b[1;1Hopencode');
+            const out = await snap.serialize();
+            const client = await replay(out, 40, 6);
+            expect(client.buffer.active.type).toBe('alternate');
+            expect(client.modes.mouseTrackingMode).toBe('drag');
+            expect(client._core.coreMouseService.activeEncoding).toBe('SGR');
+            expect(client.modes.bracketedPasteMode).toBe(true);
+            expect(client.modes.applicationCursorKeysMode).toBe(true);
+            expect(client._core.coreService.isCursorHidden).toBe(true);
+            expect(screenRows(client)[0]).toBe('opencode');
+            // Modes come AFTER the screen content, so the replayed content can't
+            // be misread under them.
+            expect(out.lastIndexOf('opencode')).toBeLessThan(out.indexOf('\x1b[?1006h'));
+            client.dispose();
+            snap.dispose();
+        });
+        it('re-emits any-motion tracking (?1003) and SGR-pixels (?1016)', async () => {
+            const snap = (0, termSnapshot_1.createTermSnapshot)(40, 6);
+            await snap.write('\x1b[?1003h\x1b[?1016h');
+            const client = await replay(await snap.serialize(), 40, 6);
+            expect(client.modes.mouseTrackingMode).toBe('any');
+            expect(client._core.coreMouseService.activeEncoding).toBe('SGR_PIXELS');
+            client.dispose();
+            snap.dispose();
+        });
+        it('emits nothing for modes the app turned back off', async () => {
+            const snap = (0, termSnapshot_1.createTermSnapshot)(40, 6);
+            await snap.write('\x1b[?1000h\x1b[?1006h\x1b[?25l\x1b[?2004h');
+            await snap.write('\x1b[?1000l\x1b[?1006l\x1b[?25h\x1b[?2004l');
+            const out = await snap.serialize();
+            expect(out).not.toMatch(/\x1b\[\?(1000|1006|25|2004)[hl]/);
+            const client = await replay(out, 40, 6);
+            expect(client.modes.mouseTrackingMode).toBe('none');
+            expect(client._core.coreMouseService.activeEncoding).toBe('DEFAULT');
+            client.dispose();
+            snap.dispose();
+        });
+    });
 });

package/dist/bridge/changesReport.js

@@ -68,6 +68,7 @@ exports.buildChangesReport = buildChangesReport;
 const crypto_1 = require("crypto");
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const redact_1 = require("../secrets/redact");
 const DEFAULT_MAX_PATCH_BYTES = 64_000;
 const GENERATED_BASENAMES = new Set([
     'package-lock.json',
@@ -96,15 +97,21 @@ class GitStepError extends Error {
         super(label);
     }
 }
-/** Cuts `patch` to the last full line that fits within `maxBytes` (UTF-8 byte length). */
+/**
+ * Cuts `patch` to the last full line that fits within `maxBytes` (UTF-8 byte
+ * length), then masks any secret in it (2026-10-17: a committed .env line is
+ * as visible in the Changes panel as in a terminal). Masking is
+ * length-preserving ASCII, so the byte budget is unchanged; `contentHash` is
+ * still taken from the unmasked full patch by the caller.
+ */
 function truncatePatch(patch, maxBytes) {
     const buf = Buffer.from(patch, 'utf8');
     if (buf.length <= maxBytes)
-        return { text: patch, truncated: false };
+        return { text: (0, redact_1.redact)(patch), truncated: false };
     const slice = buf.subarray(0, maxBytes).toString('utf8');
     const lastNewline = slice.lastIndexOf('\n');
     const text = lastNewline >= 0 ? slice.slice(0, lastNewline + 1) : '';
-    return { text, truncated: true };
+    return { text: (0, redact_1.redact)(text), truncated: true };
 }
 function parseNameStatus(stdout) {
     const entries = [];

package/dist/bridge/contextWriter.js

@@ -176,12 +176,16 @@ function writeContextFile(input, claudeMdPath, seedPath, workspaceRoot, deps) {
     const browser = (0, workGraphPointer_1.browserSection)(input);
     if (browser)
         pointers.push(browser);
+    const keys = (0, workGraphPointer_1.keysSection)(input);
+    if (keys)
+        pointers.push(keys);
+    const sections = (0, workGraphPointer_1.withSecretsSection)(pointers);
     // 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
         ? splitRegion(existingRegion).rest
         : (input.content ?? '').trim();
-    const block = pointerBlock(pointers);
+    const block = pointerBlock(sections);
     const parts = [block, fileContent].filter((part) => part.length > 0);
     const content = parts.join('\n\n');
     const isEmpty = content.trim().length === 0;

package/dist/bridge/envSaver.d.ts

@@ -0,0 +1,63 @@
+export declare const SAVE_ENV_NAME_RE: RegExp;
+export declare const MAX_SAVE_ENV_VALUE_BYTES = 4096;
+export declare const MAX_SAVE_ENV_ENTRIES = 32;
+export interface EnvEntry {
+    name: string;
+    value: string;
+}
+export type SaveEnvValidation = {
+    ok: true;
+    entries: EnvEntry[];
+} | {
+    ok: false;
+    error: string;
+};
+/** Validate the frame's entries. Error text is user-facing and never quotes a value. */
+export declare function validateEnvEntries(raw: unknown): SaveEnvValidation;
+/** Serialize one value so repoEnv.parseDotenv reads back exactly the same string. */
+export declare function formatDotenvValue(value: string): string;
+/**
+ * Upsert entries into dotenv text: the first line for a NAME is replaced in
+ * place, later duplicates of it are dropped, new names are appended. Every
+ * other line (comments, unrelated keys) is preserved byte for byte.
+ */
+export declare function upsertDotenv(existing: string, entries: EnvEntry[]): string;
+export interface EnvSaverDeps {
+    realpath: (p: string) => string;
+    /** null when the path does not exist. */
+    lstat: (p: string) => {
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+    } | null;
+    readFile: (p: string) => string;
+    /** Temp file (mode 0600) + rename, then chmod 0600. */
+    writeFileAtomic0600: (p: string, data: string) => void;
+    appendFile: (p: string, data: string) => void;
+    /** Exit code of `git <args>` run in `cwd`; 128 (or any non 0/1) when git is unusable. */
+    git: (args: string[], cwd: string) => Promise<number>;
+}
+export declare const realEnvSaverDeps: EnvSaverDeps;
+export type SaveEnvResult = {
+    ok: true;
+    names: string[];
+    gitignoreAdded: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/** Write entries into `<root>/.env`. `root` is the session's cwd. */
+export declare function saveEnvEntries(root: string, entries: EnvEntry[], deps?: EnvSaverDeps): Promise<SaveEnvResult>;
+/**
+ * The whole `save-env` frame → `save-env-result` reply, shared verbatim by the
+ * local server and the relay client so the two lanes cannot drift. The reply
+ * carries names only — never a value.
+ */
+export declare function handleSaveEnvFrame(frame: {
+    rid?: unknown;
+    sessionId?: unknown;
+    entries?: unknown;
+}, sessions: {
+    list(): string[];
+    cwdOf(id: string): string | undefined;
+}, deps?: EnvSaverDeps): Promise<Record<string, unknown>>;

package/dist/bridge/envSaver.js

@@ -0,0 +1,256 @@
+"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.realEnvSaverDeps = exports.MAX_SAVE_ENV_ENTRIES = exports.MAX_SAVE_ENV_VALUE_BYTES = exports.SAVE_ENV_NAME_RE = void 0;
+exports.validateEnvEntries = validateEnvEntries;
+exports.formatDotenvValue = formatDotenvValue;
+exports.upsertDotenv = upsertDotenv;
+exports.saveEnvEntries = saveEnvEntries;
+exports.handleSaveEnvFrame = handleSaveEnvFrame;
+/**
+ * Paste a key → saved to .env (2026-10-17, owner-approved) — the WRITE half.
+ *
+ * The pane intercepts a paste that is a key, asks "Save to .env?", and on Save
+ * sends `{t:'save-env', rid, sessionId, entries:[{name,value}]}` over its own
+ * socket (local loopback, or the relay into the hosted container — same frame,
+ * same handler, both lanes, like `attach-file`). This module writes
+ * `<session cwd>/.env`:
+ *
+ *   - The folder comes from the SESSION (cwdOf), never the frame. A session
+ *     with no project folder is refused — never falls back to $HOME.
+ *   - `.env` that git TRACKS is refused (writing a key into it would commit it).
+ *   - `.env` is added to `.gitignore` first when git does not already ignore it.
+ *   - NAME=value replaces an existing NAME line (no duplicates); others are kept.
+ *   - File mode 0600, written via temp file + rename.
+ *   - A symlinked `.env`/`.gitignore` is refused (no writes outside the root).
+ *
+ * Values are NEVER logged, echoed in a reply, or kept in memory past the write.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+const repoEnv_1 = require("./repoEnv");
+exports.SAVE_ENV_NAME_RE = /^[A-Z_][A-Z0-9_]{0,63}$/;
+exports.MAX_SAVE_ENV_VALUE_BYTES = 4096;
+exports.MAX_SAVE_ENV_ENTRIES = 32;
+/** Validate the frame's entries. Error text is user-facing and never quotes a value. */
+function validateEnvEntries(raw) {
+    if (!Array.isArray(raw) || raw.length === 0)
+        return { ok: false, error: 'Nothing to save' };
+    if (raw.length > exports.MAX_SAVE_ENV_ENTRIES)
+        return { ok: false, error: 'Too many keys' };
+    const byName = new Map();
+    for (const e of raw) {
+        const name = e?.name;
+        const value = e?.value;
+        if (typeof name !== 'string' || !exports.SAVE_ENV_NAME_RE.test(name))
+            return { ok: false, error: 'Invalid name' };
+        if ((0, repoEnv_1.isHiveOpOwnedEnvName)(name))
+            return { ok: false, error: `${name} is reserved` };
+        if (typeof value !== 'string' || value.length === 0)
+            return { ok: false, error: `${name}: empty value` };
+        if (/[\r\n\0]/.test(value))
+            return { ok: false, error: `${name}: value has a line break` };
+        if (Buffer.byteLength(value, 'utf8') > exports.MAX_SAVE_ENV_VALUE_BYTES)
+            return { ok: false, error: `${name}: value too long` };
+        byName.set(name, value);
+    }
+    return { ok: true, entries: [...byName].map(([name, value]) => ({ name, value })) };
+}
+/** Serialize one value so repoEnv.parseDotenv reads back exactly the same string. */
+function formatDotenvValue(value) {
+    if (/^[A-Za-z0-9_\-./:+=@,~%^]+$/.test(value))
+        return value;
+    if (!value.includes("'"))
+        return `'${value}'`;
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+function lineName(line) {
+    const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line);
+    return m ? m[1] : null;
+}
+/**
+ * Upsert entries into dotenv text: the first line for a NAME is replaced in
+ * place, later duplicates of it are dropped, new names are appended. Every
+ * other line (comments, unrelated keys) is preserved byte for byte.
+ */
+function upsertDotenv(existing, entries) {
+    const pending = new Map(entries.map((e) => [e.name, e.value]));
+    const written = new Set();
+    const lines = existing.length > 0 ? existing.split('\n') : [];
+    // A trailing newline yields one empty final element — keep it out of the loop.
+    const hadTrailingNewline = existing.endsWith('\n');
+    if (hadTrailingNewline)
+        lines.pop();
+    const out = [];
+    for (const line of lines) {
+        const name = lineName(line);
+        if (name && pending.has(name)) {
+            if (written.has(name))
+                continue; // a duplicate — never keep two
+            out.push(`${name}=${formatDotenvValue(pending.get(name))}`);
+            written.add(name);
+            continue;
+        }
+        out.push(line);
+    }
+    for (const [name, value] of pending) {
+        if (!written.has(name))
+            out.push(`${name}=${formatDotenvValue(value)}`);
+    }
+    return out.join('\n') + '\n';
+}
+exports.realEnvSaverDeps = {
+    realpath: (p) => fs.realpathSync(p),
+    lstat: (p) => {
+        try {
+            return fs.lstatSync(p);
+        }
+        catch {
+            return null;
+        }
+    },
+    readFile: (p) => fs.readFileSync(p, 'utf8'),
+    writeFileAtomic0600: (p, data) => {
+        const tmp = `${p}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+        fs.writeFileSync(tmp, data, { mode: 0o600 });
+        try {
+            fs.chmodSync(tmp, 0o600);
+            fs.renameSync(tmp, p);
+        }
+        catch (err) {
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch { /* best effort */ }
+            throw err;
+        }
+        fs.chmodSync(p, 0o600);
+    },
+    appendFile: (p, data) => fs.appendFileSync(p, data),
+    git: (args, cwd) => new Promise((resolve) => {
+        (0, child_process_1.execFile)('git', args, { cwd, timeout: 10_000, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } }, (err) => {
+            if (!err)
+                return resolve(0);
+            const code = err.code;
+            resolve(typeof code === 'number' ? code : 128);
+        });
+    }),
+};
+/** Write entries into `<root>/.env`. `root` is the session's cwd. */
+async function saveEnvEntries(root, entries, deps = exports.realEnvSaverDeps) {
+    let realRoot;
+    try {
+        realRoot = deps.realpath(root);
+    }
+    catch {
+        return { ok: false, error: 'Project folder not found' };
+    }
+    const rootStat = deps.lstat(realRoot);
+    if (!rootStat || !rootStat.isDirectory())
+        return { ok: false, error: 'Project folder not found' };
+    const envPath = path.join(realRoot, repoEnv_1.DOTENV_FILENAME);
+    const ignorePath = path.join(realRoot, '.gitignore');
+    // Containment: both files are direct children of the resolved root, and
+    // neither may be a symlink (which could point anywhere).
+    if (path.dirname(envPath) !== realRoot || path.dirname(ignorePath) !== realRoot) {
+        return { ok: false, error: 'Bad project folder' };
+    }
+    const envStat = deps.lstat(envPath);
+    if (envStat && (envStat.isSymbolicLink() || !envStat.isFile()))
+        return { ok: false, error: '.env is not a plain file' };
+    const ignoreStat = deps.lstat(ignorePath);
+    if (ignoreStat && (ignoreStat.isSymbolicLink() || !ignoreStat.isFile()))
+        return { ok: false, error: '.gitignore is not a plain file' };
+    // Tracked .env → refuse: the key would be committed with the next commit.
+    const tracked = await deps.git(['ls-files', '--error-unmatch', '--', repoEnv_1.DOTENV_FILENAME], realRoot);
+    if (tracked === 0)
+        return { ok: false, error: '.env is tracked by git' };
+    // Ignore it BEFORE the key lands, so it is never briefly committable.
+    // check-ignore: 0 = ignored, 1 = not ignored, 128 = not a repo / error.
+    let gitignoreAdded = false;
+    try {
+        const ignored = await deps.git(['check-ignore', '-q', '--', repoEnv_1.DOTENV_FILENAME], realRoot);
+        if (ignored !== 0) {
+            const current = ignoreStat ? deps.readFile(ignorePath) : '';
+            const sep = current.length > 0 && !current.endsWith('\n') ? '\n' : '';
+            deps.appendFile(ignorePath, `${sep}${repoEnv_1.DOTENV_FILENAME}\n`);
+            gitignoreAdded = true;
+        }
+    }
+    catch {
+        return { ok: false, error: "Couldn't update .gitignore" };
+    }
+    try {
+        const existing = envStat ? deps.readFile(envPath) : '';
+        deps.writeFileAtomic0600(envPath, upsertDotenv(existing, entries));
+    }
+    catch {
+        return { ok: false, error: "Couldn't write .env" };
+    }
+    return { ok: true, names: entries.map((e) => e.name), gitignoreAdded };
+}
+/**
+ * The whole `save-env` frame → `save-env-result` reply, shared verbatim by the
+ * local server and the relay client so the two lanes cannot drift. The reply
+ * carries names only — never a value.
+ */
+async function handleSaveEnvFrame(frame, sessions, deps = exports.realEnvSaverDeps) {
+    const head = {
+        t: 'save-env-result',
+        ...(typeof frame.rid === 'string' ? { rid: frame.rid } : {}),
+        ...(typeof frame.sessionId === 'string' ? { sessionId: frame.sessionId } : {}),
+    };
+    const sessionId = frame.sessionId;
+    if (typeof sessionId !== 'string' || !sessions.list().includes(sessionId)) {
+        return { ...head, ok: false, error: 'Terminal session not found' };
+    }
+    const root = sessions.cwdOf(sessionId);
+    if (!root)
+        return { ...head, ok: false, error: 'No project folder' };
+    const valid = validateEnvEntries(frame.entries);
+    if (!valid.ok)
+        return { ...head, ok: false, error: valid.error };
+    try {
+        const result = await saveEnvEntries(root, valid.entries, deps);
+        return result.ok
+            ? { ...head, ok: true, names: result.names, gitignoreAdded: result.gitignoreAdded }
+            : { ...head, ok: false, error: result.error };
+    }
+    catch {
+        return { ...head, ok: false, error: "Couldn't save key" };
+    }
+}

package/dist/bridge/hiveopSettings.js

@@ -81,6 +81,11 @@ function hookCommand(hooksDir, file) {
 function buildHiveOpSettingsContent(hooksDir) {
     const obj = {
         hooks: {
+            // Secret guard (2026-10-17): blocks a Bash command carrying a literal
+            // secret and tells the agent to reference it as $NAME instead.
+            PreToolUse: [
+                { matcher: 'Bash', hooks: [{ type: 'command', command: hookCommand(hooksDir, 'pre-tool-use.js') }] },
+            ],
             PostToolUse: [
                 {
                     matcher: 'Read|Edit|Write|Update|Create|MultiEdit|NotebookEdit|Bash',

package/dist/bridge/launchSupervisor.js

@@ -6,6 +6,7 @@ exports.firstMeaningfulLine = firstMeaningfulLine;
 exports.retryArgsFor = retryArgsFor;
 exports.friendlyStartFailure = friendlyStartFailure;
 exports.superviseLaunch = superviseLaunch;
+const redact_1 = require("../secrets/redact");
 /** 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. */
@@ -127,7 +128,9 @@ function superviseLaunch(factory, spawnOpts, opts = {}) {
                 return;
             }
             const raw = stripAnsi(captured).trim();
-            log(`[bridge] claude exited at startup (code ${code}, args: ${args.join(' ')}): ${raw || '(no output)'}`);
+            // The captured startup output can hold anything the shell printed, so it
+            // is masked before it reaches bridge.log (secret masking, 2026-10-17).
+            log((0, redact_1.redact)(`[bridge] claude exited at startup (code ${code}, args: ${args.join(' ')}): ${raw || '(no output)'}`));
             const nextArgs = retried ? null : retryArgsFor(args, captured);
             if (nextArgs) {
                 retried = true;

package/dist/bridge/localContextWriter.js

@@ -97,14 +97,18 @@ function writeLocalContext(input, deps) {
     const browser = (0, workGraphPointer_1.browserSection)(input);
     if (browser)
         pointers.push(browser);
+    const keys = (0, workGraphPointer_1.keysSection)(input);
+    if (keys)
+        pointers.push(keys);
+    const sections = (0, workGraphPointer_1.withSecretsSection)(pointers);
     // 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) : '';
     const fileContent = input.pointersOnly
         ? splitPointers(existingBody).rest
         : (input.content ?? '').trim();
-    const block = pointers.length > 0
-        ? `${contextWriter_1.POINTERS_START_MARKER}\n${pointers.join('\n\n')}\n${contextWriter_1.POINTERS_END_MARKER}`
+    const block = sections.length > 0
+        ? `${contextWriter_1.POINTERS_START_MARKER}\n${sections.join('\n\n')}\n${contextWriter_1.POINTERS_END_MARKER}`
         : '';
     const content = [block, fileContent].filter((part) => part.length > 0).join('\n\n');
     const isEmpty = content.trim().length === 0;

package/dist/bridge/paneClient.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Who is attaching a terminal pane — so last-attach-wins can tell a real
+ * second viewer from the same pane coming back.
+ *
+ * Prod 2026-10-17: panes showed "Session attached elsewhere" with nobody
+ * else attached. On this (loopback) lane a second mount of the same agent in
+ * one page, or a pane re-attaching on its own socket, got the same takeover a
+ * second device does. The arena sends three ids with each open/attach (the
+ * backend relay's pane-client.ts is the hosted twin of this file):
+ *
+ *   browser — one per browser profile (localStorage)
+ *   tab     — one per page load
+ *   mount   — one per terminal pane instance, stable across its reconnects
+ *
+ * All optional: an old client sends none and gets today's plain takeover.
+ */
+export interface PaneClient {
+    browser?: string;
+    tab?: string;
+    mount?: string;
+}
+/** Where the NEW attachment is, from the superseded one's point of view.
+ *  'self' = the same pane instance redialing: evict the ghost silently. */
+export type TakeoverWhere = 'self' | 'page' | 'tab' | 'device';
+/** Accept only short opaque ids; anything else is treated as absent. */
+export declare function parsePaneClient(raw: unknown): PaneClient | undefined;
+/**
+ * Compare the superseded pane's identity with the new one's. Undefined when
+ * either side did not say who it is (old client) — the caller keeps the
+ * plain takeover it always sent.
+ */
+export declare function takeoverWhere(prev: PaneClient | undefined, next: PaneClient | undefined): TakeoverWhere | undefined;

package/dist/bridge/paneClient.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePaneClient = parsePaneClient;
+exports.takeoverWhere = takeoverWhere;
+const ID = /^[A-Za-z0-9_-]{1,64}$/;
+/** Accept only short opaque ids; anything else is treated as absent. */
+function parsePaneClient(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const r = raw;
+    const pick = (v) => (typeof v === 'string' && ID.test(v) ? v : undefined);
+    const out = { browser: pick(r.browser), tab: pick(r.tab), mount: pick(r.mount) };
+    return out.browser || out.tab || out.mount ? out : undefined;
+}
+/**
+ * Compare the superseded pane's identity with the new one's. Undefined when
+ * either side did not say who it is (old client) — the caller keeps the
+ * plain takeover it always sent.
+ */
+function takeoverWhere(prev, next) {
+    if (!prev || !next)
+        return undefined;
+    if (prev.mount && next.mount && prev.mount === next.mount)
+        return 'self';
+    if (prev.tab && next.tab && prev.tab === next.tab)
+        return 'page';
+    if (prev.browser && next.browser)
+        return prev.browser === next.browser ? 'tab' : 'device';
+    return undefined;
+}

package/dist/bridge/realPty.js

@@ -41,6 +41,7 @@ exports.realPtyFactory = realPtyFactory;
  */
 const os = __importStar(require("os"));
 const envSanitize_1 = require("./envSanitize");
+const repoEnv_1 = require("./repoEnv");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 /**
@@ -86,7 +87,10 @@ function realPtyFactory() {
                 // Sanitized: the launcher's Claude-session markers must not leak into
                 // the agent (see envSanitize.ts — a bridge started from inside a Claude
                 // Code session was silently disabling transcript saving in every agent).
-                env: { ...(0, envSanitize_1.sanitizeInheritedEnv)(process.env), ...(env ?? {}) },
+                // Paste a key → .env: the session folder's `.env` is loaded too —
+                // above the inherited env, below the session's own (WENRWA_* etc.),
+                // with reserved names never taken from the file (repoEnv.ts).
+                env: (0, repoEnv_1.mergeSpawnEnv)((0, envSanitize_1.sanitizeInheritedEnv)(process.env), (0, repoEnv_1.loadRepoEnv)(cwd), env),
             });
             return {
                 write: (data) => proc.write(data),