@co0ontty/wand 4.106.0 → 4.106.1

package/dist/task-types.js

@@ -1,14 +1,30 @@
-export const WAND_TASK_STATUSES = ["backlog", "todo", "doing", "done", "archived"];
+/** done is retained for historical storage/older callers, never proof of AI approval. */
+export const WAND_TASK_STATUSES = ["backlog", "todo", "doing", "review", "ready", "done", "archived"];
+export function taskWorkflowStage(status) {
+    return status === "done" ? "review" : status;
+}
+export function taskAiVerified(task) {
+    return task.verification?.verdict === "passed" && task.verification.revision === (task.deliveryRevision ?? 0)
+        && typeof task.verification.evidence === "string" && Boolean(task.verification.evidence.trim())
+        && typeof task.verification.blocker === "string" && !task.verification.blocker.trim();
+}
+export function taskHumanAccepted(task) {
+    return Boolean(task.acceptance?.acceptedAt) && task.acceptance?.confirmedRevision === (task.deliveryRevision ?? 0)
+        && typeof task.acceptance?.evidence === "string" && Boolean(task.acceptance.evidence.trim())
+        && typeof task.acceptance?.blocker === "string" && !task.acceptance.blocker.trim();
+}
 export function isWandTaskStatus(value) {
     return typeof value === "string" && WAND_TASK_STATUSES.includes(value);
 }
-/** An explicit execution transition promotes backlog work to doing. */
+/** A new execution returns work to doing; explicit review dispatches preserve review separately. */
 export function statusAfterWandTaskDispatch(status) {
-    return status === "backlog" || status === "todo" ? "doing" : status;
+    if (status === "archived")
+        throw new Error("归档任务需要先恢复再执行。");
+    return "doing";
 }
-/** 已确认或已归档：不再算未完成，也不会被未分组会话同步重新打开。 */
+/** 仅归档关闭活动阶段；待 AI 验收与待人工确认仍属于未完成工作。 */
 export function isClosedWandTaskStatus(status) {
-    return status === "done" || status === "archived";
+    return status === "archived";
 }
 /** 新建任务的默认优先级：用户没挑就是「低」，不再落成「无优先级」。 */
 export const DEFAULT_WAND_TASK_PRIORITY = "low";

package/dist/task-workflow-cli.d.ts

@@ -0,0 +1,2 @@
+/** Never opens owner CLI authentication as a fallback. Exact task and runtime grant only. */
+export declare function runTaskWorkflowCli(args: string[], input?: AsyncIterable<string | Buffer>): Promise<void>;

package/dist/task-workflow-cli.js

@@ -0,0 +1,29 @@
+import { existsSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { WandStorage } from "./storage.js";
+/** Never opens owner CLI authentication as a fallback. Exact task and runtime grant only. */
+export async function runTaskWorkflowCli(args, input = process.stdin) {
+    if (args.length !== 2 || !args[0] || args[0].startsWith("-") || args[1] !== "--stdin")
+        throw new Error("用法：wand task:workflow <task-id> --stdin");
+    const database = process.env.WAND_TASK_DB ?? "", token = process.env.WAND_TASK_TOKEN ?? "";
+    if (!isAbsolute(database) || !existsSync(database) || !/^[A-Za-z0-9_-]{43}$/.test(token))
+        throw new Error("任务回填仅可在有任务级授权的 Wand 员工执行中使用，不能使用所有者登录替代。");
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of input) {
+        const buffer = Buffer.from(chunk);
+        bytes += buffer.length;
+        if (bytes > 96_000)
+            throw new Error("任务回填内容过长。");
+        chunks.push(buffer);
+    }
+    const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    const storage = new WandStorage(database);
+    try {
+        const task = storage.applyEmployeeTaskWorkflow(token, args[0], value);
+        process.stdout.write(JSON.stringify({ saved: true, task }) + "\n");
+    }
+    finally {
+        storage.close();
+    }
+}

package/dist/task-workflow-runner.d.ts

@@ -0,0 +1,4 @@
+import type { WandStorage } from "./storage.js";
+import type { StructuredRunnerAdapter, StructuredRunnerContext, StructuredRunnerExecution, StructuredRunnerObserver } from "./structured-runner.js";
+/** Runtime-only exact-task grant, independent of owner login and knowledge authorization. */
+export declare function startTaskWorkflowRunner(storage: WandStorage, runner: StructuredRunnerAdapter, context: StructuredRunnerContext, observer: StructuredRunnerObserver): StructuredRunnerExecution;

