@harness-mix/cli 0.2.4 → 0.3.0

package/src/main/adapters/pi-family.js

@@ -52,19 +52,45 @@ function emitAll(emitEvent, mapped) {
   for (const item of Array.isArray(mapped) ? mapped : [mapped]) if (item) emitEvent(item);
 }
 
-/** Pi 家族（Pi / Oh My Pi）的权限模型 = 项目信任（project trust）：启动时用 --approve / --no-approve 覆盖一次 */
+/** Pi 家族工厂的权限模型按家族成员原生面注入；两者的启动旗标不同，不得共用目录。
+ * Pi（pi-coding-agent）的权限模型 = 项目信任（project trust）：启动时用 --approve / --no-approve 覆盖一次。
+ * 实测校准（本机 pi 0.84.2 `pi --help`）：--approve/-a「Trust project-local files for this run」、
+ * --no-approve/-na「Ignore project-local files for this run」；default 即不传旗标（走 defaultProjectTrust 全局设置）。 */
 const PI_PERMISSION_MODES = [
   { id: "default", label: "默认", description: "按全局设置处理项目级设置与扩展（defaultProjectTrust）" },
   { id: "approve", label: "信任项目", description: "本次信任该项目的设置与扩展（--approve）" },
   { id: "no-approve", label: "忽略项目资源", description: "本次不加载项目级设置与扩展（--no-approve）" },
 ];
 
+/** OMP（Pi 的 fork）权限模型已与 Pi 分叉：启动旗标为 --approval-mode always-ask|write|yolo
+ * （覆盖 tools.approvalMode，仅本次运行不持久化；--auto-approve/--yolo 是 yolo 捷径），
+ * 无 --approve/--no-approve。实测本机 @oh-my-pi/pi-coding-agent 18.1.19：
+ * src/cli/flag-tables.ts（--approval-mode 合法值）、src/cli/args.ts（--auto-approve/--yolo 解析）、
+ * src/config/settings-schema.ts（三档语义，描述为上游原文的中文转写）。 */
+const OMP_APPROVAL_MODES = [
+  { id: "always-ask", label: "Always ask", description: "自动放行只读工具；写入与执行类工具需确认。" },
+  { id: "write", label: "Write", description: "自动放行只读与写入工具；执行类工具（bash、浏览器、任务等）需确认。" },
+  { id: "yolo", label: "Yolo", description: "自动放行全部层级工具；用户策略仍可要求确认或拦截。", dangerous: true },
+];
+
+/** Pi 的权限模式 → 启动旗标（default 不传旗标） */
+function piPermissionLaunchArgs(mode) {
+  if (mode === "approve") return ["--approve"];
+  if (mode === "no-approve") return ["--no-approve"];
+  return [];
+}
+
+/** OMP 的权限模式 → 启动旗标（--approval-mode 逐值下发，不持久化） */
+function ompPermissionLaunchArgs(mode) {
+  return OMP_APPROVAL_MODES.some((entry) => entry.id === mode) ? ["--approval-mode", mode] : [];
+}
+
 /**
  * Pi 家族 Adapter 工厂：Pi 与 Oh My Pi（OMP，Pi 的 fork）共用 --mode rpc 协议。
  * 会话/模型/工具/权限都由原生程序维护，这里只做事件投影。
  * @param {{ id: string, name: string, icon: string, bin: string, packageHint: string, aliases?: string[] }} options
  */
