@co0ontty/wand 4.83.1 → 4.84.0

package/dist/structured-thinking.d.ts

@@ -0,0 +1,15 @@
+import type { ContentBlock } from "./types.js";
+/**
+ * Reasoning events can carry boundaries only. Observation times are supplied
+ * by the live runner; historical replay must not invent recent activity.
+ *
+ * 有些 provider 会为一轮没有产出任何正文的思考发边界事件。这种轮次不该变成
+ * 一个空的思考块：它会在时间线里留下一条永远「思考中」又读不到内容的条目，
+ * 也会把轮次计数撑大。边界自证没有正文时直接丢弃，只有正在写的那一轮保留占位。
+ */
+export declare function updateThinkingActivity(blocks: ContentBlock[], update: Record<string, unknown> | null | undefined, observedAt?: string): void;
+/**
+ * 一条 assistant 消息结束时用它收尾：正文里没有思考内容时，丢掉流式留下的空占位。
+ * 返回是否清理过，供调用方在同一条消息没有正文时不再留下空轮次。
+ */
+export declare function settleThinkingRound(blocks: ContentBlock[], messageThinking: string): void;

package/dist/structured-thinking.js

@@ -0,0 +1,46 @@
+function lastThinking(blocks) {
+    const last = blocks.at(-1);
+    return last?.type === "thinking" ? last : undefined;
+}
+/**
+ * Reasoning events can carry boundaries only. Observation times are supplied
+ * by the live runner; historical replay must not invent recent activity.
+ *
+ * 有些 provider 会为一轮没有产出任何正文的思考发边界事件。这种轮次不该变成
+ * 一个空的思考块：它会在时间线里留下一条永远「思考中」又读不到内容的条目，
+ * 也会把轮次计数撑大。边界自证没有正文时直接丢弃，只有正在写的那一轮保留占位。
+ */
+export function updateThinkingActivity(blocks, update, observedAt) {
+    const type = update?.type;
+    if (type !== "thinking_start" && type !== "thinking_delta" && type !== "thinking_end")
+        return;
+    const content = typeof update?.content === "string" ? update.content : "";
+    let last = lastThinking(blocks);
+    if (type === "thinking_end" && last && !last.thinking.trim() && !content.trim()) {
+        blocks.pop();
+        return;
+    }
+    // 上一轮只开了头就再开一轮：那个空块没有发生过，不是进行中的占位。
+    if (type === "thinking_start" && last && !last.thinking.trim())
+        blocks.pop();
+    last = lastThinking(blocks);
+    if (!last) {
+        last = { type: "thinking", thinking: "" };
+        blocks.push(last);
+    }
+    if (observedAt) {
+        last.occurredAt ??= observedAt;
+        last.lastActivityAt = observedAt;
+    }
+}
+/**
+ * 一条 assistant 消息结束时用它收尾：正文里没有思考内容时，丢掉流式留下的空占位。
+ * 返回是否清理过，供调用方在同一条消息没有正文时不再留下空轮次。
+ */
+export function settleThinkingRound(blocks, messageThinking) {
+    if (messageThinking.trim())
+        return;
+    const last = lastThinking(blocks);
+    if (last && !last.thinking.trim())
+        blocks.pop();
+}

