@co0ontty/wand 4.46.0 → 4.47.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "bb2b4c9d6db5b2498473bfeec29dfdc96df2b2f0",
-  "builtAt": "2026-08-22T13:32:33.756Z",
-  "version": "4.46.0",
+  "commit": "8f7762a1d3d16afbb54650544c054f7e26df7c07",
+  "builtAt": "2026-08-23T03:26:15.182Z",
+  "version": "4.47.0",
   "channel": "stable"
 }

package/dist/distribution-manager.d.ts

@@ -45,6 +45,23 @@ export declare class DistributionManager {
     constructor(options: DistributionManagerOptions);
     resolveLatestApk(channel: ApkUpdateChannel): Promise<ResolvedDistributionAsset | null>;
     resolveAndroidDownload(channel?: ApkUpdateChannel): Promise<LocalDistributionAsset | null>;
+    /**
+     * 清理 Android 分发目录，只保留最新的一个 APK。在设备开始下载 Beta 包时
+     * 触发（见 /android/download 路由）：debug 构建每次都带独立时间戳版本号，
+     * 不清理会按构建次数无限堆积。
+     *
+     * 永不删除两类文件：
+     * - keepFileName：本次正在下发的文件（理论上就是最新的，防御性保留）；
+     * - config.android.currentApkFile 固定指向的文件（stable 通道可能仍在用）。
+     *
+     * 「最新」的判定与 resolveLocalAsset 的选择规则一致（见
+     * compareLocalAssetCandidates）。返回删除的文件名与释放字节数；目录不存在、
+     * 只剩一个包等情形都是空操作。单个文件删除失败不阻断其余清理。
+     */
+    pruneAndroidApkDirectory(keepFileName?: string): Promise<{
+        deleted: string[];
+        freedBytes: number;
+    }>;
     resolveLatestDmg(): Promise<ResolvedDistributionAsset | null>;
     resolveMacosDownload(): Promise<LocalDistributionAsset | null>;
     resolveLatestIpa(): Promise<ResolvedDistributionAsset | null>;

package/dist/distribution-manager.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { mkdir, readdir, readFile, stat } from "node:fs/promises";
+import { mkdir, readdir, readFile, stat, unlink } from "node:fs/promises";
 import path from "node:path";
 import { compareApkInstallOrder, compareSemver, extractSemver } from "./version-utils.js";
 const GITHUB_CACHE_TTL_MS = 10 * 60 * 1000;
@@ -24,6 +24,27 @@ function resolveConfiguredDir(configDir, configuredDir, fallback) {
 function extractArtifactVersion(fileName, extension) {
     return extractSemver(fileName.replace(new RegExp(`\\${extension}$`, "i"), ""));
 }
+/**
+ * 本地分发候选的统一排序：版本新者优先（调用方提供比较器），解析不出版本的
+ * 文件排在有版本的后面，同版本按修改时间新者优先。resolveLocalAsset 的挑选
+ * 和 pruneAndroidApkDirectory 的「保最新」判定共用这一份规则。
+ */
+function compareLocalAssetCandidates(a, b, extension, compareVersions) {
+    const aVersion = extractArtifactVersion(a.name, extension);
+    const bVersion = extractArtifactVersion(b.name, extension);
+    if (aVersion && bVersion) {
+        const comparison = compareVersions(bVersion, aVersion);
+        if (comparison !== 0)
+            return comparison;
+    }
+    else if (aVersion) {
+        return -1;
+    }
+    else if (bVersion) {
+        return 1;
+    }
+    return b.mtimeMs - a.mtimeMs;
+}
 function isPrerelease(version) {
     return !!version && version.includes("-");
 }
@@ -87,6 +108,63 @@ export class DistributionManager {
             acceptVersion: channel === "stable" ? (version) => !isPrerelease(version) : undefined,
         });
     }