package/dist/task-workflow-runner.js

@@ -0,0 +1,36 @@
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { shellQuote } from "./shell-quote.js";
+/** Runtime-only exact-task grant, independent of owner login and knowledge authorization. */
+export function startTaskWorkflowRunner(storage, runner, context, observer) {
+    const env = { ...context.env };
+    delete env.WAND_TASK_DB;
+    delete env.WAND_TASK_TOKEN;
+    if (context.session.automationId?.startsWith("dingtalk:"))
+        return runner.start({ ...context, env }, observer);
+    const scope = storage.knowledgeSessionScope(context.session.id);
+    const grant = (context.session.employeeId ?? null) === (scope?.employeeId ?? null) ? storage.issueTaskWorkflowAccess(context.session.id) : null;
+    if (!grant)
+        return runner.start({ ...context, env }, observer);
+    const js = fileURLToPath(new URL("./cli.js", import.meta.url));
+    const command = existsSync(js) ? `${shellQuote(process.execPath)} ${shellQuote(js)}` : `${shellQuote(process.execPath)} --import tsx ${shellQuote(js.replace(/\.js$/, ".ts"))}`;
+    const instruction = [
+        `当前任务回填范围仅为 ${grant.taskId}，交付版本 ${grant.revision}（ID/版本不是凭据）。`,
+        `先用 wand task:context ${grant.taskId} 读取最新 updatedAt、目标、证据和状态。确实完成交付时使用 submit；被明确派发验收时，根据实际证据用 pass 或 fail。未验证项按 fail 写明 blocker，不得因会话结束或自己声称完成而通过。`,
+        `回填命令：${command} task:workflow ${grant.taskId} --stdin。stdin 为 JSON {"action":"submit|pass|fail","requestId":"同一意图固定UUID","expectedUpdatedAt":"读取到的任务.updatedAt","evidence":"实际证据","blocker":"失败或无法验证的原因，通过时为空"}。`,
+        "该能力不能人工确认、归档、跨任务写入或派发。版本冲突先保留草稿并重新读取核对；未知回执不得换 requestId 重做。权限失效等待新的执行，不回退到所有者身份。提交后需独立新一轮验收，不在同一执行自提交自验收。验收结论必须实际回填，不能仅留在回复里。",
+    ].join("\n\n");
+    const cleanup = () => { try {
+        storage.revokeTaskWorkflowAccess(grant.token);
+    }
+    catch { /* storage may be shutting down */ } };
+    try {
+        const execution = runner.start({ ...context, env: { ...env, WAND_TASK_DB: storage.databasePath(), WAND_TASK_TOKEN: grant.token }, session: { ...context.session,
+                runtimeSystemPrompt: [context.session.runtimeSystemPrompt, instruction].filter(Boolean).join("\n\n") } }, observer);
+        return { ...execution, completion: execution.completion.finally(cleanup), interrupt: () => { cleanup(); execution.interrupt(); } };
+    }
+    catch (error) {
+        cleanup();
+        throw error;
+    }
+}

package/dist/task-workflow.d.ts

@@ -0,0 +1,13 @@
+import { type TaskWorkflowAction, type TaskWorkflowInput, type WandTask } from "./task-types.js";
+import type { WandTaskPatch } from "./storage/internal.js";
+export declare const TASK_WORKFLOW_ACTIONS: readonly TaskWorkflowAction[];
+export type TaskWorkflowActor = {
+    kind: "user";
+} | {
+    kind: "employee";
+    sessionId: string;
+    employeeId: string | null;
+};
+export declare function parseTaskWorkflowInput(value: unknown): TaskWorkflowInput;
+/** Pure transition; storage owns CAS, live execution checks, receipts and atomic history. */
+export declare function taskWorkflowPatch(task: WandTask, children: WandTask[], input: TaskWorkflowInput, actor: TaskWorkflowActor, now: string): WandTaskPatch;

package/dist/task-workflow.js

