@wenrwa/marketplace-cli 0.8.5 → 0.8.7

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/processCpu.d.ts

@@ -0,0 +1,29 @@
+export interface ProcEntry {
+    ppid: number;
+    /** utime + stime + cutime + cstime, in clock ticks. */
+    ticks: number;
+}
+/** Parse one /proc/<pid>/stat line. The command name sits in parentheses and
+ *  may itself contain spaces or parentheses, so split after the LAST ')'. */
+export declare function parseProcStat(line: string): ProcEntry | null;
+export declare function readProcTable(procRoot?: string): Map<number, ProcEntry>;
+/** Total ticks of `root` and every live descendant. */
+export declare function treeTicks(table: Map<number, ProcEntry>, root: number): number;
+export interface CpuBusyTrackerOptions {
+    readTable?: () => Map<number, ProcEntry>;
+    now?: () => number;
+    /** Clock ticks per second (Linux USER_HZ — 100 on every mainstream kernel). */
+    clkTck?: number;
+    /** Busy at or above this share of one core, averaged since the last sample. */
+    thresholdPct?: number;
+}
+export interface CpuBusyTracker {
+    /** Session ids whose tree used ≥ threshold CPU since the previous sample.
+     *  A session seen for the first time only sets its baseline. */
+    sample(sessions: Array<{
+        id: string;
+        pid: number | undefined;
+    }>): string[];
+}
+export declare const DEFAULT_BUSY_CPU_PCT = 20;
+export declare function createCpuBusyTracker(opts?: CpuBusyTrackerOptions): CpuBusyTracker | null;

package/dist/bridge/processCpu.js

@@ -0,0 +1,160 @@
+"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.DEFAULT_BUSY_CPU_PCT = void 0;
+exports.parseProcStat = parseProcStat;
+exports.readProcTable = readProcTable;
+exports.treeTicks = treeTicks;
+exports.createCpuBusyTracker = createCpuBusyTracker;
+/**
+ * Activity-based sleep — which PTY sessions are doing work nobody can see?
+ *
+ * The backend suspends an idle box (HT_ACTIVITY_IDLE=1). Output and keystrokes
+ * already count as activity; this covers the silent rest: a build, a test run
+ * or an install a backgrounded shell runs while the agent sits at its prompt.
+ * We measure CPU, not "is a child process alive", on purpose: an idle dev
+ * server is alive forever and must not hold a box awake, but one actually
+ * serving requests burns CPU and does.
+ *
+ * Linux only (reads /proc). Elsewhere `createCpuBusyTracker` returns null and
+ * the `sessions` frame carries no `busy` field, which the backend reads as
+ * unknown — never as busy.
+ *
+ * A session's cost is its whole process tree: utime+stime of every live
+ * process under the PTY, plus cutime+cstime, which already holds the CPU of
+ * children that have exited and been reaped (an install's short-lived compiler
+ * runs). A reaped intermediate parent takes its children's time with it; the
+ * delta is clamped at 0, so that can only under-report.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Parse one /proc/<pid>/stat line. The command name sits in parentheses and
+ *  may itself contain spaces or parentheses, so split after the LAST ')'. */
+function parseProcStat(line) {
+    const close = line.lastIndexOf(')');
+    if (close < 0)
+        return null;
+    const f = line.slice(close + 2).trim().split(/\s+/);
+    // f[0]=state f[1]=ppid … f[11]=utime f[12]=stime f[13]=cutime f[14]=cstime
+    if (f.length < 15)
+        return null;
+    const nums = [f[1], f[11], f[12], f[13], f[14]].map(Number);
+    if (nums.some((n) => !Number.isFinite(n)))
+        return null;
+    return { ppid: nums[0], ticks: nums[1] + nums[2] + nums[3] + nums[4] };
+}
+function readProcTable(procRoot = '/proc') {
+    const table = new Map();
+    let names;
+    try {
+        names = fs.readdirSync(procRoot);
+    }
+    catch {
+        return table;
+    }
+    for (const name of names) {
+        if (!/^\d+$/.test(name))
+            continue;
+        try {
+            const e = parseProcStat(fs.readFileSync(path.join(procRoot, name, 'stat'), 'utf8'));
+            if (e)
+                table.set(Number(name), e);
+        }
+        catch { /* exited between readdir and read */ }
+    }
+    return table;
+}
+/** Total ticks of `root` and every live descendant. */
+function treeTicks(table, root) {
+    const children = new Map();
+    for (const [pid, e] of table) {
+        const list = children.get(e.ppid);
+        if (list)
+            list.push(pid);
+        else
+            children.set(e.ppid, [pid]);
+    }
+    let total = 0;
+    const stack = [root];
+    const seen = new Set();
+    while (stack.length) {
+        const pid = stack.pop();
+        if (seen.has(pid))
+            continue;
+        seen.add(pid);
+        const e = table.get(pid);
+        if (e)
+            total += e.ticks;
+        for (const c of children.get(pid) ?? [])
+            stack.push(c);
+    }
+    return total;
+}
+exports.DEFAULT_BUSY_CPU_PCT = 20;
+function createCpuBusyTracker(opts = {}) {
+    const readTable = opts.readTable ?? (process.platform === 'linux' && fs.existsSync('/proc/self/stat') ? () => readProcTable() : null);
+    if (!readTable)
+        return null;
+    const now = opts.now ?? Date.now;
+    const clkTck = opts.clkTck ?? 100;
+    const thresholdPct = opts.thresholdPct ?? (Number(process.env.HIVEOP_BUSY_CPU_PCT) || exports.DEFAULT_BUSY_CPU_PCT);
+    const last = new Map();
+    return {
+        sample(sessions) {
+            const table = readTable();
+            const at = now();
+            const busy = [];
+            const live = new Set();
+            for (const { id, pid } of sessions) {
+                if (typeof pid !== 'number' || !table.has(pid))
+                    continue;
+                live.add(id);
+                const ticks = treeTicks(table, pid);
+                const prev = last.get(id);
+                last.set(id, { pid, ticks, at });
+                if (!prev || prev.pid !== pid || at <= prev.at)
+                    continue;
+                const cpuSeconds = Math.max(0, ticks - prev.ticks) / clkTck;
+                const pct = (cpuSeconds / ((at - prev.at) / 1000)) * 100;
+                if (pct >= thresholdPct)
+                    busy.push(id);
+            }
+            for (const id of [...last.keys()])
+                if (!live.has(id))
+                    last.delete(id);
+            return busy;
+        },
+    };
+}

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),
@@ -94,6 +98,7 @@ function realPtyFactory() {
                 kill: () => proc.kill(),
                 onData: (cb) => proc.onData(cb),
                 onExit: (cb) => proc.onExit(({ exitCode }) => cb(exitCode)),
+                pid: typeof proc.pid === 'number' ? proc.pid : undefined,
             };
         },
     };