+    /**
+     * 清理 Android 分发目录，只保留最新的一个 APK。在设备开始下载 Beta 包时
+     * 触发（见 /android/download 路由）：debug 构建每次都带独立时间戳版本号，
+     * 不清理会按构建次数无限堆积。
+     *
+     * 永不删除两类文件：
+     * - keepFileName：本次正在下发的文件（理论上就是最新的，防御性保留）；
+     * - config.android.currentApkFile 固定指向的文件（stable 通道可能仍在用）。
+     *
+     * 「最新」的判定与 resolveLocalAsset 的选择规则一致（见
+     * compareLocalAssetCandidates）。返回删除的文件名与释放字节数；目录不存在、
+     * 只剩一个包等情形都是空操作。单个文件删除失败不阻断其余清理。
+     */
+    async pruneAndroidApkDirectory(keepFileName) {
+        await this.refreshConfig();
+        const { config, configDir } = this.options;
+        if (config.android?.enabled !== true)
+            return { deleted: [], freedBytes: 0 };
+        const directory = resolveConfiguredDir(configDir, config.android.apkDir, "android");
+        let entries;
+        try {
+            entries = await readdir(directory, { withFileTypes: true });
+        }
+        catch {
+            return { deleted: [], freedBytes: 0 };
+        }
+        const apks = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".apk"));
+        if (apks.length === 0)
+            return { deleted: [], freedBytes: 0 };
+        const candidates = await Promise.all(apks.map(async (entry) => ({
+            name: entry.name,
+            filePath: path.join(directory, entry.name),
+            fileStat: await stat(path.join(directory, entry.name)),
+        })));
+        const sorted = [...candidates].sort((a, b) => compareLocalAssetCandidates({ name: a.name, mtimeMs: a.fileStat.mtimeMs }, { name: b.name, mtimeMs: b.fileStat.mtimeMs }, ".apk", compareApkInstallOrder));
+        const keepNames = new Set([sorted[0].name]);
+        const pinned = config.android.currentApkFile?.trim();
+        if (pinned)
+            keepNames.add(path.basename(pinned));
+        if (keepFileName)
+            keepNames.add(keepFileName);
+        const deleted = [];
+        let freedBytes = 0;
+        for (const candidate of sorted) {
+            if (keepNames.has(candidate.name))
+                continue;
+            try {
+                await unlink(candidate.filePath);
+                deleted.push(candidate.name);
+                freedBytes += candidate.fileStat.size;
+            }
+            catch {
+                // 清理是尽力而为；删不掉（如正被另一个下载流读取）留到下次触发。
+            }
+        }
+        return { deleted, freedBytes };
+    }
     async resolveLatestDmg() {
         const localDmg = await this.resolveMacosDownload();
         if (localDmg?.version) {
@@ -252,22 +330,7 @@ export class DistributionManager {
         }))).filter(({ entry }) => options.acceptVersion?.(extractArtifactVersion(entry.name, options.extension)) ?? true);
         if (candidates.length === 0)
             return null;
