@co0ontty/wand 4.82.0 → 4.83.1

package/dist/provider-catalog.js

@@ -0,0 +1,138 @@
+/**
+ * Provider 的唯一真源：受支持的 CLI 列表、展示名、别名表与推断规则。
+ *
+ * 这个模块必须保持"纯数据 + 纯函数"，不能 import 任何 `node:*`：
+ * 服务端（`src/session-provider.ts`）与浏览器 bundle（`src/web-ui/provider-identity.ts`）
+ * 都直接复用它，避免同一个 provider 概念散落在两处各写一份。
+ */
+/** 全部受支持的会话 provider；顺序即 UI / 派发选择器里的展示顺序。 */
+export const SESSION_PROVIDERS = ["claude", "codex", "opencode", "grok", "qoder", "pi", "gemini"];
+/**
+ * 拥有原生思考档位（`provider:level`）的 provider。
+ * Gemini CLI 没有档位开关，所以不出现在这里：`gemini:max` 这种值不应该被当成合法档位保留。
+ */
+export const NATIVE_THINKING_EFFORT_PROVIDERS = ["claude", "codex", "opencode", "grok", "qoder", "pi"];
+/** 原生思考档位的 `provider:level` 形状；各端必须共用同一张 provider 名单。 */
+export const NATIVE_THINKING_EFFORT_PATTERN = `^(?:${NATIVE_THINKING_EFFORT_PROVIDERS.join("|")}):[a-z0-9][a-z0-9_-]{0,31}$`;
+/** 判断字符串是否为 `provider:level` 形状的原生思考档。 */
+export function isNativeThinkingEffort(value) {
+    return typeof value === "string" && NATIVE_THINKING_EFFORT_RE.test(value);
+}
+const NATIVE_THINKING_EFFORT_RE = new RegExp(NATIVE_THINKING_EFFORT_PATTERN);
+const SESSION_PROVIDER_SET = new Set(SESSION_PROVIDERS);
+/** 运行时守卫：把配置、数据库、请求体里的任意值收敛成 SessionProvider。 */
+export function isSessionProvider(value) {
+    return typeof value === "string" && SESSION_PROVIDER_SET.has(value);
+}
+/** provider 对应的 CLI 可执行文件名（Qoder 的 CLI 叫 qodercli）。 */
+export function providerCliCommand(provider) {
+    return provider === "qoder" ? "qodercli" : provider;
+}
+/** provider 的展示名。缺省不认识的字符串一律回落到 "AI"。 */
+export const PROVIDER_LABELS = {
+    claude: "Claude",
+    codex: "Codex",
+    opencode: "OpenCode",
+    grok: "Grok",
+    qoder: "Qoder",
+    pi: "Pi",
+    gemini: "Gemini",
+};
+/**
+ * provider id 别名表：既接受用户/客户端可能写出的别名（`anthropic`、`open-code`），
+ * 也接受历史 runner 名（`claude-cli-print`、`codex-cli-exec` …），
+ * 供 `normalizeProviderId` 与 `inferProviderFromRunner` 共用。
+ */
+export const PROVIDER_ALIASES = {
+    anthropic: "claude",
+    claude: "claude",
+    "claude-cli": "claude",
+    "claude-cli-print": "claude",
+    // SDK 执行路径已移除；这里仅用于识别旧会话里的历史 runner 值。
+    "claude-sdk": "claude",
+    codex: "codex",
+    "codex-cli": "codex",
+    "codex-cli-exec": "codex",
+    grok: "grok",
+    "grok-cli": "grok",
+    "grok-cli-headless": "grok",
+    "open-code": "opencode",
+    open_code: "opencode",
+    opencode: "opencode",
+    "opencode-cli-run": "opencode",
+    qoder: "qoder",
+    "qoder-cli": "qoder",
+    "qoder-cli-print": "qoder",
+    qodercli: "qoder",
+    pi: "pi",
+    "pi-cli": "pi",
+    "pi-cli-json": "pi",
+    gemini: "gemini",
+    "gemini-cli": "gemini",
+    "gemini-cli-json": "gemini",
+};
+/** 归一化一个已持久化的 provider id 或 runner/别名；无法识别时返回 null。 */
+export function normalizeProviderId(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    return normalized ? PROVIDER_ALIASES[normalized] ?? null : null;
+}
+/** 从 runner 名推断 provider；`pty` 等与 provider 无关的 runner 返回 undefined。 */
+export function inferProviderFromRunner(runner) {
+    return normalizeProviderId(runner) ?? undefined;
+}
+/** 这些是包管理器式的启动前缀：`npx claude`、`pnpm dlx codex` 等要看到后面的真实可执行名。 */
+const PACKAGE_RUNNER_PREFIXES = new Set(["npx", "pnpx", "bunx", "yarn", "pnpm", "corepack"]);
+/** 包管理器的子命令（没有它们时，`pnpm dlx codex` 会误把 `dlx` 当可执行名）。 */
+const PACKAGE_RUNNER_SUBCOMMANDS = new Set(["dlx", "exec", "x"]);
+/** 拆出命令行第一个可执行 token，去掉引号、目录前缀与 Windows 可执行后缀。 */
+function commandExecutableName(command) {
+    const match = command.match(/^(?:"([^"]+)"|'([^']+)'|(\S+))/);
+    const executablePath = match?.[1] ?? match?.[2] ?? match?.[3] ?? "";
+    return executablePath.split(/[\\/]/).pop()?.replace(/\.(?:cmd|exe)$/i, "") ?? "";
+}
+/**
+ * 从启动命令推断 provider；识别的是命令行里真正的可执行名。
+ *
+ * - `/opt/homebrew/bin/claude --resume abc` → claude
+ * - `open-code run` / `qodercli --print` → opencode / qoder
+ * - `npx claude` / `pnpm dlx codex` → 看包管理器后面的真实 CLI
+ *
+ * 参数与父目录名不能冒充别的 provider（`claude -p codex` 仍是 claude）。
+ */
+export function inferProviderFromCommand(command) {
+    if (typeof command !== "string")
+        return undefined;
+    const value = command.trim();
+    if (!value)
+        return undefined;
+    // 先把命令行按空白切成 token，跳过包管理器前缀与它自己的 flag（--yes 之类）。
+    const tokens = value.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+    let index = 0;
+    if (PACKAGE_RUNNER_PREFIXES.has(commandExecutableName(tokens[0] ?? "").toLowerCase())) {
+        index = 1;
+        while (index < tokens.length) {
+            const token = tokens[index];
+            if (token.startsWith("-")) {
+                index += 1;
+                continue;
+            }
+            if (PACKAGE_RUNNER_SUBCOMMANDS.has(commandExecutableName(token).toLowerCase())) {
+                index += 1;
+                continue;
+            }
+            break;
+        }
+    }
+    return normalizeProviderId(commandExecutableName(tokens[index] ?? "")) ?? undefined;
+}
+/** 每个 provider 在自由文本里可能出现的写法，用于把命令名收敛成可读标签。 */
+export function providerDisplayName(value) {
+    if (typeof value === "string" && value.trim().toLowerCase() === "terminal")
+        return "终端";
+    const provider = normalizeProviderId(value);
+    if (provider)
+        return PROVIDER_LABELS[provider];
+    return typeof value === "string" && value.trim() ? value.trim() : "AI";
+}

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

