@co0ontty/wand 4.106.0 → 4.106.1

package/dist/pi-tmux-host.js

@@ -6,10 +6,11 @@ import path from "node:path";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-import { buildChildEnv } from "./env-utils.js";
+import { buildChildEnv, systemEnvValue } from "./env-utils.js";
 import { shellQuote } from "./shell-quote.js";
 import { logInfo } from "./runtime-log.js";
 import { signalNumberFromName } from "./signal-utils.js";
+import { offerNativeInput, resolveNativeInput } from "./pi-native-input.js";
 import { createUtf8TextDecoder } from "./structured-exec-host.js";
 const execute = promisify(execFile);
 const REPLAY_BYTES = 8 * 1024 * 1024;
@@ -164,7 +165,9 @@ export class PiTmuxHost {
         }
     }
     async tmux(args) {
-        const result = await execute("tmux", args, { env: buildChildEnv(false), timeout: 10000, maxBuffer: 1024 * 1024 });
+        const result = await execute("tmux", ["-L", "default", ...args], {
+            env: buildChildEnv(false, { TMUX_TMPDIR: systemEnvValue("TMUX_TMPDIR") }), timeout: 10000, maxBuffer: 1024 * 1024,
+        });
         return result.stdout;
     }
     state(job) {
@@ -264,12 +267,13 @@ export class PiTmuxHost {
         const sid = request.runId.replace(/^structured:/, "").replace(/[^a-zA-Z0-9-]/g, "-");
         const job = { runId: request.runId, requestId: request.requestId ?? incarnationId, incarnationId,
             tmux: this.prefix + sid + "-" + incarnationId.slice(0, 8), events: path.join(dir, "events.jsonl"), stderr: path.join(dir, "stderr.log"),
-            state: path.join(dir, "state.json"), ready: path.join(dir, "ready.json"), ack: path.join(dir, "ack") };
+            state: path.join(dir, "state.json"), ready: path.join(dir, "ready.json"), ack: path.join(dir, "ack"), input: path.join(dir, "input") };
+        mkdirSync(job.input, { mode: 0o700 });
         for (const file of [job.events, job.stderr])
             writeFileSync(file, "", { mode: 0o600 });
         atomic(job.state, { status: "starting", pid: -1, exitCode: null, signal: null });
         const paths = path.join(dir, "paths.json");
-        atomic(paths, { events: job.events, ready: job.ready });
+        atomic(paths, { events: job.events, ready: job.ready, input: job.input, initialMessageId: request.nativeInputMessageId });
         const launchDir = mkdtempSync(path.join(os.tmpdir(), "wand-pi-launch-"));
         const socket = path.join(launchDir, "start.sock");
         let handedOff = false;
@@ -298,7 +302,7 @@ export class PiTmuxHost {
         try {
             let exists = false;
             try {
-                await this.tmux(["has-session", "-t", job.tmux]);
+                await this.tmux(["has-session", "-t", `=${job.tmux}`]);
                 exists = true;
             }
             catch { /* a new owned session */ }
@@ -306,11 +310,13 @@ export class PiTmuxHost {
                 throw new Error("tmux 名称已被其他会话使用，未接管或停止它。");
             }
             else {
-                await this.tmux(["new-session", "-d", "-s", job.tmux, "-x", "120", "-y", "36", "-c", request.cwd, command]);
+                job.pane = (await this.tmux(["new-session", "-d", "-P", "-F", "#{pane_id}", "-s", job.tmux, "-x", "120", "-y", "36", "-c", request.cwd, command])).trim();
+                if (!/^%\d+$/.test(job.pane))
+                    throw new Error("Pi tmux pane identity is unavailable");
                 await this.tmux(["set-option", "-t", job.tmux, "@wand-native-owner", request.runId]);
-                await this.tmux(["set-window-option", "-t", `${job.tmux}:0`, "remain-on-exit", "off"]);
+                await this.tmux(["set-window-option", "-t", job.pane, "remain-on-exit", "off"]);
             }
-            const workerPid = Number((await this.tmux(["list-panes", "-t", `${job.tmux}:0.0`, "-F", "#{pane_pid}"])).trim());
+            const workerPid = Number((await this.tmux(["display-message", "-p", "-t", job.pane, "#{pane_pid}"])).trim());
             atomic(job.state, { status: "starting", pid: workerPid, workerPid, exitCode: null, signal: null });
             if (request.launchSignal?.aborted)
                 throw new Error("Pi 原生启动已取消，未发送输入。");
@@ -347,6 +353,43 @@ export class PiTmuxHost {
             rmSync(launchDir, { recursive: true, force: true });
         }
     }
+    offerPiInput(runId, boundaryId, take) {
+        const job = this.job(runId);
+        if (!job?.input || existsSync(job.ack) || this.state(job).status !== "running")
+            return false;
+        return offerNativeInput(job.input, boundaryId, job.incarnationId, take);
+    }
+    resolvePiInput(runId, handoff) {
+        const job = this.job(runId);
+        if (!job?.input || job.incarnationId !== handoff.incarnationId)
+            return { state: "unknown" };
+        const exited = this.state(job).status === "exited";
+        const resolution = resolveNativeInput(job.input, handoff, exited);
+        if (resolution.state !== "unknown" || !exited)
+            return resolution;
+        // The CLI may exit after committing its boundary but before the next event.
+        // Resolve only an exact native entry id from that execution's private session.
+        const ready = readJson(job.ready);
+        if (!ready?.sessionFile)
+            return resolution;
+        try {
+            const stat = lstatSync(ready.sessionFile);
+            if (!stat.isFile() || stat.isSymbolicLink() || stat.size > REPLAY_BYTES * 8)
+                return resolution;
+            const records = readFileSync(ready.sessionFile, "utf8").split("\n");
+            for (const line of records) {
+                if (!line.trim())
+                    continue;
+                const entry = JSON.parse(line);
+                if (entry.type === "custom_message" && entry.customType === "wand-user-input"
+                    && entry.details?.inputId === handoff.id && typeof entry.content === "string") {
+                    return { state: "committed", offer: { ...handoff, text: entry.content } };
+                }
+            }
+        }
+        catch { /* Missing or invalid native history remains unknown, never a replay permission. */ }
+        return resolution;
+    }
     async attachRun(runId, checkpoint) {
         const job = this.job(runId);
         if (job && !existsSync(job.ack)) {
@@ -396,9 +439,13 @@ export class PiTmuxHost {
         const stopping = (async () => {
             let tag;
             try {
-                const name = (await this.tmux(["display-message", "-p", "-t", job.tmux, "#{session_name}"])).trim();
-                if (name !== job.tmux)
+                const panes = (await this.tmux(["list-panes", "-t", `=${job.tmux}`, "-F", "#{session_name}\t#{pane_id}\t#{pane_pid}"])).trim().split("\n");
+                const identity = job.pane ? panes.find(line => line.split("\t")[1] === job.pane) : panes[0];
+                if (!identity || identity.split("\t")[0] !== job.tmux)
                     throw new Error("Pi tmux 精确目标不匹配，拒绝停止。");
+                const workerPid = this.state(job).workerPid;
+                if (workerPid && Number(identity.split("\t")[2]) !== workerPid)
+                    throw new Error("Pi tmux pane generation changed");
                 tag = (await this.tmux(["show-options", "-v", "-t", job.tmux, "@wand-native-owner"])).trim();
             }
             catch (error) {
@@ -408,7 +455,7 @@ export class PiTmuxHost {
             }
             if (tag !== job.runId)
                 throw new Error("Pi tmux 所有权不匹配，拒绝停止。");
-            await this.tmux(["kill-session", "-t", job.tmux]);
+            await this.tmux(["kill-session", "-t", `=${job.tmux}`]);
         })();
         this.terminations.set(job.incarnationId, stopping);
         void stopping.catch(() => this.terminations.delete(job.incarnationId));
@@ -445,14 +492,17 @@ export class PiTmuxHost {
      * 而 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) {
+        const activeSessionIds = options.activeSessionIds ?? options.liveSessionIds;
         const report = { removedSlots: 0, removedTurns: 0, freedBytes: 0 };
         const now = options.now ?? Date.now();
         let entries;
@@ -471,12 +521,13 @@ export class PiTmuxHost {
                 continue;
             const acked = existsSync(job.ack);
             const sessionId = job.runId.replace(/^structured:/, "");
-            const orphan = !options.liveSessionIds.has(sessionId);
+            const orphan = !activeSessionIds.has(sessionId);
             if (orphan) {
                 // 无主 slot 也得等 ack 完成：未 ack 说明回合可能还在收尾。
+                // 已删除和已归档都不再续接，进程退出后不再额外等保留期。
                 if (!acked)
                     continue;
-                if (!this.slotIsIdle(slot, job, now, options.retentionMs))
+                if (!this.slotIsIdle(slot, job, now, 0))
                     continue;
                 report.freedBytes += directoryBytes(slot);
                 if (removeTree(slot))
@@ -533,7 +584,7 @@ export class PiTmuxHost {
             return null;
         }
     }
-    /** 无主 slot 是否已整体静默：所有 turn 都不再是运行中，且最新写入超过保留期。 */
+    /** 无主 slot 是否已整体静默：所有 turn 都不再是运行中。retentionMs 为 0 时不等待。 */
     slotIsIdle(slot, job, now, retentionMs) {
         const current = path.dirname(job.events);
         const state = readJson(job.state);

package/dist/process-manager.js

@@ -1,5 +1,6 @@
-import { knowledgeInstructions } from "./employee-knowledge.js";
+import { globalKnowledgeContext, knowledgeInstructions } from "./employee-knowledge.js";
 import { isOpenRouterFreeSelector } from "./openrouter-free-models.js";
+import { openCodeMajorVersion } from "./opencode-cli.js";
 import { isAutoAssignSelector, defaultModelGroupSelector, resolveModelGroupModels } from "./model-groups.js";
 import { resolveAutoAssign } from "./model-auto-assign.js";
 import { getDefaultModelForProvider } from "./config.js";
@@ -794,6 +795,15 @@ export class ProcessManager extends EventEmitter {
         if (preferredModels.some(isOpenRouterFreeSelector))
             throw new Error("免费模型分组仅支持 Pi 结构化对话。");
         const baseCwd = resolveSessionCwd(cwd, this.config.defaultCwd);
+        const openCodeEnv = groupProvider === "opencode" ? buildChildEnv(this.config.inheritEnv !== false) : undefined;
+        const openCodeV2 = !!openCodeEnv && await openCodeMajorVersion(openCodeEnv) >= 2;
+        let openCodeConfig;
+        if (openCodeV2 && preferredModels[0]) {
+            const configured = openCodeEnv.OPENCODE_CONFIG_CONTENT ? JSON.parse(openCodeEnv.OPENCODE_CONFIG_CONTENT) : {};
+            if (!configured || typeof configured !== "object" || Array.isArray(configured))
+                throw new Error("OpenCode 内联配置无效。");
+            openCodeConfig = JSON.stringify({ ...configured, model: preferredModels[0] });
+        }
         if (this.disposed || start.cancelled)
             throw new Error("终端启动已取消。");
         // When a session is being resumed under the same id, capture its prior
@@ -843,7 +853,10 @@ export class ProcessManager extends EventEmitter {
         // Resolve before touching a resume record/worktree; invalid groups must not disturb prior work.
         // PTY has no reliable pre-input acceptance fact: use the preferred member, never replay automatically.
         const initialThinkingEffort = normalizeThinkingEffort(opts?.thinkingEffort);
-        let processedCommand = this.processCommandForMode(command, effectiveMode, provider, preferredModels[0], initialThinkingEffort);
+        // v2's interactive CLI takes its model from config; --model belongs to `run` only.
+        let processedCommand = this.processCommandForMode(command, effectiveMode, provider, openCodeV2 ? undefined : preferredModels[0], initialThinkingEffort);
+        if (openCodeV2 && !/--(?:standalone|server)(?:\s|=|$)/.test(processedCommand))
+            processedCommand += " --standalone";
         // 会话级系统提示：provider 有系统提示开关就走开关（PTY 与结构化行为一致），没有就并进首条输入。
         const systemPrompt = (opts?.systemPrompt ?? inheritedRole?.systemPrompt)?.trim() || undefined;
         let initialInputText = initialInput;
@@ -945,7 +958,7 @@ export class ProcessManager extends EventEmitter {
             // Derive authority only after the real session/project binding has been persisted.
             const access = provider ? this.storage.knowledgeSessionScope(id) : null;
             const knowledgeToken = access ? this.storage.issueKnowledgeAccess(id) : undefined;
-            const runtimePrompt = access ? [knowledgeInstructions(access),
+            const runtimePrompt = access ? [globalKnowledgeContext(this.storage), knowledgeInstructions(access),
                 "本终端会话的知识工具只在有效执行期内可用；每次使用知识先 search/read，不把旧轮次快照当作当前状态。访问失效时新开一轮结构化执行或恢复会话，不绕过权限。"].join("\n\n") : undefined;
             const launchPrompt = [systemPrompt, runtimePrompt].filter(Boolean).join("\n\n") || undefined;
             initialInputText = initialInput && launchPrompt && !systemPromptFlag(provider)
@@ -962,6 +975,7 @@ export class ProcessManager extends EventEmitter {
                 args: launchPlan.shellArgs,
                 cwd: resolvedCwd,
                 env: buildChildEnv(this.config.inheritEnv !== false, {
+                    ...(openCodeConfig ? { OPENCODE_CONFIG_CONTENT: openCodeConfig } : {}),
                     WAND_SESSION_ID: id,
                     WAND_KNOWLEDGE_DB: knowledgeToken ? this.storage.databasePath() : undefined,
                     WAND_KNOWLEDGE_TOKEN: knowledgeToken,

package/dist/pty-tmux-backend.d.ts

@@ -4,6 +4,8 @@ export interface DaemonPty {
     write(data: string): void;
     resize(cols: number, rows: number): void;
     kill(signal?: string): void;
+    /** Retire only the observer/attach client; the tmux pane keeps running. */
+    detach?(): void;
     onData(listener: (data: string) => void): {
         dispose(): void;
     };
@@ -11,13 +13,36 @@ export interface DaemonPty {
         dispose(): void;
     };
 }
-/** A private tmux server owns panes; attach transports are disposable, not execution owners. */
+export interface PtyTmuxGcReport {
+    removedRecords: number;
+    freedBytes: number;
+    removedSockets: number;
+}
+/** The default tmux server owns panes; attach transports are disposable, not execution owners. */
 export declare class PtyTmuxBackend {
     private readonly directory;
-    private readonly socket;
+    private readonly legacySocket;
     constructor(configPath: string);
+    private connection;
     private tmux;
+    private pane;
+    /**
+     * 只认稳定身份：会话名 + 我们创建的 pane id + 写入的 owner 标记。
+     * `pane_pid` 在新建后可能还没就绪，不能作为归属证据；需要时从实时结果取。
+     */
+    private assertOwner;
+    private isTmuxMissing;
     forget(sessionId: string): void;
+    collectGarbage(options: {
+        activeSessionIds: ReadonlySet<string>;
+        retentionMs: number;
+        now?: number;
+    }): PtyTmuxGcReport;
+    static collectGarbage(configDir: string, options: {
+        activeSessionIds: ReadonlySet<string>;
+        retentionMs: number;
+        now?: number;
+    }): PtyTmuxGcReport;
     recover(exclude?: ReadonlySet<string>): Array<{
         request: TerminalSpawnRequest;
         child: DaemonPty;