@co0ontty/wand 4.85.1 → 4.87.0-beta.gd2f0f8f

package/dist/structured-session-manager.js

@@ -1362,9 +1362,12 @@ export class StructuredSessionManager {
         const selectedModel = options.model?.trim() || null;
         const initialThinkingEffort = normalizeThinkingEffort(options.thinkingEffort);
         const autoCompaction = this.config.harness?.compaction?.enabled ?? true;
+        // 显式引擎优先：用户新建会话时选了 Wand Agent（core）就不要再被员工候选或默认推断改口。
+        const explicitEngine = provider === "pi" ? options.engine : undefined;
         // 员工 SDK 会话不静默继承用户的全局扩展，也不继承 CLI 专属的资源/CodeMode 默认。
         const sdkEmployeeSession = provider === "pi"
-            && options.employeeCandidates?.[options.employeeCandidateIndex ?? 0]?.engine === "sdk";
+            && (explicitEngine ? explicitEngine === "core"
+                : options.employeeCandidates?.[options.employeeCandidateIndex ?? 0]?.engine === "sdk");
         // CLI Pi 会话从「上次设置」起步：用户在任一 Pi 会话改过的自动选择 / CodeMode / 资源选择
         // 就是新会话的默认，不需要每开一个会话重配一次。autoCompaction 始终取当前配置。
         const rememberedPiSettings = provider === "pi" && !sdkEmployeeSession ? this.storage.getPiSessionDefaults() : null;
@@ -1420,6 +1423,7 @@ export class StructuredSessionManager {
             structuredState: {
                 provider,
                 runner,
+                ...(explicitEngine ? { engine: explicitEngine } : {}),
                 model: selectedModel ?? undefined,
                 inFlight: false,
                 activeRequestId: null,
@@ -1502,6 +1506,7 @@ export class StructuredSessionManager {
         const selected = candidates[index];
         // Explicit tool/model changes, including changes during the pending request, remain authoritative.
         if (!selected || original.provider !== selected.provider
+            || (original.structuredState?.engine && (original.structuredState.engine === "core" ? "sdk" : "cli") !== (selected.engine ?? "cli"))
             || (original.selectedModel && original.selectedModel !== this.employeeCandidateModel(selected)))
             return null;
         const current = this.sessions.get(id);
@@ -1812,8 +1817,10 @@ export class StructuredSessionManager {
             }
             else if (provider === "pi") {
                 const employeeAgent = updated.employeeCandidates?.[updated.employeeCandidateIndex ?? 0];
-                const sdkRequested = employeeAgent?.engine === "sdk";
-                // 对话框默认固定走 CLI；只有员工候选明确配置 SDK 时，员工会话才启用 core。
+                // 会话已裁决过引擎就沿用（新建会话选了 Wand Agent 或 Pi CLI）；未裁决的旧会话/员工会话回落到候选配置。
+                const decidedEngine = updated.structuredState?.engine;
+                const sdkRequested = decidedEngine ? decidedEngine === "core" : employeeAgent?.engine === "sdk";
+                // 没显式选择时对话框固定走 CLI；只有选定 Wand Agent 或员工候选配置 SDK 才是 core。
                 const resolution = sdkRequested
                     ? resolveHarnessEngineSync({ ...this.config.harness, engine: "core" }, "pi", {
                         coreRunnerSupplied: this.coreRunnerSupplied,
@@ -1832,7 +1839,7 @@ export class StructuredSessionManager {
                     await this.runClaudeStreaming(id, enginePatched, prompt, requestId, {
                         runner: this.coreRunner,
                         provider: "pi",
-                        commandLabel: "pi core（员工 SDK）",
+                        commandLabel: "Wand Agent（SDK）",
                         logKind: "pi-core",
                     });
                 }
@@ -2063,22 +2070,39 @@ export class StructuredSessionManager {
         });
         return updated;
     }
-    /** 新建空白对话可原位换 CLI；接受过输入、恢复会话和自动化不跨 provider 搬历史。 */
-    setSessionProvider(sessionId, provider) {
+    /** 空白对话原位换执行工具；引擎也是工具身份，不跨工具搬历史或能力设置。 */
+    setSessionProvider(sessionId, provider, engine) {
         const session = this.requireSession(sessionId);
         if (!isSessionProvider(provider))
-            throw new Error("请选择有效的 CLI 工具。");
+            throw new Error("请选择有效的执行工具。");
+        if (engine !== undefined && engine !== "cli" && engine !== "sdk")
+            throw new Error("执行引擎必须是 cli 或 sdk。");
+        if (engine === "sdk" && provider !== "pi")
+            throw new Error("Wand Agent 只支持 Pi 结构化会话。");
         if (session.status !== "idle" || session.archived || session.structuredState?.inFlight ||
             this.pendingRunnerExecutions.has(sessionId) || session.claudeSessionId ||
+            session.resumedFromSessionId || session.autoRecovered ||
             (session.messages?.length ?? 0) > 0 || (session.queuedMessages?.length ?? 0) > 0 ||
             session.automationId || (session.sessionSource && session.sessionSource !== "interactive") ||
             this.relayHandlerFor(session)) {
             throw new Error("只有尚未发送消息的新建空白对话可以更换工具。");
         }
-        if (session.provider === provider)
-            return session;
         const candidates = session.employeeCandidates ?? [];
-        const candidateIndex = candidates.findIndex((candidate) => candidate.provider === provider);
+        const currentCandidate = candidates[session.employeeCandidateIndex ?? 0];
+        const currentEngine = session.provider === "pi" && (session.structuredState?.engine === "core"
+            || (!session.structuredState?.engine && currentCandidate?.provider === "pi" && currentCandidate.engine === "sdk")) ? "sdk" : "cli";
+        // 旧客户端只发 provider 时，同 provider 保持原引擎；显式 Pi 选项始终传 cli。
+        const targetEngine = provider === "pi" ? engine ?? (session.provider === provider ? currentEngine : "cli") : "cli";
+        if (session.provider === provider && currentEngine === targetEngine)
+            return session;
+        if (targetEngine === "sdk" && session.provider === "pi" && (session.piSettings?.resources?.skills.length
+            || session.piSettings?.resources?.mcpServers.length || session.piSettings?.lockedSkills?.length
+            || session.piSettings?.autoResources || session.piSettings?.codemodeOverride !== undefined)) {
+            throw new Error("Wand Agent 不支持会话级 Skills / MCP、自动选择或 CodeMode 覆盖；请先在 Pi 设置中关闭这些选项再切换。");
+        }
+        const resolution = provider === "pi" ? this.resolveNewSessionPiEngine(targetEngine) : undefined;
+        const candidateIndex = candidates.findIndex((candidate) => candidate.provider === provider
+            && (candidate.engine ?? "cli") === targetEngine);
         const candidate = candidateIndex >= 0 ? candidates[candidateIndex] : undefined;
         const runner = defaultStructuredRunner(provider);
         const model = candidate && candidate.model !== "default" ? candidate.model
@@ -2094,18 +2118,19 @@ export class StructuredSessionManager {
             ...session,
             provider,
             runner,
-            // 从别的 provider 切到 Pi 的空白会话与新建 Pi 会话同等：以「上次设置」起步。
-            ...(provider === "pi" && !session.piSettings ? { piSettings: candidate?.engine === "sdk"
-                    ? defaultPiSessionSettings(this.config.harness?.compaction?.enabled ?? true)
-                    : { ...(this.storage.getPiSessionDefaults() ?? defaultPiCliSessionSettings(this.config.harness?.compaction?.enabled ?? true)),
-                        autoCompaction: this.config.harness?.compaction?.enabled ?? true } } : {}),
-            command: recoveredCommandLabel(runner),
+            // 换引擎也是换工具：使用目标自己的默认设置，不复用另一路的能力配置。
+            piSettings: provider !== "pi" ? undefined : targetEngine === "sdk"
+                ? defaultPiSessionSettings(this.config.harness?.compaction?.enabled ?? true)
+                : { ...(this.storage.getPiSessionDefaults() ?? defaultPiCliSessionSettings(this.config.harness?.compaction?.enabled ?? true)),
+                    autoCompaction: this.config.harness?.compaction?.enabled ?? true },
+            command: targetEngine === "sdk" ? "Wand Agent（SDK）" : recoveredCommandLabel(runner),
             mode,
             autoApprovePermissions: shouldAutoApproveForMode(mode),
             selectedModel: model,
             thinkingEffort,
             employeeCandidateIndex: candidateIndex >= 0 ? candidateIndex : undefined,
-            structuredState: { ...defaultStructuredState(provider, runner), model: model ?? undefined },
+            structuredState: { ...defaultStructuredState(provider, runner), model: model ?? undefined,
+                ...(resolution ? { engine: resolution.engine, engineReason: resolution.reason } : {}) },
         };
         // 身份、知识归属、任务/目录和候选快照不变；只更新本会话的执行参数。
         this.storage.saveSession(updated);
@@ -2118,12 +2143,26 @@ export class StructuredSessionManager {
         });
         return updated;
     }
+    /**
+     * 新建 pi 结构化会话前的引擎裁决。
+     *
+     * 用户在新建会话里选的是两个不同的东西：Pi CLI（`cli`）与 Wand Agent（`sdk`，进程内 harness）。
+     * 显式选了 Wand Agent 就必须真的可用：不可用时抛错由路由告诉用户，不静默退回 CLI 冒充。
+     */
+    resolveNewSessionPiEngine(engine) {
+        if (engine !== "sdk")
+            return { engine: "cli", reason: "Pi 主功能固定使用 CLI JSON" };
+        return resolveHarnessEngineSync({ ...this.config.harness, engine: "core" }, "pi", {
+            coreRunnerSupplied: this.coreRunnerSupplied,
+        });
+    }
     getPiSettings(sessionId) {
         const session = this.requireSession(sessionId);
         if (session.provider !== "pi")
             throw new Error("这些设置仅适用于 Pi 结构化会话。");
         const employeeAgent = session.employeeCandidates?.[session.employeeCandidateIndex ?? 0];
-        const sdkRequested = employeeAgent?.engine === "sdk";
+        const decidedEngine = session.structuredState?.engine;
+        const sdkRequested = decidedEngine ? decidedEngine === "core" : employeeAgent?.engine === "sdk";
         let resolution;
         if (sdkRequested) {
             try {
@@ -2157,7 +2196,7 @@ export class StructuredSessionManager {
             || patch.codemodeOverride !== undefined
             || patch.autoResources !== undefined
             || patch.lockedSkills !== undefined)) {
-            throw new Error("当前 SDK 候选尚不支持此会话级设置；没有改用全局资源或 CodeMode 配置。");
+            throw new Error("Wand Agent 尚不支持此会话级设置；没有改用全局资源或 CodeMode 配置。");
         }
         if (resolution.engine !== "core") {
             // 写入裁决与启动参数用同一套能力边界：表达不出的字段/取值不落库。

package/dist/terminal-daemon-build.d.ts

@@ -0,0 +1,4 @@
+/** Captured at process start: replacing files cannot make an old owner current. */
+export declare const TERMINAL_DAEMON_BUILD_ID: string;
+/** Pause replacement while npm is changing this installation or awaiting Server relaunch. */
+export declare function terminalDaemonBuildIsCurrent(): boolean;

package/dist/terminal-daemon-build.js

@@ -0,0 +1,54 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+/** Component content, not the Wand release version or timestamp. The runtime
+ * import graph is covered by tests/terminal-daemon-build.test.ts. */
+function daemonBuildId() {
+    const extension = import.meta.url.endsWith(".ts") ? "ts" : "js";
+    const hash = createHash("sha256");
+    hash.update(JSON.stringify([process.versions.node, process.platform, process.arch]));
+    for (const name of ["terminal-daemon-server", "terminal-daemon-protocol", "terminal-daemon-build", "terminal-host",
+        "structured-exec-host", "pty-terminal-state", "pty-shell-launch", "unix-socket-keepalive",
+        "ensure-node-pty-helper", "signal-utils", "pty-text-utils", "shell-quote", "error-utils", "render-protocol"]) {
+        hash.update(name).update("\0").update(readFileSync(new URL(`./${name}.${extension}`, import.meta.url)));
+    }
+    // Read installed versions afresh, not require()'s cached JSON. Unrelated
+    // Server/UI dependencies and package metadata must not replace terminald.
+    for (const name of ["node-pty", "@xterm/headless", "@xterm/addon-serialize", "@xterm/addon-unicode11"]) {
+        const { version } = JSON.parse(readFileSync(require.resolve(`${name}/package.json`), "utf8"));
+        if (typeof version !== "string" || !version)
+            throw new Error(`Missing daemon dependency version: ${name}`);
+        hash.update(name).update("\0").update(version);
+    }
+    return hash.digest("hex");
+}
+/** Captured at process start: replacing files cannot make an old owner current. */
+export const TERMINAL_DAEMON_BUILD_ID = daemonBuildId();
+// The installation fence has a different purpose from component equality:
+// even a Server-only install must pause the old worker until Server relaunch.
+function installationId(buildId) {
+    const hash = createHash("sha256").update(buildId);
+    for (const file of ["./build-info.json", "../package.json"]) {
+        hash.update(file).update("\0");
+        try {
+            hash.update(readFileSync(new URL(file, import.meta.url)));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            hash.update("missing"); // source checkouts have no build stamp
+        }
+    }
+    return hash.digest("hex");
+}
+const INSTALLATION_ID = installationId(TERMINAL_DAEMON_BUILD_ID);
+/** Pause replacement while npm is changing this installation or awaiting Server relaunch. */
+export function terminalDaemonBuildIsCurrent() {
+    try {
+        return installationId(daemonBuildId()) === INSTALLATION_ID;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/terminal-daemon-protocol.d.ts

@@ -10,7 +10,7 @@ export type TerminalDaemonRequest = {
     id: number;
     token: string;
     protocolVersion: number;
-    method: "hello" | "list" | "createOrAttach" | "write" | "resize" | "kill" | "forget" | "structuredSpawn" | "structuredAttach" | "structuredList" | "structuredKill" | "structuredForget";
+    method: "hello" | "list" | "createOrAttach" | "write" | "resize" | "kill" | "forget" | "structuredSpawn" | "structuredAttach" | "structuredList" | "structuredKill" | "structuredForget" | "shutdownIfIdle";
     params?: Record<string, unknown>;
 };
 export type TerminalDaemonResponse = {

package/dist/terminal-daemon-server.js

@@ -6,6 +6,7 @@ import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import pty from "node-pty";
 import { keepUnixSocketAlive } from "./unix-socket-keepalive.js";
+import { TERMINAL_DAEMON_BUILD_ID } from "./terminal-daemon-build.js";
 import { ensureNodePtyHelperExecutable } from "./ensure-node-pty-helper.js";
 import { signalNumberFromName } from "./signal-utils.js";
 import { STRUCTURED_RUN_LOG_MAX_CHARS, createUtf8TextDecoder, } from "./structured-exec-host.js";
@@ -81,6 +82,7 @@ export async function runTerminalDaemon(configPath) {
     const sessions = new Map();
     const clients = new Set();
     const structuredRuns = new Map();
+    let retiring = false;
     const send = (socket, message) => {
         if (!socket.destroyed && socket.writable)
             socket.write(`${JSON.stringify(message)}\n`);
@@ -356,12 +358,25 @@ export async function runTerminalDaemon(configPath) {
             const params = request.params ?? {};
             switch (request.method) {
                 case "hello":
-                    result = { protocolVersion: TERMINAL_DAEMON_PROTOCOL_VERSION, pid: process.pid };
+                    result = { protocolVersion: TERMINAL_DAEMON_PROTOCOL_VERSION, pid: process.pid,
+                        buildId: TERMINAL_DAEMON_BUILD_ID, shutdownIfIdle: true };
                     break;
+                case "shutdownIfIdle": {
+                    const busy = [...sessions.values(), ...structuredRuns.values()].some((entry) => entry.status === "running");
+                    result = { accepted: !busy };
+                    if (!busy && !retiring) {
+                        // The idle check and admission closure happen in the same event-loop turn.
+                        retiring = true;
+                        setTimeout(shutdown, 25).unref();
+                    }
+                    break;
+                }
                 case "list":
                     result = Array.from(sessions.values(), serialize);
                     break;
                 case "createOrAttach":
+                    if (retiring)
+                        throw new Error("Terminal daemon is updating");
                     result = createOrAttach(params);
                     break;
                 case "write": {
@@ -399,6 +414,8 @@ export async function runTerminalDaemon(configPath) {
                     result = { ok: true };
                     break;
                 case "structuredSpawn":
+                    if (retiring)
+                        throw new Error("Terminal daemon is updating");
                     result = structuredSpawn(params);
                     break;
                 case "structuredAttach": {
@@ -425,6 +442,8 @@ export async function runTerminalDaemon(configPath) {
                     structuredForget(String(params.runId ?? ""));
                     result = { ok: true };
                     break;
+                default:
+                    throw new Error("Unsupported terminal daemon method");
             }
             send(client.socket, { kind: "response", id: request.id, ok: true, result });
         }

package/dist/terminal-host.d.ts

@@ -68,6 +68,8 @@ export interface TerminalHost {
     attach(sessionId: string, afterSeq?: number): TerminalAttachResult | null;
     createOrAttach(request: TerminalSpawnRequest, afterSeq?: number): Promise<TerminalAttachResult>;
     forget(sessionId: string): void;
+    /** Publish already-read bytes before synchronous snapshots or owner teardown. */
+    flush?(): void;
     disconnect(): void;
 }
 /** Legacy/local adapter and deterministic test adapter for the TerminalHost seam. */
@@ -81,3 +83,5 @@ export declare class InProcessTerminalHost implements TerminalHost {
 }
 /** Keep a bounded replay log while preserving chunk sequence numbers. */
 export declare function appendTerminalChunkWindow(chunks: readonly TerminalDataEvent[], event: TerminalDataEvent): TerminalDataEvent[];
+/** Same replay window, computed once for a batch instead of per wire frame. */
+export declare function appendTerminalChunkBatch(chunks: readonly TerminalDataEvent[], events: readonly TerminalDataEvent[]): TerminalDataEvent[];

package/dist/terminal-host.js

@@ -103,10 +103,13 @@ function emptyRunningState(process, cols, rows, launchMarkerToken) {
 }
 /** Keep a bounded replay log while preserving chunk sequence numbers. */
 export function appendTerminalChunkWindow(chunks, event) {
-    const boundedEvent = event.data.length > PTY_OUTPUT_MAX_SIZE
-        ? { ...event, data: event.data.slice(-PTY_OUTPUT_MAX_SIZE) }
-        : event;
-    const next = [...chunks, boundedEvent];
+    return appendTerminalChunkBatch(chunks, [event]);
+}
+/** Same replay window, computed once for a batch instead of per wire frame. */
+export function appendTerminalChunkBatch(chunks, events) {
+    const next = [...chunks, ...events.map((event) => event.data.length > PTY_OUTPUT_MAX_SIZE
+            ? { ...event, data: event.data.slice(-PTY_OUTPUT_MAX_SIZE) }
+            : event)];
     let size = 0;
     let first = next.length;
     while (first > 0) {

package/dist/tui/commands.js

@@ -783,7 +783,7 @@ function staleDaemonNote(configPath) {
     if (daemonVersion && compareSemver(daemonVersion, binaryVersion) >= 0)
         return null;
     const shown = daemonVersion ? `Render ${daemonVersion}` : "Render daemon";
-    return `；但 ${shown} 仍在跑（装好的二进制是 ${binaryVersion}），它要重启才会用上新代码：./start.sh --restart-daemons`;
+    return `；底层组件将在所有会话结束后自动更新（${shown} → ${binaryVersion}）。等待期间部分功能可能暂时异常，无需操作`;
 }
 /** daemon 端点状态摘要，给服务命令的 detail 用。 */
 function describeDaemonEndpoints(configPath) {

package/dist/types.d.ts

@@ -144,6 +144,11 @@ export interface WandConfig {
     defaultProvider?: SessionProvider;
     /** 新建会话时默认使用的承载类型。 */
     defaultSessionKind?: SessionKind;
+    /**
+     * 新建会话时默认的执行引擎；只对支持多引擎的 provider 有意义（目前只有 pi）：
+     * `cli` = Pi CLI，`sdk` = Wand Agent（进程内 SDK）。缺省视为 CLI。
+     */
+    defaultEngine?: "cli" | "sdk";
     /** 新建任务时是否默认开启独立 worktree。 */
     defaultTaskWorktree?: boolean;
     defaultMode: ExecutionMode;
@@ -615,6 +620,8 @@ export interface ConversationAuthor {
     avatar?: string;
     leader?: boolean;
     provider?: SessionProvider;
+    /** 本条发言实际候选的执行引擎；历史缺省仍按 CLI 显示。 */
+    engine?: "cli" | "sdk";
     /**
      * 这条发言**实际使用候选**的模型 id（真值，不是展示文案；`"default"` 表示跟随该 provider
      * 的服务端默认模型）。老数据没有这个字段，读端要能只按 provider 显示。
@@ -761,10 +768,15 @@ export interface SessionSnapshot extends SessionCompletionState {
     /**
      * PTY 会话本轮是否正在生成回复（provider CLI busy）。语义对齐 structured 的
      * structuredState.inFlight：turn 开始置 true，回复结束/进程退出清 false。
-     * 运行时信号，不持久化，服务重启后视为 false。目前仅 Claude PTY（bridge）能精确判定；
-     * 其余 provider 不产生该信号（undefined），客户端应回落到旧行为。
+     * 运行时信号，不持久化；Claude 使用 bridge，其余 provider 使用前台资格与输出静默窗口。
      */
     ptyBusy?: boolean;
+    /**
+     * 空白 PTY 中有前台命令（如手动启动 CLI / 构建），由内核前台进程组采样得出。
+     * 与 provider 回合无关，不产生成功完成回执或回合计时；无输出也可为 true。
+     * 仅运行时，不持久化；未探测、不支持的平台、提示符与已结束终端均为 false。
+     */
+    ptyCommandRunning?: boolean;
     /**
      * PTY 本轮的时间锚点，语义与 structuredState.turnStartedAt / lastActivityAt 完全一致，
      * 是 ptyBusy 的配套读数：turn 开始（或静默窗口被输出续期）时写入，ptyBusy 清 false

package/dist/web-ui/chat-history-window.d.ts

@@ -0,0 +1,23 @@
+/** Small transport pages; the browser fills them to a measured viewport buffer. */
+export declare const CHAT_INITIAL_MESSAGE_COUNT = 8;
+export declare const CHAT_HISTORY_BLOCK_BUDGET = 12;
+export declare const CHAT_HISTORY_BYTE_BUDGET: number;
+export declare const CHAT_HISTORY_BUFFER_SCREENS = 2;
+export interface ChatScrollGeometry {
+    scrollHeight: number;
+    clientHeight: number;
+    scrollTop: number;
+}
+/** The chat scroller is column-reverse (latest at scrollTop=0). */
+export declare function chatHistoryBufferRemaining(geometry: ChatScrollGeometry): number;
+export declare function needsChatHistoryBuffer(geometry: ChatScrollGeometry): boolean;
+export declare function chatHistoryRootMargin(height: number): string;
+/** One attempt per cursor until progress or an explicit retry. Height decides
+ * how much to prefetch, never whether a successful page made progress:
+ * scrollHeight stays at clientHeight while the screen is underfilled, and
+ * folded tool pages may add no visible height at all. */
+export declare class ChatHistoryPrefetchGate {
+    private attempt;
+    canAttempt(scope: string, cursor: string, manual?: boolean): boolean;
+    attempted(scope: string, cursor: string): void;
+}

package/dist/web-ui/chat-history-window.js

@@ -0,0 +1,29 @@
+/** Small transport pages; the browser fills them to a measured viewport buffer. */
+export const CHAT_INITIAL_MESSAGE_COUNT = 8;
+export const CHAT_HISTORY_BLOCK_BUDGET = 12;
+export const CHAT_HISTORY_BYTE_BUDGET = 96 * 1024;
+export const CHAT_HISTORY_BUFFER_SCREENS = 2;
+/** The chat scroller is column-reverse (latest at scrollTop=0). */
+export function chatHistoryBufferRemaining(geometry) {
+    return Math.max(0, geometry.scrollHeight - geometry.clientHeight - Math.abs(geometry.scrollTop));
+}
+export function needsChatHistoryBuffer(geometry) {
+    return geometry.clientHeight > 0
+        && chatHistoryBufferRemaining(geometry) < geometry.clientHeight * CHAT_HISTORY_BUFFER_SCREENS;
+}
+export function chatHistoryRootMargin(height) {
+    return `${Math.max(0, Math.ceil(height * CHAT_HISTORY_BUFFER_SCREENS))}px 0px 0px 0px`;
+}
+/** One attempt per cursor until progress or an explicit retry. Height decides
+ * how much to prefetch, never whether a successful page made progress:
+ * scrollHeight stays at clientHeight while the screen is underfilled, and
+ * folded tool pages may add no visible height at all. */
+export class ChatHistoryPrefetchGate {
+    attempt = "";
+    canAttempt(scope, cursor, manual = false) {
+        return manual || this.attempt !== `${scope}\0${cursor}`;
+    }
+    attempted(scope, cursor) {
+        this.attempt = `${scope}\0${cursor}`;
+    }
+}