workoffdesk 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,71 @@
+import { basename } from 'node:path';
+import { InvalidRequest } from '../../system/errors.js';
+// Wide and tall enough that a dialog's lines and a list of options are read whole.
+export const CHAT_SIZE = { cols: 100, rows: 50 };
+export const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export const ID = /^[a-z0-9]{1,32}$/;
+// As much of a name as a row of the session list has room for.
+const TITLE_MAX = 40;
+// A name on one line, in characters rather than UTF-16 units; empty for none.
+export const nameLine = (name) => [...(name ?? '').replace(/[\s\p{Cc}]+/gu, ' ').trim()].slice(0, TITLE_MAX).join('').trimEnd();
+// A session's name; none is the directory's name.
+export function sessionTitle(name, cwd) {
+    return nameLine(name) || basename(cwd) || cwd;
+}
+// The names of the latest conversations named are kept; a name given again counts as the latest.
+const CLAUDE_NAMES_KEPT = 200;
+export function nameConversation(st, claudeSessionId, name) {
+    delete st.claudeNames[claudeSessionId];
+    if (name)
+        st.claudeNames[claudeSessionId] = name;
+    const names = Object.keys(st.claudeNames);
+    for (const old of names.slice(0, Math.max(0, names.length - CLAUDE_NAMES_KEPT)))
+        delete st.claudeNames[old];
+}
+// What more than one of the machine's parts reads or changes, per session, and who is told of a change.
+export class MachineState {
+    statuses = new Map();
+    usages = new Map();
+    // Sessions waiting on a choice only the screen shows, and the status they had before it.
+    screenWaits = new Map();
+    // When each session's conversation was last looked for on the Mac.
+    macLooks = new Map();
+    // Per Claude session, the watch on its transcript that takes what is added into the journal.
+    transcriptWatches = new Map();
+    // Per Claude conversation, the session being started to go on with it: asked again meanwhile, the same one.
+    resuming = new Map();
+    listeners = new Set();
+    notifier = null;
+    // What the machine is to do later; null once the journal is closed, when nothing is.
+    timers = new Set();
+    emit() {
+        for (const cb of this.listeners)
+            cb();
+    }
+    // Runs f in ms, unless the journal is closed first; the function returned stops it sooner.
+    later(ms, f) {
+        const timers = this.timers;
+        if (!timers)
+            return () => { };
+        const timer = setTimeout(() => {
+            timers.delete(timer);
+            f();
+        }, ms).unref();
+        timers.add(timer);
+        return () => {
+            clearTimeout(timer);
+            timers.delete(timer);
+        };
+    }
+    // With the journal closed: what was to be done later is not, and nothing more is.
+    stopTimers() {
+        for (const timer of this.timers ?? [])
+            clearTimeout(timer);
+        this.timers = null;
+    }
+}
+export function codexOf(d) {
+    if (!d.codex)
+        throw new InvalidRequest('Codex is not set up on this Mac');
+    return d.codex;
+}

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