@@ -0,0 +1,48 @@
+import { HttpError } from "./http-error.js";
+import { taskAiVerified, taskHumanAccepted, taskWorkflowStage } from "./task-types.js";
+export const TASK_WORKFLOW_ACTIONS = ["submit", "pass", "fail", "return", "accept"];
+const fail = (message) => { throw new HttpError(409, "task_workflow_conflict", message); };
+export function parseTaskWorkflowInput(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new HttpError(400, "bad_request", "需要工作流动作。");
+    const body = value;
+    if (Object.keys(body).some(key => !["action", "requestId", "expectedUpdatedAt", "evidence", "blocker"].includes(key)))
+        throw new HttpError(400, "bad_request", "工作流包含不支持的字段。");
+    if (!TASK_WORKFLOW_ACTIONS.includes(body.action)
+        || typeof body.requestId !== "string" || !/^[a-zA-Z0-9:_-]{8,80}$/.test(body.requestId)
+        || typeof body.expectedUpdatedAt !== "string" || !body.expectedUpdatedAt
+        || typeof body.evidence !== "string" || body.evidence.length > 16000
+        || typeof body.blocker !== "string" || body.blocker.length > 4000)
+        throw new HttpError(400, "bad_request", "工作流动作、请求标识、任务版本或交付证据无效。");
+    return { action: body.action, requestId: body.requestId, expectedUpdatedAt: body.expectedUpdatedAt, evidence: body.evidence.trim(), blocker: body.blocker.trim() };
+}
+/** Pure transition; storage owns CAS, live execution checks, receipts and atomic history. */
+export function taskWorkflowPatch(task, children, input, actor, now) {
+    const { action, evidence, blocker } = input;
+    const stage = taskWorkflowStage(task.status), revision = task.deliveryRevision ?? 0;
+    if (actor.kind !== "user" && (action === "accept" || action === "return"))
+        throw new HttpError(403, "forbidden", "AI 只能提交交付或回填验收，不能代替人工确认或退回。");
+    if ((action === "submit" && stage !== "doing") || ((action === "pass" || action === "fail") && stage !== "review") || ((action === "accept" || action === "return") && stage !== "ready"))
+        fail("任务阶段已变化，请刷新并核对，不能跨阶段推进。");
+    if (["submit", "pass", "accept"].includes(action) && (!evidence || blocker))
+        fail("需要交付证据，且不能遗留缺口或未验证项。");
+    if ((action === "fail" || action === "return") && !blocker)
+        fail("失败、无法验证或退回必须写明原因。");
+    const acceptance = { evidence, blocker, acceptedAt: null };
+    if (action === "submit")
+        return { status: "review", deliveryRevision: revision + 1, verification: null, acceptance };
+    if (action === "return")
+        return { status: "doing", deliveryRevision: revision + 1, verification: null, acceptance };
+    if (action === "accept") {
+        if (!taskAiVerified(task))
+            fail("没有针对当前交付的 AI 验收通过记录，请先完成验收。");
+        if (children.some(child => !taskHumanAccepted(child)))
+            fail("仍有子任务未由人工确认，请先确认子任务。");
+        return { status: "archived", acceptance: { evidence, blocker: "", acceptedAt: now, confirmedRevision: revision } };
+    }
+    if (action === "pass" && children.some(child => !taskAiVerified(child)))
+        fail("仍有子任务未通过 AI 验收，不能通过主目标整体验收。");
+    return { status: action === "pass" ? "ready" : "doing", acceptance,
+        verification: { verdict: action === "pass" ? "passed" : "failed", evidence, blocker, reviewedAt: now, revision,
+            sourceSessionId: actor.kind === "employee" ? actor.sessionId : null, reviewerId: actor.kind === "employee" ? actor.employeeId : null } };
+}

package/dist/terminal-daemon-server.js