-        candidates.sort((a, b) => {
-            const aVersion = extractArtifactVersion(a.entry.name, options.extension);
-            const bVersion = extractArtifactVersion(b.entry.name, options.extension);
-            if (aVersion && bVersion) {
-                const comparison = options.compareVersions(bVersion, aVersion);
-                if (comparison !== 0)
-                    return comparison;
-            }
-            else if (aVersion) {
-                return -1;
-            }
-            else if (bVersion) {
-                return 1;
-            }
-            return b.fileStat.mtimeMs - a.fileStat.mtimeMs;
-        });
+        candidates.sort((a, b) => compareLocalAssetCandidates({ name: a.entry.name, mtimeMs: a.fileStat.mtimeMs }, { name: b.entry.name, mtimeMs: b.fileStat.mtimeMs }, options.extension, options.compareVersions));
         const selected = candidates[0];
         return {
             fileName: selected.entry.name,

package/dist/server-update-routes.d.ts

@@ -21,6 +21,11 @@ interface ResolvedUpdateAsset {
 export interface PublicUpdateRoutesDependencies {
     resolveLatestApk(channel: "stable" | "beta"): Promise<ResolvedUpdateAsset | null>;
     resolveAndroidDownload(channel: "stable" | "beta"): Promise<DownloadAsset | null>;
+    /** Beta 包下发时清理分发目录，只保留最新一个 APK（可选，测试 stub 可不实现）。 */
+    pruneAndroidApkDirectory?(keepFileName?: string): Promise<{
+        deleted: string[];
+        freedBytes: number;
+    }>;
     /** 计算本地分发文件的 SHA-256（hex）；失败返回 null，下载响应不带哈希头。 */
     computeAssetSha256(asset: DownloadAsset): Promise<string | null>;
     resolveLatestDmg(): Promise<ResolvedUpdateAsset | null>;

package/dist/server-update-routes.js

@@ -42,6 +42,21 @@ export function registerPublicUpdateRoutes(app, deps) {
             res.status(404).json({ error: "当前没有可下载的 APK 文件。" });
             return;
         }
+        // Beta 包下发时顺手清理分发目录：debug 构建每次都带独立时间戳版本号，
+        // 不清理会按构建次数无限堆积。只保留最新一个；正在下发的文件与
+        // currentApkFile 固定指向的文件不会被删。清理失败不阻断本次下载。
+        if (channel === "beta" && deps.pruneAndroidApkDirectory) {
+            try {
+                const pruned = await deps.pruneAndroidApkDirectory(asset.fileName);
+                if (pruned.deleted.length > 0) {
+                    process.stdout.write(`[wand] 已清理旧版安装包：${pruned.deleted.join(", ")}`
+                        + `（释放 ${(pruned.freedBytes / 1024 / 1024).toFixed(1)} MB）\n`);
+                }
+            }
+            catch (error) {
+                process.stdout.write(`[wand] 清理旧版安装包失败：${getErrorMessage(error)}\n`);
+            }
+        }
         // 响应头携带实际发送字节的 SHA-256：check 与 download 之间 APK 目录若被
         // 重新构建/覆盖，客户端以响应头为准，避免用过期 check 快照误报校验失败。
         const headers = {};

package/dist/server.js

@@ -48,7 +48,7 @@ import { isLogBusActive, wandTuiLog } from "./tui/log-bus.js";
 import { EMBEDDED_WEB_ASSETS } from "./web-ui/embedded-assets.js";
 import { renderApp } from "./web-ui/index.js";
 import { WsBroadcastManager } from "./ws-broadcast.js";
-import { createTerminalHost } from "./terminal-daemon-client.js";
+import { createTerminalHost, TerminalDaemonClient } from "./terminal-daemon-client.js";
 import { checkRateLimit, recordFailedLogin, resetRateLimit } from "./middleware/rate-limit.js";
 import { updateProviderClis, verifyProviderCliUpdateResults, } from "./provider-cli-updater.js";
 const SERVER_MODULE_DIR = path.dirname(new URL(import.meta.url).pathname);
@@ -515,7 +515,10 @@ export async function startServer(config, configPath, options = {}) {
     const terminalHost = options.terminalHost ?? await createTerminalHost(configPath);
     const processes = new ProcessManager(config, storage, configDir, terminalHost);
     const structuredLogger = new SessionLogger(configDir, config.shortcutLogMaxBytes);
-    const structuredSessions = new StructuredSessionManager(storage, config, structuredLogger);
+    // Only the daemon-backed host keeps structured CLI runs alive across restarts;
+    // the in-process fallback keeps the legacy die-with-server lifecycle.
+    const structuredExecHost = terminalHost instanceof TerminalDaemonClient ? terminalHost : undefined;
+    const structuredSessions = new StructuredSessionManager(storage, config, structuredLogger, undefined, {}, structuredExecHost);
     const sessionRegistry = new SessionRegistry(processes, structuredSessions, storage);
     const missions = new Missions(storage, structuredSessions, sessionRegistry);
     const updateState = new ServerUpdateState();
@@ -1154,6 +1157,9 @@ export async function startServer(config, configPath, options = {}) {
         missions.ingest(event);
         wsManager.emitEvent(event);
     });
+    // Re-attach structured CLI runs that kept going inside terminald while the
+    // previous web process was down; fire-and-forget, failures are logged inside.
+    void structuredSessions.recoverDetachedRuns();
     // ── Restart endpoint (needs server + wss in scope) ──
     function safeServiceInstalled() {
         try {

package/dist/structured-claude-adapter.d.ts

@@ -1,3 +1,4 @@
+import type { StructuredExecHost } from "./structured-exec-host.js";
 import type { StructuredRunnerAdapter, StructuredRunnerContext, StructuredRunnerExecution, StructuredRunnerObserver } from "./structured-runner.js";
 import type { ExecutionMode, SessionSnapshot } from "./types.js";
 type WandPermissionMode = "default" | "acceptEdits" | "bypassPermissions";
@@ -24,7 +25,8 @@ export interface ClaudeCliRunnerOptions {
 /** Owns the Claude print-mode process and its stream-json protocol. */
 export declare class ClaudeCliRunner implements StructuredRunnerAdapter {
     private readonly options;
-    constructor(options?: ClaudeCliRunnerOptions);
+    private readonly execHost?;
+    constructor(options?: ClaudeCliRunnerOptions, execHost?: StructuredExecHost | undefined);
     start(context: StructuredRunnerContext, observer: StructuredRunnerObserver): StructuredRunnerExecution;
 }
 export {};

package/dist/structured-claude-adapter.js

@@ -1,8 +1,8 @@
-import { spawn } from "node:child_process";
 import { readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 import { isRunningAsRoot } from "./env-utils.js";
+import { startStructuredCli } from "./structured-exec-pump.js";
 import { buildLanguageDirective, buildManagedAutonomyDirective } from "./language-prompt.js";
 import { thinkingEffortToClaudeCliEffort, thinkingEffortToSdkBudget } from "./structured-provider-common.js";
 import { ClaudeCliProtocolReducer } from "./structured-claude-protocol.js";
@@ -120,8 +120,10 @@ export function buildClaudeSdkThinking(effort) {
 /** Owns the Claude print-mode process and its stream-json protocol. */
 export class ClaudeCliRunner {
     options;
-    constructor(options = {}) {
+    execHost;
+    constructor(options = {}, execHost) {
         this.options = options;
+        this.execHost = execHost;
     }
     start(context, observer) {
         const permissionPolicy = derivePermissionPolicy(context.session.mode, context.session.autoApprovePermissions ?? false, context.session.cwd);
@@ -129,105 +131,58 @@ export class ClaudeCliRunner {
             permissionPolicy,
             systemPromptParts: buildAppendSystemPromptParts(this.options.language?.(), context.session.mode),
         });
-        const spawnedAt = new Date().toISOString();
-        const child = spawn("claude", args, {
-            cwd: context.session.cwd,
-            env: context.env,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        child.stdin?.end(context.prompt);
         const reducer = new ClaudeCliProtocolReducer(context.session);
-        let lineBuffer = "";
-        let stderr = "";
-        let stdoutTail = "";
-        let settled = false;
         let killedForQuestion = false;
-        const result = (exitCode, signal, spawnError) => ({
-            state: reducer.state,
-            exitCode,
-            signal,
-            stderr,
-            stdoutTail,
-            primaryError: null,
-            stopReason: killedForQuestion ? "ask-user-question" : undefined,
-            spawnError,
-        });
-        const processLine = (line) => {
-            if (!observer.isActive())
-                return;
-            const trimmed = line.trim();
-            if (!trimmed)
-                return;
-            let event;
-            try {
-                event = JSON.parse(trimmed);
-            }
-            catch {
-                return;
-            }
-            if (event && typeof event === "object" && !Array.isArray(event)) {
-                observer.onEvent?.(event);
-            }
-            if (reducer.apply(event, context.session.mode === "managed")) {
-                observer.onUpdate(reducer.state);
-            }
-            if (reducer.askUserQuestionDetected && !killedForQuestion) {
-                killedForQuestion = true;
+        let stdoutTail = "";
+        return startStructuredCli({
+            sessionId: context.session.id,
+            file: "claude",
+            args,
+            cwd: context.session.cwd,
+            env: context.env,
+            stdinData: context.prompt,
+            observer,
+            execHost: this.execHost,
+            createState: () => reducer.state,
+            processLine: (line, ctx) => {
+                if (!observer.isActive())
+                    return;
+                const trimmed = line.trim();
+                if (!trimmed)
+                    return;
+                let event;
                 try {
-                    child.kill("SIGTERM");
+                    event = JSON.parse(trimmed);
                 }
-                catch { /* best effort */ }
-            }
-        };
-        const completion = new Promise((resolve) => {
-            child.stdout?.on("data", (chunk) => {
-                if (!observer.isActive())
+                catch {
                     return;
-                const text = chunk.toString();
-                observer.onStdout?.(text);
+                }
+                if (event && typeof event === "object" && !Array.isArray(event)) {
+                    observer.onEvent?.(event);
+                }
+                if (reducer.apply(event, context.session.mode === "managed")) {
+                    observer.onUpdate(reducer.state);
+                }
+                if (reducer.askUserQuestionDetected && !killedForQuestion) {
+                    killedForQuestion = true;
+                    ctx.requestStop();
+                }
+            },
+            onStdoutText: (text) => {
                 const trimmed = text.trim();
                 if (trimmed)
                     stdoutTail = trimmed.slice(-1024);
-                lineBuffer += text;
-                const lines = lineBuffer.split("\n");
-                lineBuffer = lines.pop() ?? "";
-                for (const line of lines)
-                    processLine(line);
-            });
-            child.stderr?.on("data", (chunk) => {
-                if (!observer.isActive())
-                    return;
-                const text = chunk.toString();
-                observer.onStderr?.(text);
-                stderr += text;
-            });
-            child.on("error", (error) => {
-                if (settled)
-                    return;
-                settled = true;
-                resolve(result(null, null, error));
-            });
-            child.on("close", (exitCode, signal) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (lineBuffer.trim())
-                    processLine(lineBuffer);
-                lineBuffer = "";
-                resolve(result(exitCode, signal));
-            });
-        });
-        return {
-            args,
-            spawnedAt,
-            pid: child.pid ?? null,
-            completion,
-            interrupt: () => {
-                try {
-                    child.kill("SIGTERM");
-                }
-                catch { /* best effort */ }
             },
-        };
+            finalize: (ctx, exitCode, signal, spawnError) => ({
+                state: reducer.state,
+                exitCode,
+                signal,
+                stderr: ctx.stderr,
+                stdoutTail,
+                primaryError: null,
+                stopReason: killedForQuestion ? "ask-user-question" : undefined,
+                spawnError,
+            }),
+        });
     }
 }

package/dist/structured-codex-adapter.d.ts

@@ -1,8 +1,13 @@
+import { spawn } from "node:child_process";
+import type { StructuredExecHost } from "./structured-exec-host.js";
 import type { SessionSnapshot } from "./types.js";
 import type { StructuredRunnerAdapter, StructuredRunnerContext, StructuredRunnerExecution, StructuredRunnerObserver } from "./structured-runner.js";
 /** Build the stable CLI contract for a structured Codex turn. */
 export declare function buildCodexArgs(session: SessionSnapshot): string[];
 /** Owns the Codex CLI process and translates its NDJSON protocol into runner-neutral state. */
 export declare class CodexRunner implements StructuredRunnerAdapter {
+    private readonly spawnProcess;
+    private readonly execHost?;
+    constructor(spawnProcess?: typeof spawn, execHost?: StructuredExecHost | undefined);
     start(context: StructuredRunnerContext, observer: StructuredRunnerObserver): StructuredRunnerExecution;
 }

package/dist/structured-codex-adapter.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { startStructuredCli } from "./structured-exec-pump.js";
 import { CodexProtocolReducer } from "./structured-codex-protocol.js";
 import { thinkingEffortToCodexReasoningEffort } from "./structured-provider-common.js";
 /** Build the stable CLI contract for a structured Codex turn. */
@@ -31,93 +32,54 @@ export function buildCodexArgs(session) {
 }
 /** Owns the Codex CLI process and translates its NDJSON protocol into runner-neutral state. */
 export class CodexRunner {
+    spawnProcess;
+    execHost;
+    constructor(spawnProcess = spawn, execHost) {
+        this.spawnProcess = spawnProcess;
+        this.execHost = execHost;
+    }
     start(context, observer) {
         const args = buildCodexArgs(context.session);
-        const spawnedAt = new Date().toISOString();
-        const child = spawn("codex", args, {
+        const reducer = new CodexProtocolReducer(context.session);
+        return startStructuredCli({
+            sessionId: context.session.id,
+            file: "codex",
+            args,
             cwd: context.session.cwd,
             env: context.env,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        child.stdin?.end(context.prompt);
-        const reducer = new CodexProtocolReducer(context.session);
-        let lineBuffer = "";
-        let stderr = "";
-        let settled = false;
-        const result = (exitCode, signal, spawnError) => ({
-            state: reducer.state,
-            exitCode,
-            signal,
-            stderr,
-            primaryError: reducer.primaryError,
-            errors: reducer.errors,
-            spawnError,
-        });
-        const processLine = (line) => {
-            if (!observer.isActive())
-                return;
-            const trimmed = line.trim();
-            if (!trimmed)
-                return;
-            let event;
-            try {
-                event = JSON.parse(trimmed);
-            }
-            catch {
-                return;
-            }
-            if (event && typeof event === "object" && !Array.isArray(event)) {
-                observer.onEvent?.(event);
-            }
-            if (reducer.apply(event))
-                observer.onUpdate(reducer.state);
-        };
-        const completion = new Promise((resolve) => {
-            child.stdout?.on("data", (chunk) => {
-                if (!observer.isActive())
-                    return;
-                const text = chunk.toString();
-                observer.onStdout?.(text);
-                lineBuffer += text;
-                const lines = lineBuffer.split("\n");
-                lineBuffer = lines.pop() ?? "";
-                for (const line of lines)
-                    processLine(line);
-            });
-            child.stderr?.on("data", (chunk) => {
+            stdinData: context.prompt,
+            observer,
+            execHost: this.execHost,
+            spawnProcess: this.spawnProcess,
+            createState: () => reducer.state,
+            processLine: (line) => {
                 if (!observer.isActive())
                     return;
-                const text = chunk.toString();
-                observer.onStderr?.(text);
-                stderr += text;
-            });
-            child.on("error", (error) => {
-                if (settled)
+                const trimmed = line.trim();
+                if (!trimmed)
                     return;
-                settled = true;
-                resolve(result(null, null, error));
-            });
-            child.on("close", (exitCode, signal) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (lineBuffer.trim())
-                    processLine(lineBuffer);
-                lineBuffer = "";
-                resolve(result(exitCode, signal));
-            });
-        });
-        return {
-            args,
-            spawnedAt,
-            pid: child.pid ?? null,
-            completion,
-            interrupt: () => {
+                let event;
                 try {
-                    child.kill("SIGTERM");
+                    event = JSON.parse(trimmed);
                 }
-                catch { /* best-effort external interruption */ }
+                catch {
+                    return;
+                }
+                if (event && typeof event === "object" && !Array.isArray(event)) {
+                    observer.onEvent?.(event);
+                }
+                if (reducer.apply(event))
+                    observer.onUpdate(reducer.state);
             },
-        };
+            finalize: (ctx, exitCode, signal, spawnError) => ({
+                state: reducer.state,
+                exitCode,
+                signal,
+                stderr: ctx.stderr,
+                primaryError: reducer.primaryError,
+                errors: reducer.errors,
+                spawnError,
+            }),
+        });
     }
 }

package/dist/structured-exec-host.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Ownership seam for structured CLI runs, mirroring TerminalHost for PTYs.
+ * Persistent adapters (terminald) outlive web restarts; the in-process adapter
+ * deliberately keeps the legacy "die with the server" lifecycle.
+ */
+/** Per-stream replay log cap inside the daemon. Reducers need full history. */
+export declare const STRUCTURED_RUN_LOG_MAX_CHARS: number;
+export interface StructuredSpawnRequest {
+    /** Stable across restarts: `structured:<sessionId>`. One run per session. */
+    runId: string;
+    file: string;
+    args: string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    /** Written to stdin once, then stdin is closed. Omit for stdio-ignore CLIs. */
+    stdinData?: string;
+}
+export interface StructuredRunState {
+    runId: string;
+    incarnationId: string;
+    pid: number;
+    status: "running" | "exited";
+    exitCode: number | null;
+    signal: number | null;
+    stdoutSeq: number;
+    stderrSeq: number;
+    stdoutLog: string;
+    stderrLog: string;
+    stdoutTruncated: boolean;
+    stderrTruncated: boolean;
+}
+export interface StructuredStreamEvent {
+    stream: "stdout" | "stderr";
+    data: string;
+    seq: number;
+}
+export interface StructuredExitEvent {
+    exitCode: number | null;
+    signal: number | null;
+}
+export interface StructuredExecProcess {
+    readonly runId: string;
+    readonly incarnationId: string;
+    readonly pid: number;
+    interrupt(signal?: string): void;
+    onStream(listener: (event: StructuredStreamEvent) => void): {
+        dispose(): void;
+    };
+    onExit(listener: (event: StructuredExitEvent) => void): {
+        dispose(): void;
+    };
+}
+export interface StructuredExecHost {
+    readonly persistent: boolean;
+    spawnStructured(request: StructuredSpawnRequest): Promise<StructuredExecProcess>;
+    /** Full state incl. replay logs; null when the host does not know the run. */
+    attachRun(runId: string): Promise<StructuredRunState | null>;
+    /** Subscribe to a known running run without spawning anything. */
+    adoptRun(runId: string): Promise<StructuredExecProcess | null>;
+    listRuns(): Promise<StructuredRunState[]>;
+    forgetRun(runId: string): void;
+}
+/** Resolve a stable daemon-side key for a session's active structured run. */
+export declare function structuredRunId(sessionId: string): string;
+/** Legacy/local adapter and deterministic test adapter for the structured seam. */
+export declare class InProcessStructuredExecHost implements StructuredExecHost {
+    readonly persistent = false;
+    private readonly processes;
+    spawnStructured(request: StructuredSpawnRequest): Promise<StructuredExecProcess>;
+    attachRun(): Promise<StructuredRunState | null>;
+    adoptRun(): Promise<StructuredExecProcess | null>;
+    listRuns(): Promise<StructuredRunState[]>;
+    forgetRun(runId: string): void;
+}
+/** Map a NodeJS.Signals name to the numeric value used by waitpid-style APIs. */
+export declare function osSignalNumber(signal: NodeJS.Signals): number;