package/dist/subagent-dispatch.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 子 Agent 派发判据：Web 服务端（`structured-client-protocol.ts` 盖章，Android/iOS/macOS
+ * 都消费这份章）与 Web 前端（`web-ui/browser/agent-runs.ts` 现场补判）共用同一份实现，
+ * 不再各写一套——判据只留一个地方，就不会再出现「一端改了另一端没改」的漂移。
+ *
+ * 判据只问一件事：pi 的 `subagent` 工具带不带 `action`。
+ * pi 自己把 `action` 定义成「管理/控制专用，省略才是执行」
+ * （pi-subagents schemas：`Management action (when present, tool operates in management mode)`、
+ * `Management/control only; omit for execution`），所以：
+ *   - 带 `action` ⇒ 管理调用（status / list / validate / steer / lane.* / schedule.* / command.* …），
+ *     不进子 Agent 面板，正文照常留在转录里；
+ *   - 不带 `action` ⇒ 真正的派发（agent+task、tasks/chain、workflow 脚本、`workflow: true`、
+ *     命名工作流资源、resume、mission …），一律进面板。
+ *
+ * 这里刻意**不枚举**派发形态、也**不枚举**管理动作：pi 以后新增派发参数或新增 action 值，
+ * 都自动落到正确一侧，不用再回来补名单。历史实现按「有没有 agent/task」判，于是
+ * `subagent({ workflow: "…", async: true })` 这种真派发被当成管理调用丢掉，界面上什么都不显示。
+ *
+ * Claude Code 的 `Task` / `Agent` 是另一套形状：工具名本身即派发语义，`subagent_type` 可省；
+ * 其他 provider 只要真给了 `subagent_type`，同样按派发处理。
+ */
+/** pi 扩展工具经 `piToolName` 映射后带 `Pi/` 前缀。 */
+export declare const PI_SUBAGENT_TOOL_NAME = "Pi/subagent";
+export declare const PI_TODO_TOOL_NAME = "Pi/todo";
+/** Claude Code 的派发工具名。 */
+export declare const CLAUDE_SUBAGENT_TOOL_NAMES: readonly string[];
+/** workflow 形态没有 agent 名，面板用这个类型标识；标题另取脚本名。 */
+export declare const WORKFLOW_SUBAGENT_AGENT_TYPE = "workflow";
+export interface SubagentDispatchMeta {
+    taskId: string;
+    agentType?: string;
+    taskDescription?: string;
+}
+/** 已有的 `__subagent` 盖章（服务端 `SubagentMeta` / 各端 DTO 的结构投影）。 */
+export interface SubagentStampLike {
+    taskId?: string;
+    agentType?: string;
+    taskDescription?: string;
+}
+export interface SubagentToolUseLike {
+    type?: string;
+    name?: string;
+    id?: string;
+    input?: unknown;
+    __subagent?: SubagentStampLike | null;
+}
+/**
+ * workflow 派发的可读标题：脚本路径取末段（`…/continuation.js` → `continuation.js`），
+ * 命名工作流资源取资源名。`workflow: true`（用同一条回复里的代码块）没有名字，返回 undefined。
+ */
+export declare function subagentWorkflowLabel(workflow: unknown): string | undefined;
+/**
+ * 从一次 tool_use 派生子 Agent 元数据；不是派发（或不是工具调用）时返回 null。
+ * 已盖章的块直接回投影，保证服务端盖的章在各端读出来一致。
+ */
+export declare function deriveSubagentDispatchMeta(block: SubagentToolUseLike | null | undefined): SubagentDispatchMeta | null;

package/dist/subagent-dispatch.js

