@co0ontty/wand 4.70.0 → 4.71.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "ff952fe9969d72b01a59cc98cd1ca17b9d16649e",
-  "builtAt": "2026-09-17T14:25:36.640Z",
-  "version": "4.70.0",
+  "commit": "fad4d4b5db4c4be548f414c6de249f84700daa33",
+  "builtAt": "2026-09-19T07:12:02.224Z",
+  "version": "4.71.0",
   "channel": "stable"
 }

package/dist/milestone-scope.d.ts

@@ -0,0 +1,6 @@
+import type { WandStorage } from "./storage.js";
+/**
+ * 把里程碑 id 收敛到「任务所在工作区能用」的范围；不兼容就返回 null（解绑）。
+ * 调用方负责先校验 id 是否存在。
+ */
+export declare function scopedMilestoneId(storage: WandStorage, milestoneId: string | null | undefined, workspaceId: string | null | undefined): string | null;

package/dist/milestone-scope.js

@@ -0,0 +1,20 @@
+// 迭代（里程碑）按工作区归属，规则只有一条：
+// 项目里的任务只能挂「本项目的迭代」或「全局迭代（没绑工作区的）」。
+// 没归属项目的任务（未分配 / 隐藏的全局工作区）不受限，避免把独立任务限制死。
+// 移动端只会 PATCH `workspaceId`，不会自己清里程碑，所以这条规则必须由服务端兜住。
+/**
+ * 把里程碑 id 收敛到「任务所在工作区能用」的范围；不兼容就返回 null（解绑）。
+ * 调用方负责先校验 id 是否存在。
+ */
+export function scopedMilestoneId(storage, milestoneId, workspaceId) {
+    if (!milestoneId)
+        return null;
+    const milestone = storage.getWandMilestone(milestoneId);
+    // 里程碑没了 / 是全局迭代：原样保留。
+    if (!milestone || !milestone.workspaceId)
+        return milestoneId;
+    // 任务不在项目里：不限。
+    if (!workspaceId)
+        return milestoneId;
+    return milestone.workspaceId === workspaceId ? milestoneId : null;
+}

package/dist/missions.js

@@ -3,6 +3,7 @@ import { existsSync, statSync } from "node:fs";
 import path from "node:path";
 import { buildMissionDiff } from "./mission-diff.js";
 import { isSessionProvider } from "./session-provider.js";
+import { syncWorkspaceTaskToBoard } from "./wand-task-sync.js";
 const MAX_ATTEMPTS = 6;
 function nowIso() {
     return new Date().toISOString();
@@ -321,6 +322,8 @@ export class Missions {
                 sessionSource: "automation",
                 automationId: mission.id,
             });