@@ -1,4 +1,4 @@
-export type ProviderCliId = "claude" | "codex" | "opencode" | "grok" | "qoder" | "pi" | "gemini";
+export type ProviderCliId = import("./provider-catalog.js").SessionProvider;
 export interface ProviderCliUpdateStatus {
     id: ProviderCliId;
     label: string;

package/dist/pty-foreground.d.ts

@@ -0,0 +1,37 @@
+/**
+ * PTY 前台进程组探测。
+ *
+ * 非 Claude 的 provider CLI 都写在 PTY 里，Server 看不到它们的回合边界，
+ * 只能靠「输出活动」猜（见 `pty-turn-activity.ts`）。猜的前提是「CLI 还在前台」，
+ * 而这件事以前靠一次性启动标记 `providerCliActive` 判断：标记只在 CLI **第一次**
+ * 退出时被消费，之后同一个 PTY 里再启动 CLI（自更新重启、手动重跑）就再也认不出来，
+ * 会话会永久停在「不像在跑」的状态（ptyBusy 永远为 false），任务列表也就不显示运行中。
+ *
+ * 这里换成读内核事实：终端的前台进程组（`tpgid`）。CLI 在前台时
+ * `tpgid != shell 自己的 pgid`；CLI 退回提示符后两者相等。这个判断对任意 provider 成立，
+ * 且 CLI 每次重新启动都会自动重新成立，不需要任何一次性标记。
+ *
+ * 平台覆盖 darwin / linux（两边的 `ps` 都提供 `tpgid`）。其他平台返回 null，
+ * 调用方回退到旧的 providerCliActive 判定。
+ */
+export interface PtyForegroundRow {
+    pid: number;
+    pgid: number;
+    tpgid: number;
+}
+/** 解析 `ps -o pid=,pgid=,tpgid=` 的输出（空行与不可解析行直接跳过）。 */
+export declare function parsePtyForegroundRows(stdout: string): PtyForegroundRow[];
+/**
+ * shell 进程的终端上是否有别的进程组在前台。
+ * tpgid 为 0（没有控制终端）或等于 shell 自己的进程组时都是「CLI 不在前台」。
+ */
+export declare function cliIsForeground(row: PtyForegroundRow): boolean;
+export interface SamplePtyForegroundsOptions {
+    platform?: NodeJS.Platform;
+    timeoutMs?: number;
+}
+/**
+ * 采样若干 shell 进程的前台状态。返回 pid → 是否有前台 CLI 的映射：
+ * 输出里缺失的 pid 不会出现在结果里（调用方保留上次结论）。整体不可用时返回 null。
+ */
+export declare function samplePtyForegrounds(pids: readonly number[], options?: SamplePtyForegroundsOptions): Promise<Map<number, boolean> | null>;

package/dist/pty-foreground.js

@@ -0,0 +1,56 @@
+import { execFile } from "node:child_process";
+const SUPPORTED_PLATFORMS = new Set(["darwin", "linux"]);
+/** 解析 `ps -o pid=,pgid=,tpgid=` 的输出（空行与不可解析行直接跳过）。 */
+export function parsePtyForegroundRows(stdout) {
+    const rows = [];
+    for (const line of stdout.split("\n")) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 3)
+            continue;
+        const pid = Number(parts[0]);
+        const pgid = Number(parts[1]);
+        const tpgid = Number(parts[2]);
+        if (!Number.isInteger(pid) || !Number.isInteger(pgid) || !Number.isInteger(tpgid))
+            continue;
+        if (pid <= 0)
+            continue;
+        rows.push({ pid, pgid, tpgid });
+    }
+    return rows;
+}
+/**
+ * shell 进程的终端上是否有别的进程组在前台。
+ * tpgid 为 0（没有控制终端）或等于 shell 自己的进程组时都是「CLI 不在前台」。
+ */
+export function cliIsForeground(row) {
+    return row.tpgid > 0 && row.tpgid !== row.pgid;
+}
+/**
+ * 采样若干 shell 进程的前台状态。返回 pid → 是否有前台 CLI 的映射：
+ * 输出里缺失的 pid 不会出现在结果里（调用方保留上次结论）。整体不可用时返回 null。
+ */
+export function samplePtyForegrounds(pids, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const wanted = pids.filter((pid) => Number.isInteger(pid) && pid > 0);
+    if (!SUPPORTED_PLATFORMS.has(platform) || wanted.length === 0)
+        return Promise.resolve(null);
+    return new Promise((resolve) => {
+        execFile("ps", ["-p", wanted.join(","), "-o", "pid=,pgid=,tpgid="], { timeout: options.timeoutMs ?? 2000, maxBuffer: 1024 * 1024, windowsHide: true }, (error, stdout) => {
+            const text = typeof stdout === "string" ? stdout : "";
+            const rows = parsePtyForegroundRows(text);
+            // `ps` 对含「已退出 pid」的列表会以非 0 退出码仍然打印存活行，所以先看解析结果；
+            // 一行都没有才算整体失败（例如 ps 不可用），交给调用方保留上次结论。
+            if (rows.length === 0) {
+                resolve(error ? null : new Map());
+                return;
+            }
+            const result = new Map();
+            for (const row of rows) {
+                if (!wanted.includes(row.pid))
+                    continue;
+                result.set(row.pid, cliIsForeground(row));
+            }
+            resolve(result);
+        });
+    });
+}

