hop2 0.11.72 → 0.11.74

package/hay/apps/web/src/App.tsx

@@ -264,6 +264,7 @@ type SessionInfo = {
   createdBy?: "user" | "agent";
   createdVia?: string | null;
   agent?: "claude" | "codex" | null;
+  agentHome?: { dir: string; label: string; isDefault: boolean } | null;
   // Server-decided: a turn in flight, or the last one finished — and whether
   // a human has opened the session since it finished (see lib/agent-phase.js).
   agentPhase?: "working" | "done" | null;
@@ -3272,6 +3273,7 @@ const App = () => {
           createdBy: s.createdBy === "agent" ? "agent" : "user",
           createdVia: typeof s.createdVia === "string" ? s.createdVia : null,
           agent: s.agent === "claude" || s.agent === "codex" ? s.agent : null,
+          agentHome: s.agentHome && typeof s.agentHome.dir === "string" ? s.agentHome : null,
           agentPhase: s.agentPhase === "working" || s.agentPhase === "done" ? s.agentPhase : null,
           turnSeen: s.turnSeen !== false,
           checkbacks: Number(s.checkbacks) > 0 ? Number(s.checkbacks) : undefined,

package/hay/apps/web/src/components/SessionSwitcher.tsx

@@ -35,8 +35,7 @@ import {
   type SwitcherFolder,
   type SwitcherSession,
   type SwitcherSortMode,
-  insertAfter
-} from "../utils/switcherModel";
+  insertAfter, describeAccount, type AgentHome, type AgentHomes } from "../utils/switcherModel";
 import { scanKeyboardProtocol } from "../utils/keyboardProtocol";
 import { DigestCard } from "./DigestCard";
 import { hasUnseenViews, loadViewsSeen } from "./ViewsPanel";
@@ -124,7 +123,7 @@ type Props = {
 
 type Sheet = {
   session: SwitcherSession;
-  mode: "menu" | "rename" | "folder";
+  mode: "menu" | "rename" | "folder" | "account";
   // Viewport point the menu anchors to — the ... button or the long-press
   // finger position. A bottom sheet made the thumb travel the whole screen
   // for actions about the element it was already touching.
@@ -1501,7 +1500,7 @@ export const SessionSwitcher = ({
   // buttons — right-click is a shortcut, never a second vocabulary.
   const openWallMenu = (e: ReactMouseEvent) => {
     // Only the empty wall — a right-click on a card belongs to that card.
-    if ((e.target as HTMLElement)?.closest?.(".switcher-card, .switcher-group-label, .switcher-top")) return;
+    if ((e.target as HTMLElement)?.closest?.(".switcher-card, .switcher-row, .switcher-group-label, .switcher-top")) return;
     e.preventDefault();
     setMenu({
       x: e.clientX,
@@ -1704,6 +1703,19 @@ export const SessionSwitcher = ({
   // What a new session boots into: a plain shell, or straight into an agent.
   // Maps to the create API's `startup` command.
   const [createType, setCreateType] = useState<"terminal" | "claude" | "codex">("terminal");
+  // The agents' logins on the host (one per config root). Fetched when the
+  // wall opens; labels and pickers appear only where there is a choice.
+  const [agentHomes, setAgentHomes] = useState<AgentHomes>({ claude: [], codex: [] });
+  const loadAgentHomes = () => {
+    fetch("/api/agent-homes", { cache: "no-store" })
+      .then((r) => (r.ok ? r.json() : null))
+      .then((d) => { if (d && Array.isArray(d.claude) && Array.isArray(d.codex)) setAgentHomes(d); })
+      .catch(() => { /* no accounts info: nothing labelled */ });
+  };
+  useEffect(() => { loadAgentHomes(); }, []);
+  const homesFor = (agent?: string | null): AgentHome[] => (agent === "claude" || agent === "codex" ? agentHomes[agent] : []);
+  // The account a NEW agent session starts in; "" = the agent's default.
+  const [createHome, setCreateHome] = useState("");
   const startupFor = (t: "terminal" | "claude" | "codex") => (t === "claude" ? "claude" : t === "codex" ? "codex" : "");
   // Rendered by BOTH create forms. submitCreate has always sent createType, but
   // only the top-bar form let you set it, so creating a session inside a folder
@@ -1721,6 +1733,19 @@ export const SessionSwitcher = ({
           onClick={() => setCreateType(t)}
         >{t === "terminal" ? "Terminal" : t === "claude" ? "Claude" : "Codex"}</button>
       ))}
+      {createType !== "terminal" && homesFor(createType).length > 1 && (
+        <select
+          className="create-account"
+          aria-label={`${createType === "claude" ? "Claude" : "Codex"} account`}
+          title="Which login this session runs as (its config directory)"
+          value={createHome}
+          onChange={(e) => setCreateHome(e.target.value)}
+        >
+          {homesFor(createType).map((h) => (
+            <option key={h.dir} value={h.isDefault ? "" : h.dir}>{describeAccount(h)}</option>
+          ))}
+        </select>
+      )}
     </div>
   );
   // When set, the next created session is filed here (the folder header's +).
@@ -2334,14 +2359,21 @@ export const SessionSwitcher = ({
       onClose();
       return;
     }
-    // Opening a parked session IS unparking it — best-effort, never blocking
-    // the switch itself.
+    // Opening a parked session IS unparking it. Best-effort and not awaited
+    // for a parked one; a STOPPED one waits for it, because the daemon
+    // refuses to restart a stopped session until it is unparked (a viewer's
+    // reconnect must not undo "Stop & park").
     if (session.parked) {
-      fetch("/api/sessions/park", {
+      const unparked = fetch("/api/sessions/park", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ internalName: sessionKey(session), parked: false })
       }).catch(() => { /* daemon will still show it parked; harmless */ });
+      if (session.archived) {
+        onNotice("Resuming " + (session.displayName || session.name) + "…");
+        void unparked.then(() => handleTap({ ...session, parked: false, archived: false }));
+        return;
+      }
     }
     // A DEAD terminal session starts IN PLACE instead of falling through to
     // full screen — the last accidental door into the mode. Attaching is what
@@ -2531,6 +2563,25 @@ export const SessionSwitcher = ({
 
   // Fork (same tool) or hand off (target names the other tool). One call
   // for both so the two can never disagree about the endpoint.
+  const switchAccount = async (s: SwitcherSession, home: AgentHome) => {
+    setSheet(null);
+    if (home.login && !home.login.loggedIn && !window.confirm(`The ${home.label} account is logged out. Switch anyway? You will need to run /login in the session.`)) return;
+    onNotice(`Moving ${s.displayName} to the ${home.label} account…`);
+    try {
+      const res = await fetch("/api/sessions/agent-home", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: sessionKey(s), home: home.dir })
+      });
+      const data = await res.json().catch(() => null) as { ok?: boolean; error?: string; restarted?: boolean } | null;
+      if (!res.ok || !data?.ok) { onNotice(data?.error || `Switch failed (${res.status})`); return; }
+      onNotice(data.restarted ? `${s.displayName} now runs as ${home.label}` : `${s.displayName} is set to ${home.label}; it switches on its next start`);
+      onRefresh();
+    } catch {
+      onNotice("Switch failed");
+    }
+  };
+
   const forkSession = async (s: SwitcherSession, target?: "claude" | "codex") => {
     setSheet(null);
     onNotice(target ? `Handing off to ${target === "codex" ? "Codex" : "Claude"}…` : "Forking…");
@@ -2740,7 +2791,10 @@ export const SessionSwitcher = ({
       const res = await fetch("/api/sessions", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ name: next, type: "terminal", port: null, startup: startupFor(createType), cwd: createCwd.trim() || undefined })
+        body: JSON.stringify({
+          name: next, type: "terminal", port: null, startup: startupFor(createType), cwd: createCwd.trim() || undefined,
+          agentHome: createType !== "terminal" && createHome && homesFor(createType).some((h) => h.dir === createHome) ? createHome : undefined
+        })
       });
       const data = await res.json().catch(() => ({} as { name?: string; displayName?: string; internalName?: string; error?: string }));
       if (!res.ok || !data.name) {
@@ -3033,6 +3087,18 @@ export const SessionSwitcher = ({
               ⏰ {s.checkbacks}
             </button>
           )}
+          {s.agentHome && homesFor(s.agent).length > 1 && (() => {
+            const known = homesFor(s.agent).find((h) => h.dir === s.agentHome?.dir);
+            const out = known?.login && !known.login.loggedIn;
+            return (
+              <span
+                className={"switcher-chip account" + (s.agentHome.isDefault ? " default" : "") + (out ? " logged-out" : "")}
+                title={`Runs as ${known ? describeAccount(known) : s.agentHome.label} — ${s.agentHome.dir}${out ? ". Logged out: run /login in the session, or switch it to another account." : ""}`}
+              >
+                {out ? "⚠ " : ""}{s.agentHome.label}
+              </span>
+            );
+          })()}
           {phase && (
             <span className={`switcher-chip phase ${phase}`} title={phaseTitle(phase)}>
               <span className="phase-dot" aria-hidden="true" />{phaseLabel(phase)}
@@ -3577,6 +3643,7 @@ export const SessionSwitcher = ({
               const width = 264;
               const estH = sheet.mode === "rename" ? 150
                 : sheet.mode === "folder" ? 100 + 34 * (folders.length + 3)
+                : sheet.mode === "account" ? 110 + 34 * homesFor(sheet.session.agent).length
                 : 330;
               const left = Math.min(Math.max(8, sheet.anchor.x - width), window.innerWidth - width - 8);
               let top = sheet.anchor.y + 8;
@@ -3604,6 +3671,34 @@ export const SessionSwitcher = ({
                 <button type="submit">Save</button>
                 <button type="button" onClick={() => setSheet({ session: sheetSession, mode: "menu", anchor: sheet.anchor })}>✕</button>
               </form>
+            ) : sheet.mode === "account" ? (
+              // Another login for this session: the daemon copies the
+              // conversation into that account's config root and relaunches
+              // the agent there (refused while it is mid-turn).
+              <>
+                <div className="switcher-sheet-note">
+                  Run {sheetSession.displayName} as another {sheetSession.agent === "codex" ? "Codex" : "Claude"} account.
+                  The conversation comes along; the agent restarts.
+                </div>
+                {homesFor(sheetSession.agent).map((h) => {
+                  const here = sheetSession.agentHome?.dir === h.dir;
+                  return (
+                    <button
+                      key={h.dir}
+                      type="button"
+                      className={here ? "current" : undefined}
+                      disabled={here}
+                      title={h.dir}
+                      onClick={() => { void switchAccount(sheetSession, h); }}
+                    >
+                      {describeAccount(h)}{here ? " ✓" : ""}
+                    </button>
+                  );
+                })}
+                <button type="button" className="back" onClick={() => setSheet({ session: sheetSession, mode: "menu", anchor: sheet.anchor })}>
+                  ← Back
+                </button>
+              </>
             ) : sheet.mode === "folder" ? (
               // Filing from the menu: drag-and-drop needs a pointer, a free
               // hand, and the folder on screen at the same time as the card —
@@ -3690,6 +3785,11 @@ export const SessionSwitcher = ({
                 >
                   Move to folder…
                 </button>
+                {homesFor(sheetSession.agent).length > 1 && (
+                  <button type="button" onClick={() => setSheet({ session: sheetSession, mode: "account", anchor: sheet.anchor })}>
+                    Account: {sheetSession.agentHome?.label || "default"}…
+                  </button>
+                )}
                 {sheetSession.type !== "port" && <div className="switcher-sheet-sep" aria-hidden="true" />}
                 {sheetSession.type !== "port" && (
                   <button type="button" onClick={toggleAgentAccess}>

package/hay/apps/web/src/styles.css

@@ -2363,6 +2363,40 @@ button.primary {
   color: var(--ink-muted);
 }
 
+/* Which login the agent runs as — shown only when there is more than one.
+   The default account stays quiet; another account is outlined so a
+   session spending a different quota is visible at a glance. */
+.switcher-chip.account {
+  border: 1px solid var(--accent, var(--line));
+  background: transparent;
+  color: var(--ink);
+  text-transform: none;
+}
+.switcher-chip.account.default {
+  border-color: var(--line);
+  color: var(--ink-muted);
+}
+.switcher-chip.account.logged-out {
+  border-color: #d97706;
+  color: #b45309;
+}
+.switcher-create-type .create-account {
+  margin-left: 6px;
+  font: inherit;
+  font-size: 12px;
+  padding: 2px 4px;
+  border-radius: 6px;
+  border: 1px solid var(--line);
+  background: var(--panel);
+  color: var(--ink);
+}
+.switcher-sheet-note {
+  padding: 6px 12px 8px;
+  font-size: 12px;
+  line-height: 1.4;
+  color: var(--ink-muted);
+}
+
 .switcher-more {
   flex-shrink: 0;
   width: 26px;

package/hay/apps/web/src/utils/switcherModel.ts

@@ -1,3 +1,20 @@
+/** One login of an agent: a config root on the host. */
+export type AgentHome = {
+  dir: string;
+  label: string;
+  isDefault: boolean;
+  /** Who the root is logged in as, when the host could ask (null = unknown). */
+  login?: { loggedIn: boolean; email: string | null } | null;
+};
+/** "fable · a@b.org", "claude2 · logged out", or just the label. */
+export const describeAccount = (h: AgentHome): string => {
+  const name = h.isDefault ? "default" : h.label;
+  if (!h.login) return name;
+  if (!h.login.loggedIn) return `${name} · logged out`;
+  return h.login.email ? `${name} · ${h.login.email}` : name;
+};
+export type AgentHomes = { claude: AgentHome[]; codex: AgentHome[] };
+
 // Tiered model for the mobile session switcher. Pure data shaping so it can be
 // unit-tested without the DOM: the component just renders what this returns.
 //
@@ -35,6 +52,8 @@ export type SwitcherSession = {
   foregroundProcess?: string;
   /** What the session runs, by its hooks' records: claude, codex, or nothing known. */
   agent?: "claude" | "codex" | null;
+  /** The account (config root) the agent runs as: CLAUDE_CONFIG_DIR / CODEX_HOME. */
+  agentHome?: AgentHome | null;
   /** Server-decided: a turn in flight / the last turn finished; turnSeen = a human opened it since. */
   agentPhase?: "working" | "done" | null;
   turnSeen?: boolean;

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 agentHomesLib = require('./lib/agent-homes');
 const { resolveCallerSession, sessionFromEnvLine } = require('./lib/session-identity');
 const checkbacks = require('./lib/checkbacks');
 const digestReads = require('./lib/digest-reads');
@@ -4678,7 +4679,7 @@ function buildSessionEntries(haySessions, opts = {}) {
             createdAt: config?.createdAt,
             createdBy: config?.createdBy || 'user',
             agentPermitted: config?.agentPermitted === true,
-            agent: sessionAgentKind(s.name),
+            ...sessionAgentFields(s.name, config),
             localCliCount,
             hasLocalCli: clientSummary.hasLocalCli || localCliCount > 0 || s.hasLocalCli === true,
             ...getSessionSeenInfo(s.name)
@@ -4723,7 +4724,7 @@ function buildSessionEntries(haySessions, opts = {}) {
                 createdAt: config?.createdAt,
                 createdBy,
                 agentPermitted: config?.agentPermitted === true,
-                agent: sessionAgentKind(name),
+                ...sessionAgentFields(name, config),
                 localCliCount: clientSummary.localCliCount,
                 hasLocalCli: clientSummary.hasLocalCli,
                 ...getSessionSeenInfo(name)
@@ -4788,7 +4789,7 @@ function buildSessionEntries(haySessions, opts = {}) {
             createdAt: config?.createdAt,
             createdBy: effective?.createdBy || 'user',
             agentPermitted: config?.agentPermitted === true,
-            agent: sessionAgentKind(name),
+            ...sessionAgentFields(name, config),
             localCliCount: clientSummary.localCliCount,
             hasLocalCli: clientSummary.hasLocalCli,
             ...getSessionSeenInfo(name)
@@ -4853,6 +4854,12 @@ async function listAllSessionEntriesRuntimeFirst() {
     return { entries, runtimeAvailable: runtime.runtimeAvailable, activeDisplayNames };
 }
 
+/** Stopped with "Stop & park": archived in the saved config or the durable meta. */
+function isSessionStopped(internalName) {
+    return getEffectiveSessionConfig(internalName)?.archived === true
+        || readClaudeSessionMeta(internalName)?.archived === true;
+}
+
 async function runtimeTerminalSessionExists(sessionName) {
     if (!sessionName) return false;
     const runtime = await listActiveSessionsRuntimeFirst();
@@ -5588,6 +5595,105 @@ function readTurnInfo(internalName) {
  * the foreground process name, which reports codex as "node" and any
  * argv-launched restore as the wrapper shell. 'claude' | 'codex' | null.
  */
+// ---- Accounts (config roots) ---------------------------------------------
+// One Claude login per CLAUDE_CONFIG_DIR, one Codex login per CODEX_HOME
+// (lib/agent-homes.js). Discovered from the home directory, cached briefly:
+// the session list asks per session.
+let agentHomesCache = { at: 0, value: null };
+function listAgentHomes(agent) {
+    if (!agentHomesCache.value || Date.now() - agentHomesCache.at > 30_000) {
+        let entries = [];
+        try { entries = fs.readdirSync(os.homedir()); } catch (e) { /* none */ }
+        const exists = (p) => { try { fs.statSync(p); return true; } catch (e) { return false; } };
+        const opts = { homeDir: os.homedir(), entries, exists };
+        agentHomesCache = {
+            at: Date.now(),
+            value: {
+                claude: agentHomesLib.discoverAgentHomes('claude', { ...opts, envDir: process.env.CLAUDE_CONFIG_DIR || null }),
+                codex: agentHomesLib.discoverAgentHomes('codex', { ...opts, envDir: process.env.CODEX_HOME || null })
+            }
+        };
+    }
+    return agent ? (agentHomesCache.value[agent] || []) : agentHomesCache.value;
+}
+// Who each root is logged in as: `claude auth status` (JSON: loggedIn,
+// email) and `codex login status`, run with the root pinned. Both answer
+// in well under a second; cached for two minutes. Two roots can hold the
+// SAME account (a copy of a config dir), and a root can be logged out —
+// the wall shows both before anyone switches a session into it.
+const agentLoginCache = new Map(); // `${agent}:${dir}` -> { at, value }
+let agentBinCache = null;
+function agentBinary(agent) {
+    if (!agentBinCache) agentBinCache = {};
+    if (!(agent in agentBinCache)) {
+        let bin = null;
+        try { bin = execSync(`/bin/zsh -lc 'whence -p ${agent}'`, { encoding: 'utf8', timeout: 5000 }).trim().split('\n').pop() || null; } catch (e) { bin = null; }
+        agentBinCache[agent] = bin;
+    }
+    return agentBinCache[agent];
+}
+function probeAgentLogin(agent, home) {
+    const key = `${agent}:${home.dir}`;
+    const hit = agentLoginCache.get(key);
+    if (hit && Date.now() - hit.at < 120_000) return Promise.resolve(hit.value);
+    const bin = agentBinary(agent);
+    if (!bin) return Promise.resolve(null);
+    const env = { ...process.env };
+    const varName = agentHomesLib.ENV_VAR[agent];
+    if (home.isDefault) delete env[varName]; else env[varName] = home.dir;
+    const args = agent === 'claude' ? ['auth', 'status'] : ['login', 'status'];
+    return new Promise((resolve) => {
+        execFile(bin, args, { env, timeout: 8000, encoding: 'utf8' }, (err, stdout, stderr) => {
+            const out = `${stdout || ''}${stderr || ''}`;
+            let value = null;
+            if (agent === 'claude') {
+                try {
+                    const j = JSON.parse(out.slice(out.indexOf('{'), out.lastIndexOf('}') + 1));
+                    value = { loggedIn: j.loggedIn === true, email: typeof j.email === 'string' ? j.email : null };
+                } catch (e) { value = null; }
+            } else if (out.trim()) {
+                value = { loggedIn: /logged in/i.test(out) && !/not logged in/i.test(out), email: null };
+            }
+            agentLoginCache.set(key, { at: Date.now(), value });
+            resolve(value);
+        });
+    });
+}
+async function listAgentHomesWithLogins() {
+    const all = listAgentHomes();
+    const out = {};
+    for (const agent of Object.keys(all)) {
+        out[agent] = await Promise.all(all[agent].map(async (h) => ({ ...h, login: await probeAgentLogin(agent, h) })));
+    }
+    return out;
+}
+
+/** Codex rollouts can live under any Codex account's root. */
+function codexRolloutRoots() {
+    return Array.from(new Set([...getCodexConfigRoots(), ...listAgentHomes('codex').map((h) => h.dir)]));
+}
+/**
+ * Which account a session's agent runs as. Claude: the root its SessionStart
+ * record saw (CLAUDE_CONFIG_DIR at launch; null = default), else the one the
+ * session was created with. Codex: CODEX_HOME from the session's env.
+ */
+function sessionAgentHome(internalName, agent, config) {
+    if (agent === 'claude') {
+        const rec = readClaudeSessionRecord(internalName);
+        const dir = rec ? (rec.configDir || null) : (config?.env?.CLAUDE_CONFIG_DIR || null);
+        return agentHomesLib.describeAgentHome(dir, 'claude', os.homedir());
+    }
+    if (agent === 'codex') {
+        return agentHomesLib.describeAgentHome(config?.env?.CODEX_HOME || null, 'codex', os.homedir());
+    }
+    return null;
+}
+/** The list's agent fields for one session: the tool, and the account it runs as. */
+function sessionAgentFields(internalName, config) {
+    const agent = sessionAgentKind(internalName);
+    return { agent, agentHome: agent ? sessionAgentHome(internalName, agent, config) : null };
+}
+
 function sessionAgentKind(internalName) {
     if (readClaudeSessionRecord(internalName)?.sessionId) return 'claude';
     const turn = readTurnInfo(internalName);
@@ -5597,7 +5703,7 @@ function sessionAgentKind(internalName) {
 /** A codex rollout by its session id: the id is in the file's name. */
 function findCodexRolloutById(sessionId) {
     if (!sessionId || !/^[A-Za-z0-9-]{8,}$/.test(sessionId)) return null;
-    for (const root of getCodexConfigRoots()) {
+    for (const root of codexRolloutRoots()) {
         const sessions = path.join(root, 'sessions');
         let years = [];
         try { years = fs.readdirSync(sessions).sort().reverse(); } catch (e) { continue; }
@@ -6032,7 +6138,7 @@ function claudeConfigRootsForRestore(recConfigDir) {
     push(path.join(os.homedir(), '.claude'));
     try {
         for (const dirEntry of fs.readdirSync(os.homedir())) {
-            if (/^\.claude[_-][A-Za-z0-9_-]+$/.test(dirEntry)) push(path.join(os.homedir(), dirEntry));
+            if (/^\.claude[_-]?[A-Za-z0-9][A-Za-z0-9_-]*$/.test(dirEntry)) push(path.join(os.homedir(), dirEntry));
         }
     } catch (e) { /* home unreadable — stick with the defaults */ }
     return roots;
@@ -6288,6 +6394,91 @@ function rebuildClaudeLaunch(launchCmd) {
 // start the shell in. For a claude session we use the cwd recorded by the hook
 // (where claude started), since `claude --resume` resolves the conversation from
 // that project directory.
+/**
+ * The environment a new session needs to run as `homeDir`'s account, for
+ * the agent its startup command launches. Null = nothing to pin (no agent,
+ * or the default account).
+ */
+function accountEnvForLaunch(launchCmd, homeDir) {
+    if (!homeDir) return null;
+    const word = (String(launchCmd || '').trim().split(/\s+/)[0] || '').split('/').pop();
+    const agent = word === 'codex' ? 'codex' : /^claude/.test(word) ? 'claude' : null;
+    if (!agent) return { error: 'An account applies only to a Claude or Codex session' };
+    const home = listAgentHomes(agent).find((h) => h.dir === homeDir);
+    if (!home) return { error: `No ${agent} account at ${homeDir}` };
+    return home.isDefault ? null : { env: agentHomesLib.envForAgentHome(agent, home.dir) };
+}
+
+/**
+ * Move a session to another account and relaunch it there, conversation
+ * intact: the transcript (Claude) or rollout (Codex) is copied to the same
+ * place under the new root — the old copy stays as history — the record and
+ * the session's env are re-pinned, and the session restarts through
+ * restore. Nothing changes while the agent is mid-turn.
+ */
+async function switchSessionAgentHome(name, homeDir) {
+    const internalName = resolveSessionInternalName(name, name);
+    if (!internalName) return { status: 404, body: { error: 'No such session' } };
+    const agent = sessionAgentKind(internalName);
+    if (!agent) return { status: 409, body: { error: 'Not a Claude or Codex session' } };
+    const home = listAgentHomes(agent).find((h) => h.dir === homeDir);
+    if (!home) return { status: 400, body: { error: `No ${agent} account at ${homeDir}` } };
+    const config = getSessionConfig(internalName) || getEffectiveSessionConfig(internalName) || {};
+    const current = sessionAgentHome(internalName, agent, config);
+    if (current && current.dir === home.dir) return { status: 200, body: { ok: true, unchanged: true, home } };
+
+    const probe = await restoreSavedSessions({ dryRun: true, includeAgents: true, only: [internalName], replaceIdleAgent: true });
+    const busy = (probe?.skipped || []).find((x) => /busy/.test(String(x.reason || '')));
+    if (busy) return { status: 409, body: { error: `${getSessionDisplayName(internalName) || internalName} is mid-turn — switch accounts when it is idle` } };
+
+    const copyInto = (file, fromRoot) => {
+        const target = fromRoot ? agentHomesLib.transcriptTarget(file, fromRoot, home.dir) : null;
+        if (!target) throw new Error(`conversation file ${file} is not under a known ${agent} root`);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        if (!fs.existsSync(target)) fs.copyFileSync(file, target);
+        return target;
+    };
+    let moved;
+    if (agent === 'claude') {
+        const rec = readClaudeSessionRecord(internalName);
+        if (!rec) return { status: 409, body: { error: 'No recorded Claude conversation to move' } };
+        const found = findClaudeTranscriptById(rec.sessionId);
+        if (!found) return { status: 409, body: { error: `Conversation ${rec.sessionId.slice(0, 8)}… has no transcript on this host` } };
+        const fromRoot = found.configDir || agentHomesLib.defaultHome('claude', os.homedir());
+        moved = copyInto(found.file, fromRoot);
+        // The newer layout keeps subagent transcripts in a sibling directory.
+        const sibling = found.file.endsWith('.jsonl') ? found.file.slice(0, -'.jsonl'.length) : null;
+        if (sibling && fs.existsSync(sibling) && fs.statSync(sibling).isDirectory()) {
+            const target = agentHomesLib.transcriptTarget(sibling, fromRoot, home.dir);
+            if (target && !fs.existsSync(target)) fs.cpSync(sibling, target, { recursive: true });
+        }
+        writeClaudeSessionRecord(internalName, {
+            ...rec,
+            configDir: home.isDefault ? null : home.dir,
+            launchCmd: agentHomesLib.stripConfigPrefix(rec.launchCmd || `claude --resume ${rec.sessionId}`),
+            updatedAt: new Date().toISOString()
+        });
+    } else {
+        const turn = readTurnInfo(internalName);
+        const rootId = turn?.sessionId ? codexRootThreadId(turn.sessionId) : null;
+        const file = rootId ? findCodexRolloutById(rootId) : null;
+        if (!file) return { status: 409, body: { error: 'No recorded Codex conversation to move' } };
+        moved = copyInto(file, codexRolloutRoots().find((r) => file.startsWith(r + path.sep)));
+    }
+    // The session's own env carries the account into every later launch.
+    const varName = agentHomesLib.ENV_VAR[agent];
+    const env = { ...(config.env || {}) };
+    delete env[varName];
+    if (!home.isDefault) env[varName] = home.dir;
+    const base = getSessionConfig(internalName) || getEffectiveSessionConfig(internalName);
+    if (base) setSessionConfig(internalName, { ...base, env: Object.keys(env).length ? env : undefined, updatedAt: new Date().toISOString() });
+
+    const result = await restoreSavedSessions({ includeAgents: true, only: [internalName], replaceIdleAgent: true });
+    const restarted = (result?.restored || []).length > 0;
+    log(`[account] ${internalName} (${agent}) → ${home.label} (${home.dir})${restarted ? ', relaunched' : ''}`, CYAN);
+    return { status: 200, body: { ok: true, home, moved, restarted, skipped: result?.skipped || [] } };
+}
+
 function restorePlanForSession(entry) {
     let rec = readClaudeSessionRecord(entry.internalName);
     // Codex has no SessionStart record; its notify hook leaves only the
@@ -6706,8 +6897,12 @@ async function roomIsRedoable(entry) {
     } catch (e) { return { ok: false, reason: 'screen unavailable' }; }
     if (TRUST_PROMPT_RE.test(text)) return { ok: true, reason: 'parked at the workspace-trust dialog' };
     if (RESUME_PROMPT_RE.test(text)) return { ok: true, reason: 'parked at the resume prompt' };
-    if (CLAUDE_UI_RE.test(text)) return { ok: false, reason: 'claude is running' };
-    if (fg && !isShellProcName(fg)) return { ok: false, reason: `${fg} is running` };
+    // An agent at its prompt is not redoable for a repair restore, but it
+    // IS safe to restart on purpose (an account switch): `agentIdle` says so
+    // — the screen shows no turn in flight ("esc to interrupt").
+    const agentIdle = !screenSaysWorking(text);
+    if (CLAUDE_UI_RE.test(text)) return { ok: false, reason: 'claude is running', agentIdle };
+    if (fg && !isShellProcName(fg)) return { ok: false, reason: `${fg} is running`, agentIdle: agentIdle && /^(claude|codex|node)$/.test(fg.split('/').pop()) };
     // The grid text can carry stray control bytes a shell left on: ESC c
     // (reset), CSI sequences, and a trailing SGR mouse-report fragment
     // ("...% 35;11;17M") from an app that had mouse tracking on — angler
@@ -6749,7 +6944,7 @@ function resolveRestoreTargets(names, snapshot) {
     }
     return { resolved, unknown };
 }
-async function restoreSavedSessionsUnlocked({ dryRun = false, includeAgents = false, only = null } = {}) {
+async function restoreSavedSessionsUnlocked({ dryRun = false, includeAgents = false, only = null, replaceIdleAgent = false } = {}) {
     // Folders first: a session whose meta lost its folder (records deleted,
     // meta rebuilt) is put back where the newest identity snapshot says it
     // was, so the restored wall is filed the way the user left it.
@@ -6775,7 +6970,9 @@ async function restoreSavedSessionsUnlocked({ dryRun = false, includeAgents = fa
             const entry = snapshot.entries.find((e) => e.internalName === internalName);
             const verdict = await roomIsRedoable(entry);
             const display = getSessionDisplayName(internalName) || internalName;
-            if (!verdict.ok) {
+            // A deliberate restart (account switch) may replace an agent that
+            // sits idle at its prompt — never one mid-turn.
+            if (!verdict.ok && !(replaceIdleAgent && verdict.agentIdle)) {
                 skipped.push({ name: display, reason: `busy — ${verdict.reason}` });
                 onlySet.delete(internalName);
                 continue;
@@ -7157,7 +7354,7 @@ function getClaudeConfigRoots() {
     push(path.join(os.homedir(), '.claude'));
     try {
         for (const entry of fs.readdirSync(os.homedir())) {
-            if (/^\.claude[_-][A-Za-z0-9_-]+$/.test(entry)) push(path.join(os.homedir(), entry));
+            if (/^\.claude[_-]?[A-Za-z0-9][A-Za-z0-9_-]*$/.test(entry)) push(path.join(os.homedir(), entry));
         }
     } catch (e) { /* home unreadable — defaults stand */ }
     return roots.filter((p) => { try { return fs.statSync(p).isDirectory(); } catch (e) { return false; } });
@@ -12013,6 +12210,9 @@ happens until someone clicks it.
                 cwd: s.cwd,
                 foregroundProcess: s.foregroundProcess,
                 agent: s.agent || null,
+                // Which account (config root) the agent runs as — the wall labels
+                // it when more than one is set up.
+                agentHome: s.agentHome || null,
                 // working / done + whether the human has opened it since the
                 // turn ended (server-side seen witness, so every device agrees).
                 ...(phaseBySession.get(s.internalName) || { agentPhase: null, turnSeen: true, turnAt: null }),
@@ -12379,8 +12579,10 @@ happens until someone clicks it.
                         cwd: plan?.cwd || config.cwd,
                         updatedAt: new Date().toISOString()
                     };
-                    if (savedConfig) setSessionConfig(resolved, next);
-                    else rememberRuntimeSessionMetadata(resolved, next);
+                    // Always SAVED: a stopped session has no room, and a
+                    // runtime-only definition went with it — a stopped plain
+                    // terminal vanished from the list instead of parking.
+                    setSessionConfig(resolved, next);
                     const durable = readClaudeSessionMeta(resolved) || {};
                     writeClaudeSessionMeta(resolved, { ...durable, internalName: resolved, parked: true, archived: true, cwd: next.cwd });
                     // Stop the process — records, metas, and buffers all stay.
@@ -12683,7 +12885,7 @@ happens until someone clicks it.
             req.on('data', chunk => body += chunk);
             req.on('end', async () => {
                 try {
-                    let { name, type, port, cwd, folderId, startRuntime, workspace, workspaceName, attachedTo, startup } = JSON.parse(body);
+                    let { name, type, port, cwd, folderId, startRuntime, workspace, workspaceName, attachedTo, startup, agentHome } = JSON.parse(body);
                     // The web create form takes the directory as the user
                     // typed it, ~ included; the host only checks that the
                     // path exists, so an unexpanded ~ silently fell back to
@@ -12833,8 +13035,18 @@ happens until someone clicks it.
                                 return;
                             }
                         } else if (isExternalTerminalBackend()) {
+                            // The account it runs as: a chosen non-default
+                            // root rides in the room's environment (and is
+                            // remembered there for restore).
+                            const homeEnv = accountEnvForLaunch(launchCmd, typeof agentHome === 'string' ? agentHome : null);
+                            if (homeEnv && homeEnv.error) {
+                                res.writeHead(400, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ error: homeEnv.error }));
+                                return;
+                            }
                             await ensureExternalRuntimeSession(internalName, cwd, displayName, {
                                 folderId: targetFolderId,
+                                env: homeEnv?.env || undefined,
                                 // Persist the launch so `hop restore` brings the
                                 // app back, not a bare shell. Plain terminals stay
                                 // runtime-only as before.
@@ -13072,6 +13284,33 @@ happens until someone clicks it.
             }));
             return;
         }
+        if (parsedUrl.pathname === '/api/agent-homes' && req.method === 'GET') {
+            agentHomesCache.at = 0; // a fresh look: someone may have just logged in somewhere
+            listAgentHomesWithLogins().then((homes) => {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(homes));
+            }).catch(() => {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(listAgentHomes()));
+            });
+            return;
+        }
+        if (parsedUrl.pathname === '/api/sessions/agent-home' && req.method === 'POST') {
+            let body = '';
+            req.on('data', chunk => body += chunk);
+            req.on('end', async () => {
+                try {
+                    const parsed = body ? JSON.parse(body) : {};
+                    const result = await switchSessionAgentHome(String(parsed.name || ''), String(parsed.home || ''));
+                    res.writeHead(result.status || 200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(result.body));
+                } catch (e) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: `Switch failed: ${e?.message || e}` }));
+                }
+            });
+            return;
+        }
         if (parsedUrl.pathname === '/api/sessions/restore' && req.method === 'POST') {
             let body = '';
             req.on('data', chunk => body += chunk);
@@ -14244,6 +14483,19 @@ happens until someone clicks it.
         if (isExternalTerminalBackend()) {
             (async () => {
                 try {
+                    // A STOPPED session stays stopped: a viewer that still had
+                    // it open (a wall tile, the phone) reconnects the moment
+                    // its room ends, and creating the room again relaunched
+                    // the agent — "Stop & park" undid itself within a second
+                    // (retro, 2026-10-08, respawned twice). Only a deliberate
+                    // open clears the flag (the client unparks first); until
+                    // then a reconnect of a stopped, roomless session is
+                    // refused.
+                    if (isSessionStopped(sessionName) && !(await runtimeTerminalSessionExists(sessionName))) {
+                        socket.write('HTTP/1.1 409 Session Stopped\r\n\r\n');
+                        socket.destroy();
+                        return;
+                    }
                     await reconcileExternalRuntimeSessions();
                     await ensureExternalRuntimeSession(sessionName, sessionConfig?.cwd, getSessionDisplayName(sessionName), {
                         shell: sessionConfig?.shell,

package/lib/agent-homes.js

@@ -0,0 +1,86 @@
+'use strict';
+// Which ACCOUNT an agent session runs as.
+//
+// Claude Code keeps one login per config root (CLAUDE_CONFIG_DIR: its
+// credentials, settings and transcripts all live under it), Codex one per
+// CODEX_HOME. Two logins on one machine are therefore two roots —
+// ~/.claude and ~/.claude_fable, say — and which one a session started
+// under decides whose quota it spends and whose transcript store it writes.
+// Nothing on the wall said which. These helpers name the roots, label them
+// for a chip, and move a conversation between them.
+
+const path = require('path');
+
+const DEFAULT_BASENAME = { claude: '.claude', codex: '.codex' };
+const ENV_VAR = { claude: 'CLAUDE_CONFIG_DIR', codex: 'CODEX_HOME' };
+
+const defaultHome = (agent, homeDir) => path.join(homeDir, DEFAULT_BASENAME[agent] || `.${agent}`);
+
+/** "default" for the agent's own root, else the part after `.claude_` / `.codex-`, else the basename. */
+function agentHomeLabel(dir, agent, homeDir) {
+    if (!dir || dir === defaultHome(agent, homeDir)) return 'default';
+    const base = path.basename(dir);
+    const m = new RegExp(`^\\.?${agent}[_-](.+)$`).exec(base);
+    return m ? m[1] : base.replace(/^\./, '');
+}
+
+/** { dir, label, isDefault } for a root (null/undefined = the default root). */
+function describeAgentHome(dir, agent, homeDir) {
+    const resolved = dir || defaultHome(agent, homeDir);
+    return { dir: resolved, label: agentHomeLabel(resolved, agent, homeDir), isDefault: resolved === defaultHome(agent, homeDir) };
+}
+
+// A root is an ACCOUNT only when it holds a login's footprint — not every
+// `.claude-something` directory does (`.claude-science` held one settings
+// file; `.codexbar` is another app altogether).
+const ACCOUNT_MARKERS = {
+    claude: ['.claude.json', 'projects'],
+    codex: ['auth.json', 'config.toml', 'sessions']
+};
+
+/**
+ * Every account root on this machine for one agent: the default first, then
+ * sibling installs (`.claude_x`, `.claude-y`, `.claude2`), then whatever the
+ * environment points at. `entries` is the home directory's listing;
+ * `exists(path)` checks a path. The default root is always listed when it
+ * exists at all — its login may live outside it (~/.claude.json).
+ */
+function discoverAgentHomes(agent, { homeDir, entries, exists, envDir }) {
+    const out = [];
+    const markers = ACCOUNT_MARKERS[agent] || [];
+    const push = (dir, needMarker) => {
+        if (!dir || out.some((h) => h.dir === dir)) return;
+        if (!exists(dir)) return;
+        if (needMarker && !markers.some((m) => exists(path.join(dir, m)))) return;
+        out.push(describeAgentHome(dir, agent, homeDir));
+    };
+    push(defaultHome(agent, homeDir), false);
+    const re = new RegExp(`^\\.${agent}[_-]?[A-Za-z0-9][A-Za-z0-9_-]*$`);
+    for (const e of [...(entries || [])].sort()) if (re.test(e)) push(path.join(homeDir, e), true);
+    push(envDir, true);
+    return out;
+}
+
+/** The environment that pins a launch to a root. */
+const envForAgentHome = (agent, dir) => ({ [ENV_VAR[agent]]: dir });
+
+/**
+ * A recorded launch command without its config-root pin — `CLAUDE_CONFIG_DIR=… `,
+ * `env -u CLAUDE_CONFIG_DIR `, or a wrapper launcher (`claude-fable`) that
+ * pins one itself — so restore re-pins it from the record's configDir.
+ */
+function stripConfigPrefix(launchCmd) {
+    let s = String(launchCmd || '').trim();
+    s = s.replace(/^(?:env\s+-u\s+CLAUDE_CONFIG_DIR\s+|CLAUDE_CONFIG_DIR=(?:'[^']*'|"[^"]*"|\S+)\s+)+/, '');
+    s = s.replace(/^(?:\S*\/)?claude[_-][A-Za-z0-9_-]+(?=\s|$)/, 'claude');
+    return s;
+}
+
+/** Where a transcript/rollout lands when its root changes: the same relative path under the new root. */
+function transcriptTarget(sourceFile, sourceRoot, targetRoot) {
+    const rel = path.relative(sourceRoot, sourceFile);
+    if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return null;
+    return path.join(targetRoot, rel);
+}
+
+module.exports = { agentHomeLabel, describeAgentHome, discoverAgentHomes, envForAgentHome, stripConfigPrefix, transcriptTarget, defaultHome, ENV_VAR };

package/lib/codex-identity.js

@@ -22,11 +22,26 @@
 
 const FLAG_MARK = 'shell_environment_policy.set.HOP_SESSION';
 
-/** The per-launch overrides that pin a codex thread to a hop session. */
-function codexIdentityFlags(internalName) {
+// Codex's startup update check is OFF in a hop launch. Its "Update now"
+// runs npm, prints "Please restart Codex" and exits — and what is left is
+// a hop session with a bare shell and no agent, nothing for `hop recover`
+// to recover (seen 2026-10-08: "alphagenome" never got its first turn).
+// A session is a long-lived place, not where Codex gets upgraded; the
+// person updates Codex on purpose, and the next launch picks it up. A
+// command that sets the key itself keeps its own choice.
+const UPDATE_KEY = 'check_for_update_on_startup';
+const NO_UPDATE_CHECK = `-c ${UPDATE_KEY}=false`;
+
+/**
+ * The per-launch overrides that pin a codex thread to a hop session, plus
+ * the update check switched off unless `keepUpdateCheck` says the command
+ * already decided.
+ */
+function codexIdentityFlags(internalName, { keepUpdateCheck = false } = {}) {
     const id = String(internalName || '').replace(/[^A-Za-z0-9_-]/g, '');
     if (!id) return '';
-    return `--no-daemon -c '${FLAG_MARK}="${id}"' -c 'mcp_servers.hop.env.HOP_SESSION="${id}"'`;
+    const identity = `--no-daemon -c '${FLAG_MARK}="${id}"' -c 'mcp_servers.hop.env.HOP_SESSION="${id}"'`;
+    return keepUpdateCheck ? identity : `${identity} ${NO_UPDATE_CHECK}`;
 }
 
 /**
@@ -36,7 +51,7 @@ function codexIdentityFlags(internalName) {
  */
 function withCodexIdentity(command, internalName) {
     const raw = typeof command === 'string' ? command : '';
-    const flags = codexIdentityFlags(internalName);
+    const flags = codexIdentityFlags(internalName, { keepUpdateCheck: raw.includes(UPDATE_KEY) });
     if (!flags) return raw;
     if (raw.includes(FLAG_MARK)) return raw;
     const m = /^(\s*(?:(?:command|exec)\s+)?)codex(?=\s|$)/.exec(raw);
@@ -45,4 +60,4 @@ function withCodexIdentity(command, internalName) {
     return `${m[1]}codex ${flags}${rest}`;
 }
 
-module.exports = { withCodexIdentity, codexIdentityFlags, FLAG_MARK };
+module.exports = { withCodexIdentity, codexIdentityFlags, FLAG_MARK, NO_UPDATE_CHECK };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.72",
+  "version": "0.11.74",
   "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/agent-homes.unit.test.cjs

@@ -0,0 +1,53 @@
+// Accounts = config roots: which one a session runs as, how it is labelled,
+// and how a conversation moves between them.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { agentHomeLabel, describeAgentHome, discoverAgentHomes, envForAgentHome, stripConfigPrefix, transcriptTarget } = require('../lib/agent-homes');
+
+const HOME = '/Users/j';
+
+test('labels: the agent\'s own root is "default", a sibling install is its suffix', () => {
+  assert.equal(agentHomeLabel('/Users/j/.claude', 'claude', HOME), 'default');
+  assert.equal(agentHomeLabel(null, 'claude', HOME), 'default');
+  assert.equal(agentHomeLabel('/Users/j/.claude_fable', 'claude', HOME), 'fable');
+  assert.equal(agentHomeLabel('/Users/j/.codex-work', 'codex', HOME), 'work');
+  assert.equal(agentHomeLabel('/opt/claude-cfg', 'claude', HOME), 'cfg');
+  assert.equal(agentHomeLabel('/opt/lab-accounts', 'claude', HOME), 'lab-accounts');
+  assert.deepEqual(describeAgentHome(undefined, 'codex', HOME), { dir: '/Users/j/.codex', label: 'default', isDefault: true });
+});
+
+test('discovery: default first, account-bearing sibling installs sorted, the environment\'s root last', () => {
+  const paths = new Set([
+    '/Users/j/.claude',
+    '/Users/j/.claude_fable', '/Users/j/.claude_fable/.claude.json',
+    '/Users/j/.claude2', '/Users/j/.claude2/projects',
+    '/Users/j/.claude-science', '/Users/j/.claude-science/settings.json', // no login footprint
+    '/tmp/other', '/tmp/other/projects'
+  ]);
+  const homes = discoverAgentHomes('claude', { homeDir: HOME, entries: ['.claude_fable', '.claude2', '.claude-science', '.claude.json', '.claude', 'notes'], exists: (d) => paths.has(d), envDir: '/tmp/other' });
+  assert.deepEqual(homes.map((h) => [h.label, h.isDefault]), [['default', true], ['claude2', false], ['fable', false], ['other', false]]);
+  // .codexbar is another app: no codex footprint, not an account.
+  const codex = discoverAgentHomes('codex', { homeDir: HOME, entries: ['.codex', '.codexbar'], exists: (d) => d === '/Users/j/.codex' || d === '/Users/j/.codexbar', envDir: null });
+  assert.deepEqual(codex.map((h) => h.label), ['default']);
+  assert.deepEqual(discoverAgentHomes('codex', { homeDir: HOME, entries: [], exists: () => false, envDir: null }), []);
+});
+
+test('the launch pin is an environment variable per agent', () => {
+  assert.deepEqual(envForAgentHome('claude', '/Users/j/.claude_fable'), { CLAUDE_CONFIG_DIR: '/Users/j/.claude_fable' });
+  assert.deepEqual(envForAgentHome('codex', '/Users/j/.codex'), { CODEX_HOME: '/Users/j/.codex' });
+});
+
+test('a recorded launch loses its old pin so restore can re-pin it', () => {
+  assert.equal(stripConfigPrefix("CLAUDE_CONFIG_DIR='/Users/j/.claude_fable' claude --resume abc"), 'claude --resume abc');
+  assert.equal(stripConfigPrefix('env -u CLAUDE_CONFIG_DIR claude --permission-mode auto --resume abc'), 'claude --permission-mode auto --resume abc');
+  assert.equal(stripConfigPrefix('claude-fable --dangerously-skip-permissions --resume abc'), 'claude --dangerously-skip-permissions --resume abc');
+  assert.equal(stripConfigPrefix('/usr/local/bin/claude_lab --resume abc'), 'claude --resume abc');
+  assert.equal(stripConfigPrefix('claude --resume abc'), 'claude --resume abc');
+  assert.equal(stripConfigPrefix('claude-code-x'), 'claude');
+});
+
+test('a transcript keeps its relative place under the new root', () => {
+  assert.equal(transcriptTarget('/Users/j/.claude/projects/-Users-j-Code/abc.jsonl', '/Users/j/.claude', '/Users/j/.claude_fable'), '/Users/j/.claude_fable/projects/-Users-j-Code/abc.jsonl');
+  assert.equal(transcriptTarget('/Users/j/.codex/sessions/2026/10/08/rollout-x.jsonl', '/Users/j/.codex', '/Users/j/.codex-work'), '/Users/j/.codex-work/sessions/2026/10/08/rollout-x.jsonl');
+  assert.equal(transcriptTarget('/elsewhere/abc.jsonl', '/Users/j/.claude', '/Users/j/.claude_fable'), null);
+});

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

@@ -3,18 +3,25 @@
 // session they belong to.
 const test = require('node:test');
 const assert = require('node:assert/strict');
-const { withCodexIdentity, codexIdentityFlags } = require('../lib/codex-identity');
+const { withCodexIdentity, codexIdentityFlags, NO_UPDATE_CHECK } = require('../lib/codex-identity');
 
-test('a bare codex launch gets both overrides', () => {
+test('a bare codex launch gets both overrides, and the startup update check off', () => {
   const out = withCodexIdentity('codex', 's_82da12887f');
-  assert.equal(out, `codex --no-daemon -c 'shell_environment_policy.set.HOP_SESSION="s_82da12887f"' -c 'mcp_servers.hop.env.HOP_SESSION="s_82da12887f"'`);
+  assert.equal(out, `codex --no-daemon -c 'shell_environment_policy.set.HOP_SESSION="s_82da12887f"' -c 'mcp_servers.hop.env.HOP_SESSION="s_82da12887f"' -c check_for_update_on_startup=false`);
+  assert.equal(NO_UPDATE_CHECK, '-c check_for_update_on_startup=false');
+});
+
+test('a command that decides the update check itself keeps its own choice — no duplicate -c', () => {
+  const on = withCodexIdentity('codex -c check_for_update_on_startup=true', 's_1');
+  assert.equal(on, `codex ${codexIdentityFlags('s_1', { keepUpdateCheck: true })} -c check_for_update_on_startup=true`);
+  assert.equal((on.match(/check_for_update_on_startup/g) || []).length, 1);
 });
 
 test('a resume keeps its arguments after the flags; command/exec prefixes survive', () => {
   assert.equal(withCodexIdentity("codex resume '01a0e0dc-314d'", 'surf'),
     `codex ${codexIdentityFlags('surf')} resume '01a0e0dc-314d'`);
   assert.equal(withCodexIdentity('command codex --full-auto -c check_for_update_on_startup=false', 's_1'),
-    `command codex ${codexIdentityFlags('s_1')} --full-auto -c check_for_update_on_startup=false`);
+    `command codex ${codexIdentityFlags('s_1', { keepUpdateCheck: true })} --full-auto -c check_for_update_on_startup=false`);
 });
 
 test('anything else is untouched: shells, claude, a codex somewhere later in the line, an already pinned launch', () => {
@@ -28,5 +35,5 @@ test('anything else is untouched: shells, claude, a codex somewhere later in the
 });
 
 test('the id is sanitised — it lands inside a quoted config value', () => {
-  assert.equal(codexIdentityFlags('bad"id;rm -rf'), `--no-daemon -c 'shell_environment_policy.set.HOP_SESSION="badidrm-rf"' -c 'mcp_servers.hop.env.HOP_SESSION="badidrm-rf"'`);
+  assert.equal(codexIdentityFlags('bad"id;rm -rf', { keepUpdateCheck: true }), `--no-daemon -c 'shell_environment_policy.set.HOP_SESSION="badidrm-rf"' -c 'mcp_servers.hop.env.HOP_SESSION="badidrm-rf"'`);
 });