@co0ontty/wand 4.73.0 → 4.75.1-beta.gbf7dafd

package/dist/native/darwin-x64/wand-render.sha256

@@ -1 +1 @@
-783bd070dad27f2ec879ed5853f813f7ffdb3914d719d3ed947ec86af12a7b88  wand-render
+1481b8f4688e5d0bfa2e6c1e4b41da288820fcfb43a737b027401e55334bedaf  wand-render

package/dist/native/darwin-x64/wand-render.version

@@ -1 +1 @@
-0.1.1
+0.1.3

package/dist/native/darwin-x64/wand-structured-renderd.sha256

@@ -0,0 +1 @@
+f67206b4d171f26172787e8184e684d61170c30646ab7d72a1f4232b737b4738  wand-structured-renderd

package/dist/native/darwin-x64/wand-structured-renderd.version

@@ -0,0 +1 @@
+0.1.3

package/dist/native/linux-arm64/wand-render.sha256

@@ -1 +1 @@
-7acb6e92e8f049ac87d8159905115dabe5f9a33f9d310e3c98f38b798c4302e5  wand-render
+e51aee7fde515b0356c1a6919b66812ae4ff679f693847f61e816166e99d8805  wand-render

package/dist/native/linux-arm64/wand-render.version

@@ -1 +1 @@
-0.1.1
+0.1.3

package/dist/native/linux-arm64/wand-structured-renderd.sha256

@@ -0,0 +1 @@
+af342aa8e7dcde0ce2563629921c9080131ed666ba743901ecfa22c31f04bb98  wand-structured-renderd

package/dist/native/linux-arm64/wand-structured-renderd.version

@@ -0,0 +1 @@
+0.1.3

package/dist/native/linux-x64/wand-render.sha256

@@ -1 +1 @@
-7814590a02ae2606fedc395ee1708921aec3b16332edb46fa2369e43e9a589f5  wand-render
+27c00887d03a24867f120a67852e5d0666cf7ddae18c3d708cbcca9c45a82427  wand-render

package/dist/native/linux-x64/wand-render.version

@@ -1 +1 @@
-0.1.1
+0.1.3

package/dist/native/linux-x64/wand-structured-renderd.sha256

@@ -0,0 +1 @@
+52e1ec6dc79695c6af248b4b3bce160b3fb7be2c5f786172c78e13685c89ce39  wand-structured-renderd

package/dist/native/linux-x64/wand-structured-renderd.version

@@ -0,0 +1 @@
+0.1.3

package/dist/process-manager.d.ts

@@ -2,7 +2,7 @@ import { EventEmitter } from "node:events";
 import { WandStorage } from "./storage.js";
 import { ExecutionMode, ProcessEventHandler, SessionProvider, SessionSnapshot, SessionSource, WandConfig } from "./types.js";
 import { type PermissionResolution } from "./claude-pty-bridge.js";
-import { type PtyTerminalSnapshot } from "./pty-terminal-state.js";
+import { type PtyTerminalSnapshot, type PtyHistoryPage } from "./pty-terminal-state.js";
 import { type TerminalHost } from "./terminal-host.js";
 import { type ClaudeHistorySession, type CodexHistorySession, type OpenCodeHistorySession, type QoderHistorySession } from "./provider-history-scanner.js";
 export type { ClaudeHistorySession, CodexHistorySession, OpenCodeHistorySession, QoderHistorySession, } from "./provider-history-scanner.js";