@@ -0,0 +1,102 @@
+/**
+ * 子 Agent 派发判据：Web 服务端（`structured-client-protocol.ts` 盖章，Android/iOS/macOS
+ * 都消费这份章）与 Web 前端（`web-ui/browser/agent-runs.ts` 现场补判）共用同一份实现，
+ * 不再各写一套——判据只留一个地方，就不会再出现「一端改了另一端没改」的漂移。
+ *
+ * 判据只问一件事：pi 的 `subagent` 工具带不带 `action`。
+ * pi 自己把 `action` 定义成「管理/控制专用，省略才是执行」
+ * （pi-subagents schemas：`Management action (when present, tool operates in management mode)`、
+ * `Management/control only; omit for execution`），所以：
+ *   - 带 `action` ⇒ 管理调用（status / list / validate / steer / lane.* / schedule.* / command.* …），
+ *     不进子 Agent 面板，正文照常留在转录里；
+ *   - 不带 `action` ⇒ 真正的派发（agent+task、tasks/chain、workflow 脚本、`workflow: true`、
+ *     命名工作流资源、resume、mission …），一律进面板。
+ *
+ * 这里刻意**不枚举**派发形态、也**不枚举**管理动作：pi 以后新增派发参数或新增 action 值，
+ * 都自动落到正确一侧，不用再回来补名单。历史实现按「有没有 agent/task」判，于是
+ * `subagent({ workflow: "…", async: true })` 这种真派发被当成管理调用丢掉，界面上什么都不显示。
+ *
+ * Claude Code 的 `Task` / `Agent` 是另一套形状：工具名本身即派发语义，`subagent_type` 可省；
+ * 其他 provider 只要真给了 `subagent_type`，同样按派发处理。
+ */
+/** pi 扩展工具经 `piToolName` 映射后带 `Pi/` 前缀。 */
+export const PI_SUBAGENT_TOOL_NAME = "Pi/subagent";
+export const PI_TODO_TOOL_NAME = "Pi/todo";
+/** Claude Code 的派发工具名。 */
+export const CLAUDE_SUBAGENT_TOOL_NAMES = ["Task", "Agent"];
+/** workflow 形态没有 agent 名，面板用这个类型标识；标题另取脚本名。 */
+export const WORKFLOW_SUBAGENT_AGENT_TYPE = "workflow";
+function textValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function inputRecord(block) {
+    const input = block.input;
+    return input && typeof input === "object" && !Array.isArray(input)
+        ? input
+        : {};
+}
+/**
+ * workflow 派发的可读标题：脚本路径取末段（`…/continuation.js` → `continuation.js`），
+ * 命名工作流资源取资源名。`workflow: true`（用同一条回复里的代码块）没有名字，返回 undefined。
+ */
+export function subagentWorkflowLabel(workflow) {
+    if (typeof workflow !== "string")
+        return undefined;
+    const raw = workflow.trim();
+    if (!raw || raw === "true")
+        return undefined;
+    const segments = raw.split(/[\\/]/).filter((segment) => segment.length > 0);
+    return segments.length > 0 ? segments[segments.length - 1] : raw;
+}
+/**
+ * 从一次 tool_use 派生子 Agent 元数据；不是派发（或不是工具调用）时返回 null。
+ * 已盖章的块直接回投影，保证服务端盖的章在各端读出来一致。
+ */
+export function deriveSubagentDispatchMeta(block) {
+    if (!block)
+        return null;
+    const stamped = block.__subagent;
+    const stampedTaskId = textValue(stamped?.taskId);
+    if (stampedTaskId) {
+        const stampedAgentType = textValue(stamped?.agentType);
+        const stampedDescription = textValue(stamped?.taskDescription);
+        return {
+            taskId: stampedTaskId,
+            ...(stampedAgentType ? { agentType: stampedAgentType } : {}),
+            ...(stampedDescription ? { taskDescription: stampedDescription } : {}),
+        };
+    }
+    if (block.type !== "tool_use")
+        return null;
+    const taskId = textValue(block.id);
+    if (!taskId)
+        return null;
+    const input = inputRecord(block);
+    if (block.name === "workflow" || block.name === "Pi/workflow") {
+        return { taskId, agentType: WORKFLOW_SUBAGENT_AGENT_TYPE, taskDescription: "工作流" };
+    }
+    if (block.name === PI_SUBAGENT_TOOL_NAME || block.name === "subagent") {
+        // 有 action 就是管理/控制调用：面板不收，正文照旧。省略 action 才是执行。
+        if (textValue(input.action))
+            return null;
+        const agent = textValue(input.agent);
+        const task = textValue(input.task);
+        const workflow = input.workflow;
+        const description = task ?? subagentWorkflowLabel(workflow);
+        const agentType = agent ?? (workflow === undefined ? undefined : WORKFLOW_SUBAGENT_AGENT_TYPE);
+        return {
+            taskId,
+            ...(agentType ? { agentType } : {}),
+            ...(description ? { taskDescription: description } : {}),
+        };
+    }
+    const agentType = textValue(input.subagent_type);
+    if (CLAUDE_SUBAGENT_TOOL_NAMES.indexOf(String(block.name)) < 0 && !agentType)
+        return null;
+    const description = textValue(input.description);
+    return {
+        taskId,
+        ...(agentType ? { agentType } : {}),
+        ...(description ? { taskDescription: description } : {}),
+    };
+}

package/dist/system-employee.d.ts

