linkshell-cli 0.6.2 → 0.6.4

package/dist/host/src/hub.js

@@ -1,4 +1,64 @@
 import { RpcError, sessionIdFor, } from "@linkshell/wire";
+import { inOrder } from "./drivers/acp/driver.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { PAGE, worktreeOf } from "./store.js";
+import { createWorktree, gitBranch, gitInfo, removeWorktree, worktreeState } from "./worktrees.js";
+import { conversationDigest, copied, isConversation } from "./carry.js";
+import { slimEvent } from "./slim.js";
+/**
+ * Whether an update is something happening in the session. Names, settings
+ * and usage figures arrive when a session is merely opened or renamed, and
+ * must not move it to the top of the list.
+ */
+function isActivity(update) {
+    switch (update.sessionUpdate) {
+        case "session_info_update":
+        case "ls_config":
+        case "available_commands_update":
+        case "usage_update":
+        // What state a session is in and who drives it are said again whenever it
+        // is opened; a turn starting or ending is what counts.
+        case "ls_status":
+        case "ls_driver":
+            return false;
+        default:
+            return true;
+    }
+}
+/**
+ * Whether a sub-agent is working. Its call says so while it is open; an agent
+ * that outlives its call (it reports turns of its own) counts while it keeps
+ * doing things — a turn left open by an agent that was killed doesn't run forever.
+ */
+function subagentRunning(state, now = Date.now()) {
+    if (!state.callDone)
+        return state.turnActive ?? true;
+    return state.turnActive === true && now - (state.lastChildTs ?? 0) < 15 * 60_000;
+}
+/** A short name for a worktree, from what the session is asked to do. */
+function promptLabel(prompt) {
+    return prompt ? textOf(prompt).slice(0, 40) || "session" : "session";
+}
+function worktreeLossMessage(state) {
+    const parts = [state.dirty ? "未提交的改动" : "", state.ahead > 0 ? `${state.ahead} 个新提交` : ""].filter(Boolean);
+    return `这个 worktree 里有${parts.join("和")}，删除会丢失`;
+}
+/** Driver-state key: when a session was renamed, and when it was last active before that. */
+const RENAMED = "renamed";
+/** Driver-state key: the conversation a forked session's agent is still to be told, with its first message. */
+const CARRY = "carry";
+/** A returning client catches up from where it was, unless it missed more than this. */
+const CATCH_UP = { events: 800, bytes: 4 * 1024 * 1024 };
+/** State a client needs from before its window: the latest of each applies. */
+const STANDING = [
+    "ls_config",
+    "available_commands_update",
+    "current_mode_update",
+    "usage_update",
+    "session_info_update",
+    "ls_driver",
+];
 const PREVIEW_LENGTH = 160;
 const TITLE_LENGTH = 60;
 function compact(text, max) {
@@ -22,6 +82,7 @@ function textOf(content) {
 export class SessionHub {
     store;
     log;
+    home;
     drivers = new Map();
     live = new Map();
     summaryListeners = new Set();
@@ -30,10 +91,12 @@ export class SessionHub {
     /** Terminals (`linkshell <agent>`) currently driving handoff sessions. */
     desktops = new Map();
     discoveryTimer;
+    branches = new Map();
+    worktreeCache;
     authRefreshing;
     driverHost = {
         sessionSeen: (agent, session) => this.recordDiscovered(agent, session),
-        update: (agent, nativeId, update, itemId) => this.ingest(sessionIdFor(agent, nativeId), update, itemId),
+        update: (agent, nativeId, update, itemId, ts) => this.ingest(sessionIdFor(agent, nativeId), update, itemId, ts),
         follow: (agent, nativeId) => {
             const sessionId = sessionIdFor(agent, nativeId);
             if (!this.store.getSession(sessionId))
@@ -64,9 +127,12 @@ export class SessionHub {
         },
         log: (message) => this.log(message),
     };
-    constructor(store, drivers, log = () => { }) {
+    constructor(store, drivers, log = () => { }, 
+    /** Where the host keeps its own files: worktrees go under it. */
+    home = join(homedir(), ".linkshell")) {
         this.store = store;
         this.log = log;
+        this.home = home;
         for (const driver of drivers)
             this.drivers.set(driver.id, driver);
     }
@@ -160,8 +226,22 @@ export class SessionHub {
         const last = sessions[sessions.length - 1];
         return { sessions, nextBefore: sessions.length === limit && last ? last.updatedAt : undefined };
     }
-    listProjects(limit) {
-        return this.store.listProjects(limit);
+    /** Projects, each with the branch checked out there now. */
+    async listProjects(limit) {
+        const projects = this.store.listProjects(limit);
+        const branches = await Promise.all(projects.map((project) => this.branchOf(project.cwd)));
+        return projects.map((project, index) => (branches[index] ? { ...project, branch: branches[index] } : project));
+    }
+    /** Asked for every project each time the list is: remembered for a moment. */
+    branchOf(cwd) {
+        const known = this.branches.get(cwd);
+        if (known && Date.now() - known.at < 5000)
+            return known.branch;
+        const branch = gitBranch(cwd);
+        this.branches.set(cwd, { at: Date.now(), branch });
+        if (this.branches.size > 500)
+            this.branches.delete(this.branches.keys().next().value);
+        return branch;
     }
     getSession(sessionId) {
         const summary = this.store.getSession(sessionId);
@@ -170,17 +250,43 @@ export class SessionHub {
         return this.decorate(summary);
     }
     /** Adds the live-only fields (current activity, first pending permission) to a stored summary. */
+    /** Marks a session that works in one of LinkShell's worktrees. */
+    withWorktree(summary) {
+        const worktree = worktreeOf(summary.cwd, this.worktrees());
+        return worktree ? { ...summary, worktree: { branch: worktree.branch, source: worktree.sourceCwd } } : summary;
+    }
+    /** The worktrees table, read once and again whenever it changes. */
+    worktrees() {
+        return (this.worktreeCache ??= this.store.listWorktrees());
+    }
     decorate(summary) {
         const live = this.live.get(summary.id);
         if (!live)
-            return summary;
+            return this.withWorktree(summary);
         const activity = live.turnActive ? live.activity : undefined;
         const first = live.permissions.values().next().value;
-        if (!activity && !first && !live.queue)
+        const subagents = live.attached ? this.subagentsOf(summary.id, live) : undefined;
+        summary = this.withWorktree(summary);
+        if (!activity && !first && !live.queue && live.held.length === 0 && !subagents?.size)
             return summary;
         const decorated = { ...summary };
-        if (live.queue)
-            decorated.queue = live.queue;
+        if (subagents?.size) {
+            let running = 0;
+            for (const state of subagents.values())
+                if (subagentRunning(state))
+                    running += 1;
+            decorated.subagents = { total: subagents.size, running };
+        }
+        if (live.queue || live.held.length > 0) {
+            decorated.queue = [
+                ...(live.queue ?? []),
+                ...live.held.map((entry) => ({
+                    clientMessageId: entry.clientMessageId,
+                    text: textOf(entry.content),
+                    images: entry.content.filter((block) => block.type === "image").length,
+                })),
+            ];
+        }
         if (activity)
             decorated.activity = activity;
         if (first) {
@@ -196,10 +302,13 @@ export class SessionHub {
     }
     async createSession(input) {
         const driver = this.requireDriver(input.agent);
-        const discovered = await driver.createSession({ cwd: input.cwd, model: input.model }).catch(async (error) => {
+        const worktree = input.worktree ? await this.newWorktree(input.cwd, promptLabel(input.prompt)) : undefined;
+        const discovered = await driver.createSession({ cwd: worktree?.cwd ?? input.cwd, model: input.model }).catch(async (error) => {
             // The app shows "not logged in" from the agent list; make it current.
             if (error instanceof RpcError && error.appCode === "not_logged_in")
                 await this.refreshAuth(driver);
+            if (worktree)
+                await this.dropWorktree(worktree.path);
             throw error;
         });
         this.recordDiscovered(driver.id, discovered);
@@ -211,9 +320,140 @@ export class SessionHub {
         return this.getSession(sessionId);
     }
     /**
-     * Sends everything after `fromSeq`, then streams live events. The backlog read
-     * and the subscriber registration happen in one synchronous step, so no event
-     * can fall between them.
+     * A new session that starts with this one's conversation: all of it, or
+     * through the turn `itemId` is in. With `worktree` it works in a new git
+     * worktree of the project.
+     */
+    async fork(sessionId, options = {}) {
+        const summary = this.getSession(sessionId);
+        const driver = this.requireDriver(summary.agent);
+        if (driver.tier === "terminal")
+            throw RpcError.app("not_supported", `${driver.label} 不支持从会话分叉`);
+        let upTo;
+        let cut = summary.lastSeq;
+        if (options.itemId) {
+            const located = this.store.locateItem(sessionId, options.itemId);
+            if (!located)
+                throw RpcError.app("not_found", "找不到要分叉的那条消息");
+            upTo = { itemId: options.itemId, turn: located.turn };
+            cut = this.store.turnEnd(sessionId, located.seq);
+        }
+        // A fork of a worktree session made into a new worktree branches from the project, like its original did.
+        const origin = worktreeOf(summary.cwd, this.store.listWorktrees());
+        const worktree = options.worktree ? await this.newWorktree(origin?.sourceCwd ?? summary.cwd, summary.title ?? "fork") : undefined;
+        const cwd = worktree?.cwd ?? summary.cwd;
+        try {
+            let discovered;
+            if (driver.fork && driver.capabilities.fork) {
+                discovered = await driver.fork(summary.nativeId, { cwd, sourceCwd: summary.cwd, upTo }).catch((error) => {
+                    // The agent forks, but not this way (only whole sessions, say): the fork is made by us instead.
+                    if (error instanceof RpcError && error.appCode === "not_supported")
+                        return undefined;
+                    throw error;
+                });
+            }
+            if (!discovered)
+                return await this.forkByReplay(summary, driver, cwd, cut);
+            this.recordDiscovered(driver.id, { ...discovered, title: discovered.title ?? summary.title });
+            return this.getSession(sessionIdFor(driver.id, discovered.nativeId));
+        }
+        catch (error) {
+            if (worktree)
+                await this.dropWorktree(worktree.path);
+            throw error;
+        }
+    }
+    /**
+     * A fork for an agent that can't fork a session itself: a new session that
+     * shows the conversation up to `cut` (its latest page, from our log), whose
+     * agent is told that conversation with the first message sent to it.
+     */
+    async forkByReplay(summary, driver, cwd, cut) {
+        const start = this.store.pageStart(summary.id, cut);
+        const events = this.store.readEvents(summary.id, start, PAGE.maxEvents + 1, cut).filter((event) => isConversation(event.update));
+        const discovered = await driver.createSession({ cwd });
+        this.recordDiscovered(driver.id, { ...discovered, title: discovered.title ?? summary.title });
+        const forkId = sessionIdFor(driver.id, discovered.nativeId);
+        await this.ensureAttached(forkId);
+        const live = this.liveFor(forkId);
+        live.importing = true;
+        try {
+            // Pictures and long output stay in the original; the fork's own log starts light.
+            for (const event of events)
+                this.commit(forkId, copied(slimEvent(event).update), undefined, event.ts);
+        }
+        finally {
+            live.importing = false;
+        }
+        this.commit(forkId, {
+            sessionUpdate: "ls_notice",
+            level: "info",
+            title: "分叉的会话",
+            detail: `之前的对话以文字交给 ${driver.label}${start > 0 ? "，更早的内容在原会话里" : ""}`,
+        });
+        const digest = conversationDigest(events);
+        if (digest)
+            this.store.setDriverState(forkId, CARRY, digest);
+        return this.getSession(forkId);
+    }
+    /** Hands a message to the agent — with the conversation a forked session still owes it, the first time. */
+    deliver(summary, driver, content, clientMessageId) {
+        const carry = this.store.getDriverState(summary.id, CARRY);
+        if (!carry)
+            return driver.prompt(summary.nativeId, content, clientMessageId);
+        return driver.prompt(summary.nativeId, content, clientMessageId, carry).then((delivery) => {
+            this.store.setDriverState(summary.id, CARRY, "");
+            return delivery;
+        });
+    }
+    // ── worktrees ─────────────────────────────────────────────────────
+    gitInfo(path) {
+        return gitInfo(path);
+    }
+    async newWorktree(cwd, label) {
+        const created = await createWorktree(cwd, this.home, label);
+        this.store.saveWorktree({ path: created.path, branch: created.branch, source: created.source, sourceCwd: cwd, base: created.base, createdAt: Date.now() });
+        this.worktreeCache = undefined;
+        return created;
+    }
+    async dropWorktree(path) {
+        const worktree = this.store.listWorktrees().find((entry) => entry.path === path);
+        if (!worktree)
+            return;
+        await removeWorktree(worktree).catch((error) => this.log(`[hub] couldn't remove worktree ${path}: ${String(error)}`));
+        this.store.deleteWorktree(path);
+        this.worktreeCache = undefined;
+    }
+    async listWorktrees() {
+        return Promise.all(this.store.listWorktrees().map(async (worktree) => ({
+            path: worktree.path,
+            branch: worktree.branch,
+            source: worktree.sourceCwd,
+            createdAt: worktree.createdAt,
+            sessions: this.store.sessionsUnder(worktree.path),
+            ...(await worktreeState(worktree.path, worktree.base)),
+        })));
+    }
+    /** Removes a worktree and its branch, unless a session uses it or (without `force`) work in it would be lost. */
+    async removeWorktree(path, force = false) {
+        const worktree = this.store.listWorktrees().find((entry) => entry.path === path);
+        if (!worktree)
+            throw RpcError.app("not_found", "没有这个 worktree");
+        if (this.store.sessionsUnder(path).length > 0)
+            throw RpcError.app("busy", "还有会话在用这个 worktree：先删除那些会话");
+        if (!force) {
+            const state = await worktreeState(path, worktree.base);
+            if (state.dirty || state.ahead > 0)
+                throw RpcError.app("dirty", worktreeLossMessage(state));
+        }
+        await this.dropWorktree(path);
+    }
+    /**
+     * Sends the backlog, then streams live events. A fresh subscriber (or one too
+     * far behind to catch up) gets the latest turns only, after the standing
+     * state from before them; earlier history is read in pages (`history`).
+     * The backlog read and the subscriber registration happen in one synchronous
+     * step, so no event can fall between them.
      */
     async subscribe(sessionId, fromSeq, subscriber) {
         const summary = this.getSession(sessionId);
@@ -229,22 +469,175 @@ export class SessionHub {
                 }
             }
         }
-        let cursor = fromSeq;
+        const live = this.liveFor(sessionId);
+        if (driver?.tier === "handoff")
+            this.lendCommands(this.getSession(sessionId));
+        const lastSeq = this.store.getSession(sessionId)?.lastSeq ?? 0;
+        let startSeq = fromSeq;
+        const missed = fromSeq > 0 && fromSeq <= lastSeq ? this.store.sizeAfter(sessionId, fromSeq) : undefined;
+        if (!missed || missed.events > CATCH_UP.events || missed.bytes > CATCH_UP.bytes) {
+            startSeq = this.store.pageStart(sessionId, lastSeq);
+            if (startSeq !== fromSeq)
+                subscriber.window?.(startSeq);
+            for (const event of this.standingBefore(sessionId, startSeq, live))
+                subscriber.event(event);
+        }
+        let cursor = startSeq;
         for (;;) {
-            const batch = this.store.readEvents(sessionId, cursor);
+            const batch = this.store.readEvents(sessionId, cursor, 200);
             for (const event of batch)
                 subscriber.event(event);
             if (batch.length === 0)
                 break;
             cursor = batch[batch.length - 1].seq;
         }
-        this.liveFor(sessionId).subscribers.add(subscriber);
-        return this.getSession(sessionId);
+        live.subscribers.add(subscriber);
+        return { session: this.getSession(sessionId), startSeq };
+    }
+    /**
+     * A handoff agent names its commands only once it runs here, so a session
+     * still driven at the desk has none to offer. It borrows the list of the
+     * agent's latest session in the same folder (or its latest anywhere) until
+     * it gets its own: `/compact` typed on the phone works from the first message.
+     */
+    lendCommands(summary) {
+        const kind = "available_commands_update";
+        if (this.store.latestOfKind(summary.id, kind, summary.lastSeq).length > 0)
+            return;
+        let found;
+        for (const other of this.store.listSessions({ limit: 80, includeArchived: true })) {
+            if (other.agent !== summary.agent || other.id === summary.id)
+                continue;
+            const [event] = this.store.latestOfKind(other.id, kind, other.lastSeq);
+            if (!event)
+                continue;
+            found ??= event;
+            if (other.cwd === summary.cwd) {
+                found = event;
+                break;
+            }
+        }
+        if (found)
+            this.commit(summary.id, found.update);
+    }
+    /** The page of history before `beforeSeq`, oldest first. */
+    history(sessionId, beforeSeq) {
+        this.getSession(sessionId);
+        const upTo = beforeSeq - 1;
+        if (upTo < 1)
+            return { events: [], startSeq: 0 };
+        const startSeq = this.store.pageStart(sessionId, upTo);
+        return { events: this.store.readEvents(sessionId, startSeq, PAGE.maxEvents + 1, upTo), startSeq };
+    }
+    /** The sub-agents the session started, newest first. */
+    subagents(sessionId) {
+        this.getSession(sessionId);
+        const agents = new Map();
+        for (const event of this.store.subagentCalls(sessionId)) {
+            const call = event.update;
+            // (A call still open when the session was opened again is logged again.)
+            if (agents.has(call.toolCallId))
+                continue;
+            const detail = call.detail?.type === "subagent" ? call.detail : undefined;
+            const state = this.store.toolState(sessionId, call.toolCallId);
+            const callDone = state.status === "completed" || state.status === "failed";
+            const running = subagentRunning({ callDone, turnActive: state.turnActive, lastChildTs: state.lastChildTs });
+            agents.set(call.toolCallId, {
+                toolCallId: call.toolCallId,
+                task: detail?.task ?? call.title,
+                agentType: detail?.agentType,
+                running,
+                failed: state.status === "failed" || undefined,
+                startedAt: event.ts,
+                endedAt: running ? undefined : callDone ? state.ts : state.lastChildTs,
+            });
+        }
+        return [...agents.values()].reverse();
+    }
+    subagentsOf(sessionId, live) {
+        if (!live.subagents) {
+            live.subagents = new Map();
+            for (const event of this.store.subagentCalls(sessionId)) {
+                const { toolCallId } = event.update;
+                const state = this.store.toolState(sessionId, toolCallId);
+                live.subagents.set(toolCallId, {
+                    callDone: state.status === "completed" || state.status === "failed",
+                    turnActive: state.turnActive,
+                    lastChildTs: state.lastChildTs,
+                });
+            }
+        }
+        return live.subagents;
+    }
+    /** Keeps the sub-agent tally current; true when it changed. */
+    trackSubagent(live, update) {
+        const known = live.subagents;
+        if (!known)
+            return false;
+        if (update.sessionUpdate === "tool_call" && update.detail?.type === "subagent" && (update.detail.action ?? "spawn") === "spawn") {
+            if (known.has(update.toolCallId))
+                return false;
+            known.set(update.toolCallId, { callDone: update.status === "completed" || update.status === "failed" });
+            return true;
+        }
+        if (update.sessionUpdate === "tool_call_update" && !update.parentToolCallId) {
+            const state = known.get(update.toolCallId);
+            if (!state || state.callDone || (update.status !== "completed" && update.status !== "failed"))
+                return false;
+            state.callDone = true;
+            return true;
+        }
+        const parent = update.parentToolCallId;
+        const state = parent ? known.get(parent) : undefined;
+        if (!state)
+            return false;
+        const was = subagentRunning(state);
+        state.lastChildTs = Date.now();
+        if (update.sessionUpdate === "ls_turn")
+            state.turnActive = update.state === "started";
+        return subagentRunning(state) !== was;
+    }
+    /** A sub-agent's conversation: its call, then what happened under it. */
+    subagent(sessionId, toolCallId) {
+        this.getSession(sessionId);
+        const own = this.store.toolEvents(sessionId, toolCallId);
+        if (own.length === 0)
+            throw RpcError.app("not_found", "这个子 Agent 已经不在会话记录里");
+        return [...own, ...this.store.eventsUnder(sessionId, toolCallId, 2000)].sort((a, b) => a.seq - b.seq);
+    }
+    readEvent(sessionId, seq) {
+        this.getSession(sessionId);
+        return this.store.readEvent(sessionId, seq);
+    }
+    /** What still holds at `seq` from the events before it: settings, an open turn, unanswered approvals. */
+    standingBefore(sessionId, seq, live) {
+        if (seq < 1)
+            return [];
+        const events = STANDING.flatMap((kind) => this.store.latestOfKind(sessionId, kind, seq));
+        const [turn] = this.store.latestOfKind(sessionId, "ls_turn", seq);
+        if (turn?.update.sessionUpdate === "ls_turn" && turn.update.state === "started")
+            events.push(turn);
+        if (live.permissions.size > 0) {
+            for (const event of this.store.latestOfKind(sessionId, "ls_permission", seq, 50)) {
+                if (event.update.sessionUpdate === "ls_permission" && live.permissions.has(event.update.requestId))
+                    events.push(event);
+            }
+        }
+        // Sub-agents still working were started before the window: their calls, so
+        // what they do next has its card to go under.
+        for (const [toolCallId, state] of this.subagentsOf(sessionId, live)) {
+            if (!subagentRunning(state))
+                continue;
+            const call = this.store.toolEvents(sessionId, toolCallId)[0];
+            if (call && call.seq <= seq)
+                events.push(call);
+        }
+        return events.sort((a, b) => a.seq - b.seq);
     }
     unsubscribe(sessionId, subscriber) {
         this.live.get(sessionId)?.subscribers.delete(subscriber);
     }
-    async prompt(sessionId, clientMessageId, content) {
+    async prompt(sessionId, clientMessageId, content, whenBusy) {
         const summary = this.getSession(sessionId);
         const driver = this.requireDriver(summary.agent);
         let joinAfterSend = false;
@@ -259,9 +652,15 @@ export class SessionHub {
         }
         if (!this.store.claimClientMessage(sessionId, clientMessageId))
             return "duplicate";
+        const live = this.liveFor(sessionId);
+        if (whenBusy === "queue" && (live.turnActive || live.held.length > 0)) {
+            live.held.push({ clientMessageId, content });
+            this.announce(sessionId);
+            return "queued";
+        }
         let delivery;
         try {
-            delivery = await driver.prompt(summary.nativeId, content, clientMessageId);
+            delivery = await this.deliver(summary, driver, content, clientMessageId);
         }
         catch (error) {
             this.store.releaseClientMessage(sessionId, clientMessageId);
@@ -290,12 +689,87 @@ export class SessionHub {
     unqueue(sessionId, clientMessageId) {
         const summary = this.getSession(sessionId);
         const driver = this.requireDriver(summary.agent);
-        const removed = driver.unqueue?.(summary.nativeId, clientMessageId) ?? false;
+        const live = this.liveFor(sessionId);
+        const held = live.held.findIndex((entry) => entry.clientMessageId === clientMessageId);
+        if (held >= 0) {
+            live.held.splice(held, 1);
+            this.announce(sessionId);
+        }
+        const removed = held >= 0 || (driver.unqueue?.(summary.nativeId, clientMessageId) ?? false);
         // Sent again later, it should go through.
         if (removed)
             this.store.releaseClientMessage(sessionId, clientMessageId);
         return removed;
     }
+    reorderQueue(sessionId, clientMessageIds) {
+        const summary = this.getSession(sessionId);
+        const live = this.liveFor(sessionId);
+        live.held = inOrder(live.held, clientMessageIds);
+        this.requireDriver(summary.agent).reorderQueue?.(summary.nativeId, clientMessageIds);
+        this.announce(sessionId);
+    }
+    /**
+     * Sends a queued message without waiting for the running turn to end: into
+     * that turn if the agent takes input mid-turn, otherwise by stopping it.
+     */
+    async sendQueuedNow(sessionId, clientMessageId) {
+        const summary = this.getSession(sessionId);
+        const driver = this.requireDriver(summary.agent);
+        const live = this.liveFor(sessionId);
+        const index = clientMessageId ? live.held.findIndex((entry) => entry.clientMessageId === clientMessageId) : 0;
+        const item = live.held[index];
+        if (!item) {
+            // Held by the driver (another Claude is mid-turn in the session), or already gone.
+            await driver.sendQueuedNow?.(summary.nativeId);
+            return;
+        }
+        live.held.splice(index, 1);
+        if (live.turnActive && !driver.capabilities.steer) {
+            // The turn has to end first: stop it, and this message is next.
+            live.held.unshift(item);
+            this.announce(sessionId);
+            await driver.cancel(summary.nativeId);
+            return;
+        }
+        this.announce(sessionId);
+        try {
+            const delivery = await this.deliver(summary, driver, item.content, item.clientMessageId);
+            if (delivery === "queued")
+                await driver.sendQueuedNow?.(summary.nativeId);
+        }
+        catch (error) {
+            live.held.unshift(item);
+            this.announce(sessionId);
+            throw error;
+        }
+    }
+    /** A turn ended: the next held message starts the following one. */
+    async sendHeld(sessionId) {
+        const live = this.live.get(sessionId);
+        const summary = this.store.getSession(sessionId);
+        if (!live || !summary || live.held.length === 0 || live.turnActive || live.sendingHeld)
+            return;
+        const driver = this.drivers.get(summary.agent);
+        if (!driver)
+            return;
+        const next = live.held.shift();
+        live.sendingHeld = true;
+        this.announce(sessionId);
+        try {
+            await this.deliver(summary, driver, next.content, next.clientMessageId);
+        }
+        catch (error) {
+            this.store.releaseClientMessage(sessionId, next.clientMessageId);
+            this.commit(sessionId, {
+                sessionUpdate: "ls_error",
+                code: error instanceof RpcError ? (error.appCode ?? "send_failed") : "send_failed",
+                message: `排队的消息没能发出：${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+        finally {
+            live.sendingHeld = false;
+        }
+    }
     onRemoved(listener) {
         this.removedListeners.add(listener);
         return () => this.removedListeners.delete(listener);
@@ -322,11 +796,18 @@ export class SessionHub {
                 this.log(`[hub] ${summary.agent} rename failed: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
+        // The agent writing its own title record touches the session: for the next
+        // few seconds a newer "last updated" from it is the rename, not activity.
+        this.store.setDriverState(sessionId, RENAMED, JSON.stringify({ updatedAt: summary.updatedAt, until: Date.now() + 5000 }));
         const updated = this.store.patchSession(sessionId, { customTitle: name || null });
         this.emitSummary(updated);
         return this.decorate(updated);
     }
-    async delete(sessionId) {
+    /**
+     * Deletes a session. A worktree only it used goes too when nothing in it
+     * would be lost (or `worktree` says "remove"); "keep" leaves it.
+     */
+    async delete(sessionId, worktree) {
         const summary = this.getSession(sessionId);
         const live = this.live.get(sessionId);
         if (live?.turnActive || summary.state === "running")
@@ -336,10 +817,21 @@ export class SessionHub {
         const driver = this.drivers.get(summary.agent);
         if (driver) {
             await driver.detach(summary.nativeId).catch(() => { });
-            if (driver.delete)
-                await driver.delete(summary.nativeId);
+            if (driver.delete) {
+                await driver.delete(summary.nativeId).catch((error) => {
+                    // Already gone on the agent's side (deleted there): only our record is left to remove.
+                    if (!/no rollout|not found|unknown (thread|session)|no conversation found/i.test(error instanceof Error ? error.message : String(error)))
+                        throw error;
+                });
+            }
         }
         this.forget(sessionId);
+        const own = worktreeOf(summary.cwd, this.store.listWorktrees());
+        if (!own || worktree === "keep" || this.store.sessionsUnder(own.path).length > 0)
+            return;
+        const state = await worktreeState(own.path, own.base);
+        if (worktree === "remove" || (!state.dirty && state.ahead === 0))
+            await this.dropWorktree(own.path);
     }
     /** Drops a session from LinkShell and tells every client. */
     forget(sessionId) {
@@ -358,6 +850,14 @@ export class SessionHub {
     }
     async cancel(sessionId) {
         const summary = this.getSession(sessionId);
+        // Stopping stops what's waiting too; the apps put queued text back in the composer.
+        const live = this.liveFor(sessionId);
+        if (live.held.length > 0) {
+            for (const entry of live.held)
+                this.store.releaseClientMessage(sessionId, entry.clientMessageId);
+            live.held = [];
+            this.announce(sessionId);
+        }
         await this.requireDriver(summary.agent).cancel(summary.nativeId);
     }
     async respondPermission(sessionId, requestId, optionId) {
@@ -448,6 +948,7 @@ export class SessionHub {
                 messageText: new Map(),
                 permissions: new Map(),
                 turnActive: false,
+                held: [],
             };
             this.live.set(sessionId, live);
         }
@@ -478,8 +979,9 @@ export class SessionHub {
                 live.importing = true;
                 live.importChanged = false;
                 try {
-                    // Items without a recorded time get the session's last activity, never "now".
-                    let ts = summary.createdAt;
+                    // Items without a recorded time get the time of the one before, never "now".
+                    // (An agent that only says when a session last changed gives that as its creation too.)
+                    let ts = Math.min(summary.createdAt, history.find((item) => item.ts !== undefined)?.ts ?? summary.createdAt);
                     for (const item of history) {
                         ts = Math.min(Math.max(item.ts ?? ts, ts), summary.updatedAt);
                         if (this.store.isItemLogged(sessionId, item.itemId))
@@ -501,11 +1003,11 @@ export class SessionHub {
             finally {
                 const buffered = live.buffer ?? [];
                 live.buffer = undefined;
-                for (const { update, itemId } of buffered) {
+                for (const { update, itemId, ts } of buffered) {
                     // History already covered this item; skip its completion to avoid a duplicate.
                     if (itemId && this.store.isItemLogged(sessionId, itemId))
                         continue;
-                    this.commit(sessionId, update, itemId);
+                    this.commit(sessionId, update, itemId, ts);
                 }
                 live.attaching = undefined;
             }
@@ -517,6 +1019,15 @@ export class SessionHub {
         if (this.store.isRemoved(sessionIdFor(agent, session.nativeId)))
             return;
         const before = this.store.getSession(sessionIdFor(agent, session.nativeId));
+        if (before && session.updatedAt > before.updatedAt) {
+            // Renamed just now: the session keeps its place in the list.
+            const renamed = this.store.getDriverState(before.id, RENAMED);
+            if (renamed) {
+                const hold = JSON.parse(renamed);
+                if (session.updatedAt <= hold.until)
+                    session = { ...session, updatedAt: before.updatedAt };
+            }
+        }
         const { summary, created } = this.store.upsertSession({
             id: sessionIdFor(agent, session.nativeId),
             agent,
@@ -538,23 +1049,23 @@ export class SessionHub {
         if (created || changed)
             this.emitSummary(summary);
     }
-    ingest(sessionId, update, itemId) {
+    ingest(sessionId, update, itemId, ts) {
         if (!this.store.getSession(sessionId)) {
             this.log(`[hub] dropping update for unknown session ${sessionId}`);
             return;
         }
         const live = this.liveFor(sessionId);
         if (live.buffer) {
-            live.buffer.push({ update, itemId });
+            live.buffer.push({ update, itemId, ts });
             return;
         }
-        this.commit(sessionId, update, itemId);
+        this.commit(sessionId, update, itemId, ts);
     }
     commit(sessionId, update, itemId, ts) {
         const live = this.liveFor(sessionId);
         if (update.sessionUpdate === "ls_permission_resolved" && !live.permissions.has(update.requestId))
             return;
-        const event = this.store.appendEvent(sessionId, update, ts);
+        const event = this.store.appendEvent(sessionId, update, ts, isActivity(update));
         if (itemId)
             this.store.markItemLogged(sessionId, itemId);
         this.applyToSummary(sessionId, live, update);
@@ -567,10 +1078,12 @@ export class SessionHub {
             }
         }
         // A finished turn can't still be waiting on approvals; clear stale cards.
-        if (update.sessionUpdate === "ls_turn" && update.state === "ended") {
+        if (update.sessionUpdate === "ls_turn" && update.state === "ended" && !update.parentToolCallId) {
             for (const requestId of [...live.permissions.keys()]) {
                 this.commit(sessionId, { sessionUpdate: "ls_permission_resolved", requestId });
             }
+            if (!live.importing)
+                void this.sendHeld(sessionId);
         }
     }
     applyToSummary(sessionId, live, update) {
@@ -578,7 +1091,7 @@ export class SessionHub {
         if (!before)
             return;
         const patch = {};
-        let activityChanged = false;
+        let activityChanged = this.trackSubagent(live, update) && !live.importing;
         const setActivity = (next) => {
             if (live.importing || sameActivity(live.activity, next))
                 return;
@@ -617,6 +1130,9 @@ export class SessionHub {
                 break;
             }
             case "ls_turn":
+                // A sub-agent's turn is its own; the session's is the one without a parent.
+                if (update.parentToolCallId)
+                    break;
                 live.turnActive = update.state === "started";
                 setActivity(live.turnActive ? { kind: "thinking" } : undefined);
                 // Leftover permissions are cleared right after a turn ends (see commit).
@@ -663,9 +1179,16 @@ export class SessionHub {
             live.importChanged = true;
             return;
         }
-        patch.updatedAt = Date.now();
+        if (isActivity(update))
+            patch.updatedAt = Date.now();
         this.emitSummary(this.store.patchSession(sessionId, patch));
     }
+    /** Sends the session's current summary to every client (its queue or activity changed). */
+    announce(sessionId) {
+        const stored = this.store.getSession(sessionId);
+        if (stored)
+            this.emitSummary(stored);
+    }
     emitSummary(stored) {
         const summary = this.decorate(stored);
         for (const listener of this.summaryListeners) {