@harness-mix/cli 0.1.10 → 0.1.12

package/src/main/adapters/claude.js

@@ -8,7 +8,7 @@ const manifest = {
   name: "Claude Code",
   icon: "claude-color.svg",
   aliases: ['claude', 'claude-code'],
-  // 完整接入（对齐 codex-host）：官方 Agent SDK query() 常驻双向 stream-json 会话，
+  // 完整接入：官方 Agent SDK query() 常驻双向 stream-json 会话，
   // 审批/提问经 canUseTool 桥接回 Host，中断/模型/权限模式走原生控制协议。
   capabilities: { collaborationTools: true, streaming: true, thinking: true, tools: true, approvals: true, questions: true, models: true, thinkingLevels: true, permissionModes: true, resume: true, fork: true, forkFromMessage: true, compaction: true, usage: true, contextUsage: true, attachments: true },
 };

package/src/main/adapters/codex-app-server.js

@@ -16,7 +16,7 @@ class CodexAppServer {
     this.closed = false;
     this.codexHome = codexHome ? require('node:path').resolve(codexHome) : null;
     // The Desktop-bundled CLI and the PATH CLI can be different versions.
-    const executable = process.env.HARNESS_MIX_CODEX_EXECUTABLE || process.env.CODEXHOST_STOCK_CODEX_PATH;
+    const executable = process.env.HARNESS_MIX_CODEX_EXECUTABLE || process.env.HARNESSMIX_STOCK_CODEX_PATH;
     const { command, args } = executable ? { command: executable, args: ['app-server', '--listen', 'stdio://'] } : cliSpawn('codex', ['app-server', '--stdio']);
     const env = { ...process.env, ...(this.codexHome ? { CODEX_HOME: this.codexHome } : {}) };
     this.process = new JsonlProcess(command, args, { env }, {

package/src/main/adapters/dsh.js

@@ -11,7 +11,7 @@ const manifest = {
   name: "DeepSeek Harness",
   icon: "deepseek-color.svg",
   aliases: ["dsh", "deepseek-harness"],
-  // 完整接入（对齐 codex-host）：官方 Web Remote 协议（Typert RPC + remote.mux 流），
+  // 完整接入：官方 Web Remote 协议（Typert RPC + remote.mux 流），
   // 审批/提问走 $events waterfall 原生应答；ACP 自动化面（无 fork/提问/plan）已弃用。
   capabilities: { collaborationTools: true, plan: true, streaming: true, thinking: true, tools: true, approvals: true, questions: true, models: true, thinkingLevels: true, permissionModes: false, resume: true, fork: true, forkFromMessage: true, compaction: true, usage: true, contextUsage: true, attachments: true },
 };

package/src/main/adapters/index.js

@@ -17,7 +17,7 @@ const cursor = require('./cursor');
 const cline = require('./cline');
 
 /**
- * Adapter 注册表（借鉴 codex-host 插件结构：Manifest + 工厂 + Adapter + Session）。
+ * Adapter 注册表：Manifest + 工厂 + Adapter + Session。
  * 新增 Harness 时：实现同形状模块并加入此列表，Renderer 无需改动协议。
  */
 const REGISTRY = [antigravity, pi, omp, dsh, claude, codex, opencode, grok, openclaw, hermes, qoder, codebuddy, zcode, trae, kiro, cursor, cline];

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

@@ -1,8 +1,8 @@
 const valid = n => typeof n === 'number' && Number.isFinite(n) && n >= 0;
 const clean = obj => Object.fromEntries(Object.entries(obj).filter(([, v]) => valid(v)));
 
-// Same native accounting as codex-host/pi-usage: cache tokens are separate
-// from uncached input. Session totals and latest-request cache rate must not mix.
+// Cache tokens are accounted separately from uncached input, matching the native
+// accounting. Session totals and latest-request cache rate must not mix.
 function sessionUsage(data = {}) {
   const t = data.tokens ?? {}, c = data.contextUsage ?? {};
   return { ...clean({ input: t.input, output: t.output, cacheRead: t.cacheRead,

package/src/main/harness-adapter/error-kind.js

@@ -1,4 +1,4 @@
-// 失败回合错误分类（借鉴 codeg 的失败分类 UX）：
+// 失败回合错误分类：
 // 诚实优先——适配器从原生结构化错误显式给出 errorKind / codexErrorInfo 时直接使用；
 // 否则按 HTTP 状态码与消息特征归类；都不中则 'unknown'，绝不虚构原因。
 const ERROR_KINDS = ['network', 'auth', 'quota', 'refused', 'server', 'unknown'];

package/src/main/harness-adapter/manifest.js

@@ -49,7 +49,13 @@ function normalizeCapabilities(caps = {}) {
   return createCapabilities({
     conversation: { streaming: caps.streaming === true, reasoning: caps.thinking === true, plan: caps.plan === true, compaction: caps.compaction === true, attachments: caps.attachments === true },
     interaction: { approval: caps.approvals === true, question: caps.questions === true, permissionMode: caps.permissionModes === true },
-    workspace: { nativeDiff: caps.nativeDiff === true, nativePatch: caps.nativePatch === true },
+    workspace: {
+      git: true,
+      worktree: true,
+      finalDiff: true,
+      nativeDiff: caps.nativeDiff === true,
+      nativePatch: caps.nativePatch === true,
+    },
     session: { resume: caps.resume === true, fork: caps.fork === true, forkFromMessage: caps.fork === true && caps.forkFromMessage === true },
     model: { selection: caps.models === true, thinkingLevel: caps.thinkingLevels === true },
     usage: { tokens: caps.usage === true, context: caps.contextUsage === true, cost: caps.cost === true },

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

@@ -1,9 +1,16 @@
 const object = (properties, required = []) => ({ type: 'object', properties, required, additionalProperties: false });
 const taskId = { type: 'string', minLength: 1 };
 const task = { type: 'string', minLength: 1, maxLength: 16000 };
+const teamId = { type: 'string', minLength: 1 };
+const memberId = { type: 'string', minLength: 1 };
 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. 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. 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'] } }, ['agent_type', 'task']) },
+  { 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. 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: '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']) },
   { name: 'update_agent_plan', description: 'Publish or update the lead collaboration plan shown in the conversation. Include development, review, fixes and final verification as appropriate. Mark steps completed only after collecting and verifying real results.', inputSchema: object({ steps: { type: 'array', minItems: 1, maxItems: 16, items: object({ text: task, status: { type: 'string', enum: ['pending', 'in_progress', 'completed'] } }, ['text', 'status']) } }, ['steps']) },
   { name: 'list_delegations', description: 'List this lead session\'s durable child tasks, including interrupted tasks from earlier Host runs.', inputSchema: object({}) },
   { name: 'resume_delegation', description: 'Continue an interrupted child in its recorded native session and workspace. Inspect existing progress; do not replay completed side effects.', inputSchema: object({ task_id: taskId }, ['task_id']) },

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

@@ -13,6 +13,32 @@ async function git(cwd, args, env = {}) {
   })).stdout;
 }
 
+async function inspectWorkspace(cwd, workspace = null) {
+  const result = {
+    hostManaged: true,
+    git: { available: false },
+    worktree: { available: false, active: workspace?.mode === 'worktree' },
+    finalDiff: { available: true, source: 'snapshot' },
+  };
+  try {
+    const root = (await git(cwd, ['rev-parse', '--show-toplevel'])).trim();
+    const head = (await git(cwd, ['rev-parse', '--verify', 'HEAD'])).trim();
+    let branch = null;
+    try { branch = (await git(cwd, ['symbolic-ref', '--quiet', '--short', 'HEAD'])).trim() || null; } catch {}
+    const dirty = Boolean((await git(cwd, ['status', '--porcelain', '--untracked-files=normal'])).trim());
+    result.git = { available: true, root, head, branch, dirty };
+    result.worktree = {
+      available: true,
+      active: workspace?.mode === 'worktree',
+      ...(workspace?.branch ? { branch: workspace.branch } : {}),
+      ...(workspace?.root ? { root: workspace.root } : {}),
+    };
+  } catch (error) {
+    result.git.reason = /not a git repository/i.test(error.stderr || '') ? 'not-a-git-repository' : 'git-unavailable';
+  }
+  return result;
+}
+
 // A private index snapshots tracked and non-ignored files without staging the user's index.
 async function tree(cwd) {
   const index = path.join(os.tmpdir(), `harness-mix-index-${randomUUID()}`);
@@ -148,4 +174,4 @@ async function pushWorkspace(workspace, remote = 'origin', remoteBranch = worksp
   return { remote, branch: remoteBranch, commit: newCommit, pushed: true };
 }
 
-module.exports = { createWorkspace, reviewWorkspace, applyWorkspace, removeWorkspace, discardWorkspace, pushWorkspace, git, tree };
+module.exports = { createWorkspace, inspectWorkspace, reviewWorkspace, applyWorkspace, removeWorkspace, discardWorkspace, pushWorkspace, git, tree };

package/src/main/host/collaboration.js

@@ -7,6 +7,50 @@ const { Store } = require('./store');
 const { createWorkspace, reviewWorkspace, applyWorkspace, discardWorkspace, pushWorkspace } = require('./collaboration-worktree');
 const validators = new Map(tools.map(tool => [tool.name, z.fromJSONSchema(tool.inputSchema)]));
 const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+const MAX_CONCURRENT_SUBTASKS = 6;
+const MAX_SUBTASKS_PER_TURN = 16;
+
+// Dependency depth of each task: the longest chain of prerequisites, used to
+// lay the team board out in lanes.
+// Missing dependency ids are ignored (the runtime already rejects unknown ids at
+// assign time); the cycle back-edge returns 0 so corrupted graphs terminate.
+function teamTaskDepths(tasks) {
+  const byId = new Map(tasks.map(task => [task.id, task]));
+  const depths = new Map();
+  const visiting = new Set();
+  const depthOf = id => {
+    if (depths.has(id)) return depths.get(id);
+    if (visiting.has(id)) return 0;
+    const task = byId.get(id);
+    if (!task) return 0;
+    visiting.add(id);
+    const deps = (task.dependsOn || []).filter(dep => byId.has(dep));
+    const depth = deps.length ? 1 + Math.max(...deps.map(depthOf)) : 0;
+    visiting.delete(id);
+    depths.set(id, depth);
+    return depth;
+  };
+  for (const task of tasks) depthOf(task.id);
+  return depths;
+}
+
+// Coarse team phase: forming (no tasks yet),
+// running (at least one task in flight), waiting (unfinished work but nothing
+// running — the lead still has to delegate or unblock it), completed.
+function teamPhase(team) {
+  if (!team.tasks.length) return 'forming';
+  if (team.tasks.every(task => task.status === 'completed')) return 'completed';
+  return team.tasks.some(task => task.status === 'in_progress') ? 'running' : 'waiting';
+}
+
+// Per-status task counters plus completion percent, so a reader can reconstruct
+// the workbench progress bar without walking the task list itself.
+function teamProgress(tasks) {
+  const progress = { total: tasks.length, pending: 0, blocked: 0, in_progress: 0, completed: 0, failed: 0, interrupted: 0 };
+  for (const task of tasks) if (progress[task.status] !== undefined) progress[task.status] += 1;
+  progress.percent = progress.total ? Math.round((progress.completed / progress.total) * 100) : 0;
+  return progress;
+}
 
 function defaultWorkerPermissionMode(agent) {
   switch (agent) {
@@ -33,15 +77,32 @@ class Collaboration {
     this.cancelling = new Set();
     this.closing = false;
     this.store = new Store(path.join(runtime.store.directory, 'collaboration'));
+    this.teamStore = new Store(path.join(runtime.store.directory, 'collaboration'), 'teams.json');
+    this.teams = new Map();
   }
 
   async initialize() {
-    if (!this.loading) this.loading = this.store.load().then(async rows => {
+    if (!this.loading) this.loading = Promise.all([this.store.load(), this.teamStore.load()]).then(async ([rows, teams]) => {
       for (const row of rows) {
         if (!row.id || !row.owner || !row.agent) throw new Error('Invalid collaboration history');
         this.jobs.set(row.id, { ...row, ...(row.status === 'running' ? { status: 'interrupted', error: 'Host restarted; resume this native session explicitly.' } : {}) });
       }
+      for (const team of teams) {
+        if (!team.id || !team.owner || !Array.isArray(team.members) || !Array.isArray(team.tasks) || !Array.isArray(team.messages)) throw new Error('Invalid Agent Team history');
+        if (!Array.isArray(team.history)) team.history = [];
+        this.teams.set(team.id, team);
+      }
+      for (const job of this.jobs.values()) {
+        if (job.status !== 'interrupted' || !job.teamId) continue;
+        const team = this.teams.get(job.teamId);
+        const member = team?.members.find(entry => entry.id === job.memberId);
+        const task = team?.tasks.find(entry => entry.id === job.teamTaskId);
+        if (member) member.status = 'interrupted';
+        if (task?.status === 'in_progress') task.status = 'interrupted';
+        if (team) this.refreshTeamStatus(team);
+      }
       await this.save();
+      await this.saveTeams();
     });
     return this.loading;
   }
@@ -50,8 +111,92 @@ class Collaboration {
     return this.store.save([...this.jobs.values()].map(({ done, cancelling, followupPending, applying, ...job }) => job));
   }
 
+  saveTeams() { return this.teamStore.save([...this.teams.values()]); }
+
+  recordTeamSnapshot(team, action) {
+    if (!Array.isArray(team.history)) team.history = [];
+    team.history.push({ id: randomUUID(), action, at: Date.now(), team: this.teamView(team) });
+    if (team.history.length > 200) team.history.splice(0, team.history.length - 200);
+  }
+
+  async publishTeam(team, action) {
+    this.recordTeamSnapshot(team, action);
+    await this.saveTeams();
+    this.emitTeam(team, action);
+  }
+
+  async inspectTeam(threadId, teamId) {
+    await this.initialize();
+    const participant = this.participant(threadId, teamId);
+    if (!participant) {
+      // An explicit teamId is an ownership check: outsiders are denied. Without
+      // one the caller only asks "does this thread belong to a team?" — the
+      // renderer polls exactly that for every active thread, so answer benignly
+      // instead of failing an internal error on every poll.
+      if (teamId) throw new Error('Unknown team or caller is not a team participant');
+      return { team: null, snapshots: [] };
+    }
+    return {
+      team: this.teamView(participant.team),
+      snapshots: (participant.team.history || []).map(snapshot => ({ ...snapshot, team: { ...snapshot.team } })),
+    };
+  }
+
+  refreshTeamStatus(team) {
+    team.status = team.tasks.length && team.tasks.every(task => task.status === 'completed') ? 'completed' : 'active';
+    team.updatedAt = Date.now();
+  }
+
   list(owner) { return [...this.jobs.values()].filter(j => !owner || j.owner === owner).map(j => this.view(j)); }
 
+  participant(threadId, teamId) {
+    for (const team of this.teams.values()) {
+      if (teamId && team.id !== teamId) continue;
+      if (team.owner === threadId) return { team, kind: 'lead', id: 'lead', name: 'Lead' };
+      const member = team.members.find(entry => entry.childId === threadId);
+      if (member) return { team, kind: 'member', id: member.id, name: member.name, member };
+    }
+    return null;
+  }
+
+  isTeamParticipantThread(threadId) { return !!this.participant(threadId); }
+
+  teamFor(principal, teamId) {
+    const participant = this.participant(principal, teamId);
+    if (!participant) throw new Error('Unknown team or caller is not a team participant');
+    return participant;
+  }
+
+  resolveMember(team, value) {
+    const normalized = String(value).toLowerCase();
+    const matches = team.members.filter(member => member.id === value || member.name.toLowerCase() === normalized);
+    if (matches.length !== 1) throw new Error(matches.length ? 'Team member name is ambiguous; use member_id' : 'Unknown team member');
+    return matches[0];
+  }
+
+  teamView(team) {
+    const leadThread = this.runtime.threads.find(thread => thread.id === team.owner);
+    const leadAgent = leadThread?.harnessId ?? 'codex';
+    const leadName = this.runtime.adapters.get(leadAgent)?.manifest?.name ?? leadAgent;
+    const depths = teamTaskDepths(team.tasks);
+    return {
+      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 })),
+      tasks: team.tasks.map(task => ({ ...task, depth: depths.get(task.id) ?? 0 })), messages: team.messages.slice(-40).map(message => ({ ...message })),
+      updated_at: team.updatedAt,
+    };
+  }
+
+  emitTeam(team, action) {
+    if (!this.runtime.execution.isRunning(team.owner)) return;
+    this.runtime.emitCollaboration(team.owner, {
+      kind: 'tool', toolCallId: `agent-team:${team.id}`, title: `Agent Team · ${team.name}`,
+      state: 'running', input: team.goal, output: JSON.stringify({ action, ...this.teamView(team) }),
+    });
+  }
+
   async review(id) {
     const job = this.jobs.get(id);
     if (!job || job.status === 'running') throw new Error('子任务尚未完成');
@@ -126,24 +271,108 @@ class Collaboration {
     return job;
   }
 
+  async teamCall(principal, name, args) {
+    const rt = this.runtime;
+    if (name === 'create_agent_team') {
+      const lead = rt.threads.find(thread => thread.id === principal);
+      if (!lead || lead.parentThreadId) throw new Error('Only a lead task can create an Agent Team');
+      const names = new Set();
+      const members = args.members.map(entry => {
+        const agent = rt.resolveHarnessId(entry.agent_type);
+        if (!agent || !rt.status[agent]?.available) throw new Error(`Target Harness unavailable: ${entry.agent_type}`);
+        if (!rt.adapters.get(agent)?.manifest?.capabilities?.collaborationTools) throw new Error(`Harness cannot participate in Agent Team messaging: ${agent}`);
+        if (!lead.activeMentions?.includes(agent)) throw new Error(`Agent Team member ${entry.name} uses unselected Harness "${agent}"`);
+        const key = entry.name.trim().toLowerCase();
+        if (names.has(key)) throw new Error('Agent Team member names must be unique');
+        names.add(key);
+        return { id: randomUUID(), name: entry.name.trim(), role: entry.role.trim(), agent, status: 'ready' };
+      });
+      const team = { id: randomUUID(), owner: principal, name: args.name.trim(), goal: args.goal, status: 'active', members, tasks: [], messages: [], history: [], createdAt: Date.now(), updatedAt: Date.now() };
+      this.teams.set(team.id, team);
+      await this.publishTeam(team, 'team_created');
+      return this.teamView(team);
+    }
+
+    const participant = this.teamFor(principal, args.team_id);
+    const { team } = participant;
+    if (name === 'get_team_state') return this.teamView(team);
+    if (name === 'assign_team_task') {
+      if (participant.kind !== 'lead') throw new Error('Only the Team Lead can assign team tasks');
+      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() };
+      team.tasks.push(taskEntry);
+      this.refreshTeamStatus(team);
+      await this.publishTeam(team, 'task_assigned');
+      return { task: taskEntry, team: this.teamView(team) };
+    }
+    if (name === 'update_team_task') {
+      const taskEntry = team.tasks.find(task => task.id === args.task_id);
+      if (!taskEntry) throw new Error('Unknown team task');
+      if (participant.kind === 'member' && taskEntry.assignee !== participant.id) throw new Error('A teammate can update only its assigned tasks');
+      if (participant.kind === 'member' && !['in_progress', 'completed', 'failed'].includes(args.status)) throw new Error('A teammate can only start, complete, or fail its assigned task');
+      if (participant.kind === 'member' && taskEntry.status === 'completed') throw new Error('A completed task can only be reopened by the Team Lead');
+      if (['in_progress', 'completed'].includes(args.status) && taskEntry.dependsOn.some(id => team.tasks.find(task => task.id === id)?.status !== 'completed')) throw new Error('Task dependencies are not complete');
+      taskEntry.status = args.status;
+      taskEntry.updatedAt = Date.now();
+      if (args.result !== undefined) taskEntry.result = args.result;
+      for (const candidate of team.tasks) {
+        if (candidate.status === 'blocked' && candidate.dependsOn.every(id => team.tasks.find(task => task.id === id)?.status === 'completed')) candidate.status = 'pending';
+      }
+      this.refreshTeamStatus(team);
+      await this.publishTeam(team, 'task_updated');
+      return { task: { ...taskEntry }, team: this.teamView(team) };
+    }
+    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' };
+      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();
+        });
+      }
+      team.updatedAt = Date.now();
+      await this.publishTeam(team, 'message_sent');
+      return { message, team: this.teamView(team) };
+    }
+    throw new Error('Unknown Agent Team operation');
+  }
+
   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 };
   }
 
-  async call(owner, name, args) {
+  async call(principal, name, args) {
     await this.initialize();
     if (this.closing) throw new Error('Host is closing');
     if (!validators.has(name)) throw new Error('Unknown collaboration tool');
     args = validators.get(name).parse(args);
     const rt = this.runtime;
+    const teamTools = new Set(['create_agent_team', 'assign_team_task', 'get_team_state', 'update_team_task', 'send_team_message']);
+    const participant = this.participant(principal, args.team_id);
+    const owner = participant?.team.owner ?? principal;
     const parent = rt.threads.find(t => t.id === owner);
-    if (!parent || parent.parentThreadId) throw new Error('Only lead tasks can delegate');
-    if (!rt.execution.isRunning(owner) || this.cancelling.has(owner)) throw new Error('Lead turn is no longer active');
-    if (name === 'list_agents') return [...rt.adapters.values()].map(a => ({ agent_type: a.manifest.id, name: a.manifest.name, available: !!rt.status[a.manifest.id]?.available }));
+    if (teamTools.has(name)) {
+      if (!rt.execution.isRunning(principal) || (principal === owner && this.cancelling.has(owner))) throw new Error('Collaboration turn is no longer active');
+      return this.teamCall(principal, name, args);
+    }
+    if (!parent || principal !== owner || parent.parentThreadId) throw new Error('Only lead tasks can delegate');
+    if (!rt.execution.isRunning(principal) || this.cancelling.has(owner)) throw new Error('Collaboration turn is no longer active');
+    if (name === 'list_agents') return [...rt.adapters.values()].map(a => ({ agent_type: a.manifest.id, name: a.manifest.name, available: !!rt.status[a.manifest.id]?.available, team_capable: !!a.manifest.capabilities?.collaborationTools }));
     if (name === 'list_delegations') return this.list(owner);
     if (name === 'update_agent_plan') {
       rt.emitCollaboration(owner, { kind: 'plan', entries: args.steps });
@@ -154,18 +383,43 @@ class Collaboration {
       if (!agent || !rt.status[agent]?.available) throw new Error('Target Harness unavailable');
       // Server-side enforcement: multi-agent collaboration can ONLY start when the user explicitly selected/mentioned agents.
       if (!parent.activeMentions || !parent.activeMentions.length) {
-        throw new Error('跨 Harness 协作仅在用户显式使用 #agent 或 @agent（如 #pi、#claude）指定时允许启动。用户本轮未显式委派，不能由大模型自行决定启动跨 Harness 协作。请直接使用当前 Harness 的原生工具完成任务。');
+        throw new Error('跨 Harness 协作仅在用户显式选择 Agent，或在团队/委派语境中明确写出 Harness 名称时允许启动（例如 #pi #claude，或“用 Pi 开发、Claude 审查组成团队”）。用户本轮未显式委派，不能由大模型自行决定启动跨 Harness 协作。');
       }
       if (!parent.activeMentions.includes(agent)) {
         throw new Error(`用户仅显式指定了 [${parent.activeMentions.join(', ')}]，不能委派给未指定的 "${agent}"。请向用户确认是否需要委派给其他 Harness。`);
       }
+      let team, member, teamTask, previousMemberJob;
+      const teamFields = [args.team_id, args.member_id, args.team_task_id].filter(Boolean).length;
+      if (teamFields && teamFields !== 3) throw new Error('Agent Team delegation requires team_id, member_id and team_task_id together');
+      if (teamFields) {
+        ({ team } = this.teamFor(owner, args.team_id));
+        member = this.resolveMember(team, args.member_id);
+        teamTask = team.tasks.find(entry => entry.id === args.team_task_id);
+        if (!teamTask || teamTask.assignee !== member.id) throw new Error('Team task is not assigned to this member');
+        if (member.agent !== agent) throw new Error('Delegated Harness does not match the team member');
+        if (member.childId && !rt.threads.some(thread => thread.id === member.childId)) delete member.childId;
+        previousMemberJob = member.childId ? [...this.jobs.values()].reverse().find(job => job.teamId === team.id && job.memberId === member.id && job.childId === member.childId) : null;
+        if (teamTask.dependsOn.some(id => team.tasks.find(entry => entry.id === id)?.status !== 'completed')) throw new Error('Team task dependencies are not complete');
+        if (teamTask.status === 'completed') throw new Error('Team task is already completed');
+        if (teamTask.status === 'in_progress') throw new Error('Team task is already running');
+        if ([...this.jobs.values()].some(job => job.teamId === team.id && job.memberId === member.id && job.status === 'running')) throw new Error('Team member is already working on another task');
+      }
       const jobs = [...this.jobs.values()].filter(j => j.owner === owner);
-      if (jobs.filter(j => j.status === 'running').length >= 4) throw new Error('At most four concurrent subtasks; collect existing results first');
-      if (jobs.filter(j => j.turnId === rt.execution.lastTurn(owner)?.id).length >= 16) throw new Error('At most sixteen subtasks per lead turn');
-      const job = { id: randomUUID(), owner, agent, turnId: rt.execution.lastTurn(owner).id, status: 'running', task: args.task, isolation: args.isolation || 'shared' };
+      if (jobs.filter(j => j.status === 'running').length >= MAX_CONCURRENT_SUBTASKS) throw new Error('At most six concurrent subtasks; collect existing results first');
+      if (jobs.filter(j => j.turnId === rt.execution.lastTurn(owner)?.id).length >= MAX_SUBTASKS_PER_TURN) throw new Error('At most sixteen subtasks per lead turn');
+      const job = { id: randomUUID(), owner, agent, turnId: rt.execution.lastTurn(owner).id, status: 'running', task: args.task,
+        isolation: previousMemberJob?.isolation ?? args.isolation ?? 'shared',
+        ...(previousMemberJob?.workspace ? { workspace: previousMemberJob.workspace } : {}),
+        ...(team ? { teamId: team.id, memberId: member.id, teamTaskId: teamTask.id, ...(member.childId ? { childId: member.childId } : {}) } : {}) };
       this.jobs.set(job.id, job);
+      if (team) {
+        teamTask.status = 'in_progress'; teamTask.jobId = job.id; teamTask.updatedAt = Date.now();
+        member.status = 'working'; this.refreshTeamStatus(team);
+        await this.publishTeam(team, 'task_started');
+      }
       await this.save();
-      job.done = this.run(parent, job, args.task);
+      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;
+      job.done = this.run(parent, job, teamPrompt);
       return this.view(job);
     }
     if (name === 'get_delegation_status') {
@@ -185,11 +439,19 @@ class Collaboration {
     job.followupPending = true;
     try { await job.done; } finally { job.followupPending = false; }
     if (this.closing || !rt.execution.isRunning(owner) || this.cancelling.has(owner)) throw new Error('Lead turn is no longer active');
-    if ([...this.jobs.values()].filter(j => j.owner === owner && j.status === 'running').length >= 4) throw new Error('At most four concurrent subtasks');
+    if ([...this.jobs.values()].filter(j => j.owner === owner && j.status === 'running').length >= MAX_CONCURRENT_SUBTASKS) throw new Error('At most six concurrent subtasks');
     job.status = 'running'; job.result = undefined; job.error = undefined;
     job.turnId = rt.execution.lastTurn(owner).id;
     const task = name === 'resume_delegation' ? `Continue the interrupted task in this existing workspace. Inspect existing progress before acting; do not repeat completed side effects. Original task:\n${job.task}` : args.task;
     if (name !== 'resume_delegation') job.task = task;
+    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 = 'working';
+      if (teamTask) { teamTask.status = 'in_progress'; teamTask.updatedAt = Date.now(); }
+      if (team) { this.refreshTeamStatus(team); await this.publishTeam(team, name === 'resume_delegation' ? 'task_resumed' : 'task_followup'); }
+    }
     await this.save();
     job.done = this.run(parent, job, task);
     return this.view(job);
@@ -213,7 +475,13 @@ class Collaboration {
       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 => { job.childId = thread.id; await this.save(); }
+        onCreated: async thread => {
+          job.childId = thread.id;
+          const team = job.teamId ? this.teams.get(job.teamId) : null;
+          const member = team?.members.find(entry => entry.id === job.memberId);
+          if (member) { member.childId = thread.id; member.status = 'working'; team.updatedAt = Date.now(); await this.publishTeam(team, 'member_session_ready'); }
+          await this.save();
+        }
       });
       if (!child) throw new Error('Native child history is missing; no replacement session was created');
       job.childId = child.id;
@@ -248,6 +516,21 @@ class Collaboration {
       const messages = rt.core.getItemsForTurn(turn.id).filter(i => i.type === 'agent_message');
       const finals = messages.filter(i => i.phase === 'final');
       job.result = (finals.length ? finals : messages).map(i => i.content || '').join('\n').slice(0, 48000);
+      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 = 'ready';
+        if (teamTask && teamTask.status === 'in_progress') {
+          teamTask.status = job.status === 'completed' ? 'completed' : job.status === 'cancelled' ? 'pending' : 'failed';
+          teamTask.result = job.result;
+          teamTask.updatedAt = Date.now();
+          for (const candidate of team.tasks) {
+            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 (job.workspace?.mode === 'worktree' && job.status === 'completed') {
         try {
           const rev = await reviewWorkspace(job.workspace);
@@ -255,7 +538,17 @@ class Collaboration {
           job.digest = rev.digest;
         } catch {}
       }
-    } catch (error) { if (job.status === 'running') { job.status = 'failed'; job.error = error.message; } }
+    } catch (error) {
+      if (job.status === 'running') { job.status = 'failed'; job.error = error.message; }
+      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 = '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'); }
+      }
+    }
     finally { await this.save(); emit({ kind: 'tool', toolCallId, state: job.status === 'completed' ? 'done' : 'error', output: JSON.stringify(this.view(job)) }); }
   }
 
@@ -270,7 +563,18 @@ class Collaboration {
           new Promise(r => setTimeout(r, 3_000)),
         ]).catch(() => {});
       }