@@ -6,8 +6,8 @@ export { SYSTEM_EMPLOYEE_ID, SYSTEM_EMPLOYEE_KEY, SYSTEM_EMPLOYEE_NAME, SYSTEM_E
  * 内置的「系统运维」员工。
  *
  * Wand 自己的 AI 调用（commit message / tag、提示词优化、会话与任务标题、
- * 员工起草）都由这位员工执行：名字、职责与人设写死在代码里，不可编辑、不可归档、
- * 不可删除；只有执行候选（CLI 工具 + 模型 + 思考深度，按顺序降级）由用户维护。
+ * 员工起草）都通过这位员工的 CLI 候选链执行：名字、职责与人设写死在代码里，不可编辑、不可归档、
+ * 不可删除；只有执行候选（CLI 工具 + 模型 + 思考深度，按顺序降级）由用户维护。候选中的 SDK 会被系统应用跳过。
  */
 export declare const SYSTEM_EMPLOYEE_DUTY = "Wand \u7CFB\u7EDF\u8FD0\u7EF4\uFF1A\u670D\u52A1\u4E0E CLI \u7EBF\u8DEF\u3001\u66F4\u65B0\u5206\u53D1\u3001\u4ED3\u5E93\u4E0E\u4F1A\u8BDD\u64CD\u4F5C\uFF0CWand \u81EA\u6709 AI \u4EFB\u52A1\u7684\u6267\u884C\u8005\u3002";
 /**
@@ -27,7 +27,8 @@ export interface SystemEmployeeSeed {
 /** 首次创建内置员工时使用的候选：优先沿用用户已有的系统 AI 工具与模型。 */
 export declare function systemEmployeeSeedAgents(seed?: SystemEmployeeSeed): WandTaskAgent[];
 export declare function systemEmployeeDefinition(agents: WandTaskAgent[], now: string, existing?: SiliconEmployee | null): SiliconEmployee;
+export declare function isSdkEmployeeAgent(agent: Pick<WandTaskAgent, "engine">): boolean;
 /**
- * 内部 AI 调用的 CLI 降级链：按用户设置的顺序，模型为空 / "default" 时跟随 provider 默认值。
+ * 系统应用只走员工的 CLI 渠道：员工候选里可以保存 SDK，但这里明确跳过。
  */
 export declare function systemEmployeeCliCandidates(employee: Pick<SiliconEmployee, "agents"> | null | undefined): AiCliCandidate[];

package/dist/system-employee.js

@@ -7,8 +7,8 @@ export { SYSTEM_EMPLOYEE_ID, SYSTEM_EMPLOYEE_KEY, SYSTEM_EMPLOYEE_NAME, SYSTEM_E
  * 内置的「系统运维」员工。
  *
  * Wand 自己的 AI 调用（commit message / tag、提示词优化、会话与任务标题、
- * 员工起草）都由这位员工执行：名字、职责与人设写死在代码里，不可编辑、不可归档、
- * 不可删除；只有执行候选（CLI 工具 + 模型 + 思考深度，按顺序降级）由用户维护。
+ * 员工起草）都通过这位员工的 CLI 候选链执行：名字、职责与人设写死在代码里，不可编辑、不可归档、
+ * 不可删除；只有执行候选（CLI 工具 + 模型 + 思考深度，按顺序降级）由用户维护。候选中的 SDK 会被系统应用跳过。
  */
 export const SYSTEM_EMPLOYEE_DUTY = "Wand 系统运维：服务与 CLI 线路、更新分发、仓库与会话操作，Wand 自有 AI 任务的执行者。";
 /**
@@ -57,14 +57,17 @@ export function systemEmployeeDefinition(agents, now, existing) {
         updatedAt: now,
     };
 }
+export function isSdkEmployeeAgent(agent) {
+    return agent.engine === "sdk";
+}
 /**
- * 内部 AI 调用的 CLI 降级链：按用户设置的顺序，模型为空 / "default" 时跟随 provider 默认值。
+ * 系统应用只走员工的 CLI 渠道：员工候选里可以保存 SDK，但这里明确跳过。
  */
 export function systemEmployeeCliCandidates(employee) {
     if (!employee)
         return [];
     return employee.agents
-        .filter((agent) => agent.kind === "structured")
+        .filter((agent) => agent.kind === "structured" && !isSdkEmployeeAgent(agent))
         .map((agent) => {
         const model = (agent.model ?? "").trim();
         return {

package/dist/task-retention.d.ts

@@ -0,0 +1,23 @@
+/** 看板任务的自动归档 / 自动删除。会话保留期不走这里。 */
+export declare const TASK_RETENTION_MIN_DAYS = 1;
+export declare const TASK_RETENTION_MAX_DAYS = 365;
+export declare const DEFAULT_TASK_AUTO_ARCHIVE_DAYS = 7;
+export declare const DEFAULT_TASK_AUTO_DELETE_DAYS = 7;
+export interface TaskRetentionSettings {
+    /** 空闲达到天数后自动归档。关闭后只停止自动归档，手动归档不受影响。 */
+    autoArchiveEnabled: boolean;
+    autoArchiveDays: number;
+    /** 归档后达到天数仍未恢复则删除。关闭后已归档任务会一直保留。 */
+    autoDeleteEnabled: boolean;
+    autoDeleteDays: number;
+}
+export declare function defaultTaskRetention(): TaskRetentionSettings;
+/** 读路径：缺字段或坏值回落到默认，避免旧库或脏数据把保留期清掉。 */
+export declare function normalizeTaskRetention(input: unknown): TaskRetentionSettings;
+/** 写路径：缺字段或越界直接拒绝，不能把半份设置存成「看起来保存成功」。 */
+export declare function parseTaskRetention(input: unknown): TaskRetentionSettings;
+/** `null` 表示该动作关闭。调用方每次扫描都要重新读，不能缓存启动时的窗口。 */
+export declare function taskRetentionWindows(input: unknown): {
+    idleMs: number | null;
+    archivedMs: number | null;
+};

package/dist/task-retention.js

@@ -0,0 +1,69 @@
+/** 看板任务的自动归档 / 自动删除。会话保留期不走这里。 */
+export const TASK_RETENTION_MIN_DAYS = 1;
+export const TASK_RETENTION_MAX_DAYS = 365;
+export const DEFAULT_TASK_AUTO_ARCHIVE_DAYS = 7;
+export const DEFAULT_TASK_AUTO_DELETE_DAYS = 7;
+const DAY_MS = 24 * 60 * 60 * 1000;
+export function defaultTaskRetention() {
+    return {
+        autoArchiveEnabled: true,
+        autoArchiveDays: DEFAULT_TASK_AUTO_ARCHIVE_DAYS,
+        autoDeleteEnabled: true,
+        autoDeleteDays: DEFAULT_TASK_AUTO_DELETE_DAYS,
+    };
+}
+/** 读路径：缺字段或坏值回落到默认，避免旧库或脏数据把保留期清掉。 */
+export function normalizeTaskRetention(input) {
+    const defaults = defaultTaskRetention();
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return defaults;
+    const raw = input;
+    return {
+        autoArchiveEnabled: typeof raw.autoArchiveEnabled === "boolean" ? raw.autoArchiveEnabled : defaults.autoArchiveEnabled,
+        autoArchiveDays: retentionDays(raw.autoArchiveDays, defaults.autoArchiveDays),
+        autoDeleteEnabled: typeof raw.autoDeleteEnabled === "boolean" ? raw.autoDeleteEnabled : defaults.autoDeleteEnabled,
+        autoDeleteDays: retentionDays(raw.autoDeleteDays, defaults.autoDeleteDays),
+    };
+}
+/** 写路径：缺字段或越界直接拒绝，不能把半份设置存成「看起来保存成功」。 */
+export function parseTaskRetention(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error("任务保留设置必须是对象。");
+    }
+    const raw = input;
+    return {
+        autoArchiveEnabled: retentionFlag(raw.autoArchiveEnabled, "自动归档"),
+        autoArchiveDays: requireRetentionDays(raw.autoArchiveDays, "空闲天数"),
+        autoDeleteEnabled: retentionFlag(raw.autoDeleteEnabled, "自动删除"),
+        autoDeleteDays: requireRetentionDays(raw.autoDeleteDays, "归档后天数"),
+    };
+}
+/** `null` 表示该动作关闭。调用方每次扫描都要重新读，不能缓存启动时的窗口。 */
+export function taskRetentionWindows(input) {
+    const policy = normalizeTaskRetention(input);
+    return {
+        idleMs: policy.autoArchiveEnabled ? policy.autoArchiveDays * DAY_MS : null,
+        archivedMs: policy.autoDeleteEnabled ? policy.autoDeleteDays * DAY_MS : null,
+    };
+}
+function retentionDays(value, fallback) {
+    if (typeof value !== "number" || !Number.isInteger(value))
+        return fallback;
+    if (value < TASK_RETENTION_MIN_DAYS || value > TASK_RETENTION_MAX_DAYS)
+        return fallback;
+    return value;
+}
+function retentionFlag(value, label) {
+    if (typeof value !== "boolean")
+        throw new Error(`${label}开关必须是布尔值。`);
+    return value;
+}
+function requireRetentionDays(value, label) {
+    if (typeof value !== "number"
+        || !Number.isInteger(value)
+        || value < TASK_RETENTION_MIN_DAYS
+        || value > TASK_RETENTION_MAX_DAYS) {
+        throw new Error(`${label}必须是 ${TASK_RETENTION_MIN_DAYS}–${TASK_RETENTION_MAX_DAYS} 的整数。`);
+    }
+    return value;
+}

package/dist/task-types.d.ts

@@ -7,6 +7,8 @@ export declare const DEFAULT_WAND_TASK_PRIORITY: WandTaskPriority;
 /** 任务派发时选择的 CLI 工具；空串表示尚未指定。沿用 provider 的唯一真源。 */
 export type WandTaskAgentProvider = import("./provider-catalog.js").SessionProvider;
 export type WandTaskAgentModel = string;
+export type WandTaskAgentEngine = "cli" | "sdk";
+export declare function isWandTaskAgentEngine(value: unknown): value is WandTaskAgentEngine;
 /** 与会话思考档位同一套：旧四档，或 `provider:level` 原生档。 */
 export type WandTaskAgentEffort = "off" | "standard" | "deep" | "max" | `${WandTaskAgentProvider}:${string}`;
 /**
@@ -44,6 +46,8 @@ export interface WandTaskAgent {
     /** 具体模型 ID；"default" 表示跟随服务端为该 provider 选择的默认模型。 */
     model: WandTaskAgentModel;
     thinkingEffort: WandTaskAgentEffort;
+    /** 执行引擎；缺省为 CLI。SDK 仅支持 Pi 结构化员工会话。 */
+    engine?: WandTaskAgentEngine;
     /** 执行模式；缺省时按标准模式处理。 */
     mode: WandTaskAgentMode;
     /** 派发出来的会话是结构化对话还是 PTY 终端；缺省时按结构化处理。 */

package/dist/task-types.js

@@ -4,6 +4,9 @@ export function isClosedWandTaskStatus(status) {
 }
 /** 新建任务的默认优先级：用户没挑就是「低」，不再落成「无优先级」。 */
 export const DEFAULT_WAND_TASK_PRIORITY = "low";
+export function isWandTaskAgentEngine(value) {
+    return value === "cli" || value === "sdk";
+}
 /** 合法执行模式清单；顺序即下拉顺序。 */
 export const WAND_TASK_AGENT_MODES = ["managed", "full-access", "default"];
 /** 历史行没有 mode 字段时的兜底：标准模式，与旧 `mode: "agent"` 的权限姿态一致。 */

package/dist/team-dispatch.d.ts

@@ -0,0 +1,101 @@
+import { type DecisionResult } from "./decision-types.js";
+import type { WandStorage } from "./storage.js";
+/** 团队页「直接开工」自动建卡的标记，与手写卡区分。 */
+export declare const TEAM_DISPATCH_LABEL = "team_direct";
+/** 临时派工的候选集：一次决策调用最多评估这么多员工（= 每题最多选项数）。 */
+export declare const DISPATCH_CANDIDATES_PER_CALL = 8;
+/** 建议名单默认上限：够完成一件事，又不至于把团队开成大会。 */
+export declare const DISPATCH_MAX_MEMBERS_DEFAULT = 3;
+/** 一次规划最多发多少次判断（每批 8 人）：保证响应时间与决策 worker 队列不被目录规模拖垮。 */
+export declare const DISPATCH_MAX_CALLS = 8;
+/** 入选门槛：低于这个概率视为“不参与”。概率只是参考，不是正确率。 */
+export declare const DISPATCH_MIN_PROBABILITY_DEFAULT = 0.5;
+/** 开工说明与状态的上限，与团队直接开工同口径。 */
+export declare const DISPATCH_NOTE_MAX = 4000;
+export interface TeamDispatchCandidate {
+    employeeId: string;
+    name: string;
+    duty: string;
+    tags: string[];
+    avatar: string;
+}
+export interface TeamDispatchMember extends TeamDispatchCandidate {
+    /** 本地决策给出的参与概率（0–1）；仅作参考，不是正确率。 */
+    probability: number;
+    /** 决策给出的这一题的原始判定，便于复盘。 */
+    isLeader: boolean;
+}
+export interface TeamDispatchPlan {
+    /** 建议参与的人（按概率降序），可能为空。 */
+    members: TeamDispatchMember[];
+    /** 超过上限但也被判定为参与的备选（按概率降序）。 */
+    bench: TeamDispatchMember[];
+    /** 员工目录里可派工的候选总数。 */
+    considered: number;
+    /** 因候选过多、未纳入本轮评估的人数（目录上限之外）。 */
+    omitted: number;
+    threshold: number;
+    maxMembers: number;
+    /** 人类可读说明：为空名单、被截断、覆盖范围等都由它表达。 */
+    note: string;
+    decision: {
+        calls: number;
+        model: string | null;
+        inputTokens: number;
+    };
+    experimental: true;
+}
+export interface TeamDispatchRequest {
+    storage: WandStorage;
+    note: string;
+    maxMembers?: number;
+    threshold?: number;
+    signal?: AbortSignal;
+    /** 决策调用入口：生产用 DecisionService.evaluate，测试注入替身。 */
+    evaluate: (value: unknown, caller: string, signal?: AbortSignal) => Promise<DecisionResult>;
+}
+export interface TeamDispatchStartRequest {
+    storage: WandStorage;
+    runner: {
+        start(input: {
+            teamId: string;
+            taskId: string;
+            note?: string;
+        }): Promise<unknown>;
+    };
+    workspaceId: string;
+    note: string;
+    members: Array<{
+        employeeId: string;
+        isLeader?: boolean;
+    }>;
+    name?: string;
+}
+/**
+ * 可派工的员工目录。
+ * 系统运维（Wand 自己的生成式 AI 执行者）不是干活的人，永远不进候选集；
+ * 归档员工不参与派工，但历史会话仍可打开。
+ */
+export declare function listTeamDispatchCandidates(storage: WandStorage): TeamDispatchCandidate[];
+/**
+ * 用本地决策模型给任务挑参与员工：**只产出建议名单**，不自动开工。
+ * 每批最多 8 名候选、一名一题（是非判断），批次之间顺序调用（决策服务本身是单 worker）。
+ */
+export declare function planTeamDispatch(request: TeamDispatchRequest): Promise<TeamDispatchPlan>;
+/**
+ * 确认开工：用建议名单建一个临时团队并起 run。
+ * 名单由调用方回传（服务端重新校验员工身份），所以“建议”和“开工”之间不需要服务端存计划。
+ */
+export declare function startTeamDispatch(request: TeamDispatchStartRequest): Promise<{
+    teamId: string;
+    taskId: string;
+    run: unknown;
+}>;
+/** 决策服务可用性：不可用时明确报错，绝不编造名单。 */
+export declare function assertDispatchDecisionReady(decisions: {
+    status(): {
+        enabled: boolean;
+        supported: boolean;
+        configured: boolean;
+    };
+}): void;