hop2 0.11.68 → 0.11.70

package/hop

@@ -21,6 +21,7 @@ const { AuthSessionStore, isSessionToken: isAuthSessionToken } = require('./lib/
 const { agentPhase, screenSaysWorking } = require('./lib/agent-phase');
 const { snapshotFromMetas, planRefiles, pruneList, snapshotFileName } = require('./lib/identity-snapshot');
 const { withCodexIdentity } = require('./lib/codex-identity');
+const { resolveCallerSession, sessionFromEnvLine } = require('./lib/session-identity');
 const checkbacks = require('./lib/checkbacks');
 const digestReads = require('./lib/digest-reads');
 const { rotateAuditFile, sweepStaleAuditDirs } = require('./lib/audit-rotation');
@@ -5101,6 +5102,7 @@ if (DAEMON_FLAG && TERMINAL_API_IDLE_TTL_MS > 0) {
 }
 
 function closeTerminalApiEntry(terminalId) {
+    const entry = terminalApiSessions.get(terminalId);
     terminalApiSessions.delete(terminalId);
     const streams = terminalApiStreams.get(terminalId);
     if (streams) {
@@ -5110,6 +5112,12 @@ function closeTerminalApiEntry(terminalId) {
         terminalApiStreams.delete(terminalId);
     }
     clearTerminalEventBuffer(terminalId);
+    // Detach the room client too. This only dropped the daemon's record and
+    // left the socket open, so every check-back delivery and reconcile
+    // redrive left a ghost "checkback"/"reconcile" client on the session
+    // (57 on one room) — idle presence chips across the top bar. The
+    // adapter's close() calls back here with the entry already gone.
+    if (entry?.adapter?.close) { try { entry.adapter.close(); } catch (e) { /* already closing */ } }
 }
 
 function handleTerminalApiServerMessage(terminalId, parsed) {
@@ -8101,6 +8109,56 @@ function isProcessAlive(pid) {
     }
 }
 
+// WHICH session this CLI process is in — by the process tree (its shell's
+// place under the host), not by the inherited HOP_SESSION alone; see
+// lib/session-identity.js. Cached: the tree does not change mid-command.
+let callerSessionMemo = null;
+function readProcForIdentity(pid) {
+    try {
+        if (process.platform === 'linux') {
+            const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+            const after = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+            const ppid = Number(after[1]) || 0;
+            let command = '';
+            try { command = fs.readFileSync(`/proc/${pid}/cmdline`).toString('utf8').replace(/\0/g, ' ').trim(); } catch (e) { /* gone */ }
+            let session = null;
+            try { const env = fs.readFileSync(`/proc/${pid}/environ`).toString('utf8'); const m = /(?:^|\0)HOP_SESSION=([A-Za-z0-9_-]+)/.exec(env); session = m ? m[1] : null; } catch (e) { /* not ours */ }
+            return { ppid, command, session };
+        }
+        const line = execFileSync('ps', ['-ww', '-o', 'ppid=,command=', '-p', String(pid)], { encoding: 'utf8', timeout: 2000 }).trim();
+        if (!line) return null;
+        const m = /^\s*(\d+)\s+(.*)$/s.exec(line);
+        if (!m) return null;
+        let session = null;
+        try { session = sessionFromEnvLine(execFileSync('ps', ['-Eww', '-o', 'command=', '-p', String(pid)], { encoding: 'utf8', timeout: 2000 }), m[2]); } catch (e) { /* no env access */ }
+        return { ppid: Number(m[1]) || 0, command: m[2], session };
+    } catch (e) { return null; }
+}
+function callerSession() {
+    if (callerSessionMemo) return callerSessionMemo;
+    const host = readHayHostStateFile();
+    callerSessionMemo = resolveCallerSession({
+        pid: process.pid,
+        hostPid: host && Number.isInteger(host.pid) ? host.pid : null,
+        envSession: process.env.HOP_SESSION || null,
+        readProc: readProcForIdentity
+    });
+    if (process.env.HOP_IDENTITY_DEBUG) {
+        process.stderr.write(`[identity] host=${host?.pid} env=${process.env.HOP_SESSION || ''} → ${JSON.stringify({ ok: callerSessionMemo.ok, session: callerSessionMemo.session, via: callerSessionMemo.via, reason: callerSessionMemo.reason })}\n`);
+        for (const c of callerSessionMemo.chain) process.stderr.write(`[identity]   ${c.pid} ${c.command.slice(0, 90)}\n`);
+    }
+    return callerSessionMemo;
+}
+// The session a CLI command acts on when none was named: the verified one,
+// or nothing — with the reason printed — never an inherited guess.
+function callerSessionOrExplain(what) {
+    const r = callerSession();
+    if (r.ok) { if (r.note) log(r.note, DIM); return r.session; }
+    log(r.note || 'Not inside a hop session.', YELLOW);
+    log(`${what} needs an explicit target: ${CYAN}--session <name>${RESET}`, DIM);
+    return null;
+}
+
 function readHayHostStateFile() {
     if (!fs.existsSync(HAY_HOST_STATE_FILE)) return null;
     try {
@@ -16950,7 +17008,7 @@ async function main() {
         const args = process.argv.slice(3);
         const dryRun = args.includes('--dry-run') || args.includes('-n');
         const named = args.find((a) => !a.startsWith('-')) || null;
-        const here = process.env.HOP_SESSION || null;
+        const here = callerSession().ok ? callerSession().session : null;
         if (!named && !here) {
             log(`Run ${CYAN}hop recover${RESET} inside a hop session, or name one: ${CYAN}hop recover <session>${RESET}`, YELLOW);
             process.exit(1);
@@ -17524,11 +17582,13 @@ async function main() {
     // INTERNAL name, invisible in any UI once the session is renamed, so
     // this resolves the display name humans actually see. --json for agents.
     if (process.argv[2] === 'whoami') {
-        const internal = process.env.HOP_SESSION || '';
+        const who = callerSession();
+        const internal = who.ok ? who.session : '';
         const asJson = process.argv.includes('--json');
+        if (who.ok && who.note && !asJson) log(who.note, DIM);
         if (!internal) {
-            if (asJson) { console.log(JSON.stringify({ insideHopSession: false })); process.exit(1); }
-            log('Not inside a hop session (HOP_SESSION is unset).', YELLOW);
+            if (asJson) { console.log(JSON.stringify({ insideHopSession: false, reason: who.reason || null, note: who.note || null, envSession: process.env.HOP_SESSION || null })); process.exit(1); }
+            log(who.note || 'Not inside a hop session (HOP_SESSION is unset).', YELLOW);
             log(`Publishing from here needs an explicit target: ${CYAN}hop view --session <name> …${RESET}`, DIM);
             process.exit(1);
         }
@@ -17577,7 +17637,7 @@ async function main() {
             process.exit(0);
         }
         if (has('--cancel') || has('--cancel-all')) {
-            const body = has('--cancel') ? { id: flagValue('--cancel') } : { session: flagValue('--session') || process.env.HOP_SESSION || null };
+            const body = has('--cancel') ? { id: flagValue('--cancel') } : { session: flagValue('--session') || callerSessionOrExplain('hop checkback --cancel-all') };
             if (has('--cancel-all') && !body.session) { log('--cancel-all needs --session <name> (or run it inside the session).', RED); process.exit(1); }
             const r = await callLocalApi(state, '/api/checkbacks/cancel', 'POST', body);
             if (!r?.data?.ok) { log(r?.data?.error || 'Cancel failed', RED); process.exit(1); }
@@ -17592,8 +17652,8 @@ async function main() {
             positional.push(argv[i]);
         }
         const message = positional.join(' ').trim();
-        const session = flagValue('--session') || process.env.HOP_SESSION || '';
-        if (!message || !session) { usage(); if (!session) log('No session: pass --session <name> or run inside a hop session.', RED); process.exit(1); }
+        const session = flagValue('--session') || callerSessionOrExplain('hop checkback') || '';
+        if (!message || !session) { usage(); process.exit(1); }
         const body = {
             session, message, force: has('--force'),
             in: flagValue('--in') || undefined, at: flagValue('--at') || undefined,
@@ -17616,7 +17676,7 @@ async function main() {
         }
         // The message rides the ASK record too, so the phone can say WHAT is
         // needed instead of a bare "wants you" (see readAsk / attentionReason).
-        const hs = process.env.HOP_SESSION;
+        const hs = callerSession().ok ? callerSession().session : null;
         if (hs && /^[A-Za-z0-9_-]+$/.test(hs)) {
             try {
                 const file = path.join(CLAUDE_SESSIONS_DIR, `${hs}.ask`);
@@ -17681,7 +17741,12 @@ async function main() {
         // So: explicit --session wins, the environment is the convenience
         // default, and having neither is an ERROR that says how to fix it —
         // never a quiet write into the void.
-        const session = wantSession || process.env.HOP_SESSION || '';
+        // Explicit --session wins; otherwise the VERIFIED caller session (by
+        // the process tree), and with neither this is an error that says why
+        // — never a quiet write into another session's views.
+        const session = wantSession || (callerSession().ok ? callerSession().session : '') || '';
+        if (!wantSession && !session && !wantList) { callerSessionOrExplain('hop view'); process.exit(1); }
+        if (!wantSession && callerSession().note && callerSession().ok) log(callerSession().note, DIM);
         const destDir = path.join(VIEWS_DIR, session);
 
         if (wantList) {
@@ -17804,7 +17869,7 @@ async function main() {
             // three requests past its purpose because nothing in the output
             // ever said "not the session you are in" — the human asked where
             // their files were, and they were in the other room.
-            const here = process.env.HOP_SESSION || '';
+            const here = callerSession().ok ? callerSession().session : '';
             if (here && here === session) {
                 log(`Session: ${session} (this terminal)`, DIM);
             } else if (here) {
@@ -17845,7 +17910,8 @@ async function main() {
         }
         const state = isServerRunning();
         if (!state) { printNotRunningError(); process.exit(1); }
-        const caller = process.env.HOP_SESSION || null;
+        const caller = callerSession().ok ? callerSession().session : null;
+        if (!caller && !flags.has('--standalone') && callerSession().reason === 'shared-daemon') log(callerSession().note, YELLOW);
         const standalone = flags.has('--standalone') || !caller;
         const label = positional[1] || `port-${port}`;
         const name = standalone ? label : `${caller}-${label}`;

package/lib/session-identity.js

@@ -0,0 +1,99 @@
+'use strict';
+// WHICH hop session is this process in? The honest answer comes from the
+// process tree, not from an inherited variable.
+//
+// HOP_SESSION is set on each session's shell by the host, and children
+// inherit it — which is right until something re-parents the work: Codex's
+// shared app-server daemon ran every session's commands and MCP servers
+// under the FIRST session's environment, so `hop view`, `hop checkback` and
+// the MCP tools all defaulted to that one session. An arbitrary default is
+// worse than none.
+//
+// So: walk the parents. The terminal host spawns one shell per session; the
+// ancestor that is a direct child of the host IS the session's shell, and its
+// HOP_SESSION is the truth. If the walk passes through a known multiplexer
+// (Codex's app-server daemon or its code-mode host) the answer is ambiguous
+// — the caller may belong to any session that daemon serves — and the
+// verdict says so instead of guessing. With no host in the chain at all
+// (a plain terminal, a cron), the environment is all there is, and the
+// verdict says that too.
+
+const MAX_HOPS = 24;
+// A multiplexer is recognised by WHAT RUNS, the program and its first word,
+// never by text anywhere in the arguments — a shell whose command line
+// merely mentions "codex app-server" (a test, a grep) is not one.
+const isMultiplexer = (command) => {
+    const words = String(command || '').trim().split(/\s+/);
+    const program = (words[0] || '').split('/').pop();
+    return program === 'codex-code-mode-host' || (program === 'codex' && words[1] === 'app-server');
+};
+
+/**
+ * @param {object} o
+ * @param {number} o.pid                 the calling process
+ * @param {number|null} o.hostPid        the terminal host's pid (null = unknown)
+ * @param {string|null} o.envSession     process.env.HOP_SESSION as inherited
+ * @param {(pid:number)=>{ppid:number, command:string, session?:string|null}|null} o.readProc
+ *        one process: its parent, command line, and the HOP_SESSION in its environment
+ * @returns {{ ok: boolean, session: string|null, via: 'ancestry'|'env'|null, reason?: string, note?: string, chain: Array<{pid:number, command:string}> }}
+ */
+function resolveCallerSession(o) {
+    const chain = [];
+    const env = o.envSession && /^[A-Za-z0-9_-]+$/.test(o.envSession) ? o.envSession : null;
+    let pid = Number(o.pid);
+    let viaDaemon = null;
+    let shellSession = null;
+    // The nearest ancestor whose environment could be read. The session
+    // shell itself is a login zsh whose environment macOS will not show
+    // (`ps -E` prints nothing for it); everything under it inherited the
+    // shell's HOP_SESSION, so the nearest readable one carries the truth —
+    // unless a multiplexer sits in between, which is caught separately.
+    let nearestSession = null;
+    for (let hops = 0; hops < MAX_HOPS && pid && pid > 1; hops++) {
+        const info = o.readProc(pid);
+        if (!info) break;
+        chain.push({ pid, command: String(info.command || '').slice(0, 120) });
+        if (isMultiplexer(info.command)) viaDaemon = viaDaemon || { pid, command: String(info.command || '').slice(0, 80) };
+        // The calling process's own variable is what we are checking, so it
+        // does not count as evidence; its ancestors' do.
+        if (hops > 0 && !nearestSession && info.session) nearestSession = info.session;
+        if (o.hostPid && info.ppid === o.hostPid) {
+            // This process is the session's own shell.
+            shellSession = info.session || nearestSession || null;
+            break;
+        }
+        if (!info.ppid || info.ppid === pid) break;
+        pid = info.ppid;
+    }
+    if (viaDaemon) {
+        return {
+            ok: false, session: null, via: null, chain,
+            reason: 'shared-daemon',
+            note: `This process runs under a shared agent daemon (${viaDaemon.command.trim()}), which serves several sessions — the inherited HOP_SESSION${env ? ` ("${env}")` : ''} may belong to another one. Pass the session explicitly.`
+        };
+    }
+    if (shellSession) {
+        const note = env && env !== shellSession
+            ? `HOP_SESSION says "${env}" but this process lives in session "${shellSession}" (by its shell); using the latter.`
+            : undefined;
+        return { ok: true, session: shellSession, via: 'ancestry', chain, note };
+    }
+    if (env) return { ok: true, session: env, via: 'env', chain, note: o.hostPid ? 'Not under a hop session shell; trusting HOP_SESSION as inherited.' : undefined };
+    return { ok: false, session: null, via: null, chain, reason: 'no-session', note: 'Not inside a hop session (no session shell above this process, and HOP_SESSION is unset).' };
+}
+
+/**
+ * Parse `HOP_SESSION=…` out of a `ps -E` line (macOS): the command line
+ * followed by the environment. Given the plain command line too, only the
+ * ENVIRONMENT part is read — a shell whose arguments contain
+ * "HOP_SESSION=x" (a test, a script) is not thereby in session x.
+ */
+function sessionFromEnvLine(line, plainCommand) {
+    let text = String(line || '');
+    const plain = String(plainCommand || '').trim();
+    if (plain && text.startsWith(plain)) text = text.slice(plain.length);
+    const m = /(?:^|\s)HOP_SESSION=([A-Za-z0-9_-]+)/.exec(text);
+    return m ? m[1] : null;
+}
+
+module.exports = { resolveCallerSession, sessionFromEnvLine, isMultiplexer };

package/mcp/hop-mcp.js

@@ -2,6 +2,7 @@
 'use strict';
 
 const fs = require('fs');
+const { resolveCallerSession: resolveCallerSessionLib, sessionFromEnvLine: sessionFromEnvLineLib } = require(require('path').join(__dirname, '..', 'lib', 'session-identity'));
 const os = require('os');
 const path = require('path');
 const http = require('http');
@@ -2951,6 +2952,43 @@ class TerminalStreamManager {
   }
 }
 
+// WHICH session this MCP server serves — by the process tree, not the
+// inherited HOP_SESSION alone (lib/session-identity.js). Under Codex's
+// shared app-server daemon the inherited value belonged to the first
+// session; the verdict is then "ambiguous", and tools that default to the
+// caller's session ask for it explicitly instead of guessing.
+let callerSessionMemo = null;
+function readProcForIdentity(pid) {
+  const fs = require('fs');
+  const { execFileSync } = require('child_process');
+  try {
+    if (process.platform === 'linux') {
+      const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+      const after = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+      let command = ''; try { command = fs.readFileSync(`/proc/${pid}/cmdline`).toString('utf8').replace(/\0/g, ' ').trim(); } catch { /* gone */ }
+      let session = null; try { const env = fs.readFileSync(`/proc/${pid}/environ`).toString('utf8'); const mm = /(?:^|\0)HOP_SESSION=([A-Za-z0-9_-]+)/.exec(env); session = mm ? mm[1] : null; } catch { /* not ours */ }
+      return { ppid: Number(after[1]) || 0, command, session };
+    }
+    const line = execFileSync('ps', ['-ww', '-o', 'ppid=,command=', '-p', String(pid)], { encoding: 'utf8', timeout: 2000 }).trim();
+    const mm = /^\s*(\d+)\s+(.*)$/s.exec(line);
+    if (!mm) return null;
+    let session = null;
+    try { session = sessionFromEnvLineLib(execFileSync('ps', ['-Eww', '-o', 'command=', '-p', String(pid)], { encoding: 'utf8', timeout: 2000 }), mm[2]); } catch { /* no env access */ }
+    return { ppid: Number(mm[1]) || 0, command: mm[2], session };
+  } catch { return null; }
+}
+function callerSession() {
+  if (callerSessionMemo) return callerSessionMemo;
+  let hostPid = null;
+  try {
+    const fs = require('fs'); const os = require('os'); const path = require('path');
+    const st = JSON.parse(fs.readFileSync(path.join(process.env.HOP_HOME || path.join(os.homedir(), '.hop2'), '.hay-host-state'), 'utf8'));
+    hostPid = Number.isInteger(st.pid) ? st.pid : null;
+  } catch { /* no host state: env is all there is */ }
+  callerSessionMemo = resolveCallerSessionLib({ pid: process.pid, hostPid, envSession: process.env.HOP_SESSION || null, readProc: readProcForIdentity });
+  return callerSessionMemo;
+}
+
 class HopMCPServer {
   constructor() {
     this.agentId = randomUUID();
@@ -3755,7 +3793,11 @@ class HopMCPServer {
     if (name === 'hop_current_session') {
       // Answerable WITHOUT a daemon: the env fact stands on its own, and an
       // agent asking "where am I" mid-outage still deserves the truth.
-      const internal = process.env.HOP_SESSION || null;
+      const who = callerSession();
+      const internal = who.ok ? who.session : null;
+      if (!internal && who.reason === 'shared-daemon') {
+        return this.wrapApiResult({ insideHopSession: false, ambiguous: true, reason: who.reason, note: who.note, envSession: process.env.HOP_SESSION || null }, { endpoint: 'local' });
+      }
       const payload = {
         insideHopSession: !!internal,
         internalName: internal,
@@ -3785,8 +3827,9 @@ class HopMCPServer {
         return this.wrapApiResult(await this.callApi('GET', '/api/sessions'), { endpoint: '/api/sessions' });
       case 'hop_checkback': {
         const a = args || {};
-        const session = a.session || process.env.HOP_SESSION || null;
-        if (!session) return this.wrapApiResult({ error: 'No session: pass `session` (this MCP is not running inside a hop session).' }, { endpoint: '/api/checkbacks' });
+        const who = callerSession();
+        const session = a.session || (who.ok ? who.session : null);
+        if (!session) return this.wrapApiResult({ error: `No session: pass \`session\`. ${who.note || ''}`.trim() }, { endpoint: '/api/checkbacks' });
         const body = {
           session, message: a.message, force: a.force === true,
           in: a.in, at: a.at, every: a.every, until: a.until,
@@ -3804,7 +3847,7 @@ class HopMCPServer {
         return this.wrapApiResult({ items }, { endpoint: '/api/checkbacks' });
       }
       case 'hop_cancel_checkback':
-        return this.wrapApiResult(await this.callApi('POST', '/api/checkbacks/cancel', { id: (args || {}).id, session: (args || {}).session || (!(args || {}).id ? process.env.HOP_SESSION : undefined) }), { endpoint: '/api/checkbacks/cancel' });
+        return this.wrapApiResult(await this.callApi('POST', '/api/checkbacks/cancel', { id: (args || {}).id, session: (args || {}).session || (!(args || {}).id && callerSession().ok ? callerSession().session : undefined) }), { endpoint: '/api/checkbacks/cancel' });
       case 'hop_list_terminals': {
         const listed = await this.callApi('GET', '/api/terminals');
         if (!this.isApiFailurePayload(listed) && Array.isArray(listed.terminals)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.68",
+  "version": "0.11.70",
   "description": "🐰 Hop into your terminal from anywhere. Secure remote shell access with 2FA via Cloudflare Tunnel. Next-gen rewrite with native terminal sharing.",
   "main": "hop",
   "bin": {

package/tests/session-identity.unit.test.cjs

@@ -0,0 +1,79 @@
+// Which session a process is in: by its shell's place under the host, never
+// by an inherited variable when a multiplexer sits in between.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { resolveCallerSession, sessionFromEnvLine, isMultiplexer } = require('../lib/session-identity');
+
+const HOST = 1428;
+const table = (rows) => (pid) => rows[pid] || null;
+
+test('a command under claude under the session shell resolves by ancestry', () => {
+  const readProc = table({
+    900: { ppid: 800, command: 'hop view report.html' },
+    800: { ppid: 700, command: 'claude --resume abc' },
+    700: { ppid: HOST, command: '/bin/zsh -lc env -u CLAUDE_CONFIG_DIR claude --resume abc', session: 's_room1' }
+  });
+  const r = resolveCallerSession({ pid: 900, hostPid: HOST, envSession: 's_room1', readProc });
+  assert.equal(r.ok, true); assert.equal(r.session, 's_room1'); assert.equal(r.via, 'ancestry'); assert.equal(r.note, undefined);
+});
+
+test('the shell wins over a lying environment, and says so', () => {
+  const readProc = table({
+    900: { ppid: 700, command: 'hop checkback --in 5m x' },
+    700: { ppid: HOST, command: '/bin/zsh', session: 's_room1' }
+  });
+  const r = resolveCallerSession({ pid: 900, hostPid: HOST, envSession: 's_other', readProc });
+  assert.equal(r.session, 's_room1'); assert.equal(r.via, 'ancestry'); assert.match(r.note, /HOP_SESSION says "s_other"/);
+});
+
+test("the session shell's environment is unreadable on macOS: the nearest readable ancestor below it speaks for it", () => {
+  const readProc = table({
+    900: { ppid: 850, command: 'hop whoami', session: 's_lie' },        // the caller's own variable is not evidence
+    850: { ppid: 800, command: '/bin/zsh -c snapshot', session: 's_room1' },
+    800: { ppid: 700, command: 'claude --resume abc', session: 's_room1' },
+    700: { ppid: HOST, command: '/bin/zsh -lc env -u CLAUDE_CONFIG_DIR claude', session: null }
+  });
+  const r = resolveCallerSession({ pid: 900, hostPid: HOST, envSession: 's_lie', readProc });
+  assert.equal(r.session, 's_room1'); assert.equal(r.via, 'ancestry'); assert.match(r.note, /says "s_lie"/);
+});
+
+test("under Codex's shared app-server daemon the answer is AMBIGUOUS, not the daemon owner's", () => {
+  const readProc = table({
+    950: { ppid: 940, command: 'node /x/hop-mcp.js' },
+    940: { ppid: 930, command: '/x/bin/codex app-server --listen unix:// --managed-daemon' },
+    930: { ppid: 920, command: '/x/bin/codex app-server daemon pid-update-loop' },
+    920: { ppid: 910, command: '/x/bin/codex resume 01a0' },
+    910: { ppid: HOST, command: '/bin/zsh', session: 'Accessibility-fork-codex' }
+  });
+  const r = resolveCallerSession({ pid: 950, hostPid: HOST, envSession: 'Accessibility-fork-codex', readProc });
+  assert.equal(r.ok, false); assert.equal(r.session, null); assert.equal(r.reason, 'shared-daemon');
+  assert.match(r.note, /shared agent daemon/); assert.match(r.note, /Pass the session explicitly/);
+});
+
+test('no session shell above and no variable: not inside hop; with the variable: trusted as inherited', () => {
+  const readProc = table({ 300: { ppid: 200, command: 'bash' }, 200: { ppid: 1, command: 'login' } });
+  const none = resolveCallerSession({ pid: 300, hostPid: HOST, envSession: null, readProc });
+  assert.equal(none.ok, false); assert.equal(none.reason, 'no-session');
+  const env = resolveCallerSession({ pid: 300, hostPid: HOST, envSession: 's_cron', readProc });
+  assert.equal(env.ok, true); assert.equal(env.session, 's_cron'); assert.equal(env.via, 'env');
+});
+
+test('a process the table cannot read stops the walk gracefully', () => {
+  const r = resolveCallerSession({ pid: 5, hostPid: HOST, envSession: 's_x', readProc: () => null });
+  assert.equal(r.session, 's_x'); assert.equal(r.via, 'env');
+});
+
+test('HOP_SESSION is read out of the ENVIRONMENT part of a ps -E line, never out of the arguments', () => {
+  assert.equal(sessionFromEnvLine('/bin/zsh -lc claude HOP_SESSION=s_abc PATH=/usr/bin TERM=xterm', '/bin/zsh -lc claude'), 's_abc');
+  assert.equal(sessionFromEnvLine('/bin/zsh PATH=/usr/bin', '/bin/zsh'), null);
+  // The shell's own command text mentions a session; its environment says another.
+  assert.equal(sessionFromEnvLine('/bin/zsh -c HOP_SESSION=s_lie ./hop whoami HOME=/u HOP_SESSION=s_true', '/bin/zsh -c HOP_SESSION=s_lie ./hop whoami'), 's_true');
+  assert.equal(sessionFromEnvLine('/bin/zsh -c HOP_SESSION=s_lie ./hop whoami HOME=/u', '/bin/zsh -c HOP_SESSION=s_lie ./hop whoami'), null);
+});
+
+test('a multiplexer is the program that runs, not a mention in some argument list', () => {
+  assert.equal(isMultiplexer('/x/releases/0.159/bin/codex app-server --listen unix:// --managed-daemon'), true);
+  assert.equal(isMultiplexer('/x/bin/codex-code-mode-host'), true);
+  assert.equal(isMultiplexer('/opt/homebrew/bin/codex --no-daemon resume 01a0'), false);
+  assert.equal(isMultiplexer('/bin/zsh -c "echo codex app-server is a string"'), false);
+});