@@ -0,0 +1,257 @@
+import { findTranscript } from '../../agents/claude/transcript/transcriptFile.js';
+import { notificationFor } from '../../agents/claude/hooks/status.js';
+import { turnInTranscript } from '../../agents/claude/transcript/turn.js';
+import { watchTranscript } from '../../agents/claude/transcript/watch.js';
+import { shownTitle } from '../../system/store.js';
+import { agentsRunning } from '../panes.js';
+import { tmuxName } from '../sessionName.js';
+import { UUID, nameConversation } from './state.js';
+// A turn the transcript says is over, while no hook said so, is taken as over this long after: the hook
+// for it may be on its way, and Claude may go on at once with what it was sent meanwhile.
+const TURN_OVER_AFTER_MS = 10_000;
+// How often a session working with no word from the hooks has its transcript read.
+const TURN_LOOK_MS = 5_000;
+// Following each agent: its status, its turns, compacting, quitting, its transcript, its usage.
+export class Status {
+    s;
+    d;
+    p;
+    // When each working session's transcript was last read for the end of its turn.
+    turnLooks = new Map();
+    // When each session last went to work: an end the transcript recorded before then is an earlier turn's.
+    workSince = new Map();
+    // While compacting: the status it came from, and whether its spinner has been seen on screen.
+    compactions = new Map();
+    constructor(s, d, p) {
+        this.s = s;
+        this.d = d;
+        this.p = p;
+    }
+    // A status an agent reported, told as a hook's would be.
+    moved(id, status, said) {
+        const meta = this.d.store.get().sessions[id];
+        const prev = this.getStatus(id);
+        if (!meta || prev === status)
+            return;
+        this.setStatus(id, status);
+        // What it asked on screen before its thread started is gone once the thread says how it is.
+        void this.p.input.onScreen(id).catch(() => { });
+        const n = notificationFor(prev, status, shownTitle(meta));
+        if (n && this.s.notifier)
+            void this.s.notifier.notify(id, n.title, n.event, said).catch(() => { });
+    }
+    // A new process knows no statuses: what the screen shows stands in until a hook says otherwise, and a
+    // hook that comes while the screen is being read wins.
+    filling = new Map();
+    fillStatus(id) {
+        if (this.s.statuses.has(id))
+            return Promise.resolve();
+        const reading = this.filling.get(id) ?? this.readStatus(id).finally(() => this.filling.delete(id));
+        this.filling.set(id, reading);
+        return reading;
+    }
+    async readStatus(id) {
+        try {
+            const { choices, panel } = await this.p.input.onScreen(id);
+            // Between calls Claude shows its prompt as it does when done: the transcript says which.
+            const going = !choices && !panel && (await this.turn(id))?.over === false;
+            if (!this.s.statuses.has(id))
+                this.setStatus(id, choices || panel ? 'waiting' : going ? 'working' : 'idle');
+        }
+        catch {
+            // gone meanwhile; the next listing drops it
+        }
+    }
+    // A Claude session whose Claude no longer runs, however it ended, has ended; one marked ended whose Claude runs
+    // is read again from its screen.
+    async followClaudes(panes) {
+        const running = await agentsRunning(panes.map((p) => p.panePid));
+        if (!running)
+            return;
+        for (const { id, panePid } of panes) {
+            // One being gone on with is looked at once its Claude was started.
+            const sid = this.d.store.get().sessions[id]?.claudeSessionId;
+            if (sid && this.s.resuming.has(sid))
+                continue;
+            if (!running.get(panePid))
+                this.claudeQuit(id);
+            else if (this.s.statuses.get(id) === 'ended')
+                this.s.statuses.delete(id);
+        }
+    }
+    claudeQuit(id) {
+        if (this.s.statuses.get(id) === 'ended')
+            return;
+        this.d.asks.endAll(id);
+        this.setStatus(id, 'ended');
+    }
+    // Whether what is typed into a session goes to its agent rather than the shell an ended Claude left; when it
+    // cannot be looked at, it is taken as running.
+    async agentRuns(id) {
+        if (this.d.store.get().sessions[id]?.kind !== 'claude')
+            return true;
+        const pane = await this.d.tmux.panePid(tmuxName(id)).catch(() => undefined);
+        const runs = pane === undefined ? undefined : (await agentsRunning([pane]))?.get(pane);
+        if (runs === false)
+            this.claudeQuit(id);
+        return runs !== false;
+    }
+    // Told Claude is ending (SessionEnd comes on /clear too), its process is looked at until it is gone, for a few
+    // seconds; the listing would see it within one. One quit to be started again is not.
+    claudeMayHaveQuit(id) {
+        const sid = this.d.store.get().sessions[id]?.claudeSessionId;
+        if (sid && this.s.resuming.has(sid))
+            return;
+        let looks = 15;
+        const look = async () => {
+            if ((await this.agentRuns(id)) && --looks > 0)
+                this.s.later(200, () => void look().catch(() => { }));
+        };
+        void look().catch(() => { });
+    }
+    setStatus(id, status) {
+        if (status !== 'waiting')
+            this.s.screenWaits.delete(id);
+        if (status !== 'compacting')
+            this.compactions.delete(id);
+        if (this.s.statuses.get(id) === status)
+            return;
+        if (status === 'working')
+            this.workSince.set(id, Date.now());
+        this.s.statuses.set(id, status);
+        this.d.journal.status(id, status);
+        this.s.emit();
+        if (this.d.outbox.list(id).length)
+            void this.d.outbox.flush(id);
+        if (status === 'idle')
+            void this.p.moves.turnOver(id);
+    }
+    // What each listing checks of a Claude session: its status when not known, whether a compaction is still
+    // on screen, and whether what waits for it can go.
+    look(id) {
+        void this.fillStatus(id);
+        this.watchTranscript(id);
+        // A choice or dialog no hook reports (trust this folder? before it starts, /model at the prompt) is a
+        // wait read off the screen, and it is over when the screen no longer shows it.
+        const st = this.s.statuses.get(id);
+        if (st === 'starting' || st === 'idle' || this.s.screenWaits.has(id)) {
+            void this.p.input.onScreen(id)
+                .then(({ choices, panel }) => (choices || panel ? this.p.input.waitOnScreen(id) : this.p.input.waitOnScreenOver(id)))
+                .catch(() => { });
+        }
+        if (this.s.statuses.get(id) === 'compacting')
+            void this.p.input.onScreen(id).catch(() => { });
+        if (this.s.statuses.get(id) === 'working')
+            void this.endTurnHooksMissed(id);
+        // Until its status is known, nothing goes to it: it may be at work.
+        if (this.s.statuses.has(id) && this.d.outbox.list(id).length)
+            void this.d.outbox.flush(id);
+    }
+    // A Codex session's thread is followed (again, after a restart), and what waits for it goes once it can.
+    lookCodex(id, meta) {
+        this.d.codex?.follow(id, meta.codexThreadId);
+        // One with no thread yet, as this server finds it after a restart, has not started.
+        if (!meta.codexThreadId && !this.s.statuses.has(id))
+            this.setStatus(id, 'starting');
+        if (this.p.input.beforeThread(id))
+            void this.p.input.onScreen(id)
+                .then(({ choices }) => (choices && this.p.input.beforeThread(id) ? this.p.input.waitOnScreen(id) : this.p.input.waitOnScreenOver(id)))
+                .catch(() => { });
+        if (this.s.statuses.has(id) && this.d.outbox.list(id).length)
+            void this.d.outbox.flush(id);
+    }
+    // What Claude Code's transcript says of the turn a session is on; null when there is none to read.
+    async turn(id) {
+        const sid = this.d.store.get().sessions[id]?.claudeSessionId;
+        if (!this.d.claudeProjectsRoot || !sid)
+            return null;
+        const path = await findTranscript(this.d.claudeProjectsRoot, sid).catch(() => null);
+        return path ? turnInTranscript(path) : null;
+    }
+    // A turn can end with no hook to say so (Esc typed at the Mac, a hook Claude did not send): once the
+    // transcript has said for a while that it is over, so is the work, and what waits can go.
+    async endTurnHooksMissed(id) {
+        const now = Date.now();
+        if (now - (this.turnLooks.get(id) ?? 0) < TURN_LOOK_MS)
+            return;
+        this.turnLooks.set(id, now);
+        const turn = await this.turn(id);
+        const ended = turn?.over && turn.at >= (this.workSince.get(id) ?? 0);
+        if (ended && Date.now() - turn.at >= TURN_OVER_AFTER_MS && this.s.statuses.get(id) === 'working')
+            this.setStatus(id, 'idle');
+    }
+    watchTranscript(id) {
+        if (!this.d.claudeProjectsRoot || this.s.transcriptWatches.has(id))
+            return;
+        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.
+    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);
+        this.compactions.delete(id);
+        this.s.screenWaits.delete(id);
+        this.s.usages.delete(id);
+        this.d.asks.endAll(id);
+        this.d.codex?.forget(id);
+        this.s.macLooks.delete(id);
+    }
+    compactStarted(id) {
+        if (this.compactions.has(id))
+            return;
+        const before = this.s.statuses.get(id) ?? 'idle';
+        this.setStatus(id, 'compacting');
+        this.compactions.set(id, { before, seen: false });
+    }
+    // One asked for with /compact ends at the prompt; one Claude made on its own goes back to what it was doing.
+    compactEnded(id, manual) {
+        const c = this.compactions.get(id);
+        if (c)
+            this.setStatus(id, manual ? 'idle' : c.before);
+    }
+    // The screen ends only a compaction whose spinner it has shown: a spinner it cannot make out says nothing.
+    compactingOnScreen(id, shown) {
+        if (shown) {
+            this.compactStarted(id);
+            this.compactions.get(id).seen = true;
+        }
+        else if (this.compactions.get(id)?.seen) {
+            this.compactEnded(id, false);
+        }
+    }
+    setUsage(id, usage) {
+        if (!usage || !this.d.store.get().sessions[id])
+            return;
+        if (JSON.stringify(this.s.usages.get(id)) === JSON.stringify(usage))
+            return;
+        this.s.usages.set(id, usage);
+        const meta = this.d.store.get().sessions[id];
+        if (meta.kind === 'claude' && meta.claudeDir !== undefined && (usage.fiveHour || usage.sevenDay))
+            this.p.accounts.keepLimits(meta.claudeDir, usage);
+        this.s.emit();
+    }
+    getStatus(id) {
+        return this.s.statuses.get(id) ?? null;
+    }
+    // The Claude session running in a workoffdesk session, as its hooks report it.
+    setClaudeSessionId(id, claudeSessionId) {
+        if (!UUID.test(claudeSessionId))
+            return;
+        const meta = this.d.store.get().sessions[id];
+        if (!meta || meta.claudeSessionId === claudeSessionId)
+            return;
+        this.d.store.update((st) => {
+            const name = meta.claudeSessionId && st.claudeNames[meta.claudeSessionId];
+            if (name)
+                nameConversation(st, claudeSessionId, name);
+            st.sessions[id].claudeSessionId = claudeSessionId;
+        });
+        void this.p.sessions.ingest(id);
+        this.s.emit();
+    }
+}

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