@@ -119,6 +119,7 @@ export declare class ProcessManager extends EventEmitter {
     private trackPtyInput;
     resize(id: string, cols: number, rows: number): SessionSnapshot;
     getTerminalState(id: string): PtyTerminalSnapshot | null;
+    getTerminalHistoryPage(id: string, before: number, revision: number): Promise<PtyHistoryPage | null>;
     /**
      * Finalize provider-only state while leaving the owning PTY shell alive. The
      * session itself remains running so terminal input can continue normally.

package/dist/process-manager.js

@@ -13,7 +13,7 @@ import { buildChildEnv, isRunningAsRoot } from "./env-utils.js";
 import { buildLanguageDirective, buildManagedAutonomyDirective } from "./language-prompt.js";
 import { prepareSessionWorktree } from "./git-worktree.js";
 import { getProviderCommandSessionId, getProviderResumeCommandSessionId } from "./resume-policy.js";
-import { normalizeThinkingEffort, thinkingEffortToClaudeCliEffort, thinkingEffortToClaudeSlashEffort, thinkingEffortToCodexReasoningEffort, thinkingEffortToOpenCodeVariant, thinkingEffortToPiLevel } from "./structured-provider-common.js";
+import { normalizeThinkingEffort, thinkingEffortToClaudeCliEffort, thinkingEffortToClaudeSlashEffort, thinkingEffortToCodexReasoningEffort, thinkingEffortToGrokEffort, thinkingEffortToPiLevel, thinkingEffortToQoderEffort } from "./structured-provider-common.js";
 import { consumePtyInputForTopic, createPtyTopicLineBuffer, provisionalSessionTopic, SessionTopicCoordinator, sessionTopicBlocklistForSnapshot, shouldAcceptGeneratedSessionTitle, shouldGenerateSessionTopicFromInput, } from "./session-topic.js";
 import { getErrorMessage } from "./error-utils.js";
 import { recordIterationPrompt } from "./iteration-log.js";
@@ -1461,7 +1461,7 @@ export class ProcessManager extends EventEmitter {
         return result;
     }
     getPtyTranscript(id) {
-        return this.logger.readPtyOutput(id);
+        return this.logger.readPtyOutputTail(id);
     }
     /**
      * Set the Claude model for an existing PTY session. Persists the selection
@@ -1622,6 +1622,14 @@ export class ProcessManager extends EventEmitter {
         }
         return record.terminalState.snapshot();
     }
+    async getTerminalHistoryPage(id, before, revision) {
+        const record = this.sessions.get(id);
+        if (!record)
+            return null;
+        if (!record.terminalState)
+            this.getTerminalState(id);
+        return record.terminalState?.historyPage(before, revision) ?? null;
+    }
     /**
      * Finalize provider-only state while leaving the owning PTY shell alive. The
      * session itself remains running so terminal input can continue normally.
@@ -2474,7 +2482,7 @@ export class ProcessManager extends EventEmitter {
             if (trimmedModel && trimmedModel !== "default" && !/--model(?:\s|=)/.test(result) && !/(?:^|\s)-m(?:\s|$)/.test(result)) {
                 result += ` --model '${trimmedModel.replace(/'/g, "'\\''")}'`;
             }
-            const effort = thinkingEffortToOpenCodeVariant(thinkingEffort ?? null);
+            const effort = thinkingEffortToGrokEffort(thinkingEffort ?? null);
             if (effort && !/--(?:reasoning-)?effort(?:\s|=)/.test(result)) {
                 result += ` --effort '${effort.replace(/'/g, "'\\''")}'`;
             }
@@ -2494,6 +2502,10 @@ export class ProcessManager extends EventEmitter {
             if (!/--(?:yolo|dangerously-skip-permissions|permission-mode)(?:\s|=|$)/.test(result)) {
                 result += " --permission-mode bypass_permissions";
             }
+            const qoderEffort = thinkingEffortToQoderEffort(thinkingEffort ?? null);
+            if (qoderEffort && !/--reasoning-effort(?:\s|=)/.test(result)) {
+                result += ` --reasoning-effort '${qoderEffort.replace(/'/g, "'\\''")}'`;
+            }
             return result;
         }
         if (provider === "pi") {

package/dist/pty-terminal-state.d.ts

@@ -12,7 +12,19 @@ export interface PtyTerminalSnapshot {
     cols: number;
     rows: number;
     pending: PtyTerminalOperation[];
+    /** Web scrollback cursor, absent from the Render wire protocol. */
+    historyBefore?: number;
+    historyRevision?: number;
 }
+export interface PtyHistoryPage {
+    data: string;
+    separator: string;
+    start: number;
+    before: number;
+    revision: number;
+}
+export declare const PTY_INITIAL_HISTORY_ROWS = 80;
+export declare const PTY_HISTORY_PAGE_ROWS = 80;
 /**
  * Server-side xterm screen model used only for reconnect snapshots. Live PTY
  * bytes still travel unchanged from node-pty to the browser terminal.
@@ -31,11 +43,16 @@ export declare class PtyTerminalState {
     private committedData;
     private committedCols;
     private committedRows;
+    private committedHistoryBefore;
+    private committedRevision;
+    private revision;
     private disposed;
     constructor(cols: number, rows: number, initialData?: string);
     write(data: string): void;
     resize(cols: number, rows: number): void;
     snapshot(): PtyTerminalSnapshot;
+    /** A bounded ANSI range preceding the committed baseline, never a cumulative snapshot. */
+    historyPage(before: number, revision: number, limit?: number): Promise<PtyHistoryPage | null>;
     dispose(): void;
     private addPending;
     private scheduleFlush;