-function piFamily({ id, name, icon, bin, packageHint, aliases }) {
+function piFamily({ id, name, icon, bin, packageHint, aliases, permissionModes = PI_PERMISSION_MODES, permissionLaunchArgs = piPermissionLaunchArgs }) {
   const manifest = {
     id,
     name,
@@ -117,8 +143,8 @@ function piFamily({ id, name, icon, bin, packageHint, aliases }) {
         const args = thread.restore && thread.nativeSessionFile
           ? ['--session', thread.nativeSessionFile]
           : ["--session-id", thread.nativeSessionId, "--name", sanitizeName(thread.title)];
-        if (thread.options?.permissionMode === "approve") args.push("--approve");
-        if (thread.options?.permissionMode === "no-approve") args.push("--no-approve");
+        // 权限模式只在该原生 CLI 真正支持的旗标集内映射（Pi 项目信任 vs OMP --approval-mode）
+        args.push(...permissionLaunchArgs(thread.options?.permissionMode));
         const process = spawnProcess(args, thread.cwd, {
           onEvent: event => forwardEvent(process, event, emitEvent),
           onDiagnostic: (message) => diagnostic(message),
@@ -239,7 +265,7 @@ function piFamily({ id, name, icon, bin, packageHint, aliases }) {
           return {
             models: (modelsData?.models ?? []).map((m) => ({ id: m.id, name: m.name || m.id, provider: m.provider, contextWindow: m.contextWindow })),
             thinkingLevels: (levelsData?.levels ?? []).map((l) => ({ id: l, label: l })),
-            permissionModes: PI_PERMISSION_MODES,
+            permissionModes,
           };
         } finally {
           process.stop();
@@ -251,7 +277,7 @@ function piFamily({ id, name, icon, bin, packageHint, aliases }) {
           this.listModelsFor(session),
           session.process.command({ type: 'get_available_thinking_levels' }),
         ]);
-        return { models, thinkingLevels: (levels?.levels ?? []).map(id => ({ id, label: id })), permissionModes: PI_PERMISSION_MODES };
+        return { models, thinkingLevels: (levels?.levels ?? []).map(id => ({ id, label: id })), permissionModes };
       },
 
       /** 任务级 Fork：另起进程，用 CLI --fork 从源会话分叉出全新原生会话 */
@@ -369,7 +395,8 @@ function piFamily({ id, name, icon, bin, packageHint, aliases }) {
   }
 
   // forwardEvent 暴露给回放/单测（runtime 经由 create().open() 闭包使用同一份实现）
-  return { manifest, create, project, forwardEvent };
+  // permissionModes 暴露注入的本成员权限目录（测试/契约侧可校验，不必拉起原生进程）
+  return { manifest, create, project, forwardEvent, permissionModes };
 }
 
-module.exports = { piFamily, PI_PERMISSION_MODES };
+module.exports = { piFamily, PI_PERMISSION_MODES, OMP_APPROVAL_MODES, piPermissionLaunchArgs, ompPermissionLaunchArgs };

package/src/main/adapters/zcode.js

@@ -81,9 +81,19 @@ const PERMISSION_MODES = [
 // Headless entry resolution. The desktop-bundled zcode.cjs is the primary
 // source; a standalone CLI on PATH and explicit env overrides also work.
 // The desktop app executable itself is NOT a headless CLI — never guess it
-// (the Qoder IDE-launcher lesson).
+// (the Qoder IDE-launcher lesson). The ZCode installer offers per-user
+// (%LOCALAPPDATA%\Programs) and per-machine (Program Files) layouts; probe
+// both, per-user first so existing installs keep their original path.
 function bundledCli() {
-  if (process.platform === 'win32') return path.join(process.env.LOCALAPPDATA || '', 'Programs', 'ZCode', 'resources', 'glm', 'zcode.cjs');
+  if (process.platform === 'win32') {
+    const candidates = [
+      path.join(process.env.LOCALAPPDATA || '', 'Programs', 'ZCode', 'resources', 'glm', 'zcode.cjs'),
+      path.join(process.env.ProgramFiles || 'C:\\Program Files', 'ZCode', 'resources', 'glm', 'zcode.cjs'),
+    ];
+    return candidates.find((file) => {
+      try { return fs.existsSync(file) && fs.statSync(file).isFile(); } catch { return false; }
+    }) || null;
+  }
   if (process.platform === 'darwin') return path.join(process.env.HOME || '', 'Applications', 'ZCode.app', 'Contents', 'Resources', 'glm', 'zcode.cjs');
   return null;
 }
@@ -128,12 +138,6 @@ function workspaceIdentity(cwd) {
 // (createNodeProviderRuntimePathEnv); the agent requires BOTH paths and
 // without the builtin file the provider registry stays empty ("Select a
 // model before continuing").
-function bundledCli() {
-  if (process.platform === 'win32') return path.join(process.env.LOCALAPPDATA || '', 'Programs', 'ZCode', 'resources', 'glm', 'zcode.cjs');
-  if (process.platform === 'darwin') return path.join(process.env.HOME || '', 'Applications', 'ZCode.app', 'Contents', 'Resources', 'glm', 'zcode.cjs');
-  return null;
-}
-
 function providerConfigPaths() {
   const desktopDir = bundledCli() ? path.dirname(path.dirname(bundledCli())) : null;
   const builtin = process.env.HARNESS_MIX_ZCODE_BUILTIN_CONFIG

package/src/main/host/collaboration-tools.js

@@ -7,7 +7,7 @@ const tools = [
   { name: 'list_agents', description: 'List native Harnesses available for delegation and their IDs.', inputSchema: object({}) },
   { name: 'delegate_to_agent', description: 'Start an independent native Harness session asynchronously. For Agent Team work, pass team_id, member_id and team_task_id so the native session becomes that durable teammate and can use the shared task graph and mailbox. An @Agent mention explicitly assigns that agent its associated work. Include all necessary context. By default workers share the lead working directory, so later reviewers see earlier edits; whenever another session is actively running in that directory, new workers start isolated automatically instead. Wait for development before starting dependent review; do not edit overlapping files concurrently. Use isolation=worktree for independent isolated experiments (auto also isolates Git projects). Returns task_id; collect results before finishing.', inputSchema: object({ agent_type: taskId, task, isolation: { type: 'string', enum: ['auto', 'worktree', 'shared'] }, team_id: teamId, member_id: memberId, team_task_id: taskId }, ['agent_type', 'task']) },
   { name: 'create_agent_team', description: 'Create a durable multi-Harness Agent Team with one lead and up to six named members with explicit roles. This creates shared team state, not worker sessions; assign tasks and delegate them to members next.', inputSchema: object({ name: { type: 'string', minLength: 1, maxLength: 120 }, goal: task, members: { type: 'array', minItems: 1, maxItems: 6, items: object({ name: { type: 'string', minLength: 1, maxLength: 80 }, role: { type: 'string', minLength: 1, maxLength: 240 }, agent_type: taskId }, ['name', 'role', 'agent_type']) } }, ['name', 'goal', 'members']) },
-  { name: 'assign_team_task', description: 'Add a task to the shared team task graph. Dependencies must already exist. The assignee is a team member id or unique member name.', inputSchema: object({ team_id: teamId, title: { type: 'string', minLength: 1, maxLength: 160 }, description: task, assignee: memberId, depends_on: { type: 'array', maxItems: 16, items: taskId } }, ['team_id', 'title', 'description', 'assignee']) },
+  { name: 'assign_team_task', description: 'Add a task to the shared team task graph. Dependencies must already exist. The assignee is a team member id or unique member name. Optional retry {max 1..3}: on a failed attempt the Host automatically re-dispatches the same member with the failure reason attached (session and workspace reused); without it a failure simply marks the task failed and notifies the lead mailbox.', inputSchema: object({ team_id: teamId, title: { type: 'string', minLength: 1, maxLength: 160 }, description: task, assignee: memberId, depends_on: { type: 'array', maxItems: 16, items: taskId }, retry: object({ max: { type: 'integer', minimum: 1, maximum: 3 } }, ['max']) }, ['team_id', 'title', 'description', 'assignee']) },
   { name: 'get_team_state', description: 'Read the current team roster, shared task graph and recent mailbox messages. Available to the lead and native teammate sessions. The projection includes a coarse phase (forming/running/waiting/completed), per-status progress counters, and each task\'s dependency depth so parallel lanes and pipeline stages are visible without walking depends_on by hand.', inputSchema: object({ team_id: teamId }, ['team_id']) },
   { name: 'update_team_task', description: 'Update task status/result in the shared graph. Teammates may update only tasks assigned to themselves; the lead may update any task.', inputSchema: object({ team_id: teamId, task_id: taskId, status: { type: 'string', enum: ['pending', 'blocked', 'in_progress', 'completed', 'failed'] }, result: { type: 'string', maxLength: 48000 } }, ['team_id', 'task_id', 'status']) },
   { name: 'send_team_message', description: 'Send a durable teammate-to-teammate mailbox message. Use a member id/name, lead, or * for broadcast. An idle native recipient is notified directly in its own session. Set kind to classify the hand-off: handoff (work passes to another member), review-request, or review-result; pair it with task_id so the recipient can locate the shared task. Defaults to text.', inputSchema: object({ team_id: teamId, to: { type: 'string', minLength: 1 }, message: task, task_id: taskId, kind: { type: 'string', enum: ['text', 'handoff', 'review-request', 'review-result'] } }, ['team_id', 'to', 'message']) },

package/src/main/host/collaboration.js

@@ -215,6 +215,17 @@ class Collaboration {
     return matches[0];
   }
 
+  // 成员未读数：发给该成员（定向或广播）且尚未经原生会话送达的消息条数，
+  // 让轮询 get_team_state 的成员一眼看到“有 N 条未读”，无需遍历邮箱。
+  memberUnread(team, member) {
+    return team.messages.filter(message => {
+      if (message.from === member.id) return false;
+      if (message.to !== member.id && message.to !== '*') return false;
+      const state = message.deliveryBy?.[member.id] ?? (message.to === member.id ? message.delivery : 'mailbox');
+      return state !== 'native_session';
+    }).length;
+  }
+
   teamView(team) {
     const leadThread = this.runtime.threads.find(thread => thread.id === team.owner);
     const leadAgent = leadThread?.harnessId ?? 'codex';
@@ -224,7 +235,7 @@ class Collaboration {
       team_id: team.id, name: team.name, goal: team.goal, status: team.status, lead_thread_id: team.owner,
       phase: teamPhase(team), progress: teamProgress(team.tasks),
       lead: { id: 'lead', name: 'Team Lead', role: `${leadName} · 协调与验收`, agent: leadAgent, display_status: this.runtime.execution.isRunning(team.owner) ? 'working' : 'ready' },
-      members: team.members.map(member => ({ ...member, display_status: member.childId && this.runtime.execution.isRunning(member.childId) ? 'working' : member.status })),
+      members: team.members.map(member => ({ ...member, display_status: member.childId && this.runtime.execution.isRunning(member.childId) ? 'working' : member.status, unread: this.memberUnread(team, member) })),
       tasks: team.tasks.map(task => ({ ...task, depth: depths.get(task.id) ?? 0 })), messages: team.messages.slice(-40).map(message => ({ ...message })),
       updated_at: team.updatedAt,
     };
@@ -258,11 +269,19 @@ class Collaboration {
     if (!parent || this.runtime.threads.some(t => t.id !== job.owner && t.id !== job.childId
       && (this.runtime.execution.isRunning(t.id) || t.reviewPending)
       && [parent.cwd, job.workspace?.cwd].some(cwd => String(cwd).toLowerCase() === String(t.cwd).toLowerCase()))) throw new Error('其他任务正在同一目录运行或待审查，请等待其结算后再应用');
-    if (job.childId) this.runtime.verificationGates.assertSatisfied(this.runtime.getThread(job.childId), '应用子任务改动');
+    // 子线程已删除时无从查询其门禁策略：review+digest+用户显式授权仍是硬前置，这里跳过
+    const childThread = job.childId ? this.runtime.threads.find(t => t.id === job.childId) : null;
+    if (childThread) this.runtime.verificationGates.assertSatisfied(childThread, '应用子任务改动');
     job.applying = true;
     try {
       const result = await applyWorkspace(job.workspace, digest);
       job.appliedDigest = result.digest;
+      // off 策略下的零配置安全网：apply 结果附一次 advisory 验证（不阻断、不改门禁语义）
+      const childForVerify = job.childId ? this.runtime.threads.find(t => t.id === job.childId) : null;
+      if (childForVerify) {
+        const report = await this.runtime.verificationGates.advisory(childForVerify).catch(() => null);
+        if (report) { job.verification = { mode: 'advisory', status: report.status, checks: report.checks }; result.verification = job.verification; }
+      }
       await this.save();
       return result;
     } finally { delete job.applying; }
@@ -349,7 +368,7 @@ class Collaboration {
       const assignee = this.resolveMember(team, args.assignee);
       const dependencies = [...new Set(args.depends_on ?? [])];
       if (dependencies.some(id => !team.tasks.some(task => task.id === id))) throw new Error('Unknown dependency task');
-      const taskEntry = { id: randomUUID(), title: args.title.trim(), description: args.description, assignee: assignee.id, dependsOn: dependencies, status: dependencies.length ? 'blocked' : 'pending', createdAt: Date.now(), updatedAt: Date.now() };
+      const taskEntry = { id: randomUUID(), title: args.title.trim(), description: args.description, assignee: assignee.id, dependsOn: dependencies, status: dependencies.length ? 'blocked' : 'pending', createdAt: Date.now(), updatedAt: Date.now(), ...(args.retry ? { retry: { max: args.retry.max, used: 0 } } : {}) };
       team.tasks.push(taskEntry);
       this.refreshTeamStatus(team);
       await this.publishTeam(team, 'task_assigned');
@@ -375,19 +394,18 @@ class Collaboration {
     if (name === 'send_team_message') {
       const target = args.to === '*' || args.to.toLowerCase() === 'lead' ? args.to.toLowerCase() : this.resolveMember(team, args.to).id;
       if (args.task_id && !team.tasks.some(task => task.id === args.task_id)) throw new Error('Unknown team task');
-      const message = { id: randomUUID(), from: participant.id, fromName: participant.name, to: target, kind: args.kind || 'text', body: args.message, ...(args.task_id ? { taskId: args.task_id } : {}), at: Date.now(), delivery: 'mailbox' };
+      const message = { id: randomUUID(), from: participant.id, fromName: participant.name, to: target, kind: args.kind || 'text', body: args.message, ...(args.task_id ? { taskId: args.task_id } : {}), at: Date.now(), delivery: 'mailbox', deliveryBy: {} };
       team.messages.push(message);
       if (team.messages.length > 200) team.messages.splice(0, team.messages.length - 200);
       const recipients = target === '*' ? team.members.filter(member => member.id !== participant.id) : team.members.filter(member => member.id === target);
       for (const recipient of recipients) {
-        if (!recipient.childId || rt.execution.isRunning(recipient.childId)) continue;
-        const envelope = `[Harness Mix Agent Team message]\nTeam: ${team.name} (${team.id})\nFrom: ${participant.name}\nType: ${message.kind}\n${args.task_id ? `Task: ${args.task_id}\n` : ''}Message: ${args.message}\n\nTreat this as teammate input. Inspect shared team state with get_team_state, coordinate through send_team_message, and update only your assigned tasks.`;
-        message.delivery = 'native_session';
-        const recipientJob = [...this.jobs.values()].reverse().find(job => job.teamId === team.id && job.memberId === recipient.id && job.childId === recipient.childId);
-        void rt.send(recipient.childId, envelope, { collaborationOf: team.owner, isolated: recipientJob?.workspace?.mode === 'worktree' }).catch(error => {
-          message.delivery = 'mailbox'; message.deliveryError = error.message; void this.saveTeams();
-        });
+        // 忙碌收件人不再丢弃直投机会：排队等回合边界（drainTeamMailbox 投递）；
+        // 绝不打断运行中的回合
+        if (!recipient.childId) { message.deliveryBy[recipient.id] = 'mailbox'; continue; }
+        if (rt.execution.isRunning(recipient.childId)) { message.deliveryBy[recipient.id] = 'queued'; continue; }
+        this.deliverToMember(team, recipient, message);
       }
+      this.refreshMessageDelivery(message);
       team.updatedAt = Date.now();
       await this.publishTeam(team, 'message_sent');
       return { message, team: this.teamView(team) };
@@ -395,13 +413,130 @@ class Collaboration {
     throw new Error('Unknown Agent Team operation');
   }
 
+  messageEnvelope(team, message) {
+    return `[Harness Mix Agent Team message]\nTeam: ${team.name} (${team.id})\nFrom: ${message.fromName}\nType: ${message.kind}\n${message.taskId ? `Task: ${message.taskId}\n` : ''}Message: ${message.body}\n\nTreat this as teammate input. Inspect shared team state with get_team_state, coordinate through send_team_message, and update only your assigned tasks.`;
+  }
+
+  // 单收件人直投：先同步置 delivering 防并发重投；投递状态在结果落定后才置终态——
+  // 先报 native_session 再失败会让邮箱读者看到与事实相反的送达渠道
+  deliverToMember(team, member, message) {
+    const rt = this.runtime;
+    message.deliveryBy[member.id] = 'delivering';
+    const recipientJob = [...this.jobs.values()].reverse().find(job => job.teamId === team.id && job.memberId === member.id && job.childId === member.childId);
+    void rt.send(member.childId, this.messageEnvelope(team, message), { collaborationOf: team.owner, isolated: recipientJob?.workspace?.mode === 'worktree' }).then(() => {
+      message.deliveryBy[member.id] = 'native_session'; this.refreshMessageDelivery(message); void this.saveTeams();
+    }, error => {
+      message.deliveryBy[member.id] = 'mailbox'; message.deliveryError = error.message; this.refreshMessageDelivery(message); void this.saveTeams();
+    });
+  }
+
+  // deliveryBy → delivery 聚合：任一收件人仍在排队即 queued，全部原生送达才 native_session
+  refreshMessageDelivery(message) {
+    const states = Object.values(message.deliveryBy ?? {});
+    if (!states.length) return;
+    if (states.every(state => state === 'native_session')) message.delivery = 'native_session';
+    else if (states.includes('queued') || states.includes('delivering')) message.delivery = 'queued';
+    else message.delivery = 'mailbox';
+  }
+
+  // 回合边界投递泵：把排队消息投给已空闲的收件人。由作业轮询循环与各结算路径
+  // 触发；delivering 标记同步置位，天然防并发重投。lead 已空闲时 rt.send 拒绝，
+  // 消息按既有语义降级回邮箱并记录 deliveryError。
+  drainTeamMailbox(team) {
+    if (!team || this.closing) return;
+    const rt = this.runtime;
+    for (const message of team.messages) {
+      for (const [memberId, state] of Object.entries(message.deliveryBy ?? {})) {
+        if (state !== 'queued') continue;
+        const member = team.members.find(entry => entry.id === memberId);
+        if (!member?.childId || rt.execution.isRunning(member.childId)) continue;
+        this.deliverToMember(team, member, message);
+      }
+    }
+  }
+
+  // 用户在团队看板/协作卡上的操作入口。principal 是用户：权限高于 lead 模型，
+  // 因此允许 lead-only 语义（改派/以 lead 身份发消息）。安全边界不变——改派目标
+  // 只能是团队既有成员（创建时已过 # 提及门控），派发类操作以「向 lead 线程注入
+  // 指令回合」实现：run() 把 worker 作业监管在运行中的 lead 回合上，绕过 lead
+  // 直接派发会被立刻结算为 cancelled。指令文本自带目标成员的 #提及，走与用户
+  // 手打提及完全相同的授权路径（activeMentions 按回合重算，见 runtime #send）。
+  async userAction(threadId, action, args = {}) {
+    await this.initialize();
+    if (this.closing) throw new Error('Host is closing');
+    if (!this.prefs.collaboration) throw new Error('多 Agent 协作已在设置中停用（设置 → 协作）。');
+    const rt = this.runtime;
+    const thread = rt.threads.find(t => t.id === threadId);
+    if (!thread || thread.parentThreadId) throw new Error('团队操作仅限主导者线程');
+    const dispatch = text => {
+      // 不等待回合完成（可能长达整个协作周期）；回合级失败由线程自身呈现
+      void rt.send(threadId, text, {}).catch(() => {});
+    };
+    if (action === 'continue') {
+      const interrupted = this.list(threadId).filter(job => job.status === 'interrupted');
+      if (!interrupted.length) throw new Error('没有可恢复的中断委派');
+      if (args.taskId && this.owned(threadId, args.taskId).status !== 'interrupted') throw new Error('仅中断的委派可以恢复');
+      if (rt.execution.isRunning(threadId)) throw new Error('主导者回合进行中，请在回合结束后继续协作');
+      // list() 返回 view 投影：agent 字段名是 agent_type
+      const mentions = [...new Set(interrupted.map(job => job.agent_type))].map(agent => `#${agent}`).join(' ');
+      dispatch(args.taskId
+        ? `[Harness Mix collaboration · 用户操作]\n用户要求恢复中断的委派 ${args.taskId}（${mentions}）。请调用 list_delegations 确认状态后，用 resume_delegation 恢复该任务；不要重放已完成的写入或外部副作用。`
+        : `[Harness Mix collaboration · 用户操作]\n用户要求继续之前中断的协作（涉及 ${mentions}）。请先调用 list_delegations 查看全部中断项，逐项判断能否安全继续：用户明确要求继续的用 resume_delegation 恢复，其余报告 task_id 与不恢复的原因；不要重放已完成的写入或外部副作用。`);
+      // list() 已返回 view 投影，不可再包一层 this.view（字段名会错位）
+      return { dispatched: true, interrupted };
+    }
+    const participant = this.teamFor(threadId, args.teamId);
+    if (participant.kind !== 'lead') throw new Error('团队操作仅限主导者线程');
+    const { team } = participant;
+    if (action === 'task/cancel') {
+      const task = team.tasks.find(entry => entry.id === args.taskId);
+      if (!task) throw new Error('未知的团队任务');
+      const job = [...this.jobs.values()].find(entry => entry.teamId === team.id && entry.teamTaskId === task.id && entry.status === 'running');
+      if (job) await this.cancel(job);
+      else if (task.status === 'in_progress') {
+        // 防御：in_progress 但无运行作业（状态簿记损坏）——直接归位并广播，
+        // 不让任务永久卡在进行中
+        task.status = 'pending'; task.updatedAt = Date.now();
+        const member = team.members.find(entry => entry.id === task.assignee);
+        if (member?.status === 'working') member.status = 'ready';
+        this.refreshTeamStatus(team);
+        await this.publishTeam(team, 'task_cancelled');
+      } else throw new Error('仅进行中的任务可以取消');
+      return this.teamView(team);
+    }
+    if (action === 'task/reassign') {
+      const task = team.tasks.find(entry => entry.id === args.taskId);
+      if (!task) throw new Error('未知的团队任务');
+      if (!['failed', 'interrupted', 'pending'].includes(task.status)) throw new Error('运行中或已完成的任务不能改派；请先取消或等待其结算');
+      const target = this.resolveMember(team, args.memberId);
+      if ([...this.jobs.values()].some(entry => entry.teamId === team.id && entry.memberId === target.id && entry.status === 'running')) throw new Error(`成员 ${target.name} 正在执行其他任务，不能改派`);
+      if (rt.execution.isRunning(threadId)) throw new Error('主导者回合进行中，请在回合结束后改派');
+      if (target.id !== task.assignee) { task.reassignedFrom = task.assignee; task.assignee = target.id; }
+      task.status = task.dependsOn.some(id => team.tasks.find(entry => entry.id === id)?.status !== 'completed') ? 'blocked' : 'pending';
+      task.result = undefined; task.updatedAt = Date.now();
+      this.refreshTeamStatus(team);
+      await this.publishTeam(team, 'task_reassigned');
+      dispatch(`[Harness Mix collaboration · 用户改派]\n用户在团队看板上将任务「${task.title}」改派给成员 ${target.name}（Harness: #${target.agent}）。该任务已重置为待开始。请立即调用 delegate_to_agent 派发它：team_id=${team.id}、member_id=${target.id}、team_task_id=${task.id}、agent_type=${target.agent}，任务描述写明目标${args.note ? `，并纳入用户备注：${args.note}` : ''}。${task.reassignedFrom ? '任务此前已部分执行过，派发时说明不要重复已完成的步骤。' : ''}`);
+      return this.teamView(team);
+    }
+    if (action === 'message/send') {
+      if (typeof args.message !== 'string' || !args.message.trim()) throw new Error('消息内容不能为空');
+      if (args.kind && !['text', 'handoff', 'review-request', 'review-result'].includes(args.kind)) throw new Error('未知的消息类型');
+      const to = args.to ?? '*';
+      if (to !== '*') this.resolveMember(team, to);
+      // 以 lead 身份发出：teamCall 以 team.owner 为 principal 解析为 lead
+      return this.teamCall(team.owner, 'send_team_message', { team_id: team.id, to, message: args.message, ...(args.kind ? { kind: args.kind } : {}) });
+    }
+    throw new Error('未知的用户操作');
+  }
+
   view(job) {
     const pending = job.childId ? this.runtime.core.interactions?.pending(job.childId)?.[0] : null;
     return { task_id: job.id, parent_thread_id: job.owner, child_thread_id: job.childId, agent_type: job.agent, status: job.status,
       team_id: job.teamId, member_id: job.memberId, team_task_id: job.teamTaskId,
       display_status: pending ? 'waiting_approval' : job.status, attention: pending ? { type: pending.type, title: pending.title, message: pending.message } : undefined,
       task: job.task, workspace: job.workspace, applied: !!job.appliedDigest, result: job.result, error: job.error,
-      diff: job.diff, digest: job.digest, branch: job.workspace?.branch };
+      diff: job.diff, digest: job.digest, branch: job.workspace?.branch, verification: job.verification };
   }
 
   async call(principal, name, args) {
@@ -480,7 +615,7 @@ class Collaboration {
         await this.publishTeam(team, 'task_started');
       }
       await this.save();
-      const teamPrompt = team ? `${args.task}\n\n[Harness Mix Agent Team]\nTeam: ${team.name} (${team.id})\nShared goal: ${team.goal}\nYou are ${member.name}. Role: ${member.role}\nAssigned task: ${teamTask.title} (${teamTask.id})\nYou are a persistent teammate, not a one-shot subagent. Read shared state with get_team_state, update your assigned task with update_team_task, and coordinate directly with teammates through send_team_message. Do not create or assign team members.` : args.task;
+      const teamPrompt = team ? this.teamEnvelope(team, member, teamTask, args.task) : args.task;
       job.done = this.run(parent, job, teamPrompt);
       return this.view(job);
     }
@@ -519,7 +654,7 @@ class Collaboration {
     return this.view(job);
   }
 
-  async run(parent, job, task) {
+  async run(parent, job, task) {
     const rt = this.runtime;
     const turnId = job.turnId;
     const title = `Agent 协作 · ${rt.adapters.get(job.agent).manifest.name}`;
@@ -541,7 +676,9 @@ class Collaboration {
       }
       const workerPermMode = defaultWorkerPermissionMode(job.agent);
       if (!spawnSettled) emit({ kind: 'tool', toolCallId: spawnCallId, title, input: task, state: 'running', output: JSON.stringify(this.view(job)) }, 'spawnAgent', spawnCallId);
-      const child = job.childId ? rt.threads.find(t => t.id === job.childId) : await rt.createThread({
+      // resume/follow-up 时既有子会话可能已被删除：回落新建替代会话（同一 Harness、
+      // 同一工作区），而不是永久报错把该作业废弃
+      const child = (job.childId && rt.threads.find(t => t.id === job.childId)) || await rt.createThread({
         harnessId: job.agent, cwd: job.workspace.cwd, title: `${parent.title} › ${task.slice(0, 40)}`, parentThreadId: parent.id,
         options: { ...(workerPermMode ? { permissionMode: workerPermMode } : {}) },
         onCreated: async thread => {
@@ -552,7 +689,6 @@ class Collaboration {
           await this.save();
         }
       });
-      if (!child) throw new Error('Native child history is missing; no replacement session was created');
       job.childId = child.id;
       await this.save();
       if (!spawnSettled) {
@@ -560,28 +696,70 @@ class Collaboration {
         spawnSettled = true;
       }
       emit({ kind: 'tool', toolCallId: workCallId, title, input: task, state: 'running', output: JSON.stringify(this.view(job)) }, 'sendInput', workCallId);
-      if (job.status !== 'running' || this.closing || !rt.execution.isRunning(parent.id)) { job.status = 'cancelled'; return; }
+      // 终态保持：cancel()/close() 已写入的 cancelled/interrupted 不得在此被覆写——
+      // 关机竞态下覆写成 cancelled 会让重启后的 resume_delegation 拒绝恢复该作业
+      if (job.status !== 'running' || this.closing || !rt.execution.isRunning(parent.id)) {
+        if (job.status === 'running') {
+          job.status = this.closing ? 'interrupted' : 'cancelled';
+          await this.settleStoppedJob(job);
+        }
+        return;
+      }
       // Child native file events remain visible; only the lead snapshots the shared workspace.
-      const sending = rt.send(child.id, task, { collaborationOf: parent.id, isolated: job.workspace.mode === 'worktree' });
-      let sendDone = false, sendError;
+      // 成员会话可能被并发占用（邮箱投递泵、用户追问、上一回合结算尾部，或 isRunning
+      // 已清而 sending 锁未释放的结算窗口）：busy 拒绝等空闲后重试（≤10s），而不是把
+      // 「任务正在执行」误判为任务失败（改派/重派紧跟失败结算时尤其容易触发）
+      let sendDone = false, sendError, sendRetrying = false;
+      const dispatchInput = async () => {
+        for (let attempt = 0; ; attempt++) {
+          try {
+            return await rt.send(child.id, task, { collaborationOf: parent.id, isolated: job.workspace.mode === 'worktree' });
+          } catch (error) {
+            if (!/任务正在执行/.test(String(error?.message ?? error)) || attempt >= 100) throw error;
+            sendRetrying = true;
+            await delay(100);
+            sendRetrying = false;
+          }
+        }
+      };
+      const sending = dispatchInput();
       void sending.then(() => { sendDone = true; }, error => { sendDone = true; sendError = error; });
-      const until = Date.now() + 30 * 60 * 1000;
+      const timeoutMs = rt.delegationTimeoutMs ?? 30 * 60 * 1000;
+      const until = Date.now() + timeoutMs;
       let displayedStatus = 'running';
       let turnInactiveSince = null;
       while (job.status === 'running' && !this.closing && !this.cancelling.has(parent.id) && rt.execution.isRunning(parent.id)) {
-        const childRunning = rt.execution.isRunning(child.id) || child.reviewPending;
+        // 已删除的 worker 线程：core 回合可能仍呈 running 态（removeThread 不结算回合），
+        // 不得据此继续等待，否则作业空转到超时
+        const childRunning = rt.threads.some(t => t.id === child.id) && (rt.execution.isRunning(child.id) || child.reviewPending);
         if (!childRunning) {
           if (!turnInactiveSince) turnInactiveSince = Date.now();
-          if (sendDone || Date.now() - turnInactiveSince > 2000) break;
+          // sendRetrying 期间不按「子回合静默」提前结算：投递还在等成员空闲
+          if (sendDone || (!sendRetrying && Date.now() - turnInactiveSince > 2000)) break;
         } else {
           turnInactiveSince = null;
         }
         const current = this.view(job).display_status;
         if (current !== displayedStatus) { displayedStatus = current; emit({ kind: 'tool', toolCallId: workCallId, state: 'running', output: JSON.stringify(this.view(job)) }, 'sendInput', workCallId); }
-        if (Date.now() > until) { await rt.cancel(child.id); throw new Error('Subtask timed out after 30 minutes'); }
+        if (Date.now() > until) {
+          // 先落失败再取消子线程：runtime.cancel 会把 running 作业标记为 cancelled，
+          // 若先取消后抛错，catch 的记录分支（仅认 running）会吞掉超时错误并误报已取消
+          job.status = 'failed';
+          job.error = `Subtask timed out after ${Math.round(timeoutMs / 60000)} minutes`;
+          await rt.cancel(child.id);
+          throw new Error(job.error);
+        }
+        // 顺带泵送排队消息：其他成员可能已空闲（不打断任何人运行中的回合）
+        if (job.teamId) this.drainTeamMailbox(this.teams.get(job.teamId));
         await delay(100);
       }
       if (job.status !== 'running') return;
+      if (!rt.threads.some(t => t.id === child.id)) {
+        // 子线程在执行中被删除：按停止结算，而不是把未完成的 core 回合误判为 completed
+        job.status = 'cancelled';
+        await this.settleStoppedJob(job);
+        return;
+      }
       if (sendError) throw sendError;
       const turn = rt.execution.lastTurn(child.id);
       if (!turn || turn.status === 'error') throw new Error(turn?.error || child.error || 'Subtask failed');
@@ -602,7 +780,7 @@ class Collaboration {
             if (candidate.status === 'blocked' && candidate.dependsOn.every(id => team.tasks.find(entry => entry.id === id)?.status === 'completed')) candidate.status = 'pending';
           }
         }
-        if (team) { this.refreshTeamStatus(team); await this.publishTeam(team, 'task_settled'); }
+        if (team) { this.refreshTeamStatus(team); await this.publishTeam(team, 'task_settled'); this.drainTeamMailbox(team); }
       }
       if (job.workspace?.mode === 'worktree' && job.status === 'completed') {
         try {
@@ -617,9 +795,14 @@ class Collaboration {
         const team = this.teams.get(job.teamId);
         const member = team?.members.find(entry => entry.id === job.memberId);
         const teamTask = team?.tasks.find(entry => entry.id === job.teamTaskId);
-        if (member) member.status = 'ready';
-        if (teamTask) { teamTask.status = 'failed'; teamTask.result = error.message; teamTask.updatedAt = Date.now(); }
-        if (team) { this.refreshTeamStatus(team); await this.publishTeam(team, 'task_failed'); }
+        if (member && member.status !== 'interrupted') member.status = 'ready';
+        let retried = false;
+        if (teamTask && teamTask.status === 'in_progress') {
+          // 失败必达：system 通知先进 lead 邮箱，再决定自动重派或落 failed
+          retried = await this.retryTeamTask(parent, job, team, member, teamTask, error);
+        }
+        if (teamTask && !retried) { teamTask.status = 'failed'; teamTask.result = error.message; teamTask.updatedAt = Date.now(); }
+        if (team && !retried) { this.refreshTeamStatus(team); await this.publishTeam(team, 'task_failed'); this.drainTeamMailbox(team); }
       }
     }
     finally {
@@ -630,6 +813,68 @@ class Collaboration {
     }
   }
 
+  // 团队委派的任务信封：成员身份 + 共享图约定（call() 的首次派发与失败重派共用）
+  teamEnvelope(team, member, teamTask, baseTask) {
+    return `${baseTask}\n\n[Harness Mix Agent Team]\nTeam: ${team.name} (${team.id})\nShared goal: ${team.goal}\nYou are ${member.name}. Role: ${member.role}\nAssigned task: ${teamTask.title} (${teamTask.id})\nYou are a persistent teammate, not a one-shot subagent. Read shared state with get_team_state, update your assigned task with update_team_task, and coordinate directly with teammates through send_team_message. Do not create or assign team members.`;
+  }
+
+  // system 伪参与者通知：不进 roster、不投递，只进邮箱与团队动态，供 lead 免轮询看到失败
+  pushSystemNotice(team, body, taskId) {
+    team.messages.push({ id: randomUUID(), from: 'system', fromName: 'Harness Mix', to: 'lead', kind: 'text', body, ...(taskId ? { taskId } : {}), at: Date.now(), delivery: 'mailbox' });
+    if (team.messages.length > 200) team.messages.splice(0, team.messages.length - 200);
+  }
+
+  // 失败结算的统一入口：先投 system 通知，再按 retry 预算决定自动重派（同一成员，
+  // 复用其会话与工作区，附上次失败原因）或落 failed。返回 true 表示已重新派发。
+  // 重派仍处于同一 lead 回合内（run() 的监管前提），预算只在真正重新派发时消耗。
+  async retryTeamTask(parent, failedJob, team, member, teamTask, error) {
+    if (!team || !teamTask || failedJob.status !== 'failed') return false;
+    const rt = this.runtime;
+    const reason = String(error?.message ?? error ?? 'unknown failure');
+    const budget = teamTask.retry;
+    const canRetry = !!budget && budget.used < budget.max && member
+      && !this.closing && !this.cancelling.has(parent.id) && rt.execution.isRunning(parent.id)
+      && rt.status[member.agent]?.available !== false
+      && [...this.jobs.values()].filter(j => j.owner === parent.id && j.status === 'running').length < MAX_CONCURRENT_SUBTASKS;
+    this.pushSystemNotice(team, `任务「${teamTask.title}」失败：${reason}${canRetry ? `；将自动重试（第 ${budget.used + 1}/${budget.max} 次）` : budget ? '；重试预算已耗尽' : ''}`, teamTask.id);
+    if (!canRetry) return false;
+    budget.used += 1;
+    const retryJob = { id: randomUUID(), owner: parent.id, agent: failedJob.agent, turnId: rt.execution.lastTurn(parent.id)?.id,
+      status: 'running', task: failedJob.task, isolation: failedJob.isolation,
+      ...(failedJob.workspace ? { workspace: failedJob.workspace } : {}),
+      teamId: team.id, memberId: failedJob.memberId, teamTaskId: teamTask.id,
+      ...(failedJob.childId && rt.threads.some(t => t.id === failedJob.childId) ? { childId: failedJob.childId } : {}) };
+    this.jobs.set(retryJob.id, retryJob);
+    teamTask.status = 'in_progress'; teamTask.jobId = retryJob.id; teamTask.updatedAt = Date.now();
+    if (member) member.status = 'working';
+    this.refreshTeamStatus(team);
+    await this.publishTeam(team, 'task_retry');
+    await this.save();
+    retryJob.done = this.run(parent, retryJob, this.teamEnvelope(team, member, teamTask,
+      `Previous attempt failed: ${reason}\nInspect what was already done; do not repeat completed side effects and avoid the failure path.\n\nOriginal task:\n${retryJob.task}`));
+    return true;
+  }
+
+  // 所有「作业在运行中被外力终止」的路径（取消工具、lead 停止级联、用户直接停止/
+  // 删除 worker 线程、宿主关机）共用的收尾：团队图里不得残留 in_progress 的任务——
+  // 否则该成员永远无法被再次委派（delegate_to_agent 会以 already running 拒绝）。
+  async settleStoppedJob(job) {
+    if (job.teamId) {
+      const team = this.teams.get(job.teamId);
+      const member = team?.members.find(entry => entry.id === job.memberId);
+      const teamTask = team?.tasks.find(entry => entry.id === job.teamTaskId);
+      const interrupted = job.status === 'interrupted';
+      const memberStatus = interrupted ? 'interrupted' : 'ready';
+      let changed = false;
+      if (member && member.status !== memberStatus) { member.status = memberStatus; changed = true; }
+      if (teamTask?.status === 'in_progress') { teamTask.status = interrupted ? 'interrupted' : 'pending'; teamTask.updatedAt = Date.now(); changed = true; }
+      if (team && changed) { this.refreshTeamStatus(team); await this.publishTeam(team, interrupted ? 'task_interrupted' : 'task_cancelled'); }
+      // 取消/中断 unwind 后成员空闲：泵送排队消息（lead 已停则按语义降级回邮箱）
+      if (team) this.drainTeamMailbox(team);
+    }
+    await this.save();
+  }
+
   async cancel(job) {
     if (job.status !== 'running') return;
     job.status = this.closing ? 'interrupted' : 'cancelled';
@@ -643,15 +888,7 @@ class Collaboration {
       }
     } finally {
       job.cancelling = false;
-      if (job.teamId) {
-        const team = this.teams.get(job.teamId);
-        const member = team?.members.find(entry => entry.id === job.memberId);
-        const teamTask = team?.tasks.find(entry => entry.id === job.teamTaskId);
-        if (member) member.status = this.closing ? 'interrupted' : 'ready';
-        if (teamTask?.status === 'in_progress') { teamTask.status = this.closing ? 'interrupted' : 'pending'; teamTask.updatedAt = Date.now(); }
-        if (team) { this.refreshTeamStatus(team); await this.publishTeam(team, this.closing ? 'task_interrupted' : 'task_cancelled'); }
-      }
-      await this.save();
+      await this.settleStoppedJob(job);
     }
   }
 
@@ -667,6 +904,18 @@ class Collaboration {
     } finally { this.cancelling.delete(owner); }
   }
   isParticipant(thread, owner) { return thread.id === owner || [...this.jobs.values()].some(j => j.owner === owner && j.childId === thread.id); }
+
+  // 线程删除后不得残留悬空的成员会话引用，否则团队视图会永远显示一个
+  // 已不存在的 working 成员、消息投递也会反复打到死 id 上
+  async forgetThread(threadId) {
+    let changed = false;
+    for (const team of this.teams.values()) {
+      for (const member of team.members) {
+        if (member.childId === threadId) { delete member.childId; changed = true; }
+      }
+    }
+    if (changed) await this.saveTeams();
+  }
   async close() {
     await this.initialize();
     this.closing = true;