@@ -0,0 +1,2 @@
+// How much of what scrolled off the top a look at the screen takes along, to scroll back through.
+export const SCREEN_HISTORY = 500;

package/dist/server/sessions/machine.js

@@ -0,0 +1,300 @@
+import { dirname, join } from 'node:path';
+import { PermissionAsks } from '../agents/claude/hooks/asks.js';
+import { ClaudeScreen } from '../agents/claude/screen/screen.js';
+import { CodexAgent } from '../agents/codex/agent.js';
+import { CodexThreads } from '../agents/codex/threads.js';
+import { sqliteAvailable } from '../journal/db.js';
+import { Journal } from '../journal/index.js';
+import { Conflict, InvalidRequest } from '../system/errors.js';
+import { shownTitle } from '../system/store.js';
+import { Accounts } from './machine/accounts.js';
+import { Moves } from './machine/moves.js';
+import { Input } from './machine/input.js';
+import { Lifecycle } from './machine/lifecycle.js';
+import { CHAT_SIZE, ID, MachineState, UUID, codexOf } from './machine/state.js';
+import { Status } from './machine/status.js';
+import { Outbox, migrateQueueFile } from './outbox.js';
+import { idOfTmuxName, tmuxName } from './sessionName.js';
+export * from './machine/types.js';
+// A message held back because a dialog, not the prompt, would have taken it.
+class DialogOpen extends Error {
+}
+// A message held back because Claude quit, and the shell it left behind would run it.
+class AgentQuit extends Error {
+}
+// The sessions on this Mac. The work is done by its parts in machine/; this holds them together, lists the
+// sessions, and is what the rest of the server talks to.
+export class LocalMachine {
+    id = 'local';
+    asks = new PermissionAsks((id) => this.journal.asks(id, this.asks.list(id)));
+    // Everything a session's page shows, as rows a copy catches up on (journal/), the outbox's messages too.
+    journal;
+    s = new MachineState();
+    d;
+    p;
+    // Per session, the last message still being taken in.
+    sending = new Map();
+    lastIds = '';
+    constructor(deps) {
+        const claude = new ClaudeScreen(deps.tmux, CHAT_SIZE.cols);
+        if (!sqliteAvailable())
+            throw new Error(`WorkOffDesk needs Node 22.13 or later (this is ${process.versions.node}).`);
+        this.journal = new Journal({
+            file: ':memory:',
+            log: () => { },
+            ...deps.journal,
+            root: deps.claudeProjectsRoot,
+            titled: (id, found, fresh) => this.p.lifecycle.conversationNamed(id, found, fresh),
+        });
+        migrateQueueFile(deps.queueFile ?? join(dirname(deps.store.file), 'queue.json'), this.journal);
+        const outbox = new Outbox({
+            store: this.journal,
+            status: (id) => this.getStatus(id),
+            // Claude is at work on it from the moment it goes in: the next waits until it is done, not until a
+            // hook says it started.
+            deliver: async (id, text, qid) => {
+                if (deps.store.get().sessions[id]?.kind === 'codex')
+                    return codexOf(this.d).send(id, text, qid);
+                if (!(await this.p.status.agentRuns(id)))
+                    throw new AgentQuit();
+                if (await this.p.input.dialogOpen(id))
+                    throw new DialogOpen();
+                await this.p.input.paste(id, text);
+                // A slash command may only open a dialog, which no hook reports the end of.
+                if (!text.startsWith('/') && (this.s.statuses.get(id) === 'idle' || !this.s.statuses.has(id)))
+                    this.setStatus(id, 'working');
+            },
+            changed: () => this.s.emit(),
+            failed: (id, e) => e instanceof DialogOpen || e instanceof AgentQuit || console.error(`workoffdesk: a message to session ${id} could not go and waits: ${e instanceof Error ? e.message : String(e)}`),
+        });
+        const shell = deps.shell ?? process.env.SHELL ?? '/bin/zsh';
+        const log = deps.journal?.log ?? (() => { });
+        const codex = deps.codex
+            ? new CodexAgent({ tmux: deps.tmux, sock: deps.codex.sock, codexBin: deps.codex.bin, shell }, {
+                journal: this.journal,
+                sessions: () => Object.entries(deps.store.get().sessions).flatMap(([id, m]) => (m.kind === 'codex' ? [{ id, cwd: m.cwd, createdAt: m.createdAt, threadId: m.codexThreadId }] : [])),
+                setThread: (id, threadId) => deps.store.update((st) => void (st.sessions[id] && (st.sessions[id].codexThreadId = threadId))),
+                moved: (id, status, said) => this.p.status.moved(id, status, said),
+                named: (id, name) => this.p.lifecycle.conversationNamed(id, { ai: name }, false),
+                setUsage: (id, usage) => this.setUsage(id, usage),
+                asksChanged: (id) => {
+                    this.journal.asks(id, this.d.codex?.asks(id) ?? []);
+                    this.s.emit();
+                },
+                log: (msg, o) => log(msg, o),
+            })
+            : null;
+        this.d = {
+            tmux: deps.tmux,
+            claude,
+            store: deps.store,
+            journal: this.journal,
+            outbox,
+            asks: this.asks,
+            codex,
+            codexThreads: codex && deps.codex ? new CodexThreads({ agent: codex, sock: deps.codex.sock, codexHome: deps.codex.home }) : null,
+            accounts: deps.claudeAccounts ?? null,
+            claudeSettingsPath: deps.claudeSettingsPath,
+            claudeBin: deps.claudeBin ?? 'claude',
+            shell,
+            claudeArgs: deps.claudeArgs ?? [],
+            claudeProjectsRoot: deps.claudeProjectsRoot,
+        };
+        const p = {};
+        p.sessions = this;
+        p.lifecycle = new Lifecycle(this.s, this.d, p);
+        p.input = new Input(this.s, this.d, p);
+        p.status = new Status(this.s, this.d, p);
+        p.accounts = new Accounts(this.d, p);
+        p.moves = new Moves(this.s, this.d, p);
+        this.p = p;
+    }
+    async codexOnMac() {
+        return this.d.codexThreads ? this.d.codexThreads.list() : [];
+    }
+    codexChat(threadId) {
+        if (!UUID.test(threadId))
+            throw new InvalidRequest('thread id must be a uuid');
+        return codexOf(this.d).readItems(threadId);
+    }
+    // What Codex said last in a session, for the list.
+    lastReply(id) {
+        return this.d.codex?.lastReply(id) ?? null;
+    }
+    // Where a change of status is told, for the sessions whose agent the server follows itself (Codex).
+    setNotifier(n) {
+        this.s.notifier = n;
+    }
+    // Which agents a session can be started with here, besides Claude Code.
+    get agents() {
+        return { codex: !!this.d.codex };
+    }
+    // A message as the journal has it, to answer what was done to it with.
+    message(id, qid) {
+        return this.journal.message(id, qid);
+    }
+    // Stops what writes to the journal, then the journal.
+    closeJournal() {
+        this.d.codex?.close();
+        for (const stop of this.s.transcriptWatches.values())
+            stop();
+        this.s.transcriptWatches.clear();
+        this.s.stopTimers();
+        this.journal.close();
+    }
+    // Takes what the session's conversation added into the journal.
+    ingest(id) {
+        return this.journal.ingest(id, this.d.store.get().sessions[id]?.claudeSessionId ?? null);
+    }
+    // Metadata is written only after tmux has the session, and the ids that may be
+    // pruned are read before asking tmux; so a missing id here means tmux lost it.
+    async listSessions() {
+        const known = Object.keys(this.d.store.get().sessions);
+        void this.d.accounts?.list().catch(() => { });
+        const live = (await this.d.tmux.listSessions()).flatMap((t) => {
+            const id = idOfTmuxName(t.name);
+            return id === undefined ? [] : [{ ...t, id }];
+        });
+        const liveIds = new Set(live.map((t) => t.id));
+        const stale = known.filter((id) => !liveIds.has(id));
+        if (stale.length) {
+            this.d.store.update((st) => stale.forEach((id) => delete st.sessions[id]));
+            stale.forEach((id) => this.p.status.forget(id));
+        }
+        const sessions = live.map(({ id, ...t }) => {
+            const meta = this.d.store.get().sessions[id] ?? {
+                title: t.name,
+                kind: 'shell',
+                cwd: '',
+                createdAt: t.created,
+            };
+            return { id, meta, activity: t.activity, panePid: t.panePid };
+        });
+        await this.p.status.followClaudes(sessions.flatMap((s) => (s.meta.kind === 'claude' && s.panePid ? [{ id: s.id, panePid: s.panePid }] : [])));
+        // A status not known yet is read before it is told: Claude may be at work behind its prompt.
+        await Promise.all(sessions.map((s) => s.meta.kind === 'claude' && this.p.status.fillStatus(s.id)));
+        for (const s of sessions)
+            if (s.meta.kind === 'claude')
+                this.p.status.look(s.id);
+        for (const s of sessions)
+            if (s.meta.kind === 'codex')
+                this.p.status.lookCodex(s.id, s.meta);
+        const ids = [...liveIds].sort().join(',');
+        if (ids !== this.lastIds) {
+            this.lastIds = ids;
+            this.s.emit();
+        }
+        return sessions.map((s) => this.toSession(s.id, s.meta, s.activity)).sort((a, b) => b.lastActivity - a.lastActivity);
+    }
+    async exists(id) {
+        return ID.test(id) && this.d.tmux.hasSession(tmuxName(id));
+    }
+    // Taken in the order they arrive: each waits until the one before it went in or was queued.
+    sendMessage(id, text, qid) {
+        if (!ID.test(id))
+            return Promise.reject(new InvalidRequest('bad session id'));
+        const taken = (this.sending.get(id) ?? Promise.resolve()).then(async () => {
+            // A compaction in a session that reports none shows only on screen.
+            await this.p.input.onScreen(id).catch(() => { });
+            // Nor does a status not known yet go for idle: Claude may be at work behind its prompt.
+            if (this.d.store.get().sessions[id]?.kind === 'claude')
+                await this.p.status.fillStatus(id);
+            return this.d.outbox.send(id, text, qid);
+        });
+        const last = taken.catch(() => { });
+        this.sending.set(id, last);
+        void last.then(() => {
+            if (this.sending.get(id) === last)
+                this.sending.delete(id);
+        });
+        return taken;
+    }
+    unsend(id, queuedId) {
+        return this.d.outbox.remove(id, queuedId);
+    }
+    async sendNow(id, queuedId) {
+        if (!ID.test(id))
+            throw new InvalidRequest('bad session id');
+        if (await this.p.input.dialogOpen(id))
+            throw new Conflict('a dialog is open; pick an option or press Esc first', 'dialog-open');
+        return this.d.outbox.sendNow(id, queuedId);
+    }
+    moveQueued(id, queuedId, by) {
+        return this.d.outbox.move(id, queuedId, by);
+    }
+    createSession(spec) { return this.p.lifecycle.createSession(spec); }
+    continueSession(id) { return this.p.lifecycle.continueSession(id); }
+    openOnMac() { return this.p.lifecycle.openOnMac(); }
+    takeOverWhenIdle(spec) { return this.p.lifecycle.takeOverWhenIdle(spec); }
+    takingOver(claudeSessionId) { return this.p.lifecycle.takingOver(claudeSessionId); }
+    cancelTakeOver(claudeSessionId) { return this.p.lifecycle.cancelTakeOver(claudeSessionId); }
+    killSession(id) { return this.p.lifecycle.killSession(id); }
+    renameSession(id, title) { return this.p.lifecycle.renameSession(id, title); }
+    claudeName(claudeSessionId) { return this.p.lifecycle.claudeName(claudeSessionId); }
+    choices(id) { return this.p.input.choices(id); }
+    onScreen(id) { return this.p.input.onScreen(id); }
+    screenText(id) { return this.p.input.screenText(id); }
+    choose(id, index, label, text) { return this.p.input.choose(id, index, label, text); }
+    tick(id, ticked, labels) { return this.p.input.tick(id, ticked, labels); }
+    holdPermission(id, payload, hook) { return this.p.input.holdPermission(id, payload, hook); }
+    answer(id, askId, answer) { return this.p.input.answer(id, askId, answer); }
+    type(id, text) { return this.p.input.type(id, text); }
+    close(id) { return this.p.input.close(id); }
+    press(id, keys) { return this.p.input.press(id, keys); }
+    runCommand(id, command) { return this.p.input.runCommand(id, command); }
+    fitForChat(id) { return this.p.input.fitForChat(id); }
+    getStatus(id) { return this.p.status.getStatus(id); }
+    setStatus(id, status) { this.p.status.setStatus(id, status); }
+    claudeMayHaveQuit(id) { this.p.status.claudeMayHaveQuit(id); }
+    compactStarted(id) { this.p.status.compactStarted(id); }
+    compactEnded(id, manual) { this.p.status.compactEnded(id, manual); }
+    setUsage(id, usage) { this.p.status.setUsage(id, usage); }
+    setClaudeSessionId(id, claudeSessionId) { this.p.status.setClaudeSessionId(id, claudeSessionId); }
+    claudeAccountsView() { return this.p.accounts.claudeAccountsView(); }
+    pickClaudeAccount(id) { return this.p.accounts.pickClaudeAccount(id); }
+    async moveToAccountInUse() {
+        await this.p.moves.moveAll();
+        return this.p.accounts.claudeAccountsView();
+    }
+    sessionMeta(id) {
+        return this.d.store.get().sessions[id];
+    }
+    onChange(cb) {
+        this.s.listeners.add(cb);
+        return () => this.s.listeners.delete(cb);
+    }
+    // One listing at a time: the next starts an interval after the last one ends, so a slow tmux
+    // makes the watch slower instead of piling listings onto it.
+    watch(intervalMs) {
+        let stopped = false;
+        let timer;
+        const next = () => {
+            if (stopped)
+                return;
+            timer = setTimeout(() => {
+                this.listSessions().catch(() => { }).finally(next);
+            }, intervalMs);
+            timer.unref();
+        };
+        next();
+        return () => {
+            stopped = true;
+            clearTimeout(timer);
+        };
+    }
+    toSession(id, meta, lastActivity) {
+        return {
+            id,
+            title: shownTitle(meta),
+            kind: meta.kind,
+            cwd: meta.cwd,
+            claudeSessionId: meta.claudeSessionId,
+            codexThreadId: meta.codexThreadId,
+            createdAt: meta.createdAt,
+            lastActivity,
+            status: meta.kind === 'shell' ? null : (this.s.statuses.get(id) ?? 'idle'),
+            usage: this.s.usages.get(id) ?? null,
+            claudeAccount: this.p.accounts.accountLabel(meta),
+        };
+    }
+}