linkshell-cli 0.10.53 → 0.10.54

package/dist/wire/src/watch.js

@@ -46,8 +46,9 @@ export const watchTimelineItemSchema = z.object({
         "error",
     ]),
     title: z.string().max(120).optional(),
-    text: z.string().max(600),
-    detail: z.string().max(500).optional(),
+    // The session the watch has open carries several KB per item (see watchSnapshotContent).
+    text: z.string().max(8000),
+    detail: z.string().max(4000).optional(),
     status: z.enum(["running", "completed", "failed", "waiting"]).optional(),
     filePath: z.string().max(200).optional(),
     diffAdded: z.number().int().min(0).optional(),
@@ -119,6 +120,8 @@ export const watchSnapshotSchema = z.object({
     computerKey: z.string().max(512),
     computerName: z.string().max(80),
     online: z.boolean(),
+    /** The session the watch last opened: it keeps the largest share of the byte budget. */
+    focusedSessionId: z.string().min(1).max(128).optional(),
     statusLabel: z.string().max(80),
     waitingCount: z.number().int().min(0),
     runningCount: z.number().int().min(0),
@@ -130,6 +133,17 @@ export const watchSnapshotSchema = z.object({
     sessions: z.array(watchSessionSchema).max(12),
     terminals: z.array(watchTerminalSchema).max(8),
 });
+export const WATCH_PROMPT_MAX = 8000;
+/**
+ * WCSession's applicationContext and sendMessage carry about 65 KB; the rest is
+ * headroom for the envelope and for Swift's re-serialization of the JSON.
+ */
+export const WATCH_SNAPSHOT_BYTE_LIMIT = 56_000;
+/** Snapshot sessions and terminals; the phone attaches exactly the terminals it sends. */
+export const WATCH_SESSION_LIMIT = 10;
+export const WATCH_TERMINAL_LIMIT = 6;
+export const WATCH_FOCUSED_ITEMS = 40;
+export const WATCH_MAX_ITEMS = 60;
 export const watchCommandSchema = z.discriminatedUnion("kind", [
     z.object({
         id: z.string().min(1).max(128),
@@ -141,7 +155,8 @@ export const watchCommandSchema = z.discriminatedUnion("kind", [
         kind: z.literal("prompt"),
         computerKey: z.string().min(1).max(512),
         sessionId: z.string().min(1).max(128),
-        text: z.string().min(1).max(2000),
+        // Dictation runs long; the host's sessions.prompt has no limit of its own.
+        text: z.string().min(1).max(WATCH_PROMPT_MAX),
         now: z.boolean().optional(),
     }),
     z.object({
@@ -188,7 +203,7 @@ export const watchCommandSchema = z.discriminatedUnion("kind", [
         computerKey: z.string().min(1).max(512),
         agent: z.string().min(1).max(48),
         cwd: z.string().min(1).max(240),
-        prompt: z.string().max(2000).optional(),
+        prompt: z.string().max(WATCH_PROMPT_MAX).optional(),
     }),
     z.object({
         id: z.string().min(1).max(128),
@@ -208,7 +223,7 @@ export const watchCommandSchema = z.discriminatedUnion("kind", [
         kind: z.literal("terminal-input"),
         computerKey: z.string().min(1).max(512),
         terminalId: z.string().min(1).max(128),
-        data: z.string().min(1).max(2000),
+        data: z.string().min(1).max(WATCH_PROMPT_MAX),
     }),
     z.object({
         id: z.string().min(1).max(128),
@@ -236,6 +251,106 @@ export const DEFAULT_WATCH_QUICK_PROMPTS = [
 function cut(value, max) {
     return [...(value ?? "")].slice(0, max).join("");
 }
+function utf8Length(value) {
+    let bytes = 0;
+    for (const ch of value) {
+        const code = ch.codePointAt(0);
+        bytes += code < 0x80 ? 1 : code < 0x800 ? 2 : code < 0x10000 ? 3 : 4;
+    }
+    return bytes;
+}
+/**
+ * Cuts to a UTF-8 byte budget: the WatchConnectivity limit is in bytes, and CJK text
+ * takes three a character, so a character count would let it overflow threefold.
+ */
+export function cutWatchBytes(value, maxBytes) {
+    const text = value ?? "";
+    // Every character is at most 4 bytes, so short strings need no counting.
+    if (text.length * 4 <= maxBytes || utf8Length(text) <= maxBytes)
+        return text;
+    const budget = Math.max(0, maxBytes - 3);
+    let used = 0;
+    let end = 0;
+    for (const ch of text) {
+        const code = ch.codePointAt(0);
+        const size = code < 0x80 ? 1 : code < 0x800 ? 2 : code < 0x10000 ? 3 : 4;
+        if (used + size > budget)
+            break;
+        used += size;
+        end += ch.length;
+    }
+    return `${text.slice(0, end).trimEnd()}…`;
+}
+/**
+ * Message text for the watch's conversation view. Unlike plainPreview (one line, for
+ * lists and Live Activities) it keeps line breaks and markdown: the watch renders
+ * answers as markdown, code blocks included. Only whitespace noise is tidied.
+ */
+export function watchTimelineText(text) {
+    return text
+        .replace(/\r\n?/g, "\n")
+        .replace(/\t/g, "  ")
+        .replace(/[ \u00a0]+$/gm, "")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+/**
+ * Line-kept text for rows the watch shows as plain Text (thoughts): inline markup
+ * outside code (emphasis, headings, links) is unwrapped; code lines stay as they are.
+ */
+export function watchPlainText(text) {
+    let inFence = false;
+    return watchTimelineText(text)
+        .split("\n")
+        .map((line) => {
+        if (/^\s*(```|~~~)/.test(line)) {
+            inFence = !inFence;
+            return line.trim();
+        }
+        if (inFence)
+            return line;
+        return line
+            .replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1")
+            .replace(/\[([^\]]*)\]\([^)]*\)/g, "$1")
+            .replace(/^(\s{0,3})#{1,6}\s+/, "$1")
+            .replace(/^(\s*)[-*+]\s+/, "$1• ")
+            .replace(/(\*\*|__|~~)(\S(?:.*?\S)?)\1/g, "$2")
+            .replace(/`([^`\n]+)`/g, "$1");
+    })
+        .join("\n");
+}
+/**
+ * Like cutWatchBytes, but keeps the end too: a long answer's conclusion is at the bottom.
+ * Three quarters of the budget go to the beginning, the rest to the end.
+ */
+export function cutWatchBytesMiddle(value, maxBytes) {
+    const text = value ?? "";
+    if (text.length * 4 <= maxBytes || utf8Length(text) <= maxBytes)
+        return text;
+    const chars = [...text];
+    const take = (from, step, budget) => {
+        let used = 0;
+        let count = 0;
+        for (let i = from; i >= 0 && i < chars.length; i += step) {
+            const size = utf8Length(chars[i]);
+            if (used + size > budget)
+                break;
+            used += size;
+            count += 1;
+        }
+        return count;
+    };
+    const marker = (omitted) => `\n…（中间略去 ${omitted} 字）…\n`;
+    const room = maxBytes - utf8Length(marker(chars.length));
+    if (room < 200)
+        return cutWatchBytes(text, maxBytes);
+    const headCount = take(0, 1, Math.floor(room * 0.75));
+    const tailCount = take(chars.length - 1, -1, room - utf8Length(chars.slice(0, headCount).join("")));
+    return `${chars.slice(0, headCount).join("").trimEnd()}${marker(chars.length - headCount - tailCount)}${chars
+        .slice(chars.length - tailCount)
+        .join("")
+        .trimStart()}`;
+}
 function baseName(path) {
     const parts = path.split(/[\\/]/).filter(Boolean);
     return parts[parts.length - 1] ?? path;
@@ -347,7 +462,9 @@ export function buildWatchSession(session, online, computerKey = "", options = {
             ...(options.planProgress.currentStep ? { currentStep: cut(options.planProgress.currentStep, 100) } : {}),
         }
         : undefined;
-    const maxItems = Math.max(4, Math.min(options.maxItems ?? 14, 56));
+    const maxItems = options.focused
+        ? Math.max(WATCH_FOCUSED_ITEMS, Math.min(options.maxItems ?? 0, WATCH_MAX_ITEMS))
+        : Math.max(4, Math.min(options.maxItems ?? 14, 56));
     const rawItems = options.items?.length ? options.items : fallbackTimelineItems(session, commandPreview, preview);
     const items = maxItems > 14
         ? rawItems.slice(-maxItems)
@@ -402,6 +519,29 @@ export function buildWatchTerminal(terminal, online, computerKey = "", outputPre
         deepLink: liveActivityDetailLink(computerKey, "terminal", terminal.id),
     };
 }
+/** Failed, then busy, then most recently active: the order the watch lists terminals in. */
+export function sortWatchTerminals(terminals) {
+    const rank = (s) => (s.failed ? 0 : s.busy ? 1 : 2);
+    return [...terminals].sort((a, b) => {
+        const ra = rank(terminalState(a));
+        const rb = rank(terminalState(b));
+        if (ra !== rb)
+            return ra - rb;
+        if (a.activeAt !== b.activeAt)
+            return b.activeAt - a.activeAt;
+        return a.id.localeCompare(b.id);
+    });
+}
+/** The first `max`, with the focused one swapped in for the last when it falls outside. */
+function keepFocused(list, max, focusedId) {
+    const head = list.slice(0, max);
+    if (!focusedId || head.some((item) => item.id === focusedId))
+        return head;
+    const focused = list.find((item) => item.id === focusedId);
+    if (!focused)
+        return head;
+    return head.length < max ? [...head, focused] : [...head.slice(0, max - 1), focused];
+}
 /**
  * Builds the structured Apple Watch companion snapshot for the selected computer.
  * Prioritizes sessions needing approval/input, then errors, then running, then pinned/recent.
@@ -442,16 +582,10 @@ export function buildWatchSnapshot(computerName, sessions, terminals, online, op
             return b.updatedAt - a.updatedAt;
         return a.id.localeCompare(b.id);
     });
-    const sortedTerminals = [...terminals].sort((a, b) => {
-        const sa = terminalState(a);
-        const sb = terminalState(b);
-        const rank = (s) => (s.failed ? 0 : s.busy ? 1 : 2);
-        if (rank(sa) !== rank(sb))
-            return rank(sa) - rank(sb);
-        if (a.activeAt !== b.activeAt)
-            return b.activeAt - a.activeAt;
-        return a.id.localeCompare(b.id);
-    });
+    const sortedTerminals = sortWatchTerminals(terminals);
+    const focusedId = options.focusedSessionId && liveSessions.some((s) => s.id === options.focusedSessionId)
+        ? options.focusedSessionId
+        : undefined;
     const statusLabel = !online
         ? "连接中断 · 正在重连"
         : waitingCount > 0
@@ -492,9 +626,8 @@ export function buildWatchSnapshot(computerName, sessions, terminals, online, op
         addWorkspace(s.worktree?.source ?? s.cwd);
     for (const t of sortedTerminals)
         addWorkspace(t.cwd);
-    const availableAgents = (options.availableAgents?.length
-        ? options.availableAgents
-        : ["claude", "codex", "gemini", "cursor", "opencode"])
+    // Only what the computer reported: an invented agent would fail when the watch starts it.
+    const availableAgents = (options.availableAgents ?? [])
         .map((id) => cut(id.trim(), 48))
         .filter(Boolean)
         .slice(0, 10);
@@ -504,6 +637,7 @@ export function buildWatchSnapshot(computerName, sessions, terminals, online, op
         computerKey: cut(computerKey, 512),
         computerName: cut(computerName || "电脑", 64),
         online,
+        ...(focusedId ? { focusedSessionId: focusedId } : {}),
         statusLabel: cut(statusLabel, 80),
         waitingCount,
         runningCount,
@@ -512,7 +646,7 @@ export function buildWatchSnapshot(computerName, sessions, terminals, online, op
         availableAgents,
         ...(workspaces.length ? { workspaces } : {}),
         computers: watchComputers,
-        sessions: sortedSessions.slice(0, 10).map((session) => {
+        sessions: keepFocused(sortedSessions, WATCH_SESSION_LIMIT, focusedId).map((session) => {
             const goal = goals[session.id];
             return buildWatchSession(session, online, computerKey, {
                 pinned: pinnedSet.has(session.id),
@@ -524,24 +658,122 @@ export function buildWatchSnapshot(computerName, sessions, terminals, online, op
                 maxItems: itemLimits[session.id],
                 mode: modes[session.id],
                 configOptions: configs[session.id],
+                focused: session.id === focusedId,
             });
         }),
-        terminals: sortedTerminals.slice(0, 6).map((terminal) => buildWatchTerminal(terminal, online, computerKey, terminalOutputs[terminal.id])),
+        terminals: sortedTerminals.slice(0, WATCH_TERMINAL_LIMIT).map((terminal) => buildWatchTerminal(terminal, online, computerKey, terminalOutputs[terminal.id])),
     };
     return watchSnapshotContent(snapshot);
 }
+const ITEM_TEXT_BYTES = 600;
+const ITEM_DETAIL_BYTES = 360;
+const FOCUSED_TEXT_BYTES = 6_000;
+const FOCUSED_DETAIL_BYTES = 2_400;
+const IMAGE_MAX = 12_000;
+/** What the open conversation may take before the other sessions are squeezed. */
+const FOCUSED_SHARE = 0.65;
+function jsonBytes(value) {
+    return utf8Length(JSON.stringify(value));
+}
+function boundItem(item, focused) {
+    const { imageBase64, imageMimeType, ...rest } = item;
+    // A cut base64 string is a broken picture, so an oversized one is left out whole.
+    const image = imageBase64 && imageBase64.length <= IMAGE_MAX ? imageBase64 : undefined;
+    return {
+        ...rest,
+        id: cut(item.id, 120),
+        ...(item.title ? { title: cut(item.title, 80) } : {}),
+        text: focused ? cutWatchBytesMiddle(item.text, FOCUSED_TEXT_BYTES) : cutWatchBytes(item.text, ITEM_TEXT_BYTES),
+        ...(item.detail ? { detail: cutWatchBytes(item.detail, focused ? FOCUSED_DETAIL_BYTES : ITEM_DETAIL_BYTES) } : {}),
+        ...(item.filePath ? { filePath: cut(item.filePath, 160) } : {}),
+        ...(item.subagentType ? { subagentType: cut(item.subagentType, 48) } : {}),
+        ...(item.subagentName ? { subagentName: cut(item.subagentName, 48) } : {}),
+        ...(item.subagentModel ? { subagentModel: cut(item.subagentModel, 64) } : {}),
+        ...(image ? { imageBase64: image, ...(imageMimeType ? { imageMimeType: cut(imageMimeType, 48) } : {}) } : {}),
+    };
+}
+function withoutImage(item) {
+    if (!item.imageBase64)
+        return item;
+    const { imageBase64: _image, imageMimeType: _mime, ...rest } = item;
+    return rest;
+}
 /**
- * Bounds a WatchSnapshot so it fits comfortably within WatchConnectivity's
- * applicationContext / message budget (<= 24 KB), never truncating action IDs.
+ * The newest items that fit in `budget` bytes. The newest message is the one being
+ * read, so it is cut rather than dropped; only the newest picture is kept; and the
+ * latest question from the user stays when the tail has none, so the answer has context.
  */
-export function watchSnapshotContent(snapshot) {
+function fitItems(items, budget) {
+    const kept = [];
+    let used = 2;
+    let imageKept = false;
+    let index = items.length - 1;
+    for (; index >= 0; index -= 1) {
+        let item = items[index];
+        if (imageKept)
+            item = withoutImage(item);
+        let size = jsonBytes(item) + 1;
+        if (used + size > budget && item.imageBase64) {
+            item = withoutImage(item);
+            size = jsonBytes(item) + 1;
+        }
+        if (used + size > budget) {
+            if (kept.length > 0)
+                break;
+            let room = budget - used - jsonBytes({ ...item, text: "" }) - 1;
+            while (room >= 120 && used + size > budget) {
+                item = { ...item, text: cutWatchBytes(item.text, room) };
+                size = jsonBytes(item) + 1;
+                room = Math.floor(room * 0.8);
+            }
+            if (used + size > budget)
+                break;
+        }
+        if (item.imageBase64)
+            imageKept = true;
+        kept.push(item);
+        used += size;
+    }
+    if (index >= 0 && !kept.some((item) => item.kind === "user")) {
+        const earlier = items.slice(0, index + 1).reverse().find((item) => item.kind === "user");
+        if (earlier) {
+            const asked = withoutImage({ ...earlier, text: cutWatchBytes(earlier.text, ITEM_TEXT_BYTES) });
+            const size = jsonBytes(asked) + 1;
+            if (used + size <= budget)
+                kept.push(asked);
+            else if (kept.length > 1 && jsonBytes(kept[kept.length - 1]) + 1 + budget - used >= size) {
+                kept[kept.length - 1] = asked;
+            }
+        }
+    }
+    return kept.reverse();
+}
+function squeezeSession(s, cap, textBytes) {
+    if (!s.items)
+        return s;
+    const items = sliceTimelinePreservingUsers(s.items, cap).map((item) => {
+        const { detail: _detail, ...rest } = withoutImage(item);
+        return { ...rest, text: cutWatchBytes(item.text, textBytes) };
+    });
+    return { ...s, items, hasEarlier: s.hasEarlier || items.length < s.items.length || undefined };
+}
+/**
+ * Bounds a WatchSnapshot to WATCH_SNAPSHOT_BYTE_LIMIT UTF-8 bytes, never truncating
+ * action IDs. The session the watch has open gets the largest share: pictures and the
+ * other sessions' items go first, and whatever their trimming frees goes back to it.
+ */
+export function watchSnapshotContent(snapshot, limit = WATCH_SNAPSHOT_BYTE_LIMIT) {
+    const focusedId = snapshot.focusedSessionId && snapshot.sessions.some((s) => s.id === snapshot.focusedSessionId)
+        ? snapshot.focusedSessionId
+        : undefined;
+    const isFocused = (s) => s.id === focusedId;
+    const { focusedSessionId: _focused, ...base } = snapshot;
     const next = {
-        ...snapshot,
+        ...base,
+        ...(focusedId ? { focusedSessionId: focusedId } : {}),
         computerName: cut(snapshot.computerName, 64),
         statusLabel: cut(snapshot.statusLabel, 80),
-        ...(snapshot.availableAgents?.length
-            ? { availableAgents: snapshot.availableAgents.slice(0, 10).map((a) => cut(a, 48)) }
-            : {}),
+        ...(snapshot.availableAgents ? { availableAgents: snapshot.availableAgents.slice(0, 10).map((a) => cut(a, 48)) } : {}),
         ...(snapshot.workspaces?.length
             ? {
                 workspaces: snapshot.workspaces.slice(0, 8).map((w) => ({
@@ -551,25 +783,16 @@ export function watchSnapshotContent(snapshot) {
             }
             : {}),
         computers: snapshot.computers.slice(0, 12).map((c) => ({ ...c, name: cut(c.name, 64) })),
-        sessions: snapshot.sessions.slice(0, 10).map((s) => {
+        sessions: keepFocused(snapshot.sessions, WATCH_SESSION_LIMIT, focusedId).map((s) => {
+            const focused = isFocused(s);
             const validActions = (s.actions ?? []).filter((a) => watchActionSchema.safeParse(a).success).slice(0, 3);
             const rawValidItems = (s.items ?? []).filter((item) => Boolean(item.id && item.text?.trim()));
-            const itemCap = rawValidItems.length > 14 ? Math.min(rawValidItems.length, 48) : 14;
-            const validItems = (itemCap > 14
-                ? rawValidItems.slice(-itemCap)
-                : sliceTimelinePreservingUsers(rawValidItems, itemCap)).map((item) => ({
-                ...item,
-                id: cut(item.id, 120),
-                ...(item.title ? { title: cut(item.title, 80) } : {}),
-                text: cut(item.text, 360),
-                ...(item.detail ? { detail: cut(item.detail, 360) } : {}),
-                ...(item.filePath ? { filePath: cut(item.filePath, 160) } : {}),
-                ...(item.subagentType ? { subagentType: cut(item.subagentType, 48) } : {}),
-                ...(item.subagentName ? { subagentName: cut(item.subagentName, 48) } : {}),
-                ...(item.subagentModel ? { subagentModel: cut(item.subagentModel, 64) } : {}),
-                ...(item.imageBase64 ? { imageBase64: item.imageBase64.slice(0, 12_000) } : {}),
-                ...(item.imageMimeType ? { imageMimeType: cut(item.imageMimeType, 48) } : {}),
-            }));
+            const itemCap = focused
+                ? WATCH_MAX_ITEMS
+                : rawValidItems.length > 14
+                    ? Math.min(rawValidItems.length, 48)
+                    : 14;
+            const validItems = (itemCap > 14 ? rawValidItems.slice(-itemCap) : sliceTimelinePreservingUsers(rawValidItems, itemCap)).map((item) => boundItem(item, focused));
             const validConfigs = (s.configOptions ?? []).slice(0, 4).map((opt) => ({
                 ...opt,
                 id: cut(opt.id, 48),
@@ -609,10 +832,10 @@ export function watchSnapshotContent(snapshot) {
                 ...(validActions.length ? { actions: validActions } : { actions: undefined }),
                 hasMoreActions: s.hasMoreActions || validActions.length < (s.actions?.length ?? 0) || undefined,
                 ...(hasEarlier ? { hasEarlier: true } : { hasEarlier: undefined }),
-                ...(validItems.length ? { items: validItems } : {}),
+                ...(validItems.length ? { items: validItems } : { items: undefined }),
             };
         }),
-        terminals: snapshot.terminals.slice(0, 6).map((t) => ({
+        terminals: snapshot.terminals.slice(0, WATCH_TERMINAL_LIMIT).map((t) => ({
             ...t,
             title: cut(t.title, 80),
             subtitle: cut(t.subtitle, 120),
@@ -622,62 +845,60 @@ export function watchSnapshotContent(snapshot) {
             ...(t.outputPreview ? { outputPreview: cut(t.outputPreview, 1400) } : {}),
         })),
     };
-    const size = () => new TextEncoder().encode(JSON.stringify(next)).length;
-    if (size() > 24_000) {
-        next.sessions = next.sessions.map((s, idx) => {
-            const isExpanded = (s.items?.length ?? 0) > 14;
-            const cap = isExpanded ? 32 : idx < 4 ? 10 : 4;
-            return {
+    const size = () => jsonBytes(next);
+    const over = () => size() > limit;
+    const others = (change) => {
+        next.sessions = next.sessions.map((s) => (isFocused(s) ? s : change(s)));
+    };
+    const focusedItems = next.sessions.find(isFocused)?.items ?? [];
+    // Everything but the open conversation, counted with an empty one in its place.
+    const restBytes = () => jsonBytes({ ...next, sessions: next.sessions.map((s) => (isFocused(s) ? { ...s, items: [], hasEarlier: true } : s)) });
+    let focusedTrimmed = false;
+    const fitFocused = (budget) => {
+        if (!focusedItems.length)
+            return;
+        focusedTrimmed = true;
+        const items = fitItems(focusedItems, budget);
+        next.sessions = next.sessions.map((s) => isFocused(s)
+            ? {
                 ...s,
-                hasEarlier: s.hasEarlier || (s.items?.length ?? 0) > cap || undefined,
-                items: s.items
-                    ? (isExpanded ? s.items.slice(-cap) : sliceTimelinePreservingUsers(s.items, cap)).map((i) => ({
-                        ...i,
-                        text: cut(i.text, idx < 4 || isExpanded ? 260 : 160),
-                        ...(i.detail ? { detail: cut(i.detail, 150) } : {}),
-                        imageBase64: idx === 0 ? i.imageBase64 : undefined,
-                    }))
-                    : undefined,
-            };
-        });
-    }
-    if (size() > 24_000) {
+                items: items.length ? items : undefined,
+                hasEarlier: s.hasEarlier || items.length < focusedItems.length || undefined,
+            }
+            : s);
+    };
+    if (over())
+        others((s) => (s.items ? { ...s, items: s.items.map(withoutImage) } : s));
+    if (over())
+        fitFocused(Math.max(Math.floor(limit * FOCUSED_SHARE), limit - restBytes()));
+    if (over())
+        others((s) => squeezeSession(s, 6, 300));
+    if (over()) {
         next.terminals = next.terminals.map((t) => ({
             ...t,
             outputPreview: t.outputPreview ? cut(t.outputPreview, 800) : undefined,
         }));
     }
-    if (size() > 24_000) {
-        next.sessions = next.sessions.map((s, idx) => {
-            const isExpanded = (s.items?.length ?? 0) > 14;
-            const cap = isExpanded ? 24 : idx < 3 ? 6 : 3;
-            return {
-                ...s,
-                configOptions: idx < 2 || isExpanded ? s.configOptions : undefined,
-                hasEarlier: s.hasEarlier || (s.items?.length ?? 0) > cap || undefined,
-                items: s.items
-                    ? (isExpanded ? s.items.slice(-cap) : sliceTimelinePreservingUsers(s.items, cap)).map((i) => ({
-                        ...i,
-                        text: cut(i.text, 160),
-                        detail: undefined,
-                        imageBase64: undefined,
-                    }))
-                    : undefined,
-            };
-        });
-    }
-    while (size() > 24_000 && next.terminals.length > 2)
+    if (over())
+        others((s) => ({ ...squeezeSession(s, 3, 160), configOptions: undefined }));
+    while (over() && next.terminals.length > 2)
         next.terminals.pop();
-    while (size() > 24_000 && next.sessions.length > 4)
-        next.sessions.pop();
-    if (size() > 24_000) {
-        next.sessions = next.sessions.map((s) => ({
+    while (over() && next.sessions.filter((s) => !isFocused(s)).length > 3) {
+        const lastOther = next.sessions.map(isFocused).lastIndexOf(false);
+        next.sessions.splice(lastOther, 1);
+    }
+    if (over()) {
+        others((s) => ({
             ...s,
             detailPreview: s.detailPreview ? cut(s.detailPreview, 60) : undefined,
             commandPreview: s.commandPreview ? cut(s.commandPreview, 60) : undefined,
             items: undefined,
+            hasEarlier: s.items?.length ? true : s.hasEarlier,
         }));
     }
+    // Whatever squeezing the others freed goes back to the open conversation.
+    if (focusedTrimmed || over())
+        fitFocused(limit - restBytes());
     return next;
 }
 /**