+            // 关联任务的派发会话立刻落到任务卡片上，不等下一次看板列表的兜底同步。
+            syncWorkspaceTaskToBoard(this.storage, mission.taskId);
             attempt = {
                 ...attempt,
                 sessionId: session.id,

package/dist/provider-cli-updater.d.ts

@@ -1,4 +1,4 @@
-export type ProviderCliId = "claude" | "codex" | "opencode" | "qoder" | "pi";
+export type ProviderCliId = "claude" | "codex" | "opencode" | "grok" | "qoder" | "pi";
 export interface ProviderCliUpdateStatus {
     id: ProviderCliId;
     label: string;
@@ -31,7 +31,21 @@ export interface ProviderCliUpdaterOptions {
     onLog?: (line: string) => void;
 }
 export declare function parseProviderCliVersion(output: string): string | null;
+/**
+ * Homebrew 托管的 CLI 官方更新器会拒绍动手（实测 `claude update` 只打印
+ * "managed by Homebrew" 并不改版本），所以直接给出正确的 brew 命令。
+ */
+export declare function homebrewUpdateHint(executable: string | null): string | null;
+/** 从 `/opt/homebrew/Caskroom/<cask>/…` / `/Cellar/<formula>/…` 反解 Homebrew 包名。 */
+export declare function parseHomebrewInstall(executable: string | null): {
+    kind: "cask" | "formula";
+    name: string;
+} | null;
 export declare function providerCliUpdateAvailable(currentVersion: string | null, latestVersion: string | null): boolean;
+/** 从 `brew info --json=v2` 输出里取 cask version / formula stable 版本。 */
+export declare function parseBrewInfoVersion(output: string, kind: "cask" | "formula"): string | null;
+/** `grok update --check --json` 的 JSON 行里取 `latestVersion`；日志混排也能挑出来。 */
+export declare function parseCliLatestVersionJson(output: string): string | null;
 export declare function checkProviderCliUpdates(options?: ProviderCliUpdaterOptions): Promise<ProviderCliUpdateStatus[]>;
 export declare function updateProviderClis(statuses: ProviderCliUpdateStatus[], ids?: ProviderCliId[], options?: ProviderCliUpdaterOptions): Promise<ProviderCliUpdateResult[]>;
 /** Re-check the active PATH after updating so duplicate installs cannot masquerade as success. */

package/dist/provider-cli-updater.js

@@ -36,6 +36,15 @@ const PROVIDER_CLI_SPECS = [
         versionArgs: ["--version"],
         updateArgs: ["upgrade"],
     },
+    {
+        id: "grok",
+        label: "Grok CLI",
+        command: "grok",
+        // Grok CLI 没有 npm 发布渠道，最新版只能问它自己。
+        versionArgs: ["--version"],
+        updateArgs: ["update"],
+        cliLatestArgs: ["update", "--check", "--json"],
+    },
     {
         id: "qoder",
         label: "Qoder CLI",
@@ -48,7 +57,9 @@ const PROVIDER_CLI_SPECS = [
         id: "pi",
         label: "Pi CLI",
         command: "pi",
-        npmPackage: "@mariozechner/pi-coding-agent",
+        // pi 已从 @mariozechner/pi-coding-agent 改名到 @earendil-works/pi-coding-agent，
+        // 继续查旧包会拿到低于本机安装版本的“最新版”，把更新判断彻底带偏。
+        npmPackage: "@earendil-works/pi-coding-agent",
         versionArgs: ["--version"],
         updateArgs: ["update", "self"],
     },
@@ -79,10 +90,32 @@ function resolveInstallKind(executable, id, version) {
         return "npm";
     if (normalized.includes("/cellar/") || normalized.includes("/caskroom/") || normalized.includes("/homebrew/"))
         return "brew";
-    if (normalized.includes("/.claude/") || normalized.includes("/.codex/") || normalized.includes("/.opencode/") || normalized.includes("/.qoder/"))
+    if (normalized.includes("/.claude/") || normalized.includes("/.codex/") || normalized.includes("/.opencode/") || normalized.includes("/.grok/") || normalized.includes("/.qoder/") || normalized.includes("/.qoder-cn/"))
         return "native";
     return "unknown";
 }
+/**
+ * Homebrew 托管的 CLI 官方更新器会拒绍动手（实测 `claude update` 只打印
+ * "managed by Homebrew" 并不改版本），所以直接给出正确的 brew 命令。
+ */
+export function homebrewUpdateHint(executable) {
+    const install = parseHomebrewInstall(executable);
+    return install ? `brew upgrade ${install.name}` : null;
+}
+/** 从 `/opt/homebrew/Caskroom/<cask>/…` / `/Cellar/<formula>/…` 反解 Homebrew 包名。 */
+export function parseHomebrewInstall(executable) {
+    if (!executable)
+        return null;
+    let resolved = executable;
+    try {
+        resolved = realpathSync(executable);
+    }
+    catch { /* keep original */ }
+    const matched = /\/(Caskroom|Cellar)\/([^/]+)\//i.exec(resolved.replace(/\\/g, "/"));
+    if (!matched)
+        return null;
+    return { kind: matched[1].toLowerCase() === "caskroom" ? "cask" : "formula", name: matched[2] };
+}
 function isUpdateSupported(id, version) {
     return !(id === "opencode" && version !== null && /^0\.0\./.test(version));
 }
@@ -107,7 +140,18 @@ async function readInstalledVersion(spec, options) {
         return { executable, version: null, error: getErrorMessage(error, "读取版本失败。") };
     }
 }
-async function readLatestVersion(spec, options) {
+async function readLatestVersion(spec, options, status) {
+    if (spec.cliLatestArgs)
+        return readLatestVersionFromCli(spec, options);
+    // Homebrew 安装跟 npm 的 latest 不是同一个发布渠道（cask 通常落后一两个版本），
+    // 拿 npm 比会永久显示“有更新”。
+    if (status?.installKind === "brew") {
+        const install = parseHomebrewInstall(status.executable);
+        if (install)
+            return readBrewLatestVersion(install, options);
+    }
+    if (!spec.npmPackage)
+        return { version: null, error: "该 CLI 没有配置版本来源。" };
     const npm = options.env?.WAND_NPM_BIN || process.env.WAND_NPM_BIN || (process.platform === "win32" ? "npm.cmd" : "npm");
     try {
         const result = await runCommand(npm, ["view", `${spec.npmPackage}@latest`, "version"], options.registryTimeoutMs ?? REGISTRY_TIMEOUT_MS, options);
@@ -118,12 +162,85 @@ async function readLatestVersion(spec, options) {
         return { version: null, error: getErrorMessage(error, "无法连接 npm registry。") };
     }
 }
+/** `brew info --json=v2` 的 cask/formula 最新版。 */
+async function readBrewLatestVersion(install, options) {
+    const env = resolveChildEnv(options);
+    const brew = whichSync("brew", { env, timeoutMs: options.versionTimeoutMs ?? VERSION_TIMEOUT_MS });
+    if (!brew)
+        return { version: null, error: "未找到 brew 命令，无法检查 Homebrew 最新版。" };
+    try {
+        const result = await runCommand(brew, ["info", "--json=v2", install.kind === "cask" ? "--cask" : "--formula", install.name], options.registryTimeoutMs ?? REGISTRY_TIMEOUT_MS, options);
+        const version = parseBrewInfoVersion(result.stdout, install.kind);
+        return version ? { version } : { version: null, error: "brew info 未返回版本。" };
+    }
+    catch (error) {
+        return { version: null, error: getErrorMessage(error, "无法运行 brew info。") };
+    }
+}
+/** 从 `brew info --json=v2` 输出里取 cask version / formula stable 版本。 */
+export function parseBrewInfoVersion(output, kind) {
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch {
+        return null;
+    }
+    const root = parsed && typeof parsed === "object" ? parsed : {};
+    const list = kind === "cask" ? root.casks : root.formulae;
+    const entry = Array.isArray(list) && list.length && list[0] && typeof list[0] === "object"
+        ? list[0]
+        : null;
+    if (!entry)
+        return null;
+    if (kind === "cask")
+        return typeof entry.version === "string" ? extractSemver(entry.version) : null;
+    const versions = entry.versions && typeof entry.versions === "object" ? entry.versions : {};
+    return typeof versions.stable === "string" ? extractSemver(versions.stable) : null;
+}
+/** `grok update --check --json` 的 JSON 行里取 `latestVersion`；日志混排也能挑出来。 */
+export function parseCliLatestVersionJson(output) {
+    for (const line of output.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{") || !trimmed.endsWith("}"))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        const latest = parsed && typeof parsed === "object"
+            ? parsed.latestVersion
+            : null;
+        const version = typeof latest === "string" ? extractSemver(latest) : null;
+        if (version)
+            return version;
+    }
+    return null;
+}
+async function readLatestVersionFromCli(spec, options) {
+    const env = resolveChildEnv(options);
+    const executable = whichSync(spec.command, { env, timeoutMs: options.versionTimeoutMs ?? VERSION_TIMEOUT_MS });
+    // 没装就没有“最新版”可比，交给上面按未安装展示。
+    if (!executable)
+        return { version: null };
+    try {
+        const result = await runCommand(executable, spec.cliLatestArgs, options.registryTimeoutMs ?? REGISTRY_TIMEOUT_MS, options);
+        const version = parseCliLatestVersionJson(`${result.stdout}\n${result.stderr}`);
+        return version ? { version } : { version: null, error: "CLI 未返回可解析的最新版本。" };
+    }
+    catch (error) {
+        return { version: null, error: getErrorMessage(error, "无法检查 CLI 最新版本。") };
+    }
+}
 export async function checkProviderCliUpdates(options = {}) {
     return Promise.all(PROVIDER_CLI_SPECS.map(async (spec) => {
-        const [installed, latest] = await Promise.all([
-            readInstalledVersion(spec, options),
-            readLatestVersion(spec, options),
-        ]);
+        // 串行：查最新版要先用 installKind 判断是不是 Homebrew 安装（其它 5 个 CLI 仍并发）。
+        const installed = await readInstalledVersion(spec, options);
+        const installKind = resolveInstallKind(installed.executable, spec.id, installed.version);
+        const latest = await readLatestVersion(spec, options, { executable: installed.executable, installKind });
         const updateSupported = isUpdateSupported(spec.id, installed.version);
         const errors = [installed.error, latest.error].filter(Boolean);
         if (!updateSupported) {
@@ -139,7 +256,7 @@ export async function checkProviderCliUpdates(options = {}) {
             latestVersion: latest.version,
             updateAvailable: providerCliUpdateAvailable(installed.version, latest.version),
             updateSupported,
-            installKind: resolveInstallKind(installed.executable, spec.id, installed.version),
+            installKind,
             ...(errors.length ? { error: errors.join("；") } : {}),
         };
     }));
@@ -192,6 +309,22 @@ export async function updateProviderClis(statuses, ids, options = {}) {
             continue;
         }
         const executable = status.executable;
+        // Homebrew 托管的安装不能靠 CLI 自更新（它会直接拒绍），别浪费一次必然失败的子进程。
+        if (status.installKind === "brew") {
+            const hint = homebrewUpdateHint(executable);
+            results.push({
+                id: spec.id,
+                label: spec.label,
+                ok: false,
+                skipped: true,
+                fromVersion: status.currentVersion,
+                toVersion: status.latestVersion,
+                message: hint
+                    ? `${spec.label} 由 Homebrew 安装，请运行 \`${hint}\` 更新。`
+                    : `${spec.label} 由 Homebrew 安装，请用 \`brew upgrade\` 更新。`,
+            });
+            continue;
+        }
         options.onLog?.(`[CLI Update] ${spec.label}: ${status.currentVersion} -> ${status.latestVersion}`);
         try {
             const output = await runCommand(executable, spec.updateArgs, options.updateTimeoutMs ?? UPDATE_TIMEOUT_MS, options);

package/dist/server-session-routes.js

@@ -16,6 +16,7 @@ import { sendRouteError } from "./server-request.js";
 import { registerStructuredResumeRoutes } from "./server-resume-routes.js";
 import { addHiddenSessionIds, removeHiddenSessionIds } from "./session-registry.js";
 import { enrichStructuredMessages, WAND_PROTOCOL_VERSION } from "./structured-client-protocol.js";
+import { syncWorkspaceTaskToBoard } from "./wand-task-sync.js";
 import { buildDirectoryTree, normalizeSessionDirectory, } from "./session-directory-tree.js";
 import { projectCwdForSession, renameWorkspaceDirectory, resolveWorkspaceIdForNewSession, } from "./workspace-binding.js";
 export function parseExecutionMode(value, fallback) {
@@ -446,6 +447,8 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 ...origin,
             });
             onSessionCreated?.(snapshot.cwd);
+            // 会话一落地就挂到任务的看板卡片上，不等下一次看板列表的兜底同步。
+            syncWorkspaceTaskToBoard(storage, snapshot.workspaceTaskId);
             const prompt = body.prompt?.trim();
             if (prompt) {
                 const finished = await structured.sendMessage(snapshot.id, prompt);

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

@@ -3,7 +3,8 @@ import { type WandStorage } from "./storage.js";
 import { generateWandTaskTitle } from "./task-title.js";
 import type { SessionRegistry } from "./session-registry.js";
 import type { StructuredSessionManager } from "./structured-session-manager.js";
-import type { WandTaskAgent, WandTaskAgentMode } from "./task-types.js";
+import type { ProcessManager } from "./process-manager.js";
+import type { WandTaskAgent, WandTaskAgentKind, WandTaskAgentMode } from "./task-types.js";
 import type { WandConfig } from "./types.js";
 /** 任务面板上次选用的 CLI 工具 / 模型 / 思考深度；从未保存过时回落到 Claude 默认。 */
 export declare function readTaskBoardLastAgent(storage: WandStorage): WandTaskAgent;
@@ -12,6 +13,8 @@ export interface TaskRouteDependencies {
     storage: WandStorage;
     sessions?: SessionRegistry;
     structured?: StructuredSessionManager;
+    /** PTY 会话创建入口；派发 `kind: "pty"` 的任务时使用。测试里可换成同步桩。 */
+    processes?: ProcessManager;
     config?: WandConfig;
     /** 可注入的任务标题生成器；测试里换成同步桩，避免真的起 CLI。 */
     generateTitle?: typeof generateWandTaskTitle;
@@ -21,7 +24,7 @@ export interface TaskRouteDependencies {
  * 老客户端（Android / iOS 尚未发 mode）不传 mode，PATCH / dispatch 时传任务当前值，
  * 避免把用户在 Web 上选的工作模式悄悄复位成标准。
  */
-export declare function parseTaskAgent(value: unknown, fallbackMode?: WandTaskAgentMode): WandTaskAgent | null;
+export declare function parseTaskAgent(value: unknown, fallbackMode?: WandTaskAgentMode, fallbackKind?: WandTaskAgentKind): WandTaskAgent | null;
 /** 等待排队中的标题生成全部结束；只有测试用，避免用例轮询。 */
 export declare function whenWandTaskTitlesSettled(): Promise<void>;
 export interface AutoTaskTitleOptions {

package/dist/server-task-routes.js

@@ -3,17 +3,18 @@ import { asyncRoute } from "./express-async.js";
 import { getErrorMessage } from "./error-utils.js";
 import { bodyObject, sendRouteError, text } from "./server-request.js";
 import { parseWandTaskAgent } from "./storage.js";
+import { scopedMilestoneId } from "./milestone-scope.js";
 import { generateWandTaskTitle, provisionalTaskTitleFromDescription, TASK_TITLE_MAX_LENGTH } from "./task-title.js";
 import { resolveSystemAiContext } from "./session-ai-context.js";
-import { DEFAULT_WAND_TASK_AGENT_MODE, isWandTaskAgentMode, normalizeWandTaskAgentMode, WAND_MILESTONE_NAME_MAX_LENGTH } from "./task-types.js";
-import { archiveBoardTask, ensureWorkspaceTaskForBoardTask, isAutoNameableBoardTask, moveSessionToWorkspaceTask, syncClosedBoardTask, syncUngroupedSessionsToBoard, taskAutoNameSignature, taskAutoNameSourceText } from "./wand-task-sync.js";
-import { isSessionProvider } from "./session-provider.js";
+import { DEFAULT_WAND_TASK_AGENT_KIND, DEFAULT_WAND_TASK_AGENT_MODE, DEFAULT_WAND_TASK_PRIORITY, isWandTaskAgentKind, isWandTaskAgentMode, normalizeWandTaskAgentMode, WAND_MILESTONE_NAME_MAX_LENGTH } from "./task-types.js";
+import { archiveBoardTask, ensureWorkspaceTaskForBoardTask, isAutoNameableBoardTask, moveSessionToWorkspaceTask, syncClosedBoardTask, syncUngroupedSessionsToBoard, syncWorkspaceTaskToBoard, taskAutoNameSignature, taskAutoNameSourceText } from "./wand-task-sync.js";
+import { isSessionProvider, providerCliCommand } from "./session-provider.js";
 const STATUSES = new Set(["todo", "doing", "done", "archived"]);
 const PRIORITIES = new Set(["none", "low", "medium", "high", "urgent"]);
 const AGENT_EFFORTS = new Set(["off", "standard", "deep", "max"]);
 const TASK_BOARD_LAST_AGENT_KEY = "pref:taskBoardLastAgent";
 function defaultTaskBoardAgent() {
-    return { provider: "claude", model: "default", thinkingEffort: "off", mode: DEFAULT_WAND_TASK_AGENT_MODE };
+    return { provider: "claude", model: "default", thinkingEffort: "off", mode: DEFAULT_WAND_TASK_AGENT_MODE, kind: DEFAULT_WAND_TASK_AGENT_KIND };
 }
 /** 任务面板上次选用的 CLI 工具 / 模型 / 思考深度；从未保存过时回落到 Claude 默认。 */
 export function readTaskBoardLastAgent(storage) {
@@ -33,6 +34,7 @@ export function writeTaskBoardLastAgent(storage, agent) {
         model: agent.model,
         thinkingEffort: agent.thinkingEffort,
         mode: agent.mode,
+        kind: agent.kind,
     });
 }
 function dateValue(value) {
@@ -68,12 +70,23 @@ function milestoneIdFrom(storage, value) {
         throw new Error("未找到该里程碑。");
     return id;
 }
+/** 新建里程碑时归属的工作区；null 表示全局（未指定项目）。 */
+function milestoneWorkspaceIdFrom(storage, value) {
+    if (value === null || value === undefined)
+        return null;
+    const workspaceId = text(value);
+    if (!workspaceId)
+        return null;
+    if (!storage.getWorkspace(workspaceId))
+        throw new Error("项目不存在。");
+    return workspaceId;
+}
 /**
  * 任务派发配置：provider / model / thinkingEffort 必须合法；mode 缺省时用 `fallbackMode`。
  * 老客户端（Android / iOS 尚未发 mode）不传 mode，PATCH / dispatch 时传任务当前值，
  * 避免把用户在 Web 上选的工作模式悄悄复位成标准。
  */
-export function parseTaskAgent(value, fallbackMode = DEFAULT_WAND_TASK_AGENT_MODE) {
+export function parseTaskAgent(value, fallbackMode = DEFAULT_WAND_TASK_AGENT_MODE, fallbackKind = DEFAULT_WAND_TASK_AGENT_KIND) {
     if (value === null)
         return null;
     if (!value || typeof value !== "object" || Array.isArray(value))
@@ -93,7 +106,11 @@ export function parseTaskAgent(value, fallbackMode = DEFAULT_WAND_TASK_AGENT_MOD
         throw new Error("工作模式无效。");
     // Codex 之类只认一种模式的 provider 在这里夹到有效值，落库值与实际执行保持一致。
     const mode = normalizeWandTaskAgentMode(provider, rawMode);
-    return { provider, model, thinkingEffort, mode };
+    // kind 与 mode 同样兼容老客户端：不传就沿用任务当前值，避免把 PTY 悄悄复位成结构化。
+    const rawKind = body.kind === undefined || body.kind === null || body.kind === "" ? fallbackKind : body.kind;
+    if (!isWandTaskAgentKind(rawKind))
+        throw new Error("会话形态无效。");
+    return { provider, model, thinkingEffort, mode, kind: rawKind };
 }
 function taskDto({ storage, sessions }, task) {
     if (!task)
@@ -214,7 +231,7 @@ function taskTitleAiOptions(config) {
     return resolveSystemAiContext(defaultSession, config);
 }
 export function registerTaskRoutes(app, deps) {
-    const { storage, sessions, structured, config } = deps;
+    const { storage, sessions, structured, processes, config } = deps;
     const dto = (task) => taskDto(deps, task);
     app.get("/api/wand-tasks", (req, res) => {
         try {
@@ -237,11 +254,13 @@ export function registerTaskRoutes(app, deps) {
     app.get("/api/wand-task-agent-defaults", (_req, res) => {
         res.json(readTaskBoardLastAgent(storage));
     });
-    // ── 里程碑：跨项目全局列表，所有任务面板的「新建任务」共用 ──
-    app.get("/api/wand-milestones", (_req, res) => {
+    // ── 里程碑（迭代）：归属工作区，任务面板的「新建任务」按工作区过滤 ──
+    app.get("/api/wand-milestones", (req, res) => {
+        // 不传 workspaceId 返回全部；传了就只给「该工作区 + 全局」的里程碑。
+        const workspaceId = typeof req.query.workspaceId === "string" ? req.query.workspaceId : null;
         const counts = storage.countWandTasksByMilestone();
         res.json({
-            milestones: storage.listWandMilestones().map((milestone) => ({
+            milestones: storage.listWandMilestones(workspaceId).map((milestone) => ({
                 ...milestone,
                 taskCount: counts[milestone.id] ?? 0,
             })),
@@ -251,11 +270,13 @@ export function registerTaskRoutes(app, deps) {
         try {
             const body = bodyObject(req.body);
             const name = milestoneNameFrom(body.name);
-            const duplicate = storage.listWandMilestones()
+            const workspaceId = milestoneWorkspaceIdFrom(storage, body.workspaceId);
+            // 重名只在「同一个工作区可见的里程碑」里查：不同工作区可以各有同名迭代。
+            const duplicate = storage.listWandMilestones(workspaceId)
                 .find((milestone) => milestone.name.toLowerCase() === name.toLowerCase());
             if (duplicate)
                 throw new Error(`里程碑「${duplicate.name}」已存在。`);
-            const created = storage.createWandMilestone({ name, dueDate: dateValue(body.dueDate) ?? null });
+            const created = storage.createWandMilestone({ name, dueDate: dateValue(body.dueDate) ?? null, workspaceId });
             res.status(201).json({ ...created, taskCount: 0 });
         }
         catch (error) {
@@ -273,12 +294,21 @@ export function registerTaskRoutes(app, deps) {
             const patch = {};
             if (body.name !== undefined) {
                 const name = milestoneNameFrom(body.name);
-                const duplicate = storage.listWandMilestones()
+                const duplicate = storage.listWandMilestones(current.workspaceId)
                     .find((milestone) => milestone.id !== current.id && milestone.name.toLowerCase() === name.toLowerCase());
                 if (duplicate)
                     throw new Error(`里程碑「${duplicate.name}」已存在。`);
                 patch.name = name;
             }
+            if (body.workspaceId !== undefined) {
+                // 允许改挂工作区（例如新建任务时目录对应的项目还没建，提交后再绑上）。
+                const workspaceId = milestoneWorkspaceIdFrom(storage, body.workspaceId);
+                const duplicate = storage.listWandMilestones(workspaceId)
+                    .find((milestone) => milestone.id !== current.id && milestone.name.toLowerCase() === current.name.toLowerCase());
+                if (duplicate)
+                    throw new Error(`里程碑「${duplicate.name}」已存在。`);
+                patch.workspaceId = workspaceId;
+            }
             if (body.dueDate !== undefined)
                 patch.dueDate = dateValue(body.dueDate) ?? null;
             const updated = storage.updateWandMilestone(current.id, patch);
@@ -320,13 +350,13 @@ export function registerTaskRoutes(app, deps) {
             const titleSource = providedTitle ? "user" : "auto";
             const title = providedTitle || provisionalTaskTitleFromDescription(description) || "新建任务";
             const status = STATUSES.has(body.status) ? body.status : "todo";
-            const priority = PRIORITIES.has(body.priority) ? body.priority : "none";
+            const priority = PRIORITIES.has(body.priority) ? body.priority : DEFAULT_WAND_TASK_PRIORITY;
             const agent = body.agent === undefined ? null : parseTaskAgent(body.agent);
             if (agent)
                 writeTaskBoardLastAgent(storage, agent);
             const labels = labelsFrom(body.labels);
             const dueDate = dateValue(body.dueDate) ?? null;
-            const milestoneId = milestoneIdFrom(storage, body.milestoneId);
+            const milestoneId = scopedMilestoneId(storage, milestoneIdFrom(storage, body.milestoneId), workspaceId);
             const task = storage.transaction(() => {
                 const card = storage.createWandTask({
                     workspaceId,
@@ -391,11 +421,16 @@ export function registerTaskRoutes(app, deps) {
                 if (workspaceId && !storage.getWorkspace(workspaceId))
                     throw new Error("项目不存在。");
                 patch.workspaceId = workspaceId || null;
+                // 换项目后原迭代不再属于新工作区就一并摘掉；移动端只 PATCH workspaceId，不会自己清。
+                const milestoneId = body.milestoneId !== undefined
+                    ? patch.milestoneId
+                    : storage.getWandTask(req.params.id)?.milestoneId ?? null;
+                patch.milestoneId = scopedMilestoneId(storage, milestoneId, patch.workspaceId);
             }
             if (body.agent !== undefined) {
-                // 老客户端不传 mode：沿用任务当前的工作模式，而不是复位成标准。
+                // 老客户端不传 mode / kind：沿用任务当前值，而不是复位成标准 / 结构化。
                 const current = storage.getWandTask(req.params.id);
-                patch.agent = parseTaskAgent(body.agent, current?.agent?.mode);
+                patch.agent = parseTaskAgent(body.agent, current?.agent?.mode, current?.agent?.kind);
                 if (patch.agent)
                     writeTaskBoardLastAgent(storage, patch.agent);
             }
@@ -457,8 +492,9 @@ export function registerTaskRoutes(app, deps) {
         res.json({ ok: true });
     });
     /**
-     * 用选定的 CLI 工具开一个结构化会话，把这次派发的 prompt 作为首条消息，
-     * 并把会话绑定回该任务。cwd 取任务所属项目目录；未指定项目时用全局默认目录。
+     * 用选定的 CLI 工具开一个会话（`agent.kind` 为 structured 时是结构化对话，pty 时是原始
+     * CLI 终端），把这次派发的 prompt 作为首条消息 / 初始输入，并把会话绑定回该任务。
+     * cwd 取任务所属项目目录；未指定项目时用全局默认目录。
      */
     app.post("/api/wand-tasks/:id/dispatch", asyncRoute(async (req, res) => {
         try {
@@ -467,14 +503,18 @@ export function registerTaskRoutes(app, deps) {
                 res.status(404).json({ error: "未找到该任务。" });
                 return;
             }
-            if (!structured || !config)
-                throw new Error("当前服务未启用结构化会话，无法派发 Agent。");
+            if (!config)
+                throw new Error("当前服务未启用派发，无法派发 Agent。");
             const body = bodyObject(req.body);
             const agent = body.agent === undefined
                 ? task.agent ?? parseWandTaskAgent(JSON.stringify(body))
-                : parseTaskAgent(body.agent, task.agent?.mode);
+                : parseTaskAgent(body.agent, task.agent?.mode, task.agent?.kind);
             if (!agent)
                 throw new Error("请先为该任务选择 CLI 工具。");
+            if (agent.kind === "structured" && !structured)
+                throw new Error("当前服务未启用结构化会话，无法派发 Agent。");
+            if (agent.kind === "pty" && !processes)
+                throw new Error("当前服务未启用终端会话，无法派发 Agent。");
             writeTaskBoardLastAgent(storage, agent);
             if (body.workspaceId !== undefined) {
                 const workspaceId = body.workspaceId === null ? null : text(body.workspaceId) || null;
@@ -494,28 +534,43 @@ export function registerTaskRoutes(app, deps) {
                 throw new Error("请输入提示词。");
             const prompt = requestedPrompt || task.description.trim() || task.title || "执行此任务";
             const model = agent.model === "default" ? "" : agent.model;
-            const session = structured.createSession({
-                cwd,
-                mode: agent.mode,
-                provider: agent.provider,
-                model: model || getDefaultModelForProvider(config, agent.provider) || undefined,
-                thinkingEffort: agent.thinkingEffort,
-                worktreeEnabled: false,
-                sessionSource: "automation",
-                automationId: `wand-task:${task.id}`,
-                workspaceId: group.workspaceId,
-                workspaceTaskId: group.id,
-            });
+            const provider = agent.provider;
+            const resolvedModel = model || getDefaultModelForProvider(config, provider) || undefined;
+            const session = agent.kind === "pty"
+                ? await processes.start(providerCliCommand(provider), cwd, agent.mode, prompt, {
+                    provider,
+                    model: resolvedModel,
+                    thinkingEffort: agent.thinkingEffort,
+                    sessionSource: "automation",
+                    automationId: `wand-task:${task.id}`,
+                    workspaceId: group.workspaceId,
+                    workspaceTaskId: group.id,
+                })
+                : structured.createSession({
+                    cwd,
+                    mode: agent.mode,
+                    provider,
+                    model: resolvedModel,
+                    thinkingEffort: agent.thinkingEffort,
+                    worktreeEnabled: false,
+                    sessionSource: "automation",
+                    automationId: `wand-task:${task.id}`,
+                    workspaceId: group.workspaceId,
+                    workspaceTaskId: group.id,
+                });
             storage.updateWandTask(task.id, { agent, status: task.status === "todo" ? "doing" : task.status });
             storage.bindWandTaskSession(task.id, session.id);
-            const completion = structured.sendMessage(session.id, prompt);
-            completion.catch((error) => console.error(`[WandTask] Agent dispatch failed for ${task.id}:`, error));
+            if (agent.kind !== "pty") {
+                const completion = structured.sendMessage(session.id, prompt);
+                completion.catch((error) => console.error(`[WandTask] Agent dispatch failed for ${task.id}:`, error));
+            }
             res.status(202).json({
                 ok: true,
                 taskId: task.id,
                 session: {
                     id: session.id,
                     provider: session.provider,
+                    sessionKind: session.sessionKind ?? "pty",
                     model: session.selectedModel,
                     thinkingEffort: session.thinkingEffort,
                     mode: session.mode,
@@ -528,6 +583,9 @@ export function registerTaskRoutes(app, deps) {
         }
     }));
     app.get("/api/wand-tasks/:id", asyncRoute(async (req, res) => {
+        // 单卡读取不跑全量同步，但至少把这张卡片自己的任务归属对上：
+        // 原生客户端 / 详情面板只拉单卡时，也不会看到一张没有会话的卡片。
+        syncWorkspaceTaskToBoard(storage, storage.getWandTask(req.params.id)?.workspaceTaskId);
         const task = dto(storage.getWandTask(req.params.id));
         if (!task) {
             res.status(404).json({ error: "未找到该任务。" });

package/dist/server-update-routes.js

@@ -361,7 +361,7 @@ export function registerAdminUpdateRoutes(app, deps) {
             return;
         }
         const rawIds = Array.isArray(req.body?.ids) ? req.body.ids : [];
-        const ids = rawIds.filter((value) => value === "claude" || value === "codex" || value === "opencode" || value === "qoder" || value === "pi");
+        const ids = rawIds.filter((value) => value === "claude" || value === "codex" || value === "opencode" || value === "grok" || value === "qoder" || value === "pi");
         state.providerCliUpdateInFlight = true;
         try {
             const before = await refreshProviderCliUpdateState(state, config);

package/dist/server-workspace-routes.js

@@ -9,6 +9,7 @@ import { checkSessionWorktreeMergeabilityAsync, cleanupWorktreeSync, prepareSess
 import { collectSessionTopicBlocklist } from "./session-topic.js";
 import { resolveSessionDisplayTitle } from "./session-transport.js";
 import { attachUnboundSessionsToWorkspace, backfillSessionWorkspaces, normalizeProjectCwd, projectCwdForSession, isGlobalWorkspace, syncDirectoryNameForWorkspace } from "./workspace-binding.js";
+import { scopedMilestoneId } from "./milestone-scope.js";
 import { archiveBoardTaskForWorkspaceTask, archiveWorkspaceTask, ensureBoardTaskForWorkspaceTask, isUnnamedWorkspaceTaskName, moveSessionToWorkspaceTask, syncSidebarTasksFromBoard, UNNAMED_WORKSPACE_TASK_NAME } from "./wand-task-sync.js";
 import { isSessionProvider } from "./session-provider.js";
 import { firstLayoutTabId } from "./layout-tree.js";
@@ -118,12 +119,12 @@ function createTaskForWorkspace(storage, workspace, body) {
     // 留空（或老客户端回传的占位名）走自动命名：先用提示词总结，再交给模型改写。
     const named = name.length > 0 && !isUnnamedWorkspaceTaskName(name);
     const provisional = named ? "" : provisionalTaskTitleFromDescription(description);
-    // 里程碑是全局列表；建任务时可选，非法 id 直接报错而不是静默丢掉。
+    // 迭代按工作区归属：项目里的任务只能挂本项目或全局的迭代（详见 milestone-scope.ts）。
     const requestedMilestoneId = typeof body.milestoneId === "string" ? body.milestoneId.trim() : "";
     if (requestedMilestoneId && !storage.getWandMilestone(requestedMilestoneId)) {
         throw new Error("未找到该里程碑。");
     }
-    const milestoneId = requestedMilestoneId || null;
+    const milestoneId = scopedMilestoneId(storage, requestedMilestoneId || null, isGlobalWorkspace(workspace) ? null : workspace.id);
     let mountedCwd;
     if (body.cwd !== undefined && body.cwd !== null && String(body.cwd).trim()) {
         mountedCwd = resolveWorkspaceCwd(body.cwd);