@@ -379,10 +379,11 @@ export async function runTerminalDaemon(configPath) {
             switch (request.method) {
                 case "hello":
                     result = { protocolVersion: TERMINAL_DAEMON_PROTOCOL_VERSION, pid: process.pid,
-                        buildId: TERMINAL_DAEMON_BUILD_ID, shutdownIfIdle: true };
+                        buildId: TERMINAL_DAEMON_BUILD_ID, shutdownIfIdle: true, ...(tmux ? { detachTmuxOnShutdown: true } : {}) };
                     break;
                 case "shutdownIfIdle": {
-                    const busy = pendingStarts.size > 0 || [...sessions.values(), ...structuredRuns.values()].some((entry) => entry.status === "running");
+                    const busy = pendingStarts.size > 0 || [...structuredRuns.values()].some(entry => entry.status === "running")
+                        || (!tmux && [...sessions.values()].some(entry => entry.status === "running"));
                     result = { accepted: !busy };
                     if (!busy && !retiring) {
                         // The idle check and admission closure happen in the same event-loop turn.
@@ -546,8 +547,15 @@ export async function runTerminalDaemon(configPath) {
         retiring = true;
         await Promise.allSettled(pendingStarts.values());
         stopSocketKeepalive();
-        for (const sessionId of Array.from(sessions.keys()))
-            forget(sessionId);
+        for (const [sessionId, session] of sessions) {
+            if (tmux && session.process?.detach) {
+                session.process.detach();
+                session.terminalState.dispose();
+                sessions.delete(sessionId);
+            }
+            else
+                forget(sessionId);
+        }
         for (const runId of Array.from(structuredRuns.keys()))
             structuredForget(runId);
         for (const client of clients)

package/dist/tmux-policy.d.ts

@@ -1,2 +1,11 @@
+export interface TmuxProbeResult {
+    ok: boolean;
+    version?: string;
+    path?: string;
+    error?: string;
+}
+export declare const TMUX_MINIMUM_VERSION = "2.9";
+/** 探测系统 tmux 可用性与版本能力（最低要求 2.9+ 以支持 pane 管道与用户元数据）。 */
+export declare function probeTmuxSupport(env?: NodeJS.ProcessEnv): TmuxProbeResult;
 /** Configuration selects new executions only; existing owners remain recoverable. */
 export declare function tmuxEnabled(env?: NodeJS.ProcessEnv): boolean;

package/dist/tmux-policy.js

@@ -1,3 +1,49 @@
+import { execFileSync } from "node:child_process";
+export const TMUX_MINIMUM_VERSION = "2.9";
+/** 探测系统 tmux 可用性与版本能力（最低要求 2.9+ 以支持 pane 管道与用户元数据）。 */
+export function probeTmuxSupport(env = process.env) {
+    if (process.platform === "win32") {
+        return { ok: false, error: "tmux 执行环境仅支持 POSIX 主机系统。" };
+    }
+    const childEnv = { PATH: env.PATH, HOME: env.HOME, LANG: env.LANG };
+    let rawVersion;
+    try {
+        rawVersion = execFileSync("tmux", ["-V"], {
+            encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 3000, env: childEnv,
+        }).trim();
+    }
+    catch (error) {
+        const err = error;
+        return {
+            ok: false,
+            error: err.code === "ENOENT"
+                ? "未找到 tmux 可执行文件，请确认 tmux 已安装且在系统 PATH 中。"
+                : `tmux 探测失败: ${error.message}`,
+        };
+    }
+    const match = rawVersion.match(/(\d+)\.(\d+)/);
+    if (!match) {
+        return { ok: true, version: rawVersion, path: resolveTmuxPath(childEnv) };
+    }
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    if (major < 2 || (major === 2 && minor < 9)) {
+        return {
+            ok: false,
+            version: rawVersion,
+            error: `tmux 版本过低（当前 ${rawVersion}，最低需要 ${TMUX_MINIMUM_VERSION}+ 以支持 pane 管道与用户元数据）。`,
+        };
+    }
+    return { ok: true, version: rawVersion, path: resolveTmuxPath(childEnv) };
+}
+function resolveTmuxPath(env) {
+    try {
+        return execFileSync("which", ["tmux"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], env }).trim();
+    }
+    catch {
+        return "tmux";
+    }
+}
 /** Configuration selects new executions only; existing owners remain recoverable. */
 export function tmuxEnabled(env = process.env) {
     const mode = env.WAND_TMUX_MODE;

package/dist/tmux-terminal-host.js

@@ -1,22 +1,25 @@
 import path from "node:path";
 import { createTerminalHost, TerminalDaemonClient } from "./terminal-daemon-client.js";
-import { tmuxEnabled } from "./tmux-policy.js";
+import { probeTmuxSupport, tmuxEnabled } from "./tmux-policy.js";
 import { logInfo } from "./runtime-log.js";
 /** Existing owners win even after changing the policy; unknown inventory fails closed. */
 export async function createTmuxTerminalHost(configPath, previous, createHost = createTerminalHost) {
     const daemonConfig = path.join(path.dirname(configPath), "tmux-terminald.json");
     const enabled = tmuxEnabled();
+    const probe = enabled ? probeTmuxSupport() : { ok: true };
     const { existsSync } = await import("node:fs");
     if (!enabled && !existsSync(path.join(path.dirname(configPath), "pty-tmux"))) {
         return { host: previous, client: null, configPath: daemonConfig };
     }
     let tmux;
     try {
+        if (!probe.ok)
+            throw new Error(probe.error);
         tmux = await createHost(daemonConfig, { persistent: true });
     }
     catch (cause) {
         const unavailable = () => new Error("tmux terminal ownership is unavailable; refusing execution or maintenance", { cause });
-        logInfo("tmux terminal backend unavailable; existing other owners remain accessible, new PTY execution is blocked");
+        logInfo(`tmux terminal backend unavailable${probe.error ? `: ${probe.error}` : ""}; existing other owners remain accessible, new PTY execution is blocked`);
         return {
             configPath: daemonConfig,
             client: null,

package/dist/tui/commands.js

@@ -11,6 +11,7 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { checkPackageUpdateSync, installPackageGloballySync, normalizeUpdateChannel, resolveGlobalWandBin, resolveGlobalWandCli, } from "../npm-update-utils.js";
+import { RUNNING_BUILD_INFO } from "../build-info.js";
 import { whichSync } from "../path-repair.js";
 import { computeRelaunch } from "../relaunch.js";
 import { ensureDatabaseFile, resolveDatabasePath, WandStorage } from "../storage.js";
@@ -68,7 +69,7 @@ export function readUpdateChannel(configPath) {
 }
 /** 通过 npm dist-tag 拿到当前通道最新版本号。失败返回 latest=null。 */
 export function checkUpdate(currentVersion, channel = "stable") {
-    const info = checkPackageUpdateSync(currentVersion, channel);
+    const info = checkPackageUpdateSync(currentVersion, channel, undefined, RUNNING_BUILD_INFO);
     return {
         channel: info.channel,
         current: info.current,

package/dist/types.d.ts

@@ -438,6 +438,8 @@ export interface CommandRequest {
 }
 export interface InputRequest {
     input?: string;
+    /** Structured input acceptance identity; same key must preserve the same intent. */
+    idempotencyKey?: string;
     /**
      * Structured sessions normally keep the HTTP request open until the whole
      * turn finishes. Native clients can opt into an accepted snapshot instead
@@ -743,6 +745,8 @@ export interface StructuredSessionState {
     lastActivityAt?: string | null;
     /** Pi 已结束前台回复、但 CLI 仍在等待异步子任务收尾。 */
     phase?: "responding" | "background";
+    /** Actual running input capability; absent/turn-end means wait for the whole run. */
+    inputMode?: "steer" | "turn-end";
     /**
      * 本轮实际使用的执行引擎：`core` = Wand 进程内 harness（目前仅 pi），
      * `cli` = 外部 CLI runner。决定重启后能否恢复：进程内回合不会比服务活得更久。
@@ -983,6 +987,7 @@ export type WorkspaceTaskStatus = "active" | "done";
  * 一个工作空间下可有多个任务，任务在侧栏列表里单独展示；每个任务的会话共享该任务的 worktree。
  */
 export interface WorkspaceTask {
+    kind?: "task" | "section";
     id: string;
     workspaceId: string;
     name: string;

package/dist/wand-task-sync.js

@@ -51,6 +51,11 @@ function taskNamingSessions(storage, card) {
     const addSlim = (session) => {
         if (!session)
             return;
+        // An explicit verification round describes the check, not a new delivery goal.
+        // Classify by its durable dispatch purpose, never by words in the title/prompt.
+        if (session.automationId?.startsWith("wand-task-comment:")
+            && storage.isTaskReviewComment(session.automationId.slice("wand-task-comment:".length)))
+            return;
         add(session);
         // boardTitleFromSession 只在 title/description 都缺时才翻 messages 找首条用户输入。
         if (!isBlankTerminal(session) && !session.title?.trim() && !session.description?.trim()) {