@co0ontty/wand 4.106.0 → 4.106.1

package/dist/models.js

@@ -12,6 +12,7 @@ import { AUTO_ASSIGN_LABEL, AUTO_ASSIGN_SELECTOR, FREE_MODEL_GROUP_ID, isAutoAss
 import { MODEL_ID_PATTERN, QODER_MODEL_ID_PATTERN, CLAUDE_BUILTIN_MODELS, CODEX_FALLBACK_MODELS, OPENCODE_FALLBACK_MODELS, GROK_FALLBACK_MODELS, QODER_FALLBACK_MODELS, PI_FALLBACK_MODELS, cloneModels, isRecord } from "./models/shared.js";
 import { EFFORT_ID_PATTERN, FALLBACK_PROVIDER_THINKING, cloneThinkingEfforts, effortLevelsFromIds, unionModelEfforts, parseCliEffortList } from "./models/thinking.js";
 import { parseOpenCodeModelCatalog } from "./models/parsers/opencode.js";
+import { openCodeCatalogArgs } from "./opencode-cli.js";
 import { parseGrokModels } from "./models/parsers/grok.js";
 import { parseQoderModels } from "./models/parsers/qoder.js";
 import { parsePiRpcModels, parsePiModels } from "./models/parsers/pi.js";
@@ -288,20 +289,20 @@ async function probeCodexModels(runner, env) {
     }
 }
 async function probeOpenCode(runner, env) {
-    const [modelsResult, versionResult] = await Promise.allSettled([
-        runner("opencode", ["models", "--verbose"], { env, timeout: 8000 }),
-        runner("opencode", ["--version"], { env, timeout: 5000 }),
-    ]);
-    const models = modelsResult.status === "fulfilled"
-        ? { ok: true, value: parseOpenCodeModelCatalog(modelsResult.value.stdout) }
-        : { ok: false };
-    const version = versionResult.status === "fulfilled"
-        ? {
-            ok: true,
-            value: extractSemver(versionResult.value.stdout) ?? (versionResult.value.stdout.trim().slice(0, 64) || null),
-        }
-        : { ok: false };
-    return { models, version };
+    let version = { ok: false };
+    try {
+        const result = await runner("opencode", ["--version"], { env, timeout: 5000 });
+        version = { ok: true, value: extractSemver(result.stdout) ?? (result.stdout.trim().slice(0, 64) || null) };
+    }
+    catch { /* Directory failure preserves the last known catalog. */ }
+    try {
+        const major = version.ok ? Number(version.value?.split(".")[0]) : 1;
+        const result = await runner("opencode", openCodeCatalogArgs(major), { env, timeout: 8000 });
+        return { models: { ok: true, value: parseOpenCodeModelCatalog(result.stdout) }, version };
+    }
+    catch {
+        return { models: { ok: false }, version };
+    }
 }
 async function probeGrokModels(runner, env) {
     try {

package/dist/npm-update-utils.d.ts

@@ -11,6 +11,7 @@
  * 我们的策略：安装前备份当前全局包，补齐 npm 子进程 PATH，清掉
  * `@co0ontty/.wand-*` 残留目录；失败时恢复备份，避免运行中的服务被半成品安装拆掉。
  */
+import type { WandBuildInfo } from "./build-info.js";
 export declare const PACKAGE_NAME = "@co0ontty/wand";
 export type UpdateChannel = "stable" | "beta";
 export interface PackageUpdateInfo {
@@ -28,8 +29,9 @@ export declare function normalizeUpdateChannel(value: unknown): UpdateChannel;
 export declare function getInstallSpecForChannel(channel: UpdateChannel): string;
 export declare function buildPackageUpdateInfo(currentVersion: string, channel: UpdateChannel, latestVersion: string | null): PackageUpdateInfo;
 export declare function selectPackageUpdateInfo(currentVersion: string, channel: UpdateChannel, stableVersion: string | null, betaVersion?: string | null): PackageUpdateInfo;
-export declare function checkPackageUpdateAsync(currentVersion: string, channel: UpdateChannel, timeoutMs?: number): Promise<PackageUpdateInfo>;
-export declare function checkPackageUpdateSync(currentVersion: string, channel: UpdateChannel, timeoutMs?: number): PackageUpdateInfo;
+type UpdateBuildIdentity = Pick<WandBuildInfo, "version" | "commit">;
+export declare function checkPackageUpdateAsync(currentVersion: string, channel: UpdateChannel, timeoutMs?: number, build?: UpdateBuildIdentity): Promise<PackageUpdateInfo>;
+export declare function checkPackageUpdateSync(currentVersion: string, channel: UpdateChannel, timeoutMs?: number, build?: UpdateBuildIdentity): PackageUpdateInfo;
 export declare function resolveInstalledNpmPrefix(moduleUrl?: string, platform?: NodeJS.Platform): {
     root: string;
     prefix: string;
@@ -88,3 +90,4 @@ export declare function resolveGlobalWandCli(): string | null;
  * dist/cli.js；更新回滚期间 shim 会临时指向同盘安全备份，始终保持可启动。
  */
 export declare function resolveGlobalWandBin(): string | null;
+export {};

package/dist/npm-update-utils.js

@@ -103,17 +103,47 @@ export function selectPackageUpdateInfo(currentVersion, channel, stableVersion,
     const info = buildPackageUpdateInfo(currentVersion, useBeta ? "beta" : "stable", useBeta ? beta : stable);
     return { ...info, channel, stableVersion: stable, betaVersion: beta };
 }
-export async function checkPackageUpdateAsync(currentVersion, channel, timeoutMs = NPM_VIEW_TIMEOUT_MS) {
+function localDebugCommit(info, build) {
+    if (!info.updateAvailable || !/^\d+\.\d+\.\d+-debug\./.test(info.current)
+        || !build?.commit || build.version === null || cleanVersion(build.version) !== info.current
+        || !/^[a-f0-9]{40}$/i.test(build.commit))
+        return null;
+    return build.commit.toLowerCase();
+}
+function applySourceCommit(info, currentCommit, candidateCommit) {
+    // start.sh uses X.Y.Z-debug while CI uses X.Y.(Z+1)-beta, even for the same
+    // commit. A published copy must not replace local changes on that commit.
+    return candidateCommit.trim().toLowerCase() === currentCommit ? { ...info, updateAvailable: false } : info;
+}
+export async function checkPackageUpdateAsync(currentVersion, channel, timeoutMs = NPM_VIEW_TIMEOUT_MS, build) {
     const [stable, beta] = await Promise.all([
         viewPackageVersionAsync("stable", timeoutMs),
         channel === "beta" ? viewPackageVersionAsync("beta", timeoutMs) : null,
     ]);
-    return selectPackageUpdateInfo(currentVersion, channel, stable, beta);
+    const info = selectPackageUpdateInfo(currentVersion, channel, stable, beta);
+    const commit = localDebugCommit(info, build);
+    if (!commit)
+        return info;
+    try {
+        const { stdout } = await execFileAsync(npmBin(), ["view", info.installSpec, "gitHead"], {
+            timeout: timeoutMs, env: getChildEnv(), maxBuffer: INSTALL_MAX_BUFFER,
+        });
+        return applySourceCommit(info, commit, stdout);
+    }
+    catch {
+        // Missing provenance does not prove equal source; retain version ordering.
+        return info;
+    }
 }
-export function checkPackageUpdateSync(currentVersion, channel, timeoutMs = NPM_VIEW_TIMEOUT_MS) {
+export function checkPackageUpdateSync(currentVersion, channel, timeoutMs = NPM_VIEW_TIMEOUT_MS, build) {
     const stable = viewPackageVersionSync("stable", timeoutMs);
     const beta = channel === "beta" ? viewPackageVersionSync("beta", timeoutMs) : null;
-    return selectPackageUpdateInfo(currentVersion, channel, stable, beta);
+    const info = selectPackageUpdateInfo(currentVersion, channel, stable, beta);
+    const commit = localDebugCommit(info, build);
+    if (!commit)
+        return info;
+    const result = runNpmSync(["view", info.installSpec, "gitHead"], timeoutMs);
+    return result.status === 0 ? applySourceCommit(info, commit, result.stdout ?? "") : info;
 }
 export function resolveInstalledNpmPrefix(moduleUrl = import.meta.url, platform = process.platform) {
     try {

package/dist/opencode-cli.d.ts

@@ -0,0 +1,6 @@
+/** Resolve the actual executable; an upgrade invalidates the cached CLI dialect. */
+export declare function openCodeMajorVersion(env: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<number>;
+/** v2 returns priced native records through its read-only API, v1 through verbose models. */
+export declare function openCodeCatalogArgs(major: number, nativeFree?: boolean): string[];
+/** v2 folds the reasoning variant into the model reference. */
+export declare function openCodeModelArgs(model: string | null | undefined, variant: string | null, major: number): string[];

package/dist/opencode-cli.js

@@ -0,0 +1,51 @@
+import { execFile } from "node:child_process";
+import { statSync } from "node:fs";
+import { promisify } from "node:util";
+import { whichSync } from "./path-repair.js";
+import { extractSemver } from "./version-utils.js";
+const execFileAsync = promisify(execFile);
+let cachedVersion;
+/** Resolve the actual executable; an upgrade invalidates the cached CLI dialect. */
+export async function openCodeMajorVersion(env, signal) {
+    signal?.throwIfAborted();
+    const executable = whichSync("opencode", { env });
+    if (!executable)
+        throw new Error("未找到 OpenCode CLI。");
+    const stat = statSync(executable);
+    const identity = `${executable}:${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
+    if (cachedVersion?.identity !== identity) {
+        const version = execFileAsync(executable, ["--version"], { env, timeout: 5_000, maxBuffer: 64 * 1024, encoding: "utf8" })
+            .then(({ stdout }) => {
+            const parsed = extractSemver(stdout);
+            if (!parsed)
+                throw new Error("无法识别 OpenCode CLI 版本。");
+            return Number(parsed.split(".")[0]);
+        });
+        cachedVersion = { identity, version };
+        void version.catch(() => { if (cachedVersion?.version === version)
+            cachedVersion = undefined; });
+    }
+    const major = await cachedVersion.version;
+    signal?.throwIfAborted();
+    return major;
+}
+/** v2 returns priced native records through its read-only API, v1 through verbose models. */
+export function openCodeCatalogArgs(major, nativeFree = false) {
+    return major >= 2
+        ? ["api", "--standalone", "model.list"]
+        : nativeFree ? ["models", "opencode", "--verbose", "--refresh", "--pure"] : ["models", "--verbose"];
+}
+/** v2 folds the reasoning variant into the model reference. */
+export function openCodeModelArgs(model, variant, major) {
+    const value = model?.trim();
+    const args = [];
+    if (value && value !== "default") {
+        args.push("--model", major >= 2 && variant ? `${value.split("#")[0]}#${variant}` : value);
+    }
+    else if (major >= 2 && variant) {
+        throw new Error("OpenCode 2 的思考深度需要具体模型，请先选择模型。");
+    }
+    if (major < 2 && variant)
+        args.push("--variant", variant);
+    return args;
+}

package/dist/opencode-system-fallback.d.ts

@@ -29,6 +29,7 @@ export declare class OpenCodeFreeModelsService implements OpenCodeFreePool {
     private readonly options;
     private controller;
     private setup;
+    private cliMajor;
     private pending;
     private retryAfter;
     private disposed;

package/dist/opencode-system-fallback.js

@@ -11,6 +11,7 @@ import { AI_TEAM_MAX_CANDIDATES } from "./ai-team-types.js";
 import { systemEmployeeDefaultAgents } from "./system-employee.js";
 import { whichSync } from "./path-repair.js";
 import { parseProviderCliVersion } from "./provider-cli-updater.js";
+import { openCodeCatalogArgs } from "./opencode-cli.js";
 import { asRecord } from "./structured-content.js";
 import { redactSystemAiText } from "./system-ai-redaction.js";
 const pools = new WeakMap();
@@ -56,10 +57,19 @@ export function parseOpenCodeFreeModels(stdout) {
         return !!row && Object.keys(row).length > 0 && Object.values(row).every(allZero);
     };
     return [...new Set(parseOpenCodeModelRecords(stdout).flatMap(({ id, record }) => {
-            const api = asRecord(record.api), cost = asRecord(record.cost), capabilities = asRecord(record.capabilities);
+            const api = asRecord(record.api), capabilities = asRecord(record.capabilities);
+            // v2 supplies a price per context tier. Every tier and every price must be zero.
+            const costs = Array.isArray(record.cost) ? record.cost : [record.cost];
+            const free = costs.length > 0 && costs.every((value) => {
+                const cost = asRecord(value);
+                if (!cost || !zero(cost.input) || !zero(cost.output))
+                    return false;
+                const { tier: _tier, ...prices } = cost;
+                return allZero(prices);
+            });
             if (!isOpenCodeNativeModelId(id) || record.providerID !== "opencode" || record.status !== "active"
                 || api?.id !== id.slice("opencode/".length) || typeof api.url !== "string" || !NATIVE_API_URLS.has(api.url)
-                || typeof api.npm !== "string" || !NATIVE_SDKS.has(api.npm) || !cost || !zero(cost.input) || !zero(cost.output) || !allZero(cost)
+                || typeof api.npm !== "string" || !NATIVE_SDKS.has(api.npm) || !free
                 || asRecord(capabilities?.input)?.text !== true || asRecord(capabilities?.output)?.text !== true
                 || capabilities?.toolcall !== true)
                 return [];
@@ -122,6 +132,7 @@ export class OpenCodeFreeModelsService {
     options;
     controller = new AbortController();
     setup;
+    cliMajor = 1;
     pending;
     retryAfter = 0;
     disposed = false;
@@ -160,7 +171,7 @@ export class OpenCodeFreeModelsService {
         return this.options.find ? this.options.find(command, this.env()) : whichSync(command, { env: this.env() });
     }
     async run(file, args, timeout, signal = this.controller.signal) {
-        const nativeModels = args[0] === "models";
+        const nativeModels = args[0] === "models" || args[0] === "api";
         const result = await (this.options.run ?? runCommand)(file, args, { env: nativeModels ? this.execution.env(this.env()) : this.env(), timeout,
             ...(nativeModels ? { cwd: this.execution.cwd } : {}), signal: AbortSignal.any([signal, this.controller.signal]) });
         this.controller.signal.throwIfAborted();
@@ -200,6 +211,7 @@ export class OpenCodeFreeModelsService {
         const version = parseProviderCliVersion(await this.run(executable, ["--version"], 8_000));
         if (!version || /^0\.0\./.test(version))
             throw new Error("现有 OpenCode 版本不可用；未覆盖用户安装。");
+        this.cliMajor = Number(version.split(".")[0]);
         return executable;
     }
     ensure() {
@@ -222,7 +234,7 @@ export class OpenCodeFreeModelsService {
         const sequence = ++this.catalogSequence;
         const executable = await this.ensure();
         signal?.throwIfAborted();
-        return { sequence, models: parseOpenCodeFreeModels(await this.run(executable, ["models", "opencode", "--verbose", "--refresh", "--pure"], 15_000, signal)) };
+        return { sequence, models: parseOpenCodeFreeModels(await this.run(executable, openCodeCatalogArgs(this.cliMajor, true), 15_000, signal)) };
     }
     async probe(model) {
         try {

package/dist/pi-native-event-bridge.js

@@ -2,6 +2,7 @@
 // Do not import a Wand SDK runtime: the native CLI owns its extensions and TUI.
 import { appendFileSync, readFileSync, writeFileSync } from "node:fs";
 import { projectPiProtocolEvent } from "./pi-event-projection.js";
+import { claimNativeInput, nativeInputFile, openNativeInputBoundary, writeNativeInput } from "./pi-native-input.js";
 export default function wandNativeEvents(pi) {
     const file = process.env.WAND_PI_NATIVE_PATHS;
     if (!file)
@@ -28,7 +29,10 @@ export default function wandNativeEvents(pi) {
         if (ctx.mode !== "tui")
             throw new Error("Pi 原生 tmux 会话必须使用 TUI 模式。");
         append({ type: "session", id: ctx.sessionManager.getSessionId() });
-        writeFileSync(paths.ready, JSON.stringify({ mode: ctx.mode, hasUI: ctx.hasUI, pid: process.pid }) + "\n", { mode: 0o600 });
+        if (paths.input)
+            append({ type: "wand_input_ready", id: paths.initialMessageId });
+        writeFileSync(paths.ready, JSON.stringify({ mode: ctx.mode, hasUI: ctx.hasUI, pid: process.pid,
+            sessionFile: ctx.sessionManager.getSessionFile() }) + "\n", { mode: 0o600 });
     });
     const capture = (event) => {
         if (event.type === "message_update") {
@@ -42,8 +46,55 @@ export default function wandNativeEvents(pi) {
         else
             append(event);
     };
+    let pending = null;
+    const confirmInput = (ctx) => {
+        if (!pending || !paths.input)
+            return;
+        const offer = pending;
+        const found = ctx.sessionManager.getBranch().some((entry) => entry.type === "custom_message"
+            && entry.customType === "wand-user-input"
+            && entry.details?.inputId === offer.id);
+        if (!found)
+            return;
+        writeNativeInput(nativeInputFile(paths.input, offer.boundaryId, "committed"), offer);
+        append({ type: "wand_input_committed", id: offer.boundaryId, message: offer });
+        pending = null;
+    };
+    pi.on("turn_end", async (event, ctx) => {
+        if (!paths.input || !Array.isArray(event.entries) || !event.context
+            || event.outcome === "error" || event.outcome === "aborted" || ctx.signal?.aborted
+            || event.message.stopReason === "error"
+            || event.message.stopReason === "aborted")
+            return;
+        confirmInput(ctx);
+        // A prior unconfirmed handoff must never be followed by another injection.
+        if (pending || ctx.hasPendingMessages())
+            return;
+        const boundaryId = openNativeInputBoundary(paths.input);
+        append({ type: "wand_input_boundary", id: boundaryId });
+        try {
+            const deadline = Date.now() + 2000;
+            while (!ctx.signal?.aborted && Date.now() < deadline) {
+                const offer = claimNativeInput(paths.input, boundaryId);
+                if (offer !== undefined) {
+                    if (!offer)
+                        return;
+                    pending = offer;
+                    // Official awaited boundary entries commit to the native session before
+                    // continuing. Unlike sendUserMessage(), no discarded async enqueue runs.
+                    return { entries: [...event.entries, { type: "custom_message",
+                                customType: "wand-user-input", content: offer.text, display: true,
+                                details: { inputId: offer.id, boundaryId } }], continue: true };
+                }
+                await new Promise((resolve) => setTimeout(resolve, 20));
+            }
+        }
+        finally {
+            writeNativeInput(nativeInputFile(paths.input, boundaryId, "closed"), { id: boundaryId });
+        }
+    });
     pi.on("agent_start", capture);
-    pi.on("turn_start", capture);
+    pi.on("turn_start", (event, ctx) => { confirmInput(ctx); capture(event); });
     pi.on("message_start", capture);
     pi.on("message_update", capture);
     pi.on("message_end", capture);
@@ -51,8 +102,9 @@ export default function wandNativeEvents(pi) {
     pi.on("tool_execution_start", capture);
     pi.on("tool_execution_update", capture);
     pi.on("tool_execution_end", capture);
-    pi.on("agent_end", capture);
+    pi.on("agent_end", (event, ctx) => { confirmInput(ctx); capture(event); });
     pi.on("agent_settled", (event, ctx) => {
+        confirmInput(ctx);
         append(event);
         // Match the existing per-submit CLI lifetime. This boundary is later than
         // agent_end: queued/background work, retry and compaction have drained.

package/dist/pi-native-input.d.ts

@@ -0,0 +1,22 @@
+/** Private per-execution mailbox; never a client request path or an SDK runtime. */
+export interface PiInputHandoff {
+    id: string;
+    boundaryId: string;
+    incarnationId: string;
+}
+export interface PiInputOffer extends PiInputHandoff {
+    text: string;
+}
+export interface PiInputResolution {
+    state: "committed" | "unclaimed" | "unknown";
+    offer?: PiInputOffer;
+}
+export declare function nativeInputFile(directory: string, boundaryId: string, name: string): string;
+export declare function writeNativeInput(file: string, value: unknown): void;
+export declare function readNativeInput<T>(file: string): T | null;
+export declare function openNativeInputBoundary(directory: string): string;
+/** Queue reservation is synchronous and durable before publishing the response. */
+export declare function offerNativeInput(directory: string, boundaryId: string, incarnationId: string, take: (identity: PiInputHandoff) => string | null): boolean;
+/** Claim precedes any native transcript mutation; an absent claim is safe to release after close/exit. */
+export declare function claimNativeInput(directory: string, boundaryId: string): PiInputOffer | null | undefined;
+export declare function resolveNativeInput(directory: string, handoff: PiInputHandoff, exited: boolean): PiInputResolution;

package/dist/pi-native-input.js

@@ -0,0 +1,77 @@
+import { randomUUID } from "node:crypto";
+import { constants, closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
+const MAX_MAILBOX_BYTES = 8 * 1024 * 1024;
+export function nativeInputFile(directory, boundaryId, name) {
+    if (!UUID.test(boundaryId))
+        throw new Error("Pi 输入边界标识无效。");
+    return path.join(directory, boundaryId, name + ".json");
+}
+export function writeNativeInput(file, value) {
+    const temporary = file + "." + randomUUID() + ".tmp";
+    writeFileSync(temporary, JSON.stringify(value) + "\n", { mode: 0o600, flag: "wx" });
+    renameSync(temporary, file);
+}
+export function readNativeInput(file) {
+    let fd;
+    try {
+        fd = openSync(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.size > MAX_MAILBOX_BYTES)
+            throw new Error("Pi 输入邮箱无效或超过容量。");
+        return JSON.parse(readFileSync(fd, "utf8"));
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function openNativeInputBoundary(directory) {
+    const id = randomUUID();
+    mkdirSync(path.join(directory, id), { recursive: true, mode: 0o700 });
+    writeNativeInput(nativeInputFile(directory, id, "request"), { id });
+    return id;
+}
+/** Queue reservation is synchronous and durable before publishing the response. */
+export function offerNativeInput(directory, boundaryId, incarnationId, take) {
+    const file = (name) => nativeInputFile(directory, boundaryId, name);
+    if (readNativeInput(file("request"))?.id !== boundaryId
+        || existsSync(file("closed")) || existsSync(file("response")) || existsSync(file("claimed")))
+        return false;
+    const identity = { id: randomUUID(), boundaryId, incarnationId };
+    const text = take(identity);
+    writeNativeInput(file("response"), text === null ? null : { ...identity, text });
+    return true;
+}
+/** Claim precedes any native transcript mutation; an absent claim is safe to release after close/exit. */
+export function claimNativeInput(directory, boundaryId) {
+    const response = nativeInputFile(directory, boundaryId, "response");
+    if (!existsSync(response))
+        return undefined;
+    const claimed = nativeInputFile(directory, boundaryId, "claimed");
+    renameSync(response, claimed);
+    const offer = readNativeInput(claimed);
+    if (offer === null)
+        return null;
+    if (!UUID.test(offer.id) || offer.boundaryId !== boundaryId || !UUID.test(offer.incarnationId)
+        || typeof offer.text !== "string" || !offer.text.trim())
+        throw new Error("Pi 输入交接内容无效。");
+    return offer;
+}
+export function resolveNativeInput(directory, handoff, exited) {
+    const file = (name) => nativeInputFile(directory, handoff.boundaryId, name);
+    const committed = readNativeInput(file("committed"));
+    if (committed?.id === handoff.id && committed.incarnationId === handoff.incarnationId) {
+        return { state: "committed", offer: committed };
+    }
+    if (!existsSync(file("claimed")) && (exited || existsSync(file("closed"))))
+        return { state: "unclaimed" };
+    return { state: "unknown" };
+}

package/dist/pi-tmux-host.d.ts

@@ -1,14 +1,17 @@
+import { type PiInputHandoff, type PiInputResolution } from "./pi-native-input.js";
 import { type StructuredExecHost, type StructuredExecProcess, type StructuredSpawnRequest, type StructuredRunState } from "./structured-exec-host.js";
 interface NativeJob {
     runId: string;
     requestId: string;
     incarnationId: string;
     tmux: string;
+    pane?: string;
     events: string;
     stderr: string;
     state: string;
     ready: string;
     ack: string;
+    input?: string;
 }
 interface WorkerState {
     status: "starting" | "running" | "exited";
@@ -36,6 +39,8 @@ export declare class PiTmuxHost implements StructuredExecHost {
     state(job: NativeJob): WorkerState;
     private snapshot;
     spawnStructured(request: StructuredSpawnRequest): Promise<StructuredExecProcess>;
+    offerPiInput(runId: string, boundaryId: string, take: (identity: PiInputHandoff) => string | null): boolean;
+    resolvePiInput(runId: string, handoff: PiInputHandoff): PiInputResolution;
     attachRun(runId: string, checkpoint?: import("./pi-cli-checkpoint.js").PiCliCheckpoint): Promise<StructuredRunState | null>;
     adoptRun(runId: string): Promise<StructuredExecProcess | null>;
     listRuns(): Promise<StructuredRunState[]>;
@@ -47,21 +52,25 @@ export declare class PiTmuxHost implements StructuredExecHost {
      * 而 forgetRun 只写 ack 标记、从不删目录，所以会按回合数无限堆积。
      *
      * 只回收三类确定无主的东西：
-     * - slot 已 ack 且 runId 不再属于任何存活会话：整个 slot 无主；
+     * - slot 已 ack 且 runId 不在 activeSessionIds 里：整个 slot 无主；
      * - slot 无主的，整槽删除；
      * - slot 仍有主的，只删非 current.json 引用、已 ack 且进程已退出、超保留期的 turn。
      *
-     * 保留 current.json 指向的 turn：`listRuns` / `adoptRun` 仍靠它的 events.jsonl
-     * 重放恢复；未 ack 的 slot 可能是尚未收尾的回合，一律不动。
+     * activeSessionIds 只含未归档会话。归档后不再续接这些 turn，已 ack 且进程退出
+     * 就可以整槽删除，不再额外等保留期；取消归档从会话自己的消息快照恢复。
+     * 保留未归档会话 current.json 指向的 turn：`listRuns` / `adoptRun` 仍靠它的
+     * events.jsonl 重放恢复；未 ack 的 slot 可能是尚未收尾的回合，一律不动。
      */
     collectGarbage(options: {
-        /** 仍在数据库里的会话 id；不在其中的 slot 视为无主。 */
+        /** 未归档会话 id；不在其中的 slot（已删除或已归档）视为无主。 */
         liveSessionIds: ReadonlySet<string>;
+        /** 与 liveSessionIds 同义。传入时优先于旧字段，避免把归档会话算成仍在使用。 */
+        activeSessionIds?: ReadonlySet<string>;
         retentionMs: number;
         now?: number;
     }): PiNativeGcReport;
     private readJob;
-    /** 无主 slot 是否已整体静默：所有 turn 都不再是运行中，且最新写入超过保留期。 */
+    /** 无主 slot 是否已整体静默：所有 turn 都不再是运行中。retentionMs 为 0 时不等待。 */
     private slotIsIdle;
 }
 /** pi-native 回收结果：删了几个 slot / 几个旧 turn / 释放多少字节。 */