package/dist/pty-turn-activity.d.ts

@@ -9,11 +9,12 @@
  * bytes stop. So a turn is opened on submit and closed once the session has been
  * silent for a quiet window, refreshed on every chunk.
  *
- * The principled alternative is to ask the OS whether the terminal's foreground
- * process group is blocked on a tty read (that is the real meaning of "waiting
- * for input"). It works for any provider and is immune to spinners, but it needs
- * the PTY-owning daemon (Render) to expose foreground-pgrp state, so it is left
- * as a follow-up. This module is the deliberate fallback.
+ * The principled input — is the CLI still in the foreground? — now comes from
+ * the kernel instead of a one-shot marker: `pty-foreground.ts` samples each
+ * live terminal's foreground process group (`tpgid`), so a CLI that exits and is
+ * started again in the same terminal (self-update, manual re-run) is recognised
+ * again. Output activity then only decides whether the current turn is still
+ * running. This module remains the quiet-window fallback for that last call.
  */
 /**
  * Whether a PTY input chunk is a line submit rather than body text.

package/dist/pty-turn-activity.js

@@ -9,11 +9,12 @@
  * bytes stop. So a turn is opened on submit and closed once the session has been
  * silent for a quiet window, refreshed on every chunk.
  *
- * The principled alternative is to ask the OS whether the terminal's foreground
- * process group is blocked on a tty read (that is the real meaning of "waiting
- * for input"). It works for any provider and is immune to spinners, but it needs
- * the PTY-owning daemon (Render) to expose foreground-pgrp state, so it is left
- * as a follow-up. This module is the deliberate fallback.
+ * The principled input — is the CLI still in the foreground? — now comes from
+ * the kernel instead of a one-shot marker: `pty-foreground.ts` samples each
+ * live terminal's foreground process group (`tpgid`), so a CLI that exits and is
+ * started again in the same terminal (self-update, manual re-run) is recognised
+ * again. Output activity then only decides whether the current turn is still
+ * running. This module remains the quiet-window fallback for that last call.
  */
 /**
  * Whether a PTY input chunk is a line submit rather than body text.

package/dist/retention.d.ts

@@ -0,0 +1,29 @@
+import type { SessionRegistry } from "./session-registry.js";
+import type { WandStorage } from "./storage.js";
+/**
+ * 统一保留期策略（会话与看板任务同一套）：
+ *   1. 超过 IDLE 没有活动的会话 / 任务 → 自动归档；
+ *   2. 归档后经过 ARCHIVED 仍没被恢复 → 自动清理（删除）。
+ *
+ * 会话的自动归档此前散在两个 runner 里（24h），这里收敛成同一份常量，避免
+ * 「会话 24h、任务 7 天」两套口径。运行中的会话/任务永不归档或清理。
+ */
+export declare const RETENTION_IDLE_MS: number;
+export declare const RETENTION_ARCHIVED_MS: number;
+export interface RetentionDeps {
+    storage: WandStorage;
+    sessions: SessionRegistry;
+}
+export interface RetentionResult {
+    archivedSessions: number;
+    purgedSessions: number;
+    archivedTasks: number;
+    purgedTasks: number;
+}
+/**
+ * 跑一遍保留期清理。返回本轮的实际动作计数，便于日志与测试断言。
+ * 纯函数式编排：只依赖 storage / registry，方便在单测里注入固定时间。
+ */
+export declare function runRetentionSweep(deps: RetentionDeps, now?: number): RetentionResult;
+/** 每小时的保留期扫描；返回清理定时器，调用方负责 clearInterval。 */
+export declare function startRetentionTimer(deps: RetentionDeps, intervalMs?: number): NodeJS.Timeout;

package/dist/retention.js

@@ -0,0 +1,142 @@
+import { cleanupWorktreeSync } from "./git-worktree.js";
+/**
+ * 统一保留期策略（会话与看板任务同一套）：
+ *   1. 超过 IDLE 没有活动的会话 / 任务 → 自动归档；
+ *   2. 归档后经过 ARCHIVED 仍没被恢复 → 自动清理（删除）。
+ *
+ * 会话的自动归档此前散在两个 runner 里（24h），这里收敛成同一份常量，避免
+ * 「会话 24h、任务 7 天」两套口径。运行中的会话/任务永不归档或清理。
+ */
+export const RETENTION_IDLE_MS = 7 * 24 * 60 * 60 * 1000;
+export const RETENTION_ARCHIVED_MS = 7 * 24 * 60 * 60 * 1000;
+function timestamp(value) {
+    if (!value)
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+/**
+ * 任务的「最后一次活动」：卡片自身的 updated_at、容器最后一次被打开的时间，
+ * 以及它名下会话的结束/开始时间，取三者里最新的一个。
+ */
+function taskLastActivity(storage, task, bound) {
+    const times = [];
+    const updated = timestamp(task?.updatedAt);
+    if (updated !== null)
+        times.push(updated);
+    const container = task?.workspaceTaskId ? storage.getWorkspaceTask(task.workspaceTaskId) : null;
+    const opened = timestamp(container?.lastOpenedAt);
+    if (opened !== null)
+        times.push(opened);
+    for (const session of bound) {
+        const reference = timestamp(session.endedAt ?? session.startedAt);
+        if (reference !== null)
+            times.push(reference);
+    }
+    return times.length > 0 ? Math.max(...times) : null;
+}
+/**
+ * 跑一遍保留期清理。返回本轮的实际动作计数，便于日志与测试断言。
+ * 纯函数式编排：只依赖 storage / registry，方便在单测里注入固定时间。
+ */
+export function runRetentionSweep(deps, now = Date.now()) {
+    const result = { archivedSessions: 0, purgedSessions: 0, archivedTasks: 0, purgedTasks: 0 };
+    const snapshots = deps.sessions.listSlim();
+    for (const session of snapshots) {
+        // 运行中的会话既不属于「没动」，也不能被杀掉。
+        if (session.status === "running")
+            continue;
+        if (session.archived) {
+            const archivedAt = timestamp(session.archivedAt);
+            if (archivedAt === null) {
+                // 历史归档行没有时间戳：先补上，让 7 天窗口从这一刻起算，而不是立刻删除。
+                try {
+                    deps.sessions.setArchived(session.id, true);
+                }
+                catch { /* already gone */ }
+                continue;
+            }
+            if (now - archivedAt < RETENTION_ARCHIVED_MS)
+                continue;
+            try {
+                deps.sessions.delete(session.id);
+                result.purgedSessions += 1;
+            }
+            catch { /* best-effort: a session may disappear between the read and the purge */ }
+            continue;
+        }
+        const reference = timestamp(session.endedAt ?? session.startedAt);
+        if (reference === null || now - reference < RETENTION_IDLE_MS)
+            continue;
+        try {
+            deps.sessions.setArchived(session.id, true);
+            result.archivedSessions += 1;
+        }
+        catch { /* best-effort */ }
+    }
+    const sessionsByTask = new Map();
+    for (const session of snapshots) {
+        const taskId = session.workspaceTaskId;
+        if (!taskId)
+            continue;
+        const bucket = sessionsByTask.get(taskId);
+        if (bucket)
+            bucket.push(session);
+        else
+            sessionsByTask.set(taskId, [session]);
+    }
+    for (const task of deps.storage.listWandTasks()) {
+        const bound = task.workspaceTaskId ? sessionsByTask.get(task.workspaceTaskId) ?? [] : [];
+        const running = bound.some((session) => session.status === "running");
+        if (task.status === "archived") {
+            if (running)
+                continue;
+            const archivedAt = timestamp(task.archivedAt);
+            if (archivedAt === null) {
+                // 历史归档行（归档时间尚未落库）：补写时间戳，给用户留出恢复窗口。
+                deps.storage.updateWandTask(task.id, { status: "archived" });
+                continue;
+            }
+            if (now - archivedAt < RETENTION_ARCHIVED_MS)
+                continue;
+            const container = task.workspaceTaskId ? deps.storage.getWorkspaceTask(task.workspaceTaskId) : null;
+            if (container?.worktree) {
+                try {
+                    cleanupWorktreeSync(container.worktree);
+                }
+                catch { /* never block cleanup */ }
+            }
+            deps.storage.deleteWandTask(task.id);
+            result.purgedTasks += 1;
+            continue;
+        }
+        if (running)
+            continue;
+        const lastActivity = taskLastActivity(deps.storage, task, bound);
+        if (lastActivity === null || now - lastActivity < RETENTION_IDLE_MS)
+            continue;
+        deps.storage.updateWandTask(task.id, { status: "archived" });
+        result.archivedTasks += 1;
+    }
+    return result;
+}
+/** 每小时的保留期扫描；返回清理定时器，调用方负责 clearInterval。 */
+export function startRetentionTimer(deps, intervalMs = 60 * 60 * 1000) {
+    const sweep = () => {
+        try {
+            const result = runRetentionSweep(deps);
+            const acted = result.archivedSessions + result.purgedSessions + result.archivedTasks + result.purgedTasks;
+            if (acted > 0) {
+                console.log(`[retention] archived sessions=${result.archivedSessions} tasks=${result.archivedTasks}; `
+                    + `purged sessions=${result.purgedSessions} tasks=${result.purgedTasks}`);
+            }
+        }
+        catch (error) {
+            console.error(`[retention] sweep failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    sweep();
+    const timer = setInterval(sweep, intervalMs);
+    timer.unref?.();
+    return timer;
+}

package/dist/server-ai-team-routes.d.ts

@@ -1,10 +1,11 @@
 import type { Express } from "express";
 import { type AiTeamRunner } from "./ai-team-runner.js";
 import { type AiTeam } from "./ai-team-types.js";
+import { type AiTeamEmployeeSource } from "./ai-team-employee-binding.js";
 import type { WandStorage } from "./storage.js";
 /** 团队页「直接开工」自动建卡的标记（§4.2 / Q3）：看板靠它区分团队卡与手写卡。 */
 export declare const TEAM_DIRECT_LABEL = "team_direct";
-export declare function parseAiTeamInput(value: unknown, existing: AiTeam | null, now: string): AiTeam;
+export declare function parseAiTeamInput(value: unknown, existing: AiTeam | null, now: string, source?: AiTeamEmployeeSource): AiTeam;
 export declare function registerAiTeamRoutes(app: Express, deps: {
     storage: WandStorage;
     runner: AiTeamRunner;

package/dist/server-ai-team-routes.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { AiTeamConflictError } from "./ai-team-runner.js";
 import { AI_TEAM_AVATAR_MAX_CHARS, AI_TEAM_DEFAULT_MAX_STEPS, AI_TEAM_MAX_CANDIDATES, AI_TEAM_MAX_MEMBERS, AI_TEAM_MAX_STEPS, AI_TEAM_MIN_MEMBERS, AI_TEAM_MIN_STEPS, agentKey, isTeamMemberRole, memberAgents, } from "./ai-team-types.js";
+import { requireTeamEmployee } from "./ai-team-employee-binding.js";
 import { asyncRoute } from "./express-async.js";
 import { getErrorMessage } from "./error-utils.js";
 import { defaultMilestoneIdForWrite, scopedMilestoneId } from "./milestone-scope.js";
@@ -37,7 +38,7 @@ function parseAvatar(value, name) {
         throw new Error(`成员「${name}」的头像太大。`);
     return avatar;
 }
-function parseMembers(value) {
+function parseMembers(value, existing, source) {
     if (!Array.isArray(value))
         throw new Error("成员列表必须是数组。");
     if (value.length < AI_TEAM_MIN_MEMBERS || value.length > AI_TEAM_MAX_MEMBERS) {
@@ -45,14 +46,27 @@ function parseMembers(value) {
     }
     const names = new Set();
     const ids = new Set();
+    const employees = new Set();
     const members = value.map((raw, index) => {
         const body = bodyObject(raw);
-        const name = boundedText(body.name, `第 ${index + 1} 位成员的名字`, 1, 40);
+        const rawId = text(body.id);
+        const prior = existing?.members.find((member) => member.id === rawId);
+        if (body.employeeId !== undefined && body.employeeId !== null && typeof body.employeeId !== "string") {
+            throw new Error("员工 ID 必须是文字。");
+        }
+        const employeeId = body.employeeId === undefined ? prior?.employeeId : text(body.employeeId) || undefined;
+        if (employeeId && !source)
+            throw new Error("员工绑定需要真实员工来源。");
+        if (employeeId && employees.has(employeeId))
+            throw new Error("同一员工不能重复加入同一团队。");
+        if (employeeId)
+            employees.add(employeeId);
+        const employee = employeeId ? requireTeamEmployee(source, employeeId) : null;
+        const name = employee?.name ?? boundedText(body.name, `第 ${index + 1} 位成员的名字`, 1, 40);
         const key = name.toLowerCase();
         if (names.has(key))
             throw new Error(`成员名字「${name}」重复。`);
         names.add(key);
-        const rawId = text(body.id);
         const id = /^m_[A-Za-z0-9]{1,32}$/.test(rawId) && !ids.has(rawId)
             ? rawId
             : `m_${randomUUID().replace(/-/g, "").slice(0, 8)}`;
@@ -62,7 +76,10 @@ function parseMembers(value) {
             throw new Error(`成员「${name}」的职责不能超过 2000 个字符。`);
         let agents;
         try {
-            if (Array.isArray(body.agents)) {
+            if (employee) {
+                agents = employee.agents.map((candidate) => ({ ...candidate }));
+            }
+            else if (Array.isArray(body.agents)) {
                 if (body.agents.length === 0)
                     throw new Error("至少需要一个执行候选。");
                 if (body.agents.length > AI_TEAM_MAX_CANDIDATES)
@@ -92,10 +109,11 @@ function parseMembers(value) {
             throw new Error(`成员「${name}」的执行候选重复。`);
         const member = {
             id, name, duty, agents,
+            ...(employeeId ? { employeeId } : {}),
             // 服务端强制兼容字段 = 首选候选，不信任客户端传来的 agent。
             agent: agents[0],
             isLeader: body.isLeader === true,
-            avatar: parseAvatar(body.avatar, name),
+            avatar: employee?.avatar ?? parseAvatar(body.avatar, name),
         };
         if (isTeamMemberRole(body.role))
             member.role = body.role;
@@ -105,7 +123,7 @@ function parseMembers(value) {
         throw new Error("团队需要恰好一位负责人。");
     return members;
 }
-export function parseAiTeamInput(value, existing, now) {
+export function parseAiTeamInput(value, existing, now, source) {
     const body = bodyObject(value);
     const maxSteps = body.maxSteps === undefined ? existing?.maxSteps ?? AI_TEAM_DEFAULT_MAX_STEPS : Number(body.maxSteps);
     if (!Number.isInteger(maxSteps) || maxSteps < AI_TEAM_MIN_STEPS || maxSteps > AI_TEAM_MAX_STEPS) {
@@ -122,7 +140,7 @@ export function parseAiTeamInput(value, existing, now) {
         name: boundedText(body.name, "团队名", 1, 60),
         description,
         instructions,
-        members: parseMembers(body.members),
+        members: parseMembers(body.members, existing, source),
         requirePlanApproval: typeof body.requirePlanApproval === "boolean"
             ? body.requirePlanApproval
             : existing?.requirePlanApproval ?? true,
@@ -146,7 +164,7 @@ export function registerAiTeamRoutes(app, deps) {
     });
     app.post("/api/ai-teams", (req, res) => {
         try {
-            const team = parseAiTeamInput(req.body, null, new Date().toISOString());
+            const team = parseAiTeamInput(req.body, null, new Date().toISOString(), storage);
             storage.saveAiTeam(team);
             res.status(201).json(team);
         }
@@ -159,7 +177,7 @@ export function registerAiTeamRoutes(app, deps) {
             const existing = storage.getAiTeam(req.params.id);
             if (!existing)
                 throw new Error("团队不存在。");
-            const team = parseAiTeamInput(req.body, existing, new Date().toISOString());
+            const team = parseAiTeamInput(req.body, existing, new Date().toISOString(), storage);
             storage.saveAiTeam(team);
             notifyTeam(team.id);
             res.json(team);

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

@@ -0,0 +1,10 @@
+import type { Express, RequestHandler } from "express";
+import type { WandStorage } from "./storage.js";
+import type { DecisionService } from "./decision-service.js";
+/** Mounted before generic /api auth so inference-only capabilities cannot authorize any other route. */
+export declare function registerDecisionRoutes(app: Express, deps: {
+    storage: WandStorage;
+    decisions: DecisionService;
+    requireAuth: RequestHandler;
+    requireSessions: RequestHandler;
+}): void;

package/dist/server-decision-routes.js

@@ -0,0 +1,52 @@
+import { DecisionError } from "./decision-types.js";
+/** Mounted before generic /api auth so inference-only capabilities cannot authorize any other route. */
+export function registerDecisionRoutes(app, deps) {
+    const authorize = (req, res, next) => {
+        res.setHeader("Cache-Control", "no-store");
+        const header = req.headers.authorization ?? "";
+        const token = /^Bearer (wd_[A-Za-z0-9_-]{43})$/.exec(header)?.[1];
+        const sessionId = token ? deps.storage.resolveDecisionAccess(token) : null;
+        if (sessionId) {
+            res.locals.decisionCaller = `session:${sessionId}`;
+            next();
+            return;
+        }
+        deps.requireAuth(req, res, (error) => {
+            if (error) {
+                next(error);
+                return;
+            }
+            deps.requireSessions(req, res, (scopeError) => {
+                if (scopeError) {
+                    next(scopeError);
+                    return;
+                }
+                res.locals.decisionCaller = "authenticated-client";
+                next();
+            });
+        });
+    };
+    app.get("/api/decisions/status", authorize, (_req, res) => {
+        res.json(deps.decisions.status());
+    });
+    app.post("/api/decisions/evaluate", authorize, async (req, res) => {
+        const abort = new AbortController();
+        const disconnected = () => { if (!res.writableEnded)
+            abort.abort(); };
+        res.once("close", disconnected);
+        try {
+            const result = await deps.decisions.evaluate(req.body, res.locals.decisionCaller, abort.signal);
+            if (!res.destroyed)
+                res.json(result);
+        }
+        catch (error) {
+            if (res.destroyed)
+                return;
+            const failure = error instanceof DecisionError ? error : new DecisionError("INTERNAL_ERROR", "决策请求失败。", 500);
+            res.status(failure.status).json({ error: failure.message, code: failure.code });
+        }
+        finally {
+            res.off("close", disconnected);
+        }
+    });
+}