workoffdesk 1.0.0 → 1.0.2

package/dist/server/sessions/machine/lifecycle.js

@@ -1,7 +1,7 @@
 import { randomBytes, randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { findTranscript } from '../../agents/claude/transcript/transcriptFile.js';
-import { busiest, listMacClaudes, stopMacProcess } from '../../agents/claude/terminals.js';
+import { findMacClaude, listMacClaudes, MacUnanswered, openStatus, stopMacProcess } from '../../agents/claude/terminals.js';
 import { tuiCommand } from '../../agents/codex/appServer.js';
 import { expandHome, isDir } from '../../system/dirs.js';
 import { Conflict, InvalidRequest, NotFound } from '../../system/errors.js';
@@ -14,9 +14,6 @@ import { CHAT_SIZE, ID, UUID, codexOf, nameConversation, nameLine, sessionTitle
 const STARTING_MAX_MS = 20_000;
 // How long a Claude asked to quit, to start again on another account, is waited for.
 const MOVE_QUIT_MS = 5_000;
-// How often a conversation waited on is looked at on the Mac, and for how long at most.
-const TAKE_OVER_LOOK_MS = 2_000;
-const TAKE_OVER_WAIT_MS = 12 * 3600_000;
 // A program in the alternate screen keeps its output out of the scrollback, where a dialog taller than the screen starts.
 // Claude Code goes there by default; this keeps it inline, for claude typed into a shell session too.
 const KEEP_OUTPUT_IN_SCROLLBACK = { CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN: '1' };
@@ -31,8 +28,6 @@ export class Lifecycle {
     s;
     d;
     p;
-    // Per Claude conversation waited on to be idle on the Mac, the way to stop waiting.
-    takeOvers = new Map();
     constructor(s, d, p) {
         this.s = s;
         this.d = d;
@@ -50,7 +45,12 @@ export class Lifecycle {
     async continueSession(id) {
         if (!ID.test(id))
             throw new InvalidRequest('bad session id');
-        const meta = this.d.store.get().sessions[id];
+        const past = this.d.store.get().past[id];
+        if (past?.kind === 'codex' && past.codexThreadId) {
+            const tid = past.codexThreadId;
+            return this.resumeOnce(tid, () => this.resumeCodex({ kind: 'codex', cwd: past.cwd, resumeId: tid }));
+        }
+        const meta = past ?? this.d.store.get().sessions[id];
         if (!meta)
             throw new NotFound('no such session');
         const sid = meta.claudeSessionId;
@@ -72,7 +72,7 @@ export class Lifecycle {
     // Claude quit holding it goes on with it (`into`, when asked of that one), rather than a second session.
     async resumeClaude(spec, into) {
         if (spec.takeOver)
-            this.cancelTakeOver(spec.resumeId);
+            this.p.takeOvers.cancel(spec.resumeId);
         const here = (await this.p.sessions.listSessions()).filter((s) => s.claudeSessionId === spec.resumeId);
         // Asked of its process: the listing does not look at a session while it is gone on with.
         for (const s of here)
@@ -93,6 +93,11 @@ export class Lifecycle {
         }
         if (!quit)
             return this.startSession(spec, id);
+        if (quit.past) {
+            if (this.d.claudeProjectsRoot && !(await findTranscript(this.d.claudeProjectsRoot, spec.resumeId).catch(() => null)))
+                throw conversationGone('Claude');
+            return this.revive(id, spec);
+        }
         // The shell its Claude left is not ended while something runs in it.
         const pane = await this.d.tmux.panePid(tmuxName(id));
         if (pane && (await shellBusy(pane)))
@@ -100,9 +105,10 @@ export class Lifecycle {
         return this.restartClaude(id, spec);
     }
     // A session's Claude quit and started again in its pane on the account in use, going on with its conversation, as
-    // one resume of it, so nothing takes the moment between the two for Claude having quit. One whose Claude does not
+    // one resume of it, so nothing takes the moment between the two for Claude having quit. The Claudes in terminals on
+    // the Mac holding the conversation are quit first (quitOnMac, its refusals as they are). One whose Claude does not
     // quit, or could not start again for its folder being gone, is left as it was.
-    moveClaude(id) {
+    moveClaude(id, forceMac = false) {
         const meta = this.d.store.get().sessions[id];
         const sid = meta?.claudeSessionId;
         if (!sid)
@@ -111,28 +117,54 @@ export class Lifecycle {
             return Promise.reject(folderGone(meta.cwd));
         return this.resumeOnce(sid, async () => {
             this.p.status.setStatus(id, 'starting');
-            const pane = await this.d.tmux.panePid(tmuxName(id)).catch(() => undefined);
-            if (!pane || !(await quitAgent(pane, MOVE_QUIT_MS))) {
+            const stay = (e) => {
                 this.s.statuses.delete(id);
                 void this.p.status.fillStatus(id);
-                throw new Error(`its Claude did not quit within ${MOVE_QUIT_MS / 1000} seconds, and it stays on its account`);
-            }
+                throw e;
+            };
+            await this.quitOnMac(sid, id, forceMac).catch(stay);
+            const pane = await this.d.tmux.panePid(tmuxName(id)).catch(() => undefined);
+            if (!pane || !(await quitAgent(pane, MOVE_QUIT_MS)))
+                stay(new Error(`its Claude did not quit within ${MOVE_QUIT_MS / 1000} seconds, and it stays on its account`));
             return this.restartClaude(id, { resumeId: sid });
         });
     }
+    async quitOthersOnMac(id, force = false) {
+        const meta = this.d.store.get().sessions[id];
+        if (!meta)
+            throw new NotFound('no such session');
+        if (meta.claudeSessionId)
+            await this.quitOnMac(meta.claudeSessionId, id, force);
+    }
+    // Each Claude in a terminal on the Mac holding a conversation quit, and told the session it went on in; unless
+    // force, none quit while one there is at work or asking. The sessions here then learn it is open there no longer.
+    async quitOnMac(sid, goneTo, force = false) {
+        const there = (await this.openOnMac()).get(sid);
+        if (!there)
+            return;
+        if (!force && there.status !== 'idle')
+            throw new Conflict(m.moveThis.macBusy, 'open-on-mac-busy');
+        const stopped = await Promise.all(there.claudes.map((c) => stopMacProcess(c, m.takeOver.goneToPhone(goneTo))));
+        await this.openOnMac();
+        if (stopped.includes(false))
+            throw new Conflict(m.takeOver.wouldNotQuit('Claude'), 'mac-would-not-quit');
+    }
     // As for Claude, by the thread's writer lock: whoever holds it writes the thread, and Codex lets no one else.
     // A Codex in a terminal is quit there first; another app's is left alone, and the thread is not resumed.
     // The taken-over Codex's environment stays behind: its commands run in this server's app server.
     async resumeCodex(spec) {
         if (spec.takeOver)
-            this.cancelTakeOver(spec.resumeId);
+            this.p.takeOvers.cancel(spec.resumeId);
         const here = (await this.p.sessions.listSessions()).find((s) => s.codexThreadId === spec.resumeId);
-        if (here)
+        if (here && !here.past)
             return here;
         if (!isDir(expandHome(spec.cwd, homedir())))
             throw folderGone(spec.cwd);
-        const holder = (await this.codexWhere(spec.resumeId))?.holder;
-        const id = newId();
+        const thread = await this.codexWhere(spec.resumeId);
+        if (here && !thread)
+            throw conversationGone('Codex');
+        const holder = thread?.holder;
+        const id = here?.id ?? newId();
         if (holder?.at === 'elsewhere')
             throw new Conflict(m.takeOver.openElsewhere, 'open-elsewhere');
         if (holder?.at === 'terminal') {
@@ -141,72 +173,56 @@ export class Lifecycle {
             if (!(await stopMacProcess(holder, m.takeOver.goneToPhone(id))))
                 throw new Conflict(m.takeOver.wouldNotQuit('Codex'), 'mac-would-not-quit');
         }
-        return this.startSession({ kind: 'codex', cwd: spec.cwd, resumeId: spec.resumeId, title: spec.title }, id);
+        const codex = { kind: 'codex', cwd: spec.cwd, resumeId: spec.resumeId, title: spec.title };
+        return here ? this.revive(id, codex) : this.startSession(codex, id);
+    }
+    // A past session started again in place, going on with its conversation: the same id, name and journal. A name
+    // given it while it was past is given its agent's conversation too.
+    async revive(id, spec) {
+        const was = this.d.store.get().past[id];
+        const started = await this.startSession(spec, id);
+        this.d.store.update((st) => {
+            delete st.past[id];
+            const now = st.sessions[id];
+            if (!now)
+                return;
+            const { title, named, customTitle, aiTitle, createdAt, pinned } = was;
+            Object.assign(now, { title, named, customTitle, aiTitle, createdAt, pinned });
+            if (named && (spec.kind === 'claude' && spec.resumeId ? this.claudeName(spec.resumeId) : null) !== title)
+                now.naming = title;
+        });
+        this.p.naming.watch();
+        return (await this.p.sessions.listSessions()).find((s) => s.id === id) ?? started;
     }
     codexWhere(threadId) {
         if (!this.d.codexThreads)
             throw new InvalidRequest('Codex is not set up on this Mac');
         return this.d.codexThreads.where(threadId);
     }
-    // What a conversation is doing in a terminal on the Mac: undefined when it is open in none.
-    async onMacStatus(spec) {
-        if (spec.kind === 'claude')
-            return (await this.openOnMac()).get(spec.resumeId)?.status;
-        const t = await this.codexWhere(spec.resumeId);
-        return t?.holder?.at === 'terminal' ? (t.busy ? 'busy' : 'idle') : undefined;
-    }
-    // Each session here learns from it whether its conversation is open on the Mac too.
-    async openOnMac() {
+    // Each session here learns from it whether its conversation is open on the Mac too. recentMs: as
+    // listMacClaudes takes it, for what is only shown.
+    async openOnMac(recentMs = 0) {
         const open = new Map();
-        for (const c of await listMacClaudes(this.d.claudeBin))
+        const listed = await listMacClaudes(this.d.claudeBin, recentMs).catch((e) => {
+            throw e instanceof MacUnanswered ? new Conflict(m.takeOver.macUnanswered, 'mac-unanswered') : e;
+        });
+        for (const c of listed)
             open.set(c.sessionId, [...(open.get(c.sessionId) ?? []), c]);
         for (const [id, meta] of Object.entries(this.d.store.get().sessions)) {
             if (meta.kind === 'claude' && meta.claudeSessionId)
                 this.d.journal.onMac(id, open.get(meta.claudeSessionId)?.length ?? 0);
         }
-        return new Map([...open].map(([sid, list]) => [sid, { claudes: list, status: busiest(list) }]));
+        const transcript = (sid) => (this.d.claudeProjectsRoot ? findTranscript(this.d.claudeProjectsRoot, sid).catch(() => null) : null);
+        return new Map(await Promise.all([...open].map(async ([sid, list]) => [sid, { claudes: list, status: await openStatus(list, () => transcript(sid)) }])));
     }
-    async takeOverWhenIdle(spec) {
-        const sid = spec.resumeId;
-        if (this.takeOvers.has(sid))
-            return null;
-        const there = await this.onMacStatus(spec);
-        const takeOver = spec.kind === 'claude' ? { ...spec, kind: 'claude', takeOver: true } : { ...spec, kind: 'codex', takeOver: true };
-        if (!there || there === 'idle')
-            return this.createSession(takeOver);
-        const until = Date.now() + TAKE_OVER_WAIT_MS;
-        let stop;
-        const done = () => {
-            stop();
-            this.takeOvers.delete(sid);
-            this.s.emit();
-        };
-        const look = async () => {
-            const now = await this.onMacStatus(spec).catch(() => there);
-            if (this.takeOvers.get(sid) !== done)
-                return;
-            if (now && now !== 'idle') {
-                if (Date.now() > until)
-                    return done();
-                stop = this.s.later(TAKE_OVER_LOOK_MS, () => void look());
-                return;
-            }
-            done();
-            await this.createSession(takeOver).catch((e) => console.error(`workoffdesk: conversation ${sid} could not be taken over from the Mac: ${e instanceof Error ? e.message : String(e)}`));
-        };
-        this.takeOvers.set(sid, done);
-        stop = this.s.later(TAKE_OVER_LOOK_MS, () => void look());
-        this.s.emit();
-        return null;
+    macClaudeOf(pid) {
+        return findMacClaude(this.d.claudeBin, pid).catch((e) => {
+            throw e instanceof MacUnanswered ? new Conflict(m.takeOver.macUnanswered, 'mac-unanswered') : e;
+        });
     }
     // Waited on, or being taken over now (Claude on the Mac quitting, the session here starting).
-    takingOver(claudeSessionId) {
-        return this.takeOvers.has(claudeSessionId) || this.s.resuming.has(claudeSessionId);
-    }
-    cancelTakeOver(claudeSessionId) {
-        const done = this.takeOvers.get(claudeSessionId);
-        done?.();
-        return !!done;
+    takingOver(sid) {
+        return this.p.takeOvers.waiting(sid) || this.s.resuming.has(sid);
     }
     async startSession(spec, id) {
         const cwd = spec.cwd ? expandHome(spec.cwd, homedir()) : homedir();
@@ -216,6 +232,9 @@ export class Lifecycle {
         const resumed = spec.kind !== 'shell' && spec.resumeId;
         const given = resumed ? ((spec.kind === 'claude' && this.claudeName(resumed)) || undefined) : spec.title;
         const meta = { title: sessionTitle(given, cwd), named: !!nameLine(given), kind: spec.kind, cwd, createdAt: Date.now() };
+        // Claude is started with it; Codex's thread is named once it is known.
+        if (spec.kind === 'codex' && meta.named)
+            meta.naming = meta.title;
         let command;
         if (spec.kind === 'codex') {
             const codex = codexOf(this.d);
@@ -226,7 +245,7 @@ export class Lifecycle {
         }
         if (spec.kind === 'claude') {
             meta.claudeSessionId = spec.resumeId ?? randomUUID();
-            const claude = await this.claudeCommand(spec.resumeId ? { resume: spec.resumeId } : { sessionId: meta.claudeSessionId }, spec.env);
+            const claude = await this.claudeCommand(spec.resumeId ? { resume: spec.resumeId } : { sessionId: meta.claudeSessionId }, spec.env, nameLine(given) || undefined);
             command = claude.command;
             if (claude.dir !== undefined)
                 meta.claudeDir = claude.dir;
@@ -248,9 +267,9 @@ export class Lifecycle {
     }
     // What a Claude session's pane runs: Claude, then a login shell once it ends, however it ends (panes.ts). It runs on
     // the account in use, or, started from a terminal (with that terminal's environment), on that terminal's; dir is
-    // that account, when known.
-    async claudeCommand(conversation, terminal) {
-        const idArgs = 'resume' in conversation ? `--resume ${shq(conversation.resume)}` : `--session-id ${shq(conversation.sessionId)}`;
+    // that account, when known. name: the name given the session here, which Claude takes for the conversation's.
+    async claudeCommand(conversation, terminal, name) {
+        const idArgs = `${'resume' in conversation ? `--resume ${shq(conversation.resume)}` : `--session-id ${shq(conversation.sessionId)}`}${name ? ` --name ${shq(name)}` : ''}`;
         const account = terminal ? undefined : await this.p.accounts.accountInUse();
         const dirArgs = account === undefined ? '' : account ? `env CLAUDE_CONFIG_DIR=${shq(account)} ` : 'env -u CLAUDE_CONFIG_DIR ';
         const dir = terminal ? this.d.accounts?.idOf(terminal.CLAUDE_CONFIG_DIR) : (account ?? this.d.accounts?.ownId());
@@ -277,12 +296,15 @@ export class Lifecycle {
         const said = this.d.claudeProjectsRoot ? await findTranscript(this.d.claudeProjectsRoot, spec.resumeId).catch(() => null) : true;
         this.p.status.setStatus(id, 'starting');
         try {
-            const claude = await this.claudeCommand(said ? { resume: spec.resumeId } : { sessionId: spec.resumeId }, spec.env);
+            const given = meta.named === false ? undefined : nameLine(meta.title) || undefined;
+            const claude = await this.claudeCommand(said ? { resume: spec.resumeId } : { sessionId: spec.resumeId }, spec.env, given);
             await this.d.tmux.respawnPane(name, { cwd: meta.cwd, command: claude.command, env: this.sessionEnv(id, spec.env) });
+            this.p.naming.taken(id);
             this.d.store.update((st) => {
                 const now = st.sessions[id];
                 if (!now)
                     return;
+                delete now.naming;
                 if (claude.dir !== undefined)
                     now.claudeDir = claude.dir;
                 if (spec.env)
@@ -298,45 +320,89 @@ export class Lifecycle {
         this.startingAtMost(id);
         return (await this.p.sessions.listSessions()).find((s) => s.id === id) ?? this.p.sessions.toSession(id, meta, Date.now());
     }
+    // Ends a running session, which keeps it as past; deletes a past one, and what its journal held.
     async killSession(id) {
         if (!ID.test(id))
             throw new InvalidRequest('bad session id');
+        if (this.d.store.get().past[id]) {
+            this.d.store.update((st) => delete st.past[id]);
+            this.d.journal.drop(id);
+            this.s.emit();
+            return;
+        }
         await this.d.tmux.killSession(tmuxName(id));
-        this.d.store.update((st) => delete st.sessions[id]);
-        this.p.status.forget(id);
         await this.p.sessions.listSessions();
     }
+    async pinSession(id, on) {
+        if (!ID.test(id))
+            throw new InvalidRequest('bad session id');
+        const st = this.d.store.get();
+        const meta = st.past[id] ?? ((await this.p.sessions.exists(id)) ? st.sessions[id] : undefined);
+        if (!meta)
+            return false;
+        if (!!meta.pinned === on)
+            return true;
+        this.d.store.update((next) => {
+            const now = next.past[id] ?? next.sessions[id];
+            if (!now)
+                return;
+            if (on)
+                now.pinned = Date.now();
+            else
+                delete now.pinned;
+        });
+        this.s.emit();
+        return true;
+    }
     async renameSession(id, title) {
         if (!ID.test(id))
             throw new InvalidRequest('bad session id');
+        const name = nameLine(title);
+        if (!name)
+            throw new InvalidRequest('a name cannot be empty');
+        if (this.d.store.get().past[id]) {
+            this.d.store.update((st) => Object.assign(st.past[id], { title: name, named: true }));
+            this.s.emit();
+            return (await this.p.sessions.listSessions()).find((s) => s.id === id) ?? null;
+        }
         const meta = this.d.store.get().sessions[id];
         if (!meta || !(await this.p.sessions.exists(id)))
             return null;
+        // The name its agent has, or is being given: nothing to give it again.
+        if ((meta.naming ?? meta.customTitle) === name)
+            return (await this.p.sessions.listSessions()).find((s) => s.id === id) ?? null;
         this.d.store.update((st) => {
             const now = st.sessions[id];
             if (!now)
                 return;
-            now.title = sessionTitle(title, meta.cwd);
-            now.named = !!nameLine(title);
+            now.title = name;
+            now.named = true;
+            now.naming = name;
             if (now.claudeSessionId)
-                nameConversation(st, now.claudeSessionId, nameLine(title));
+                nameConversation(st, now.claudeSessionId, name);
         });
         this.s.emit();
+        this.p.naming.watch();
         return (await this.p.sessions.listSessions()).find((s) => s.id === id) ?? null;
     }
     // What the agent calls a session's conversation. Read from its start, the names it was given there;
     // after, one given by /rename is given as one given here is, the latest name given being the one kept.
+    // While a name given here is on its way, only that name counts: any other is one the agent held before.
     conversationNamed(id, found, fresh) {
         const meta = this.d.store.get().sessions[id];
         if (!meta)
             return;
-        const custom = nameLine(found.custom) || undefined;
+        const written = nameLine(found.custom) || undefined;
+        const taken = !!meta.naming && written === meta.naming;
+        const custom = meta.naming && !taken ? undefined : written;
         const ai = nameLine(found.ai) || undefined;
         const customTitle = fresh ? custom : (custom ?? meta.customTitle);
         const aiTitle = fresh ? ai : (ai ?? meta.aiTitle);
-        const renamed = !fresh && !!custom && meta.named !== false;
+        const renamed = taken || (!fresh && !!custom && meta.named !== false);
         if (customTitle === meta.customTitle && aiTitle === meta.aiTitle && !renamed)
             return;
+        if (taken)
+            this.p.naming.taken(id);
         this.d.store.update((st) => {
             const now = st.sessions[id];
             if (!now)
@@ -345,6 +411,8 @@ export class Lifecycle {
             now.aiTitle = aiTitle;
             if (!renamed)
                 return;
+            if (taken)
+                delete now.naming;
             now.named = false;
             if (now.claudeSessionId)
                 nameConversation(st, now.claudeSessionId, '');
@@ -355,3 +423,5 @@ export class Lifecycle {
         return this.d.store.get().claudeNames[claudeSessionId] ?? null;
     }
 }
+// A conversation its agent no longer keeps: what was said can be read here, not gone on with.
+const conversationGone = (agent) => new Conflict(m.goOn.conversationGone(agent), 'conversation-gone');

package/dist/server/sessions/machine/moves.js

@@ -1,21 +1,32 @@
 import { isDir } from '../../system/dirs.js';
-import { Conflict } from '../../system/errors.js';
+import { Conflict, NotFound } from '../../system/errors.js';
+import { m } from '../../system/messages.js';
 // A message Claude may not have taken in yet: waiting to go, being pasted, or held in Claude's own queue.
 const NOT_TAKEN_IN = new Set(['queued', 'delivering', 'enqueued']);
+// How often a session to move is looked at again while a Claude on the Mac holding its conversation is at work.
+const MAC_LOOK_MS = 3000;
 // Open Claude sessions moved to the account in use, each between its turns.
 export class Moves {
     s;
     d;
     p;
+    lookingAgain = new Set();
     constructor(s, d, p) {
         this.s = s;
         this.d = d;
         this.p = p;
     }
-    // A Claude session here whose Claude runs, started here rather than from a terminal, on another account than inUse,
-    // in a folder still there to start it again in.
+    // Its Claude idle, and all it was sent taken in.
+    betweenTurns(id) {
+        return this.s.statuses.get(id) === 'idle' && !this.d.journal.messages(id).some((q) => NOT_TAKEN_IN.has(q.state));
+    }
+    // A Claude session here whose Claude runs, in a folder still there to start it again in.
+    movable(id, meta) {
+        return meta.kind === 'claude' && !!meta.claudeSessionId && this.s.statuses.get(id) !== 'ended' && isDir(meta.cwd);
+    }
+    // One movable, started here rather than from a terminal, on another account than inUse.
     onAnother(id, meta, inUse) {
-        return (meta.kind === 'claude' && !!meta.claudeSessionId && !meta.terminal && this.s.statuses.get(id) !== 'ended' && meta.claudeDir !== inUse && isDir(meta.cwd));
+        return this.movable(id, meta) && !meta.terminal && meta.claudeDir !== inUse;
     }
     // Those on another account, and of them those to move once their turn is over; none before an account is picked.
     counts(inUse) {
@@ -45,9 +56,10 @@ export class Moves {
         for (const id of ids)
             void this.turnOver(id);
     }
-    // Told a session is at its prompt: one to move moves now, unless what was sent to it may not be taken in yet, and
-    // stays marked until it has moved or failed to. One no longer on another account (its account picked again, or
-    // gone on with after its Claude quit) is not moved.
+    // Told a session is at its prompt: one to move moves now, unless what was sent to it may not be taken in yet or a
+    // Claude on the Mac holding its conversation is at work, and stays marked until it has moved or failed to. The
+    // idle Claudes there are quit first. One no longer on another account (its account picked again, or gone on with
+    // after its Claude quit) is not moved.
     async turnOver(id) {
         if (!this.d.store.get().sessions[id]?.moving)
             return;
@@ -55,14 +67,54 @@ export class Moves {
         const meta = this.d.store.get().sessions[id];
         if (!meta?.moving)
             return;
-        if (inUse === undefined || !this.onAnother(id, meta, inUse))
+        if (inUse === undefined || !this.movable(id, meta) || meta.claudeDir === inUse)
             return this.unmark(id);
-        if (this.s.statuses.get(id) !== 'idle' || this.d.journal.messages(id).some((q) => NOT_TAKEN_IN.has(q.state)))
+        if (!this.betweenTurns(id))
             return;
-        await this.p.lifecycle
-            .moveClaude(id)
-            .catch((e) => console.error(`workoffdesk: session ${id} could not be moved to the Claude account in use: ${e instanceof Error ? e.message : String(e)}`))
-            .finally(() => this.unmark(id));
+        try {
+            await this.p.lifecycle.moveClaude(id);
+        }
+        catch (e) {
+            if (e instanceof Conflict && e.code === 'open-on-mac-busy')
+                return this.lookAgain(id);
+            console.error(`workoffdesk: session ${id} could not be moved to the Claude account in use: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        this.unmark(id);
+    }
+    // The one session asked for, one started from a terminal too, any Claude in a terminal on the Mac holding its
+    // conversation quit first. With no when, moved now if nothing is at work, else refused saying why; now, moved whatever
+    // is at work; free, marked to move once it is free (turnOver). Answered once it runs on the account in use, or marked.
+    async moveThis(id, when) {
+        const inUse = await this.p.accounts.accountInUse();
+        if (inUse === undefined)
+            throw new Conflict('no Claude account was picked yet', 'account-none-picked');
+        const meta = this.d.store.get().sessions[id];
+        if (!meta)
+            throw new NotFound('no such session');
+        if (!this.movable(id, meta))
+            throw new Conflict(m.moveThis.cannot, 'cannot-move');
+        if (meta.claudeDir === inUse)
+            return this.p.sessions.toSession(id, meta, Date.now());
+        if (when === 'free') {
+            this.d.store.update((st) => void (st.sessions[id] && (st.sessions[id].moving = true)));
+            this.s.emit();
+            void this.turnOver(id);
+            return this.p.sessions.toSession(id, this.d.store.get().sessions[id] ?? meta, Date.now());
+        }
+        if (when !== 'now' && !this.betweenTurns(id))
+            throw new Conflict(m.moveThis.busy, 'session-busy');
+        return this.p.lifecycle.moveClaude(id, when === 'now').catch((e) => {
+            throw e instanceof Conflict ? e : new Conflict(m.moveThis.failed(e instanceof Error ? e.message : String(e)), 'move-failed');
+        });
+    }
+    lookAgain(id) {
+        if (this.lookingAgain.has(id))
+            return;
+        this.lookingAgain.add(id);
+        setTimeout(() => {
+            this.lookingAgain.delete(id);
+            void this.turnOver(id);
+        }, MAC_LOOK_MS).unref();
     }
     unmark(id) {
         this.d.store.update((st) => void (st.sessions[id] && delete st.sessions[id].moving));

package/dist/server/sessions/machine/naming.js

@@ -0,0 +1,85 @@
+import { tmuxName } from '../sessionName.js';
+// How often the names on their way are looked at, and how long one typed waits for Claude to take it before it
+// is typed again.
+const CHECK_MS = 2_000;
+const TYPED_AGAIN_MS = 30_000;
+// A name given a session here, given to its agent too (SessionMeta.naming): Codex sets it on the thread; a
+// Claude that runs is typed /rename when its prompt is free, and one that does not is started with --name.
+export class Naming {
+    s;
+    d;
+    p;
+    typedAt = new Map();
+    run = null;
+    again = false;
+    cancel = null;
+    constructor(s, d, p) {
+        this.s = s;
+        this.d = d;
+        this.p = p;
+    }
+    // Gives each name on its way now, and again every CHECK_MS while any is.
+    watch() {
+        if (this.run) {
+            this.again = true;
+            return;
+        }
+        this.cancel?.();
+        this.cancel = null;
+        this.run = this.giveAll().finally(() => {
+            this.run = null;
+            if (this.again) {
+                this.again = false;
+                this.watch();
+            }
+            else if (this.onTheirWay().length)
+                this.cancel = this.s.later(CHECK_MS, () => this.watch());
+        });
+    }
+    // The agent took the name, or was started with it.
+    taken(id) {
+        this.typedAt.delete(id);
+    }
+    onTheirWay() {
+        return Object.entries(this.d.store.get().sessions).flatMap(([id, meta]) => (meta.naming ? [id] : []));
+    }
+    async giveAll() {
+        for (const id of this.onTheirWay())
+            await this.give(id).catch(() => { });
+    }
+    async give(id) {
+        const meta = this.d.store.get().sessions[id];
+        const name = meta?.naming;
+        if (!name)
+            return;
+        if (meta.kind === 'codex') {
+            if (!meta.codexThreadId || !this.d.codex)
+                return;
+            await this.d.codex.rename(meta.codexThreadId, name);
+            return this.clear(id, name);
+        }
+        if (meta.kind !== 'claude')
+            return this.clear(id, name);
+        const typed = this.typedAt.get(id);
+        if (typed !== undefined && Date.now() - typed < TYPED_AGAIN_MS)
+            return;
+        // One that ended is started again with --name.
+        if (this.s.statuses.get(id) === 'ended')
+            return;
+        // Typed over a dialog it would go into it; after half a message, it would send that.
+        if (!(await this.p.status.agentRuns(id)) || (await this.p.input.dialogOpen(id)))
+            return;
+        if (await this.d.claude.typed(tmuxName(id)))
+            return;
+        await this.d.tmux.leaveCopyMode(tmuxName(id));
+        await this.d.tmux.sendRaw(tmuxName(id), `/rename ${name}\r`);
+        this.typedAt.set(id, Date.now());
+    }
+    clear(id, name) {
+        this.d.store.update((st) => {
+            const now = st.sessions[id];
+            if (now?.naming === name)
+                delete now.naming;
+        });
+    }
+}

package/dist/server/sessions/machine/state.js

@@ -69,3 +69,5 @@ export function codexOf(d) {
         throw new InvalidRequest('Codex is not set up on this Mac');
     return d.codex;
 }
+// The conversation a session holds, Claude's or Codex's.
+export const conversationOf = (s) => s.claudeSessionId ?? s.codexThreadId;

package/dist/server/sessions/machine/status.js

@@ -186,11 +186,10 @@ export class Status {
         const stop = watchTranscript(this.d.claudeProjectsRoot, () => this.d.store.get().sessions[id]?.claudeSessionId, () => void this.p.sessions.ingest(id));
         this.s.transcriptWatches.set(id, stop);
     }
-    // A session gone from tmux is gone for good, and so are its rows; a device keeps its own copy.
+    // A session gone from tmux: nothing of it runs to follow. Its rows stay while it is kept as past.
     forget(id) {
         this.s.transcriptWatches.get(id)?.();
         this.s.transcriptWatches.delete(id);
-        this.d.journal.drop(id);
         this.s.statuses.delete(id);
         this.workSince.delete(id);
         this.turnLooks.delete(id);