-    } finally { job.cancelling = false; await this.save(); }
+    } 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();
+    }
   }
 
   async cancelOwner(owner) {
@@ -292,6 +596,7 @@ class Collaboration {
     await Promise.all([...this.jobs.values()].map(j => j.done));
     this.keys.clear();
     await this.save();
+    await this.saveTeams();
     if (this.server) await new Promise(resolve => this.server.close(resolve));
   }
 }
@@ -306,7 +611,35 @@ function mentionedAgents(text, runtime) {
     const id = runtime.resolveHarnessId(match[1] || match[2]);
     if (id) ids.add(id);
   }
+  // Natural-language team requests may name Harnesses without using the picker.
+  // Require an explicit collaboration intent so ordinary product discussion such
+  // as "Codex UI" does not silently authorize cross-Harness delegation.
+  const teamIntent = /agent\s*team|团队|组队|协作|委派|调度|分工|成员|队长|主导者|\b(?:team|delegate|delegation|assign|member|teammate)\b/i.test(prose);
+  if (teamIntent) {
+    for (const adapter of runtime.adapters.values()) {
+      const labels = [adapter.manifest.id, adapter.manifest.name, ...(adapter.manifest.aliases ?? [])]
+        .filter(label => String(label ?? '').trim().length >= 2)
+        .sort((a, b) => String(b).length - String(a).length);
+      if (labels.some(label => containsPlainAgentName(prose, label))) ids.add(adapter.manifest.id);
+    }
+  }
   return [...ids];
 }
 
-module.exports = { Collaboration, mentionedAgents, defaultWorkerPermissionMode };
+function containsPlainAgentName(text, label) {
+  const haystack = String(text).toLowerCase();
+  const needle = String(label).trim().toLowerCase();
+  for (let offset = haystack.indexOf(needle); offset !== -1; offset = haystack.indexOf(needle, offset + 1)) {
+    const before = offset === 0 ? '' : haystack[offset - 1];
+    const afterIndex = offset + needle.length;
+    const after = afterIndex === haystack.length ? '' : haystack[afterIndex];
+    if (plainNameBoundary(before) && plainNameBoundary(after)) return true;
+  }
+  return false;
+}
+
+function plainNameBoundary(char) {
+  return !char || /[\s\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff,;:!?()[\]{}"'，。；：、！？“”‘’]/u.test(char);
+}
+
+module.exports = { Collaboration, mentionedAgents, defaultWorkerPermissionMode, teamTaskDepths, teamPhase, teamProgress };