package/dist/pty-terminal-state.js

@@ -2,6 +2,10 @@ import headless from "@xterm/headless";
 import { SerializeAddon } from "@xterm/addon-serialize";
 import { Unicode11Addon } from "@xterm/addon-unicode11";
 const { Terminal } = headless;
+export const PTY_INITIAL_HISTORY_ROWS = 80;
+const PTY_INITIAL_HISTORY_MAX_BYTES = 256 * 1024;
+export const PTY_HISTORY_PAGE_ROWS = 80;
+const PTY_HISTORY_PAGE_MAX_BYTES = 192 * 1024;
 /**
  * Incoming PTY chunks are coalesced into one xterm write per flush. xterm's
  * write callback costs a timer turn per call, so one write per node-pty chunk
@@ -63,6 +67,9 @@ export class PtyTerminalState {
     committedData = "";
     committedCols;
     committedRows;
+    committedHistoryBefore = 0;
+    committedRevision = 0;
+    revision = 0;
     disposed = false;
     constructor(cols, rows, initialData = "") {
         this.committedCols = cols;
@@ -77,6 +84,7 @@ export class PtyTerminalState {
     write(data) {
         if (this.disposed || !data)
             return;
+        this.revision++;
         this.buffered += data;
         if (this.buffered.length >= WRITE_BATCH_MAX_CHARS)
             this.flushBuffered();
@@ -86,6 +94,7 @@ export class PtyTerminalState {
     resize(cols, rows) {
         if (this.disposed)
             return;
+        this.revision++;
         // Bytes that arrived before the resize must land before it.
         this.flushBuffered();
         this.addPending({ type: "resize", cols, rows });
@@ -105,6 +114,37 @@ export class PtyTerminalState {
             cols: this.committedCols,
             rows: this.committedRows,
             pending: coalesceOperations(this.pending),
+            historyBefore: this.committedHistoryBefore,
+            historyRevision: this.committedRevision,
+        };
+    }
+    /** A bounded ANSI range preceding the committed baseline, never a cumulative snapshot. */
+    async historyPage(before, revision, limit = PTY_HISTORY_PAGE_ROWS) {
+        if (this.disposed || !Number.isSafeInteger(before) || !Number.isSafeInteger(revision)
+            || !Number.isSafeInteger(limit) || limit < 1 || limit > PTY_HISTORY_PAGE_ROWS)
+            return null;
+        // Wait for buffered writes/checkpoints. If output or resize changed the row indices,
+        // the caller must resync rather than concatenate unrelated lines.
+        await this.tail;
+        if (this.revision !== revision || before > this.committedHistoryBefore || before <= 0)
+            return null;
+        const count = Math.min(before, limit);
+        let start = before - count;
+        let data = "";
+        while (start < before) {
+            data = this.serializer.serialize({ range: { start, end: before - 1 } });
+            if (Buffer.byteLength(data, "utf8") <= PTY_HISTORY_PAGE_MAX_BYTES)
+                break;
+            if (start === before - 1)
+                return null;
+            start = Math.min(before - 1, start + Math.max(1, Math.ceil((before - start) / 2)));
+        }
+        return {
+            data,
+            separator: this.terminal.buffer.normal.getLine(before)?.isWrapped ? "" : "\r\n",
+            start,
+            before,
+            revision,
         };
     }
     dispose() {
@@ -186,14 +226,24 @@ export class PtyTerminalState {
         const cutoff = this.pending.at(-1)?.id ?? 0;
         if (!cutoff)
             return;
+        const revision = this.revision;
         this.checkpointQueued = true;
         this.tail = this.tail.then(() => {
             if (this.disposed)
                 return;
             try {
-                this.committedData = this.serializer.serialize({ scrollback: 5000 });
+                let historyRows = PTY_INITIAL_HISTORY_ROWS;
+                this.committedData = this.serializer.serialize({ scrollback: historyRows });
+                while (historyRows > 0 && Buffer.byteLength(this.committedData) > PTY_INITIAL_HISTORY_MAX_BYTES) {
+                    historyRows = Math.floor(historyRows / 2);
+                    this.committedData = this.serializer.serialize({ scrollback: historyRows });
+                }
                 this.committedCols = this.terminal.cols;
                 this.committedRows = this.terminal.rows;
+                this.committedHistoryBefore = Math.max(0, this.terminal.buffer.normal.baseY - historyRows);
+                // A newer write can arrive while the queued checkpoint drains. Only the
+                // operations through cutoff are represented by this baseline.
+                this.committedRevision = revision;
                 this.pending = this.pending.filter((entry) => entry.id > cutoff);
             }
             catch {

package/dist/render-daemon-client.d.ts

@@ -10,6 +10,15 @@ import { type TerminalAttachResult, type TerminalHost, type TerminalSessionState
 export declare class RenderAuthError extends Error {
     constructor(message: string);
 }
+/**
+ * 远端 PTY 句柄。Render 可能在这个对象挂上 listener 之前就推来 data/exit
+ * （大输出场景几乎必然发生），所以先做有界缓存，挂上后按序补发。
+ */
+/**
+ * 运行时自愈回调：把「端点已消失、且 config 上没有活着的 daemon」的 Render 重新拉起来。
+ * 返回 true 表示起了新进程（调用方应立刻重连）。
+ */
+export type RenderDaemonReviver = () => Promise<boolean>;
 /**
  * Render（常驻 PTY 持有者）的 Node 客户端。
  *
@@ -28,6 +37,11 @@ export declare class RenderDaemonClient implements TerminalHost {
     private readonly tokenPath;
     /** Persisted PTY IDs used only if v1 `list` exceeds its aggregate frame limit. */
     private readonly knownSessionIds;
+    /**
+     * 运行时自愈回调：重连失败时问它能不能把 daemon 拉回来（返回 true = 起了新进程）。
+     * 只有「端点已消失 + config 上没有活着的 daemon」时它才动手，见 `render-host.ts`。
+     */
+    private readonly reviveDaemon;
     readonly persistent = true;
     private socket;
     private nextRequestId;
@@ -71,8 +85,21 @@ export declare class RenderDaemonClient implements TerminalHost {
      */
     tokenPath?: string | null, 
     /** Persisted PTY IDs used only if v1 `list` exceeds its aggregate frame limit. */
-    knownSessionIds?: readonly string[]);
+    knownSessionIds?: readonly string[], 
+    /**
+     * 运行时自愈回调：重连失败时问它能不能把 daemon 拉回来（返回 true = 起了新进程）。
+     * 只有「端点已消失 + config 上没有活着的 daemon」时它才动手，见 `render-host.ts`。
+     */
+    reviveDaemon?: RenderDaemonReviver | null);
     get version(): string;
+    /** daemon 侧已知的会话数（`inventory` 是 `list`/`attach` 的权威投影）。 */
+    get sessionCount(): number;
+    /**
+     * 让 daemon 干净收摊（`shutdown mode=now`：杀掉所有 PTY 后退出）。
+     * **只允许用在「daemon 空闲」的升级场景**（sessionCount === 0）；持有活会话时
+     * 调用它会杀掉用户的 shell。
+     */
+    requestShutdownNow(): Promise<void>;
     connect(): Promise<void>;
     private open;
     /**
@@ -137,6 +164,10 @@ export declare class RenderDaemonClient implements TerminalHost {
      */
     private scheduleReconnect;
     private tryReconnect;
+    private noteReconnectSuccess;
+    /** 自愈回调本身绝不能让重连路径抛错；失败按「没拉起」处理。 */
+    private reviveDaemonForRetry;
+    private noteReconnectFailureAndSchedule;
     /**
      * 重连失败的日志与「同一把废 token」判定。
      *
@@ -168,4 +199,4 @@ export declare function normalizeRenderSessionState(value: unknown): TerminalSes
  * 连接一个已经存在的 Render（socket + token 都在）。**不 spawn**，找不到就返回 null，
  * 这样调用方可以区分「已被别处 adopt」和「需要自己拉起」。
  */
-export declare function connectExistingRenderClient(configPath: string, knownSessionIds?: readonly string[]): Promise<RenderDaemonClient | null>;
+export declare function connectExistingRenderClient(configPath: string, knownSessionIds?: readonly string[], reviveDaemon?: RenderDaemonReviver | null): Promise<RenderDaemonClient | null>;

package/dist/render-daemon-client.js

@@ -32,10 +32,6 @@ export class RenderAuthError extends Error {
         this.name = "RenderAuthError";
     }
 }
-/**
- * 远端 PTY 句柄。Render 可能在这个对象挂上 listener 之前就推来 data/exit
- * （大输出场景几乎必然发生），所以先做有界缓存，挂上后按序补发。
- */
 class RemoteRenderProcess {
     sessionId;
     incarnationId;
@@ -149,6 +145,7 @@ export class RenderDaemonClient {
     token;
     tokenPath;
     knownSessionIds;
+    reviveDaemon;
     persistent = true;
     socket = null;
     nextRequestId = 1;
@@ -193,16 +190,34 @@ export class RenderDaemonClient {
      */
     tokenPath = null, 
     /** Persisted PTY IDs used only if v1 `list` exceeds its aggregate frame limit. */
-    knownSessionIds = []) {
+    knownSessionIds = [], 
+    /**
+     * 运行时自愈回调：重连失败时问它能不能把 daemon 拉回来（返回 true = 起了新进程）。
+     * 只有「端点已消失 + config 上没有活着的 daemon」时它才动手，见 `render-host.ts`。
+     */
+    reviveDaemon = null) {
         this.socketPath = socketPath;
         this.token = token;
         this.tokenPath = tokenPath;
         this.knownSessionIds = knownSessionIds;
+        this.reviveDaemon = reviveDaemon;
         this.lastKnownToken = token;
     }
     get version() {
         return this.daemonVersion;
     }
+    /** daemon 侧已知的会话数（`inventory` 是 `list`/`attach` 的权威投影）。 */
+    get sessionCount() {
+        return this.inventory.size;
+    }
+    /**
+     * 让 daemon 干净收摊（`shutdown mode=now`：杀掉所有 PTY 后退出）。
+     * **只允许用在「daemon 空闲」的升级场景**（sessionCount === 0）；持有活会话时
+     * 调用它会杀掉用户的 shell。
+     */
+    async requestShutdownNow() {
+        await this.request("shutdown", { mode: "now" });
+    }
     connect() {
         if (this.disposed)
             return Promise.reject(new Error("Render client disposed"));
@@ -789,22 +804,57 @@ export class RenderDaemonClient {
             return;
         try {
             await this.connect();
-            this.reconnectDelayMs = RECONNECT_INITIAL_MS;
-            this.reconnectFailureLogged = false;
-            this.authBackoff = false;
+            this.noteReconnectSuccess();
+            return;
         }
         catch (error) {
             if (this.disposed)
                 return;
-            const stalled = this.noteReconnectFailure(error);
-            if (stalled && this.reconnectTimer) {
-                // 断线路径已经按普通退避排过一次；用 60s 的长退避覆盖它。
-                clearTimeout(this.reconnectTimer);
-                this.reconnectTimer = null;
+            // 端点本身没了（socket 文件被临时目录清理器删掉，或 daemon 崩了没留下 socket）：
+            // 重试同一个路径永远不会成功，先把 daemon 拉回来再连一次。只要 pid 文件里还有
+            // 活进程，回调就不会动手 —— 那个 daemon 会自己重建端点（docs/render-protocol.md §6）。
+            if (await this.reviveDaemonForRetry()) {
+                try {
+                    await this.connect();
+                    this.noteReconnectSuccess();
+                    return;
+                }
+                catch (retryError) {
+                    this.noteReconnectFailureAndSchedule(retryError);
+                    return;
+                }
             }
-            this.scheduleReconnect();
+            this.noteReconnectFailureAndSchedule(error);
         }
     }
+    noteReconnectSuccess() {
+        this.reconnectDelayMs = RECONNECT_INITIAL_MS;
+        this.reconnectFailureLogged = false;
+        this.authBackoff = false;
+    }
+    /** 自愈回调本身绝不能让重连路径抛错；失败按「没拉起」处理。 */
+    async reviveDaemonForRetry() {
+        if (!this.reviveDaemon)
+            return false;
+        try {
+            return await this.reviveDaemon();
+        }
+        catch (error) {
+            process.stderr.write(`[wand] Render daemon revival failed: ${getErrorMessage(error)}\n`);
+            return false;
+        }
+    }
+    noteReconnectFailureAndSchedule(error) {
+        if (this.disposed)
+            return;
+        const stalled = this.noteReconnectFailure(error);
+        if (stalled && this.reconnectTimer) {
+            // 断线路径已经按普通退避排过一次；用 60s 的长退避覆盖它。
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.scheduleReconnect();
+    }
     /**
      * 重连失败的日志与「同一把废 token」判定。
      *
@@ -1087,7 +1137,7 @@ function asNumber(value, fallback, problems, label) {
  * 连接一个已经存在的 Render（socket + token 都在）。**不 spawn**，找不到就返回 null，
  * 这样调用方可以区分「已被别处 adopt」和「需要自己拉起」。
  */
-export async function connectExistingRenderClient(configPath, knownSessionIds = []) {
+export async function connectExistingRenderClient(configPath, knownSessionIds = [], reviveDaemon = null) {
     const { socketPath, tokenPath } = renderPaths(configPath);
     let token;
     try {
@@ -1099,7 +1149,7 @@ export async function connectExistingRenderClient(configPath, knownSessionIds =
     if (!token)
         return null;
     // 传 tokenPath 让重连路径在 daemon 轮换 token 后能自愈（见构造函数注释）。
-    const client = new RenderDaemonClient(socketPath, token, tokenPath, knownSessionIds);
+    const client = new RenderDaemonClient(socketPath, token, tokenPath, knownSessionIds, reviveDaemon);
     try {
         await client.connect();
         return client;

package/dist/render-host.d.ts

@@ -1,4 +1,4 @@
-import { type RenderDaemonClient } from "./render-daemon-client.js";
+import { type RenderDaemonClient, type RenderDaemonReviver } from "./render-daemon-client.js";
 import { TerminalDaemonClient } from "./terminal-daemon-client.js";
 import { type TerminalAttachResult, type TerminalHost, type TerminalSpawnRequest } from "./terminal-host.js";
 import type { RenderEngine } from "./types.js";
@@ -10,6 +10,18 @@ export interface RenderHostOptions {
     /** DB 中仍在运行的 PTY，用于旧版 Render 的超大 list 失败时逐个 attach。 */
     knownSessionIds?: readonly string[];
 }
+/**
+ * 运行时自愈：没有活着的 owner、且端点不可用时，起一个 detached Render。
+ * 返回 true 表示起了新进程（调用方应立刻重连）。
+ *
+ * 覆盖两种「重试永远不会好」的形状（都是同一个后果：终端一直断、只能重启整个服务）：
+ * - daemon 没了，socket 文件也被清掉（临时目录清理器，线上真发生过）；
+ * - daemon 被 kill -9 / 崩溃，socket 文件作为陈留文件留了下来（没有监听者）。
+ *
+ * 保守之处：pid 文件里还有活进程就不插手（那个 daemon 会自己重建端点，
+ * docs/render-protocol.md §6 single instance）；能连上监听者也不插手；同一个窗口只 spawn 一次。
+ */
+export declare function createRenderDaemonReviver(configPath: string, binaryPath: string | null): RenderDaemonReviver;
 export interface UpgradeAwareTerminalHost {
     host: TerminalHost;
     renderHost: TerminalHost | null;
@@ -60,5 +72,17 @@ export declare function createRenderTerminalHost(configPath: string, options?: {
     binaryPath?: string;
     knownSessionIds?: readonly string[];
 }): Promise<RenderDaemonClient>;
-/** detached spawn（stdio 忽略、unref），并等 socket + token 就绪。 */
-export declare function spawnDetachedRender(configPath: string, binaryPath: string, knownSessionIds?: readonly string[]): Promise<RenderDaemonClient>;
+/**
+ * 该不该把正在跑的 daemon 换成装好的二进制：只有「装好的更新」且「daemon 空闲」才换。
+ * 纯决策，便于单测；daemon 持有 PTY 时绝不能动它（会杀掉用户的 shell）。
+ */
+export declare function shouldUpgradeRenderDaemon(daemonVersion: string | null, binaryVersion: string | null, sessionCount: number): boolean;
+/**
+ * detached spawn（stdio 忽略、unref），返回子进程 pid。
+ *
+ * `-c <configPath>` 是按 config 隔离的既定约定（docs/render-protocol.md §6）：
+ * socket / token / pid / meta 全部由它派生。
+ */
+export declare function spawnDetachedRenderProcess(configPath: string, binaryPath: string): number | null;
+/** spawn 并等 socket + token 就绪（启动路径用）。 */
+export declare function spawnDetachedRender(configPath: string, binaryPath: string, knownSessionIds?: readonly string[], reviveDaemon?: RenderDaemonReviver | null): Promise<RenderDaemonClient>;