@hueyexe/opencode-ensemble 0.16.0 → 0.17.0

package/dist/index.js

@@ -17608,7 +17608,12 @@ var MIGRATIONS = [
    CREATE INDEX IF NOT EXISTS team_message_to_idx ON team_message(to_name);
    CREATE INDEX IF NOT EXISTS team_message_undelivered_idx ON team_message(team_id, delivered) WHERE delivered = 0;
    CREATE INDEX IF NOT EXISTS team_message_unread_idx ON team_message(team_id, read) WHERE read = 0;
-   PRAGMA foreign_keys=ON;`
+   PRAGMA foreign_keys=ON;`,
+  `ALTER TABLE team_member ADD COLUMN last_nudged_at INTEGER;`,
+  `ALTER TABLE team_member ADD COLUMN retry_until INTEGER;
+   ALTER TABLE team_member ADD COLUMN retry_attempt INTEGER;
+   ALTER TABLE team_member ADD COLUMN retry_provider TEXT;
+   ALTER TABLE team_member ADD COLUMN retry_message TEXT;`
 ];
 function applyMigrations(db) {
   const { user_version: current } = db.query("PRAGMA user_version").get();
@@ -17807,10 +17812,59 @@ function hasReportedCompletion(db, teamId, memberName) {
   return row?.reported_to_lead === 1;
 }
 
+// src/tasks.ts
+function releaseMemberTasks(db, teamId, memberName) {
+  const result = db.run("UPDATE team_task SET status = 'pending', assignee = NULL, time_updated = ? WHERE team_id = ? AND assignee = ? AND status = 'in_progress'", [Date.now(), teamId, memberName]);
+  return result.changes;
+}
+
+// src/member-model.ts
+function parseModelId(model) {
+  const slash = model.indexOf("/");
+  if (slash <= 0 || slash === model.length - 1)
+    return;
+  return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
+}
+function getMemberModel(db, teamId, memberName) {
+  const row = db.query("SELECT model FROM team_member WHERE team_id = ? AND name = ?").get(teamId, memberName);
+  if (!row?.model)
+    return;
+  return parseModelId(row.model);
+}
+
 // src/recovery.ts
 init_merge_helper();
 init_process();
-async function recoverStaleMembers(db, client3, cwd) {
+async function isSessionAlive(client3, sessionId, timeoutMs = 5000) {
+  try {
+    await Promise.race([
+      client3.session.get({ sessionID: sessionId }),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("isSessionAlive timed out")), timeoutMs))
+    ]);
+    return true;
+  } catch (err) {
+    if (err instanceof Error && err.message === "isSessionAlive timed out") {
+      log(`recovery:team:liveness-check-timeout session=${sessionId}`);
+      return true;
+    }
+    return false;
+  }
+}
+async function recoverOrphanedTeams(db, client3, cwd, registry2) {
+  const active = db.query(`SELECT id, lead_session_id FROM team
+     WHERE status = 'active' AND (? IS NULL OR project_id = ? OR project_id = 'default')`).all(cwd ?? null, cwd ?? null);
+  let archived = 0;
+  for (const team of active) {
+    if (await isSessionAlive(client3, team.lead_session_id))
+      continue;
+    db.run("UPDATE team SET status = 'archived', time_updated = ? WHERE id = ?", [Date.now(), team.id]);
+    registry2?.unregisterTeam(team.id);
+    archived++;
+    log(`recovery:team:orphaned team_id=${team.id} lead_session=${team.lead_session_id}`);
+  }
+  return { archived };
+}
+async function recoverStaleMembers(db, client3, cwd, abortTimeoutMs = 5000) {
   const stale = db.query(`SELECT tm.session_id, tm.worktree_branch, tm.name, tm.team_id, t.name as team_name, p.name as project_name
       FROM team_member tm
       JOIN team t ON tm.team_id = t.id
@@ -17820,6 +17874,11 @@ async function recoverStaleMembers(db, client3, cwd) {
   const result = db.run(`UPDATE team_member SET status = 'error', execution_status = 'idle', time_updated = ?
       WHERE status = 'busy'
         AND team_id IN (SELECT id FROM team WHERE status = 'active' AND (? IS NULL OR project_id = ? OR project_id = 'default'))`, [Date.now(), cwd ?? null, cwd ?? null]);
+  for (const member of stale) {
+    const released = releaseMemberTasks(db, member.team_id, member.name);
+    if (released > 0)
+      log(`recovery:tasks:released name=${member.name} count=${released}`);
+  }
   if (client3) {
     for (const member of stale) {
       if (cwd && member.worktree_branch && !member.worktree_branch.startsWith("ensemble/preserved/")) {
@@ -17831,8 +17890,15 @@ async function recoverStaleMembers(db, client3, cwd) {
         }
       }
       try {
-        await client3.session.abort({ sessionID: member.session_id });
-      } catch {}
+        await Promise.race([
+          client3.session.abort({ sessionID: member.session_id }),
+          new Promise((_, reject) => setTimeout(() => reject(new Error("session.abort timed out")), abortTimeoutMs))
+        ]);
+      } catch (err) {
+        if (err instanceof Error && err.message === "session.abort timed out") {
+          log(`recovery:stale-members:abort-timeout session=${member.session_id}`);
+        }
+      }
     }
   }
   return { interrupted: result.changes };
@@ -17881,9 +17947,11 @@ async function recoverUndeliveredMessages(db, client3, registry2) {
         continue;
       }
       try {
+        const recipientModel = getMemberModel(db, team.id, msg.to_name);
         await client3.session.promptAsync({
           sessionID: recipientSessionId,
-          parts: [{ type: "text", text: `[Recovered team message from ${msg.from_name}]: ${msg.content}` }]
+          parts: [{ type: "text", text: `[Recovered team message from ${msg.from_name}]: ${msg.content}` }],
+          ...recipientModel ? { model: recipientModel } : {}
         });
         markDelivered(db, msg.id);
         redelivered++;
@@ -18096,6 +18164,77 @@ class PendingPurgeApprovals {
   }
 }
 
+// src/notify.ts
+var TOAST_CONFIG = {
+  spawn: { variant: "success", duration: 3000 },
+  message: { variant: "info", duration: 3000 },
+  completed: { variant: "info", duration: 4000 },
+  error: { variant: "error", duration: 5000 },
+  shutdown: { variant: "info", duration: 3000 }
+};
+function formatMessage(type, data) {
+  switch (type) {
+    case "spawn":
+      return `Teammate ${data.memberName} spawned (${data.agent})`;
+    case "message":
+      return `Message from ${data.from}`;
+    case "completed":
+      return `${data.memberName} finished work`;
+    case "error":
+      return `${data.memberName} encountered an error`;
+    case "shutdown":
+      return `${data.memberName} shut down`;
+  }
+}
+async function notifyTeamEvent(client3, type, data) {
+  const config2 = TOAST_CONFIG[type];
+  try {
+    await client3.tui.showToast({
+      title: "Team",
+      message: formatMessage(type, data),
+      variant: config2.variant,
+      duration: config2.duration
+    });
+  } catch {}
+}
+async function notifyWorkingProgress(client3, db, teamId) {
+  const members = db.query("SELECT name, status FROM team_member WHERE team_id = ? ORDER BY time_created ASC").all(teamId);
+  if (members.length === 0)
+    return;
+  const busy = members.filter((m) => m.status === "busy");
+  try {
+    if (busy.length === 0) {
+      await client3.tui.showToast({
+        title: "Team",
+        message: "All teammates finished",
+        variant: "success",
+        duration: 4000
+      });
+    } else {
+      const names = busy.map((m) => m.name).join(", ");
+      await client3.tui.showToast({
+        title: "Team",
+        message: `Working: ${names} (${busy.length}/${members.length})`,
+        variant: "info",
+        duration: 5000
+      });
+    }
+  } catch {}
+}
+function notifyLead(client3, db, teamId, content) {
+  const id = sendMessage(db, { teamId, from: "system", to: "lead", content });
+  const team = db.query("SELECT lead_session_id FROM team WHERE id = ?").get(teamId);
+  if (!team?.lead_session_id)
+    return id;
+  client3.session.promptAsync({
+    sessionID: team.lead_session_id,
+    parts: [{ type: "text", text: "[System: New team message from system]" }]
+  }).catch((err) => {
+    log(`notifyLead:wake:failed team=${teamId} err=${err instanceof Error ? err.message : String(err)}`);
+  });
+  return id;
+}
+
 // src/types.ts
 function findTeamBySession(db, registry2, sessionId) {
   const entry = registry2.getBySession(sessionId);
@@ -18139,7 +18278,7 @@ function resolveRecipientSession(db, registry2, teamId, recipientName) {
 
 // src/hooks.ts
 var TEAM_TOOL_PREFIX = "team_";
-function handleSessionStatusEvent(db, registry2, sessionId, status) {
+function handleSessionStatusEvent(db, registry2, sessionId, status, retryPayload) {
   const entry = registry2.getBySession(sessionId);
   if (!entry)
     return;
@@ -18154,6 +18293,9 @@ function handleSessionStatusEvent(db, registry2, sessionId, status) {
     if (member.status === newStatus)
       return;
     db.run("UPDATE team_member SET status = ?, execution_status = 'idle', time_updated = ? WHERE team_id = ? AND name = ?", [newStatus, Date.now(), entry.teamId, entry.memberName]);
+    if (newStatus === "shutdown") {
+      releaseMemberTasks(db, entry.teamId, entry.memberName);
+    }
     if (member.status === "busy" && newStatus === "ready") {
       const leadMsgCount = db.query("SELECT COUNT(*) as c FROM team_message WHERE team_id = ? AND from_name = ? AND to_name = 'lead'").get(entry.teamId, entry.memberName).c;
       if (leadMsgCount > 0) {
@@ -18166,10 +18308,26 @@ function handleSessionStatusEvent(db, registry2, sessionId, status) {
       db.run("UPDATE team_member SET status = 'busy', execution_status = 'running', reported_to_lead = 0, time_updated = ? WHERE team_id = ? AND name = ?", [Date.now(), entry.teamId, entry.memberName]);
       return { memberName: entry.memberName, teamId: entry.teamId, from: member.status, to: "busy" };
     }
+    if (member.status === "busy" && member.execution_status === "starting") {
+      db.run("UPDATE team_member SET execution_status = 'running', time_updated = ? WHERE team_id = ? AND name = ?", [Date.now(), entry.teamId, entry.memberName]);
+      return { memberName: entry.memberName, teamId: entry.teamId, from: member.status, to: "busy" };
+    }
     if (member.status === "shutdown_requested") {
       return { memberName: entry.memberName, teamId: entry.teamId, from: "shutdown_requested", to: "busy_while_shutdown" };
     }
   } else if (status === "retry") {
+    if (retryPayload) {
+      const next = typeof retryPayload.next === "number" && Number.isFinite(retryPayload.next) ? retryPayload.next : null;
+      const attempt = typeof retryPayload.attempt === "number" && Number.isFinite(retryPayload.attempt) ? retryPayload.attempt : null;
+      db.run("UPDATE team_member SET retry_until = ?, retry_attempt = ?, retry_provider = ?, retry_message = ? WHERE team_id = ? AND name = ?", [
+        next,
+        attempt,
+        retryPayload.action?.provider ?? null,
+        retryPayload.action?.message ?? retryPayload.message ?? null,
+        entry.teamId,
+        entry.memberName
+      ]);
+    }
     return { memberName: entry.memberName, teamId: entry.teamId, from: member.status, to: "retry" };
   }
   return;
@@ -18205,77 +18363,14 @@ function shouldNudgeIdleMember(db, teamId, memberName) {
   const msg = db.query("SELECT id FROM team_message WHERE team_id = ? AND from_name = ? AND (to_name = 'lead' OR to_name IS NULL) LIMIT 1").get(teamId, memberName);
   return !msg;
 }
-function handleSessionErrorEvent(db, registry2, sessionId, error45) {
+function handleSessionErrorEvent(db, registry2, client3, sessionId, error45) {
   if (!sessionId)
     return;
   const teamInfo = findTeamBySession(db, registry2, sessionId);
   if (!teamInfo || teamInfo.role !== "member" || !teamInfo.memberName)
     return;
   const errMsg = error45?.data?.message ?? error45?.name ?? "unknown error";
-  sendMessage(db, {
-    teamId: teamInfo.teamId,
-    from: "system",
-    to: "lead",
-    content: `Teammate "${teamInfo.memberName}" had a session error: ${errMsg}. Check their session for details. They may be stuck and need investigation or shutdown.`
-  });
-}
-
-// src/notify.ts
-var TOAST_CONFIG = {
-  spawn: { variant: "success", duration: 3000 },
-  message: { variant: "info", duration: 3000 },
-  completed: { variant: "info", duration: 4000 },
-  error: { variant: "error", duration: 5000 },
-  shutdown: { variant: "info", duration: 3000 }
-};
-function formatMessage(type, data) {
-  switch (type) {
-    case "spawn":
-      return `Teammate ${data.memberName} spawned (${data.agent})`;
-    case "message":
-      return `Message from ${data.from}`;
-    case "completed":
-      return `${data.memberName} finished work`;
-    case "error":
-      return `${data.memberName} encountered an error`;
-    case "shutdown":
-      return `${data.memberName} shut down`;
-  }
-}
-async function notifyTeamEvent(client3, type, data) {
-  const config2 = TOAST_CONFIG[type];
-  try {
-    await client3.tui.showToast({
-      title: "Team",
-      message: formatMessage(type, data),
-      variant: config2.variant,
-      duration: config2.duration
-    });
-  } catch {}
-}
-async function notifyWorkingProgress(client3, db, teamId) {
-  const members = db.query("SELECT name, status FROM team_member WHERE team_id = ? ORDER BY time_created ASC").all(teamId);
-  if (members.length === 0)
-    return;
-  const busy = members.filter((m) => m.status === "busy");
-  try {
-    if (busy.length === 0) {
-      await client3.tui.showToast({
-        title: "Team",
-        message: "All teammates finished",
-        variant: "success",
-        duration: 4000
-      });
-    } else {
-      const names = busy.map((m) => m.name).join(", ");
-      await client3.tui.showToast({
-        title: "Team",
-        message: `Working: ${names} (${busy.length}/${members.length})`,
-        variant: "info",
-        duration: 5000
-      });
-    }
-  } catch {}
+  notifyLead(client3, db, teamInfo.teamId, `Teammate "${teamInfo.memberName}" had a session error: ${errMsg}. Check their session for details. They may be stuck and need investigation or shutdown.`);
 }
 
 // src/result-parser.ts
@@ -18544,6 +18639,7 @@ class ProgressTracker {
   steps = new Map;
   lastMessageAt = new Map;
   lastTaskAt = new Map;
+  busySince = new Map;
   peerMessages = new Map;
   reported = new Set;
   chattyReported = new Set;
@@ -18598,14 +18694,18 @@ class ProgressTracker {
     const recent = records.slice(-minSteps);
     return recent.every((r) => r.outputTokens < threshold);
   }
-  isTimeStalled(sessionId, thresholdMs) {
+  recordBusyStart(sessionId) {
+    this.busySince.set(sessionId, Date.now());
+  }
+  lastActivityAt(sessionId) {
     const records = this.steps.get(sessionId);
-    if (!records || records.length === 0)
+    const lastStepAt = records && records.length > 0 ? records[records.length - 1].timestamp : 0;
+    return Math.max(this.lastMessageAt.get(sessionId) ?? 0, this.lastTaskAt.get(sessionId) ?? 0, lastStepAt, this.busySince.get(sessionId) ?? 0);
+  }
+  isTimeStalled(sessionId, thresholdMs) {
+    const baseline = this.lastActivityAt(sessionId);
+    if (baseline === 0)
       return false;
-    const msgAt = this.lastMessageAt.get(sessionId) ?? 0;
-    const taskAt = this.lastTaskAt.get(sessionId) ?? 0;
-    const lastStep = records[records.length - 1]?.timestamp ?? 0;
-    const baseline = Math.max(msgAt, taskAt, lastStep);
     return Date.now() - baseline >= thresholdMs;
   }
   markReported(sessionId) {
@@ -18621,6 +18721,7 @@ class ProgressTracker {
     this.steps.delete(sessionId);
     this.lastMessageAt.delete(sessionId);
     this.lastTaskAt.delete(sessionId);
+    this.busySince.delete(sessionId);
     this.peerMessages.delete(sessionId);
     this.reported.delete(sessionId);
     this.chattyReported.delete(sessionId);
@@ -19163,7 +19264,7 @@ function rAgents(t){
       '<div class="flex items-center gap-2">'+
         '<span class="w-[8px] h-[8px] rounded-full '+s.d+(m.status==='busy'?' pulse':'')+' shrink-0"></span>'+
         '<span class="font-mono font-semibold text-[14px] truncate">'+E(m.name)+'</span>'+
-        '<span class="text-[10px] px-1.5 py-[1px] rounded '+s.t+' bg-base-800/80 shrink-0">'+s.l+'</span>'+
+        '<span class="text-[10px] px-1.5 py-[1px] rounded '+s.t+' bg-base-800/80 shrink-0">'+s.l+(m.lastNudgedAt?', nudged '+relT(m.lastNudgedAt):'')+'</span>'+
         spark+
         '<span class="text-[10px] text-txt-500 ml-auto shrink-0">'+E(m.agent)+'</span>'+
         (m.model?chip(E(m.model),'muted'):'')+
@@ -19172,6 +19273,7 @@ function rAgents(t){
       (mp?'<div class="mt-1 text-[12px] text-txt-400 truncate">Latest: '+E(mp)+'</div>':'')+
       '<div class="mt-2 flex items-center gap-1.5 flex-wrap">'+
         chip('status '+d,'muted')+chip('msg '+mi,'muted')+chip(E(m.executionStatus||m.status),m.status==='busy'?'blue':m.status==='error'?'red':'muted')+
+        (m.isRetrying?chip('retrying'+(m.retryAttempt!=null?' (attempt '+m.retryAttempt+')':''),'amber'):'')+
         (m.worktreeBranch?chip(E(m.worktreeBranch),'muted'):'')+
       '</div></button>';
   }).join('');
@@ -19195,6 +19297,8 @@ function openDrawer(name){
   meta.push(chip(E(m.executionStatus||m.status),m.status==='busy'?'blue':m.status==='error'?'red':'muted'));
   if(m.planApproval&&m.planApproval!=='none')meta.push(chip(E(m.planApproval),m.planApproval==='approved'?'green':m.planApproval==='rejected'?'red':'amber'));
   meta.push(chip('spawned '+relT(m.timeCreated),'muted'));
+  if(m.lastNudgedAt)meta.push(chip('nudged '+relT(m.lastNudgedAt),'amber'));
+  if(m.isRetrying)meta.push(chip('retrying'+(m.retryAttempt!=null?' (attempt '+m.retryAttempt+')':'')+(m.retryMessage?': '+E(m.retryMessage):''),'amber'));
   if(m.worktreeBranch)meta.push(chip(E(m.worktreeBranch),'muted'));
   h+='<div class="flex flex-wrap gap-1.5 mb-4 pb-4 border-b border-base-800/50">'+meta.join('')+'</div>';
   // Prompt
@@ -19262,7 +19366,7 @@ function rDrawerActivityUpdate(){
     el.innerHTML='<div class="text-txt-500 text-[12px]">No activity recorded</div>';
     return;
   }
-  var html=drawerActivity.map(function(a){
+  var html=drawerActivity.slice().reverse().map(function(a){
     var icon='\\u25CF',color='text-txt-500',label=a.type;
     if(a.type==='tool_call'){icon='\\u25B8';color='text-blue-400';label=a.tool||'tool'}
     if(a.type==='tool_result'){icon='\\u25B8';color=a.error?'text-red-400':'text-emerald-400';label=a.tool||'tool'}
@@ -19458,10 +19562,11 @@ function parseDependsOn(value) {
   }
   return [];
 }
+var ENSEMBLE_STATE_VERSION = 1;
 function buildState(db) {
   const projects = db.query("SELECT id, name, path, status, time_created, time_updated FROM project ORDER BY time_updated DESC").all();
-  const teams = db.query("SELECT id, name, project_id, status, lead_agent, time_created, time_updated FROM team ORDER BY time_created DESC").all();
-  const memberStmt = db.query("SELECT name, agent, status, execution_status, session_id, worktree_branch, prompt, model, plan_approval, time_created, time_updated FROM team_member WHERE team_id = ?");
+  const teams = db.query("SELECT id, name, project_id, lead_session_id, status, lead_agent, time_created, time_updated FROM team ORDER BY time_created DESC").all();
+  const memberStmt = db.query("SELECT name, agent, status, execution_status, session_id, worktree_branch, prompt, model, plan_approval, time_created, time_updated, last_nudged_at, retry_until, retry_attempt, retry_provider, retry_message FROM team_member WHERE team_id = ?");
   const taskStmt = db.query("SELECT id, content, status, priority, assignee, depends_on, time_created, time_updated FROM team_task WHERE team_id = ?");
   const msgStmt = db.query("SELECT id, from_name, to_name, content, delivered, read, time_created FROM team_message WHERE team_id = ? ORDER BY time_created DESC LIMIT 50");
   const mappedTeams = teams.map((t) => {
@@ -19476,12 +19581,19 @@ function buildState(db) {
       model: m.model,
       planApproval: m.plan_approval,
       timeCreated: m.time_created,
-      timeUpdated: m.time_updated
+      timeUpdated: m.time_updated,
+      lastNudgedAt: m.last_nudged_at,
+      isRetrying: m.retry_until !== null && m.retry_until > Date.now(),
+      retryUntil: m.retry_until,
+      retryAttempt: m.retry_attempt,
+      retryProvider: m.retry_provider,
+      retryMessage: m.retry_message
     }));
     return {
       id: t.id,
       name: t.name,
       projectId: t.project_id,
+      leadSessionId: t.lead_session_id,
       status: t.status,
       leadAgent: t.lead_agent,
       timeCreated: t.time_created,
@@ -19514,6 +19626,7 @@ function buildState(db) {
     teamsByProject.set(projectId, [...teamsByProject.get(projectId) ?? [], team]);
   });
   return {
+    version: ENSEMBLE_STATE_VERSION,
     projects: projects.flatMap((project) => {
       const projectTeams = teamsByProject.get(project.id) ?? [];
       if (projectTeams.length === 0)
@@ -19543,10 +19656,25 @@ function sendJson(res, data) {
   });
   res.end(JSON.stringify(data));
 }
+function parseMessageTime(time3) {
+  if (typeof time3 === "object" && time3 !== null) {
+    const created = time3.created;
+    if (typeof created === "number" && Number.isFinite(created))
+      return created;
+  }
+  if (typeof time3 === "number" && Number.isFinite(time3))
+    return time3;
+  if (typeof time3 === "string") {
+    const ms = new Date(time3).getTime();
+    if (!Number.isNaN(ms))
+      return ms;
+  }
+  return Date.now();
+}
 function parseMessageParts(parts, msgInfo) {
   const entries = [];
   const info = msgInfo ?? {};
-  const timestamp = info.time ? new Date(info.time).getTime() : Date.now();
+  const timestamp = parseMessageTime(info.time);
   for (const part of parts) {
     if (typeof part !== "object" || part === null)
       continue;
@@ -19697,9 +19825,14 @@ async function executeTeamCreate(deps, args, sessionId) {
       throw new Error(projectNameError);
   }
   const projectId = deps.directory;
-  const existing = deps.db.query("SELECT id FROM team WHERE name = ? AND project_id = ? AND status = 'active'").get(args.name, projectId);
-  if (existing)
-    throw new Error(`Team "${args.name}" already exists`);
+  const existing = deps.db.query("SELECT id, lead_session_id FROM team WHERE name = ? AND project_id = ? AND status = 'active'").get(args.name, projectId);
+  if (existing) {
+    if (await isSessionAlive(deps.client, existing.lead_session_id)) {
+      throw new Error(`Team "${args.name}" already exists`);
+    }
+    deps.db.run("UPDATE team SET status = 'archived', time_updated = ? WHERE id = ?", [Date.now(), existing.id]);
+    deps.registry.unregisterTeam(existing.id);
+  }
   const lead = findTeamBySession(deps.db, deps.registry, sessionId);
   if (lead)
     throw new Error(`This session already belongs to team "${lead.teamName}"`);
@@ -19773,15 +19906,33 @@ function requireCanPurgeArchivedTeams(deps, sessionId) {
   }
 }
 
+// src/tools/team-claim.ts
+function claimTask(db, teamId, taskId, assignee) {
+  const task = db.query("SELECT content, status, assignee FROM team_task WHERE id = ? AND team_id = ?").get(taskId, teamId);
+  if (!task)
+    throw new Error(`Task "${taskId}" not found`);
+  if (task.status === "blocked")
+    throw new Error(`Task "${taskId}" is blocked by unresolved dependencies`);
+  if (task.status !== "pending")
+    throw new Error(`Task "${taskId}" is not pending (status: ${task.status})`);
+  if (task.assignee)
+    throw new Error(`Task "${taskId}" is already claimed by ${task.assignee}`);
+  const result = db.run("UPDATE team_task SET status = 'in_progress', assignee = ?, time_updated = ? WHERE id = ? AND status = 'pending' AND assignee IS NULL", [assignee, Date.now(), taskId]);
+  if (result.changes === 0) {
+    throw new Error(`Task "${taskId}" is already claimed (race condition)`);
+  }
+  return task.content;
+}
+async function executeTeamClaim(deps, args, sessionId) {
+  const teamInfo = requireTeamMember(deps, sessionId);
+  const claimerName = teamInfo.role === "lead" ? "lead" : teamInfo.memberName ?? "unknown";
+  const content = claimTask(deps.db, teamInfo.teamId, args.task_id, claimerName);
+  return `Claimed task: ${content}`;
+}
+
 // src/tools/team-spawn.ts
 init_merge_helper();
 var spawnFailures = new Map;
-function parseModelId(model) {
-  const slash = model.indexOf("/");
-  if (slash <= 0 || slash === model.length - 1)
-    return;
-  return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
-}
 function resolveModel(explicitModel, agentType, teamMemberCount, config2) {
   if (explicitModel)
     return explicitModel;
@@ -19813,6 +19964,7 @@ function withTimeout(promise2, ms, label) {
   ]);
 }
 async function executeTeamSpawn(deps, args, sessionId) {
+  const agent = args.agent ?? "build";
   const nameError = validateMemberName(args.name);
   if (nameError)
     throw new Error(nameError);
@@ -19824,10 +19976,10 @@ async function executeTeamSpawn(deps, args, sessionId) {
   const existing = deps.db.query("SELECT name FROM team_member WHERE team_id = ? AND name = ?").get(teamInfo.teamId, args.name);
   if (existing)
     throw new Error(`Teammate "${args.name}" already exists in team "${teamInfo.teamName}"`);
-  const isReadOnly = args.agent === "plan" || args.agent === "explore";
+  const isReadOnly = agent === "plan" || agent === "explore";
   const useWorktree = args.worktree !== false && !isReadOnly && !isWorktreeDirectory(deps.directory);
   const usePlanApproval = args.plan_approval === true;
-  log(`spawn:start name=${args.name} agent=${args.agent} worktree=${useWorktree}`);
+  log(`spawn:start name=${args.name} agent=${agent} worktree=${useWorktree}`);
   let worktreeDir = null;
   let worktreeBranch = null;
   if (useWorktree) {
@@ -19883,7 +20035,7 @@ async function executeTeamSpawn(deps, args, sessionId) {
     log(`spawn:session:start name=${args.name}`);
     const createResult = await withTimeout(deps.client.session.create({
       parentID: sessionId,
-      title: `${args.name} (@${args.agent} teammate)`,
+      title: `${args.name} (@${agent} teammate)`,
       permission,
       ...workspaceId ? { workspaceID: workspaceId } : {}
     }), getSpawnTimeout(), `session.create for "${args.name}"`);
@@ -19922,15 +20074,27 @@ async function executeTeamSpawn(deps, args, sessionId) {
   const planApproval = usePlanApproval ? "pending" : "none";
   const now = Date.now();
   const memberCount = deps.db.query("SELECT COUNT(*) as c FROM team_member WHERE team_id = ?").get(teamInfo.teamId).c;
-  const resolvedModel = resolveModel(args.model, args.agent, memberCount, deps.config);
+  const resolvedModel = resolveModel(args.model, agent, memberCount, deps.config);
   if (resolvedModel)
     log(`spawn:model name=${args.name} model=${resolvedModel}`);
   deps.db.run(`INSERT INTO team_member (team_id, name, session_id, agent, status, execution_status, model, prompt, worktree_dir, worktree_branch, workspace_id, plan_approval, time_created, time_updated)
-     VALUES (?, ?, ?, ?, 'busy', 'starting', ?, ?, ?, ?, ?, ?, ?, ?)`, [teamInfo.teamId, args.name, childSessionId, args.agent, resolvedModel ?? null, args.prompt, worktreeDir, worktreeBranch, workspaceId, planApproval, now, now]);
+     VALUES (?, ?, ?, ?, 'busy', 'starting', ?, ?, ?, ?, ?, ?, ?, ?)`, [teamInfo.teamId, args.name, childSessionId, agent, resolvedModel ?? null, args.prompt, worktreeDir, worktreeBranch, workspaceId, planApproval, now, now]);
+  deps.progressTracker.recordBusyStart(childSessionId);
   deps.registry.register(teamInfo.teamId, args.name, childSessionId);
+  let claimedTaskContent = null;
+  let claimWarning = null;
+  if (args.claim_task && !isReadOnly) {
+    try {
+      claimedTaskContent = claimTask(deps.db, teamInfo.teamId, args.claim_task, args.name);
+      log(`spawn:claim:ok name=${args.name} task=${args.claim_task}`);
+    } catch (err) {
+      claimWarning = err instanceof Error ? err.message : String(err);
+      log(`spawn:claim:failed name=${args.name} task=${args.claim_task} err=${claimWarning}`);
+    }
+  }
   const context = [
     `You are "${args.name}", a teammate in team "${teamInfo.teamName}".`,
-    `Your agent type is "${args.agent}".`
+    `Your agent type is "${agent}".`
   ];
   const otherMembers = deps.db.query("SELECT name FROM team_member WHERE team_id = ? AND name != ? AND status NOT IN ('shutdown', 'error')").all(teamInfo.teamId, args.name);
   if (otherMembers.length > 0) {
@@ -19973,7 +20137,7 @@ async function executeTeamSpawn(deps, args, sessionId) {
   const lastStep = !isReadOnly && worktreeBranch ? "4" : !isReadOnly ? "3" : "2";
   context.push(`${lastStep}. STOP. Do not send follow-up confirmations, status updates, or 'standing by' messages.`, "", "If you are blocked:", "- Send ONE message to the lead via team_message describing the specific blocker.", "- Do NOT attempt workarounds or make assumptions. Wait for the lead's response.", "", "Your plain text output is NOT visible to the team. You MUST use team_message to communicate.");
   context.push("", "Your task:", args.prompt);
-  if (args.claim_task) {
+  if (claimedTaskContent) {
     context.push("", `You have been assigned task ${args.claim_task}. Mark it complete when done.`);
   }
   const contextStr = context.join(`
@@ -19986,7 +20150,7 @@ async function executeTeamSpawn(deps, args, sessionId) {
   deps.client.session.promptAsync({
     sessionID: childSessionId,
     parts: [{ type: "text", text: contextStr }],
-    agent: args.agent,
+    agent,
     ...modelParam ? { model: modelParam } : {}
   }).catch((err) => {
     const errMsg = err instanceof Error ? err.message : String(err);
@@ -19994,6 +20158,9 @@ async function executeTeamSpawn(deps, args, sessionId) {
     try {
       deps.db.run("DELETE FROM team_member WHERE team_id = ? AND session_id = ?", [teamInfo.teamId, childSessionId]);
       deps.registry.unregister(childSessionId);
+      if (claimedTaskContent) {
+        deps.db.run("UPDATE team_task SET status = 'pending', assignee = NULL, time_updated = ? WHERE id = ? AND assignee = ? AND status = 'in_progress'", [Date.now(), args.claim_task, args.name]);
+      }
       deps.client.session.abort({ sessionID: childSessionId }).catch(() => {});
       if (workspaceId) {
         deps.client.workspace.remove({ id: workspaceId }).catch(() => {});
@@ -20008,25 +20175,46 @@ async function executeTeamSpawn(deps, args, sessionId) {
         variant: "error",
         duration: 8000
       }).catch(() => {});
-      sendMessage(deps.db, {
-        teamId: teamInfo.teamId,
-        from: "system",
-        to: "lead",
-        content: `Teammate "${args.name}" failed to start and was removed${modelInfo}. Error: ${errMsg}. You may retry the spawn.`
-      });
+      notifyLead(deps.client, deps.db, teamInfo.teamId, `Teammate "${args.name}" failed to start and was removed${modelInfo}. Error: ${errMsg}. You may retry the spawn.`);
     } catch {}
   });
   const branchInfo = worktreeBranch ? ` (branch: ${worktreeBranch})` : "";
   const planInfo = usePlanApproval ? " [plan mode — will send plan for approval]" : "";
+  const claimInfo = claimedTaskContent ? ` (claimed task: ${args.claim_task})` : claimWarning ? ` (could not claim task: ${claimWarning})` : "";
   spawnFailures.delete(teamInfo.teamId);
   log(`spawn:done name=${args.name} sessionId=${childSessionId}`);
-  return `Teammate "${args.name}" spawned (agent: ${args.agent})${branchInfo}${planInfo}. They are working on: ${args.prompt.slice(0, 120)}${args.prompt.length > 120 ? "..." : ""}`;
+  return `Teammate "${args.name}" spawned (agent: ${agent})${branchInfo}${planInfo}${claimInfo}. They are working on: ${args.prompt.slice(0, 120)}${args.prompt.length > 120 ? "..." : ""}`;
 }
 
 // src/tools/team-message.ts
 async function executeTeamMessage(deps, args, sessionId) {
   const teamInfo = requireTeamMember(deps, sessionId);
+  if (args.force && teamInfo.role !== "lead") {
+    throw new Error("Only the lead can force-deliver a message to a completed teammate.");
+  }
   const senderName = teamInfo.role === "lead" ? "lead" : teamInfo.memberName ?? "unknown";
+  if (args.model !== undefined) {
+    if (teamInfo.role !== "lead")
+      throw new Error("Only the lead can update a teammate's model.");
+    const parsed = parseModelId(args.model);
+    if (!parsed)
+      throw new Error(`Invalid model "${args.model}" — expected "provider/model" format (e.g. "anthropic/claude-sonnet").`);
+    const member = deps.db.query("SELECT status FROM team_member WHERE team_id = ? AND name = ?").get(teamInfo.teamId, args.to);
+    if (!member)
+      throw new Error(`Teammate "${args.to}" not found in team "${teamInfo.teamName}".`);
+    if (member.status === "shutdown" || member.status === "error") {
+      throw new Error(`Teammate "${args.to}" is shut down — spawn a new teammate instead of updating the model.`);
+    }
+    deps.db.run("UPDATE team_member SET model = ?, time_updated = ? WHERE team_id = ? AND name = ?", [args.model, Date.now(), teamInfo.teamId, args.to]);
+    log(`team_message:model-update to=${args.to} model=${args.model}`);
+    if (!args.text) {
+      return `Updated ${args.to}'s model to ${args.model}. It applies on their next turn.`;
+    }
+  }
+  if (args.text === undefined) {
+    throw new Error("team_message requires either 'text' or 'model'.");
+  }
+  const text = args.text;
   const recipientSessionId = resolveRecipientSession(deps.db, deps.registry, teamInfo.teamId, args.to);
   if (!recipientSessionId && args.to !== "lead") {
     if (args.approve || args.reject) {
@@ -20036,14 +20224,14 @@ async function executeTeamMessage(deps, args, sessionId) {
       teamId: teamInfo.teamId,
       from: senderName,
       to: args.to,
-      content: args.text
+      content: text
     });
     log(`team_message:queued from=${senderName} to=${args.to} (recipient not yet spawned)`);
     return `Message queued for ${args.to} — they haven't been spawned yet. It will be delivered when they join the team.`;
   }
   if (!recipientSessionId)
     throw new Error(`Recipient "${args.to}" not found in team "${teamInfo.teamName}"`);
-  let messageText = args.text;
+  let messageText = text;
   if (args.approve || args.reject) {
     if (args.approve && args.reject) {
       throw new Error("Cannot both approve and reject a plan.");
@@ -20080,13 +20268,15 @@ async function executeTeamMessage(deps, args, sessionId) {
     });
     return `Message sent to ${args.to}.`;
   }
-  if (hasReportedCompletion(deps.db, teamInfo.teamId, args.to)) {
-    return `Message stored for ${args.to} (teammate has completed their task — message will not wake them).`;
+  if (hasReportedCompletion(deps.db, teamInfo.teamId, args.to) && !args.force) {
+    return `Message stored for ${args.to} (teammate has completed their task — message will not wake them). Pass force:true to re-activate them.`;
   }
   const deliveryText = `[Team message from ${senderName}]: ${messageText}`;
+  const recipientModel = getMemberModel(deps.db, teamInfo.teamId, args.to);
   deps.client.session.promptAsync({
     sessionID: recipientSessionId,
-    parts: [{ type: "text", text: deliveryText }]
+    parts: [{ type: "text", text: deliveryText }],
+    ...recipientModel ? { model: recipientModel } : {}
   }).then(() => {
     markDelivered(deps.db, msgId);
   }).catch((err) => {
@@ -20201,6 +20391,9 @@ async function preserveAndAbort(deps, teamId, memberName, sessionId, worktreeBra
     await deps.client.session.abort({ sessionID: sessionId });
   } catch {}
   deps.db.run("UPDATE team_member SET status = 'shutdown', execution_status = 'idle', time_updated = ? WHERE team_id = ? AND name = ?", [Date.now(), teamId, memberName]);
+  const released = releaseMemberTasks(deps.db, teamId, memberName);
+  if (released > 0)
+    log(`shutdown:tasks:released name=${memberName} count=${released}`);
 }
 async function getBranchStatus(deps, teamId, memberName, worktreeDir, isDirty, commitCount) {
   const row = deps.db.query("SELECT worktree_branch FROM team_member WHERE team_id = ? AND name = ?").get(teamId, memberName);
@@ -20670,9 +20863,9 @@ Review with: git diff`);
 
 // src/tools/team-merge.ts
 init_merge_helper();
-async function executeTeamMerge(deps, args, sessionId, merge2 = mergeBranch, delBranch = deleteBranch, overlapCheck = getOverlappingFiles) {
+async function executeTeamMerge(deps, args, sessionId, merge2 = mergeBranch, delBranch = deleteBranch, overlapCheck = getOverlappingFiles, commitCount = countBranchCommits, isDirty = checkWorktreeDirty) {
   const teamInfo = requireLead(deps, sessionId);
-  const member = deps.db.query("SELECT status, worktree_branch FROM team_member WHERE team_id = ? AND name = ?").get(teamInfo.teamId, args.member);
+  const member = deps.db.query("SELECT status, worktree_branch, worktree_dir FROM team_member WHERE team_id = ? AND name = ?").get(teamInfo.teamId, args.member);
   if (!member)
     throw new Error(`Teammate "${args.member}" not found in team "${teamInfo.teamName}"`);
   if (member.status !== "shutdown" && member.status !== "error") {
@@ -20683,6 +20876,21 @@ async function executeTeamMerge(deps, args, sessionId, merge2 = mergeBranch, del
   }
   const branch = member.worktree_branch;
   log(`merge:start member=${args.member} branch=${branch}`);
+  const commits = await commitCount(branch, deps.directory);
+  if (commits === 0) {
+    const dirty = member.worktree_dir ? await isDirty(member.worktree_dir).catch(() => false) : false;
+    if (dirty) {
+      return [
+        `Nothing to merge for "${args.member}" — their branch (${branch}) has no commits.`,
+        `Their worktree still has uncommitted changes that were never captured on the branch.`,
+        `This work will be permanently lost if the worktree is removed (e.g. via team_cleanup).`,
+        member.worktree_dir ? `Worktree: ${member.worktree_dir}` : ``,
+        `Recover manually (copy files out of the worktree) before shutting down/cleaning up, or re-spawn and instruct them to commit their changes before reporting done.`
+      ].filter(Boolean).join(`
+`);
+    }
+    return `Nothing to merge for "${args.member}" — their branch (${branch}) has no commits and no uncommitted changes. They made no changes.`;
+  }
   try {
     const overlap = await overlapCheck(branch, deps.directory);
     if (overlap.length > 0) {
@@ -20754,11 +20962,28 @@ async function executeTeamTasksAdd(deps, args, sessionId) {
 // src/tools/team-tasks-complete.ts
 async function executeTeamTasksComplete(deps, args, sessionId) {
   const teamInfo = requireTeamMember(deps, sessionId);
-  const task = deps.db.query("SELECT * FROM team_task WHERE id = ? AND team_id = ?").get(args.task_id, teamInfo.teamId);
+  const caller = teamInfo.role === "lead" ? "lead" : teamInfo.memberName ?? "unknown";
+  const task = deps.db.query("SELECT id, content, status, assignee FROM team_task WHERE id = ? AND team_id = ?").get(args.task_id, teamInfo.teamId);
   if (!task)
     throw new Error(`Task "${args.task_id}" not found`);
+  if (task.status === "completed")
+    throw new Error(`Task "${args.task_id}" is already completed`);
+  if (task.status === "cancelled")
+    throw new Error(`Task "${args.task_id}" was cancelled`);
+  if (task.status === "blocked")
+    throw new Error(`Task "${args.task_id}" is blocked by unresolved dependencies`);
+  if (task.status === "in_progress" && task.assignee && teamInfo.role !== "lead" && caller !== task.assignee) {
+    throw new Error(`Task "${args.task_id}" is claimed by ${task.assignee}`);
+  }
   const now = Date.now();
-  deps.db.run("UPDATE team_task SET status = 'completed', time_updated = ? WHERE id = ?", [now, args.task_id]);
+  if (task.assignee) {
+    deps.db.run("UPDATE team_task SET status = 'completed', time_updated = ? WHERE id = ?", [now, args.task_id]);
+  } else {
+    const result = deps.db.run("UPDATE team_task SET status = 'completed', assignee = ?, time_updated = ? WHERE id = ? AND assignee IS NULL", [caller, now, args.task_id]);
+    if (result.changes === 0) {
+      throw new Error(`Task "${args.task_id}" was just completed by another teammate`);
+    }
+  }
   const allTasks = deps.db.query("SELECT id, depends_on, status FROM team_task WHERE team_id = ?").all(teamInfo.teamId);
   let unblocked = 0;
   for (const t of allTasks) {
@@ -20796,26 +21021,6 @@ async function executeTeamTasksComplete(deps, args, sessionId) {
   return `Completed task: ${task.content}${unblockedMsg}`;
 }
 
-// src/tools/team-claim.ts
-async function executeTeamClaim(deps, args, sessionId) {
-  const teamInfo = requireTeamMember(deps, sessionId);
-  const claimerName = teamInfo.role === "lead" ? "lead" : teamInfo.memberName ?? "unknown";
-  const task = deps.db.query("SELECT * FROM team_task WHERE id = ? AND team_id = ?").get(args.task_id, teamInfo.teamId);
-  if (!task)
-    throw new Error(`Task "${args.task_id}" not found`);
-  if (task.status === "blocked")
-    throw new Error(`Task "${args.task_id}" is blocked by unresolved dependencies`);
-  if (task.status !== "pending")
-    throw new Error(`Task "${args.task_id}" is not pending (status: ${task.status})`);
-  if (task.assignee)
-    throw new Error(`Task "${args.task_id}" is already claimed by ${task.assignee}`);
-  const result = deps.db.run("UPDATE team_task SET status = 'in_progress', assignee = ?, time_updated = ? WHERE id = ? AND status = 'pending' AND assignee IS NULL", [claimerName, Date.now(), args.task_id]);
-  if (result.changes === 0) {
-    throw new Error(`Task "${args.task_id}" is already claimed (race condition)`);
-  }
-  return `Claimed task: ${task.content}`;
-}
-
 // src/tools/team-results.ts
 async function executeTeamResults(deps, args, sessionId) {
   const team = requireTeamMember(deps, sessionId);
@@ -20838,7 +21043,16 @@ ${r.content}`;
 
 // src/tools/team-status.ts
 var lastCallTime = new Map;
+var lastKnownState = new Map;
 var RATE_LIMIT_MS = 30000;
+function computeStateMarker(deps, teamId) {
+  const row = deps.db.query(`SELECT MAX(x) as marker FROM (
+       SELECT MAX(time_updated) as x FROM team_member WHERE team_id = ?
+       UNION SELECT MAX(time_updated) FROM team_task WHERE team_id = ?
+       UNION SELECT MAX(time_created) FROM team_message WHERE team_id = ?
+     )`).get(teamId, teamId, teamId);
+  return row?.marker ?? 0;
+}
 function formatDuration(ms) {
   if (ms < 60000)
     return `${Math.floor(ms / 1000)}s`;
@@ -20850,11 +21064,13 @@ async function executeTeamStatus(deps, sessionId) {
   const teamInfo = requireTeamMember(deps, sessionId);
   const now = Date.now();
   const last = lastCallTime.get(teamInfo.teamId);
-  if (last !== undefined && now - last < RATE_LIMIT_MS) {
+  const currentMarker = computeStateMarker(deps, teamInfo.teamId);
+  if (last !== undefined && now - last < RATE_LIMIT_MS && lastKnownState.get(teamInfo.teamId) === currentMarker) {
     return "No changes since last check.";
   }
   lastCallTime.set(teamInfo.teamId, now);
-  const members = deps.db.query("SELECT name, session_id, agent, status, execution_status, worktree_branch, worktree_dir, plan_approval, time_updated FROM team_member WHERE team_id = ? ORDER BY time_created ASC").all(teamInfo.teamId);
+  lastKnownState.set(teamInfo.teamId, currentMarker);
+  const members = deps.db.query("SELECT name, session_id, agent, status, execution_status, worktree_branch, worktree_dir, plan_approval, time_updated, last_nudged_at, retry_until, retry_attempt FROM team_member WHERE team_id = ? ORDER BY time_created ASC").all(teamInfo.teamId);
   const tasks = deps.db.query("SELECT status FROM team_task WHERE team_id = ?").all(teamInfo.teamId);
   const lines = [];
   lines.push(`Team: ${teamInfo.teamName} (you are the ${teamInfo.role})`);
@@ -20868,9 +21084,12 @@ async function executeTeamStatus(deps, sessionId) {
       const duration3 = formatDuration(now - m.time_updated);
       const branch = m.worktree_branch ? `  branch: ${m.worktree_branch}` : "";
       const plan = m.plan_approval !== "none" ? `, plan: ${m.plan_approval}` : "";
+      const nudged = m.last_nudged_at ? `, nudged ${formatDuration(now - m.last_nudged_at)} ago` : "";
+      const isRetrying = m.retry_until !== null && m.retry_until > now;
+      const retrying = isRetrying ? `, retrying (attempt ${m.retry_attempt}, ~${formatDuration(m.retry_until - now)})` : "";
       const lastMsg = deps.db.query("SELECT MAX(time_created) as last_msg FROM team_message WHERE team_id = ? AND from_name = ?").get(teamInfo.teamId, m.name);
       const msgInfo = lastMsg?.last_msg ? `last msg: ${formatDuration(now - lastMsg.last_msg)} ago` : "no messages yet";
-      lines.push(`  ${m.name}  [${statusIcon} ${duration3}, ${msgInfo}${plan}]  agent: ${m.agent}${branch}`);
+      lines.push(`  ${m.name}  [${statusIcon} ${duration3}, ${msgInfo}${plan}${nudged}${retrying}]  agent: ${m.agent}${branch}`);
       const task = deps.db.query("SELECT content FROM team_task WHERE team_id = ? AND assignee = ? AND status = 'in_progress' LIMIT 1").get(teamInfo.teamId, m.name);
       if (task) {
         const truncated = task.content.length > 80 ? `${task.content.slice(0, 80)}...` : task.content;
@@ -21054,18 +21273,32 @@ class Watchdog {
       const timeStalled = this.progressTracker.isTimeStalled(member.session_id, this.stallThresholdMs);
       if (!tokenStalled && !timeStalled)
         continue;
-      this.progressTracker.markReported(member.session_id);
+      if (hasReportedCompletion(this.db, member.team_id, member.name)) {
+        log(`watchdog:stall:skip member=${member.name} team=${member.team_id} reason=already-reported-completion`);
+        continue;
+      }
       const reason = tokenStalled ? "low output tokens" : "no communication";
+      const recentNudgeRow = this.db.query("SELECT last_nudged_at FROM team_member WHERE team_id = ? AND name = ?").get(member.team_id, member.name);
+      if (recentNudgeRow?.last_nudged_at) {
+        const nudgedAt = recentNudgeRow.last_nudged_at;
+        const activeSinceNudge = (this.progressTracker?.lastActivityAt(member.session_id) ?? 0) >= nudgedAt;
+        if (!activeSinceNudge && Date.now() - nudgedAt < this.stallThresholdMs) {
+          log(`watchdog:stall:skip member=${member.name} team=${member.team_id} reason=recently-nudged`);
+          continue;
+        }
+      }
+      this.db.run("UPDATE team_member SET last_nudged_at = ? WHERE team_id = ? AND name = ?", [Date.now(), member.team_id, member.name]);
+      const stallModel = getMemberModel(this.db, member.team_id, member.name);
       this.client.session.promptAsync({
         sessionID: member.session_id,
-        parts: [{ type: "text", text: "[System]: You appear stalled — no progress detected. Report your current status to the lead via team_message, or wrap up your work." }]
-      }).catch(() => {});
-      sendMessage(this.db, {
-        teamId: member.team_id,
-        from: "system",
-        to: "lead",
-        content: `Teammate "${member.name}" appears stalled (${reason}). Consider checking on them via team_message or shutting them down.`
+        parts: [{ type: "text", text: "[System]: You appear stalled — no progress detected. Report your current status to the lead via team_message, or wrap up your work." }],
+        ...stallModel ? { model: stallModel } : {}
+      }).then(() => {
+        this.progressTracker.markReported(member.session_id);
+      }).catch((err) => {
+        log(`watchdog:stall:nudge-failed member=${member.name} team=${member.team_id} session=${member.session_id} err=${err instanceof Error ? err.message : String(err)}`);
       });
+      notifyLead(this.client, this.db, member.team_id, `Teammate "${member.name}" appears stalled (${reason}). Consider checking on them via team_message or shutting them down.`);
       try {
         await this.client.tui.showToast({
           title: "Team",
@@ -21088,17 +21321,20 @@ class Watchdog {
         continue;
       if (!this.progressTracker.isChatty(member.session_id, this.peerMessageLimit, this.peerMessageWindowMs))
         continue;
+      if (hasReportedCompletion(this.db, member.team_id, member.name)) {
+        log(`watchdog:chatty:skip member=${member.name} team=${member.team_id} reason=already-reported-completion`);
+        continue;
+      }
       this.progressTracker.markChattyReported(member.session_id);
+      const chattyModel = getMemberModel(this.db, member.team_id, member.name);
       this.client.session.promptAsync({
         sessionID: member.session_id,
-        parts: [{ type: "text", text: "[System]: You've sent several messages to teammates. Focus on completing your task and send your results to the lead via team_message." }]
-      }).catch(() => {});
-      sendMessage(this.db, {
-        teamId: member.team_id,
-        from: "system",
-        to: "lead",
-        content: `Agent "${member.name}" is sending many peer messages and may be over-coordinating. Consider checking on them.`
+        parts: [{ type: "text", text: "[System]: You've sent several messages to teammates. Focus on completing your task and send your results to the lead via team_message." }],
+        ...chattyModel ? { model: chattyModel } : {}
+      }).catch((err) => {
+        log(`watchdog:chatty:nudge-failed member=${member.name} team=${member.team_id} session=${member.session_id} err=${err instanceof Error ? err.message : String(err)}`);
       });
+      notifyLead(this.client, this.db, member.team_id, `Agent "${member.name}" is sending many peer messages and may be over-coordinating. Consider checking on them.`);
       log(`watchdog:chatty member=${member.name} limit=${this.peerMessageLimit}`);
     }
   }
@@ -21126,6 +21362,10 @@ class Watchdog {
         }
       }
       this.db.run("UPDATE team_member SET status = 'error', execution_status = 'timed_out', time_updated = ? WHERE team_id = ? AND name = ?", [Date.now(), member.team_id, member.name]);
+      const released = releaseMemberTasks(this.db, member.team_id, member.name);
+      if (released > 0)
+        log(`watchdog:tasks:released name=${member.name} count=${released}`);
+      notifyLead(this.client, this.db, member.team_id, `Teammate "${member.name}" timed out after exceeding the busy time limit and was aborted. Their in-progress work has been released. Review their session, then re-spawn or reassign the task if needed.`);
       try {
         await this.client.session.abort({ sessionID: member.session_id });
       } catch {}
@@ -21176,9 +21416,15 @@ var plugin = async (input) => {
   const rawClient = new OpencodeClient({ client: pluginTransport });
   initLog(rawClient);
   const client3 = wrapThrowingClient(rawClient);
-  const deps = { db, registry: registry2, tracker, purgeApprovals, client: client3, directory: input.directory, config: config2 };
+  const deps = { db, registry: registry2, tracker, purgeApprovals, client: client3, directory: input.directory, config: config2, progressTracker };
   if (!isWorktreeInstance(input.directory)) {
     log("init:recovery:start (main instance)");
+    recoverOrphanedTeams(db, client3, input.directory, registry2).then((result) => {
+      if (result.archived > 0)
+        log(`init:recovery:orphaned-teams-archived=${result.archived}`);
+    }).catch((err) => {
+      log(`init:recover-orphaned-teams:failed err=${err instanceof Error ? err.message : String(err)}`);
+    });
     const recovery = await recoverStaleMembers(db, client3, input.directory);
     if (recovery.interrupted > 0) {
       log(`init:recovery:interrupted=${recovery.interrupted}`);
@@ -21229,7 +21475,8 @@ var plugin = async (input) => {
       if (event.type === "session.status") {
         const { sessionID, status } = event.properties;
         const statusType = status.type;
-        const transition = handleSessionStatusEvent(db, registry2, sessionID, statusType);
+        const retryPayload = statusType === "retry" ? status : undefined;
+        const transition = handleSessionStatusEvent(db, registry2, sessionID, statusType, retryPayload);
         if (transition) {
           if (transition.to === "shutdown") {
             notifyTeamEvent(client3, "shutdown", { memberName: transition.memberName });
@@ -21245,12 +21492,7 @@ var plugin = async (input) => {
                   nudgedMembers.add(fastIdleKey);
                   const modelInfo = memberInfo.model ? ` (model: ${memberInfo.model})` : "";
                   log(`fast-idle: ${transition.memberName} went idle ${Math.round(spawnAge / 1000)}s after spawn with 0 messages${modelInfo}`);
-                  sendMessage(db, {
-                    teamId: transition.teamId,
-                    from: "system",
-                    to: "lead",
-                    content: `Warning: Teammate "${transition.memberName}" went idle immediately after spawning with no output${modelInfo}. This usually means the model failed to start (authentication error, invalid model, or provider issue). Check your API key and model configuration, then retry the spawn.`
-                  });
+                  notifyLead(client3, db, transition.teamId, `Warning: Teammate "${transition.memberName}" went idle immediately after spawning with no output${modelInfo}. This usually means the model failed to start (authentication error, invalid model, or provider issue). Check your API key and model configuration, then retry the spawn.`);
                   client3.tui.showToast({
                     title: "Team",
                     message: `${transition.memberName} failed to produce output${modelInfo}`,
@@ -21264,13 +21506,19 @@ var plugin = async (input) => {
             if (!nudgedMembers.has(nudgeKey) && shouldNudgeIdleMember(db, transition.teamId, transition.memberName) && !hasReportedCompletion(db, transition.teamId, transition.memberName)) {
               nudgedMembers.add(nudgeKey);
               log(`nudge:idle-without-report name=${transition.memberName}`);
+              const nudgeModel = getMemberModel(db, transition.teamId, transition.memberName);
               client3.session.promptAsync({
                 sessionID,
-                parts: [{ type: "text", text: "[System]: You completed your work but did not report results. Send your findings to the lead via team_message now." }]
-              }).catch(() => {});
+                parts: [{ type: "text", text: "[System]: You completed your work but did not report results. Send your findings to the lead via team_message now." }],
+                ...nudgeModel ? { model: nudgeModel } : {}
+              }).catch((err) => {
+                log(`nudge:idle-without-report:failed name=${transition.memberName} team=${transition.teamId} err=${err instanceof Error ? err.message : String(err)}`);
+              });
             }
           } else if (transition.to === "error") {
             notifyTeamEvent(client3, "error", { memberName: transition.memberName });
+          } else if (transition.to === "busy") {
+            progressTracker.recordBusyStart(sessionID);
           } else if (transition.to === "retry") {
             try {
               await client3.tui.showToast({
@@ -21323,9 +21571,11 @@ var plugin = async (input) => {
             const peerMsgs = db.query("SELECT COUNT(*) as c FROM team_message WHERE team_id = ? AND to_name = ? AND delivered = 0 AND time_created < ?").get(member.team_id, member.name, staleThreshold);
             if (peerMsgs.c > 0) {
               log(`wake-peer: ${member.name} has ${peerMsgs.c} pending peer messages`);
+              const peerModel = getMemberModel(db, member.team_id, member.name);
               client3.session.promptAsync({
                 sessionID,
-                parts: [{ type: "text", text: `[System: ${peerMsgs.c} new message(s) from teammates]` }]
+                parts: [{ type: "text", text: `[System: ${peerMsgs.c} new message(s) from teammates]` }],
+                ...peerModel ? { model: peerModel } : {}
               }).catch((err) => {
                 log(`wake-peer:failed err=${err instanceof Error ? err.message : String(err)}`);
               });
@@ -21341,7 +21591,7 @@ var plugin = async (input) => {
       }
       if (event.type === "session.error") {
         const props = event.properties;
-        handleSessionErrorEvent(db, registry2, props.sessionID, props.error);
+        handleSessionErrorEvent(db, registry2, client3, props.sessionID, props.error);
       }
       if (event.type === "message.part.updated") {
         const part = event.properties.part;
@@ -21436,19 +21686,21 @@ var plugin = async (input) => {
         }
       }),
       team_message: tool({
-        description: "Send a message to a specific teammate or to the lead. Use 'lead' to message the team lead.",
+        description: "Send a message to a specific teammate or to the lead. Use 'lead' to message the team lead. " + "Lead only: pass 'model' (provider/model) to update a teammate's model in-place — it applies on their next turn. " + "When updating a model, 'text' is optional; omit it to change the model without sending a message.",
         args: {
           to: tool.schema.string().describe("Recipient name ('lead' or teammate name)"),
-          text: tool.schema.string().describe("Message content (max 10KB)"),
+          text: tool.schema.string().optional().describe("Message content (max 10KB). Optional only when 'model' is provided."),
           approve: tool.schema.boolean().optional().describe("Approve a teammate's plan (only when recipient has plan_approval='pending')"),
-          reject: tool.schema.string().optional().describe("Reject a teammate's plan with reason (only when recipient has plan_approval='pending')")
+          reject: tool.schema.string().optional().describe("Reject a teammate's plan with reason (only when recipient has plan_approval='pending')"),
+          force: tool.schema.boolean().optional().describe("Lead only. Re-activate a teammate who already reported task completion (normally their session won't be woken again). Use for legitimate follow-on work — e.g. the next round of a multi-round debate — not for courtesy replies."),
+          model: tool.schema.string().optional().describe("Lead only: update the recipient teammate's model in-place, in 'provider/model' format (e.g. 'anthropic/claude-sonnet').")
         },
         async execute(args, ctx) {
           const result = await executeTeamMessage(deps, args, ctx.sessionID);
           progressTracker.recordMessage(ctx.sessionID);
           if (args.to !== "lead")
             progressTracker.recordPeerMessage(ctx.sessionID);
-          ctx.metadata({ title: `Message → ${args.to}` });
+          ctx.metadata({ title: args.model ? `Set ${args.to} model → ${args.model}` : `Message → ${args.to}` });
           return result;
         }
       }),
@@ -21460,6 +21712,7 @@ var plugin = async (input) => {
         async execute(args, ctx) {
           const result = await executeTeamBroadcast(deps, args, ctx.sessionID);
           progressTracker.recordMessage(ctx.sessionID);
+          progressTracker.recordPeerMessage(ctx.sessionID);
           ctx.metadata({ title: "Broadcast to team" });
           return result;
         }