@hueyexe/opencode-ensemble 0.7.0 → 0.8.0

package/src/index.ts

@@ -8,11 +8,13 @@ import { wrapThrowingClient } from "./client"
 import { recoverStaleMembers, recoverUndeliveredMessages, recoverOrphanedWorktrees } from "./recovery"
 import { MemberRegistry, DescendantTracker } from "./state"
 import { isWorktreeInstance } from "./util"
-import { handleSessionStatusEvent, handleSessionCreatedEvent, checkToolIsolation } from "./hooks"
+import { handleSessionStatusEvent, handleSessionCreatedEvent, checkToolIsolation, shouldNudgeIdleMember } from "./hooks"
 import { notifyTeamEvent, notifyWorkingProgress } from "./notify"
 import { buildLeadSystemPrompt, buildTeammateSystemPrompt, buildTeamCompactionContext } from "./system-prompt"
 import { log, initLog } from "./log"
 import { findTeamBySession } from "./types"
+import { loadConfig } from "./config"
+import { ProgressTracker } from "./progress"
 import { executeTeamCreate } from "./tools/team-create"
 import { executeTeamSpawn } from "./tools/team-spawn"
 import { executeTeamMessage } from "./tools/team-message"
@@ -30,10 +32,8 @@ import type { ToolDeps, } from "./types"
 import { TokenBucket } from "./rate-limit"
 import { Watchdog } from "./watchdog"
 
-const DEFAULT_RATE_LIMIT_CAPACITY = 10
 const DEFAULT_RATE_LIMIT_REFILL = 2
 const DEFAULT_RATE_LIMIT_INTERVAL_MS = 1000
-const DEFAULT_WATCHDOG_TTL_MS = 30 * 60 * 1000 // 30 minutes
 const DEFAULT_WATCHDOG_CHECK_MS = 60 * 1000 // 60 seconds
 
 /**
@@ -47,9 +47,14 @@ const plugin: Plugin = async (input) => {
   mkdirSync(path.dirname(dbPath), { recursive: true })
   const db = createDb(dbPath)
 
+  // Load plugin configuration (global → project → env vars)
+  const config = loadConfig(input.directory)
+
   // Initialize in-memory state
   const registry = new MemberRegistry()
   const tracker = new DescendantTracker()
+  const nudgedMembers = new Set<string>()
+  const progressTracker = new ProgressTracker()
 
   // Extract the working HeyAPI transport from the plugin-provided v1 client and pass it
   // to the v2 OpencodeClient. The plugin framework provides a v1 client which stores its
@@ -88,24 +93,22 @@ const plugin: Plugin = async (input) => {
     log(`init:skip-recovery (worktree instance: ${input.directory})`)
   }
 
-  // Initialize rate limiter
-  // OPENCODE_ENSEMBLE_RATE_LIMIT=0 disables it entirely
-  const rateLimitEnv = process.env.OPENCODE_ENSEMBLE_RATE_LIMIT
-  const rateLimitCapacity = rateLimitEnv === "0" ? 0 : (parseInt(rateLimitEnv ?? "", 10) || DEFAULT_RATE_LIMIT_CAPACITY)
+  // Initialize rate limiter — config value already accounts for env var override
   const rateLimiter = new TokenBucket({
-    capacity: rateLimitCapacity,
+    capacity: config.rateLimitCapacity,
     refillRate: DEFAULT_RATE_LIMIT_REFILL,
     refillIntervalMs: DEFAULT_RATE_LIMIT_INTERVAL_MS,
   })
 
-  // Initialize watchdog for teammate timeouts
-  // OPENCODE_ENSEMBLE_TIMEOUT=0 disables it entirely
-  const timeoutEnv = process.env.OPENCODE_ENSEMBLE_TIMEOUT
-  const watchdogTtl = timeoutEnv === "0" ? 0 : (parseInt(timeoutEnv ?? "", 10) || DEFAULT_WATCHDOG_TTL_MS)
+  // Initialize watchdog — config value already accounts for env var override
   const watchdog = new Watchdog({
     db, client, registry,
-    ttlMs: watchdogTtl,
+    ttlMs: config.timeoutMs,
     checkIntervalMs: DEFAULT_WATCHDOG_CHECK_MS,
+    progressTracker,
+    stallThresholdMs: config.stallThresholdMs,
+    stallMinSteps: config.stallMinSteps,
+    stallTokenThreshold: config.stallTokenThreshold,
   })
   watchdog.start()
 
@@ -123,6 +126,16 @@ const plugin: Plugin = async (input) => {
             notifyTeamEvent(client, "shutdown", { memberName: transition.memberName })
           } else if (transition.to === "ready" && transition.from === "busy") {
             notifyTeamEvent(client, "completed", { memberName: transition.memberName })
+            // Nudge teammate if they went idle without reporting to the lead (once only)
+            const nudgeKey = `${transition.teamId}:${transition.memberName}`
+            if (!nudgedMembers.has(nudgeKey) && shouldNudgeIdleMember(db, transition.teamId, transition.memberName)) {
+              nudgedMembers.add(nudgeKey)
+              log(`nudge:idle-without-report name=${transition.memberName}`)
+              client.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(() => { /* best effort */ })
+            }
           } else if (transition.to === "error") {
             notifyTeamEvent(client, "error", { memberName: transition.memberName })
           } else if (transition.to === "retry") {
@@ -174,6 +187,16 @@ const plugin: Plugin = async (input) => {
           handleSessionCreatedEvent(tracker, info.id, info.parentID)
         }
       }
+
+      // Track per-step output tokens for stall detection
+      if (event.type === "message.part.updated") {
+        const part = (event.properties as { part?: { type?: string; sessionID?: string; tokens?: { output?: number } } }).part
+        if (part?.type === "step-finish" && part.sessionID && part.tokens?.output !== undefined) {
+          if (registry.getBySession(part.sessionID)) {
+            progressTracker.recordStep(part.sessionID, part.tokens.output)
+          }
+        }
+      }
     },
 
     // Sub-agent isolation + rate limiting hook
@@ -272,6 +295,8 @@ const plugin: Plugin = async (input) => {
         },
         async execute(args, ctx) {
           const result = await executeTeamMessage(deps, args, ctx.sessionID)
+          // Track message activity for stall detection
+          progressTracker.recordMessage(ctx.sessionID)
           ctx.metadata({ title: `Message → ${args.to}` })
           return result
         },
@@ -284,6 +309,8 @@ const plugin: Plugin = async (input) => {
         },
         async execute(args, ctx) {
           const result = await executeTeamBroadcast(deps, args, ctx.sessionID)
+          // Track broadcast activity for stall detection
+          progressTracker.recordMessage(ctx.sessionID)
           ctx.metadata({ title: "Broadcast to team" })
           return result
         },
@@ -323,6 +350,8 @@ const plugin: Plugin = async (input) => {
         },
         async execute(args, ctx) {
           const result = await executeTeamTasksComplete(deps, args, ctx.sessionID)
+          // Track task completion for stall detection
+          progressTracker.recordTaskComplete(ctx.sessionID)
           ctx.metadata({ title: `Completed task` })
           return result
         },
@@ -361,6 +390,9 @@ const plugin: Plugin = async (input) => {
         },
         async execute(args, ctx) {
           const result = await executeTeamShutdown(deps, args, ctx.sessionID)
+          // Clean up progress tracking for the shut-down member
+          const member = deps.db.query("SELECT session_id FROM team_member WHERE name = ? AND status IN ('shutdown', 'shutdown_requested')").get(args.member) as { session_id: string } | null
+          if (member) progressTracker.remove(member.session_id)
           const hasWarning = result.includes("uncommitted")
           ctx.metadata({ title: hasWarning ? `${args.member} shut down — uncommitted changes` : `${args.member} shut down` })
           return result
@@ -374,7 +406,7 @@ const plugin: Plugin = async (input) => {
           acknowledge_uncommitted: tool.schema.boolean().default(false),
         },
         async execute(args, ctx) {
-          const result = await executeTeamCleanup(deps, args, ctx.sessionID)
+          const result = await executeTeamCleanup(deps, args, ctx.sessionID, undefined, undefined, config.mergeOnCleanup)
           const blocked = result.includes("uncommitted")
           ctx.metadata({ title: blocked ? "Cleanup blocked — uncommitted changes" : "Team cleaned up" })
           return result

package/src/progress.ts

@@ -0,0 +1,85 @@
+/** A single model step record. */
+export interface StepRecord {
+  outputTokens: number
+  timestamp: number
+}
+
+/**
+ * In-memory tracker for teammate activity signals.
+ * Used by the watchdog for stall detection.
+ */
+export class ProgressTracker {
+  private steps = new Map<string, StepRecord[]>()
+  private lastMessageAt = new Map<string, number>()
+  private lastTaskAt = new Map<string, number>()
+  private reported = new Set<string>()
+  private readonly maxSteps: number
+
+  constructor(maxSteps = 10) {
+    this.maxSteps = maxSteps
+  }
+
+  /** Record a model step completion with output token count. Keeps last `maxSteps` entries. */
+  recordStep(sessionId: string, outputTokens: number): void {
+    const records = this.steps.get(sessionId) ?? []
+    records.push({ outputTokens, timestamp: Date.now() })
+    if (records.length > this.maxSteps) records.shift()
+    this.steps.set(sessionId, records)
+  }
+
+  /** Record that this member sent a team_message. Clears stall report. */
+  recordMessage(sessionId: string): void {
+    this.lastMessageAt.set(sessionId, Date.now())
+    this.clearReport(sessionId)
+  }
+
+  /** Record that this member completed a task. Clears stall report. */
+  recordTaskComplete(sessionId: string): void {
+    this.lastTaskAt.set(sessionId, Date.now())
+    this.clearReport(sessionId)
+  }
+
+  /** Token-based stall: last `minSteps` steps all produced < `threshold` output tokens. */
+  isTokenStalled(sessionId: string, minSteps: number, threshold: number): boolean {
+    const records = this.steps.get(sessionId)
+    if (!records || records.length < minSteps) return false
+    const recent = records.slice(-minSteps)
+    return recent.every(r => r.outputTokens < threshold)
+  }
+
+  /** Time-based stall: no message or task completion within `thresholdMs` of now. */
+  isTimeStalled(sessionId: string, thresholdMs: number): boolean {
+    const records = this.steps.get(sessionId)
+    if (!records || records.length === 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
+  }
+
+  /** Mark this session as reported-stalled (avoid spam). */
+  markReported(sessionId: string): void {
+    this.reported.add(sessionId)
+  }
+
+  /** Check if already reported. */
+  isReported(sessionId: string): boolean {
+    return this.reported.has(sessionId)
+  }
+
+  /** Clear stall report (called on new activity). */
+  clearReport(sessionId: string): void {
+    this.reported.delete(sessionId)
+  }
+
+  /** Remove all tracking for a session (on shutdown). */
+  remove(sessionId: string): void {
+    this.steps.delete(sessionId)
+    this.lastMessageAt.delete(sessionId)
+    this.lastTaskAt.delete(sessionId)
+    this.reported.delete(sessionId)
+  }
+}

package/src/system-prompt.ts

@@ -1,6 +1,11 @@
 import type { Database } from "bun:sqlite"
 import { markDelivered } from "./messaging"
 
+/** Truncate a string to maxLen chars, appending "..." if truncated. */
+function truncate(s: string, maxLen: number): string {
+  return s.length > maxLen ? `${s.slice(0, maxLen)}...` : s
+}
+
 /** Status display mapping from DB status to human-readable label. */
 const STATUS_DISPLAY: Record<string, string> = {
   busy: "working",
@@ -51,6 +56,28 @@ export function buildLeadSystemPrompt(db: Database, teamId: string): string {
     `Tasks: ${completed} completed, ${inProgress} in progress, ${pending} pending`,
   ]
 
+  // Inline active and recently completed tasks
+  const activeTasks = db.query(
+    "SELECT content, assignee FROM team_task WHERE team_id = ? AND status = 'in_progress' ORDER BY time_updated DESC LIMIT 5"
+  ).all(teamId) as Array<{ content: string; assignee: string | null }>
+
+  const recentCompleted = db.query(
+    "SELECT content, assignee FROM team_task WHERE team_id = ? AND status = 'completed' ORDER BY time_updated DESC LIMIT 3"
+  ).all(teamId) as Array<{ content: string; assignee: string | null }>
+
+  if (activeTasks.length > 0) {
+    lines.push("Active tasks:")
+    for (const t of activeTasks) {
+      lines.push(`  [in_progress] ${truncate(t.content, 120)}${t.assignee ? ` → ${t.assignee}` : ""}`)
+    }
+  }
+  if (recentCompleted.length > 0) {
+    lines.push("Recently completed:")
+    for (const t of recentCompleted) {
+      lines.push(`  [completed] ${truncate(t.content, 120)}${t.assignee ? ` → ${t.assignee}` : ""}`)
+    }
+  }
+
   if (pendingMessages.length > 0) {
     lines.push("", "--- Team Messages ---")
     const MAX_MSG = 500
@@ -92,7 +119,7 @@ export function buildTeammateSystemPrompt(db: Database, teamId: string, memberNa
   const team = db.query("SELECT name FROM team WHERE id = ?").get(teamId) as { name: string } | null
   if (!team) return ""
 
-  return `You are "${memberName}", a teammate in team "${team.name}". Use team_message to communicate.`
+  return `You are "${memberName}", a teammate in team "${team.name}". Use team_message to communicate. You MUST send your results to the lead via team_message before stopping.`
 }
 
 /**
@@ -135,9 +162,48 @@ export function buildTeamCompactionContext(
     ? `Members: ${memberList}`
     : "Members: none"
 
-  return [
+  const lines = [
     roleLine,
     membersLine,
     `Tasks: ${completed} completed, ${inProgress} in progress, ${pending} pending`,
-  ].join("\n")
+  ]
+
+  if (role === "member" && memberName) {
+    lines.push("IMPORTANT: You MUST send your results to the lead via team_message before stopping.")
+
+    // Include original task prompt
+    const member = db.query("SELECT prompt FROM team_member WHERE team_id = ? AND name = ?")
+      .get(teamId, memberName) as { prompt: string | null } | null
+    if (member?.prompt) {
+      lines.push(`Your original task: ${truncate(member.prompt, 300)}`)
+    }
+
+    // Include recent messages involving this member
+    const recentMsgs = db.query(
+      "SELECT from_name, content FROM team_message WHERE team_id = ? AND (from_name = ? OR to_name = ?) ORDER BY time_created DESC LIMIT 3"
+    ).all(teamId, memberName, memberName) as Array<{ from_name: string; content: string }>
+    if (recentMsgs.length > 0) {
+      lines.push("Recent context:")
+      for (const msg of recentMsgs) {
+        lines.push(`  [${msg.from_name}]: ${truncate(msg.content, 200)}`)
+      }
+    }
+  } else if (role === "member") {
+    lines.push("IMPORTANT: You MUST send your results to the lead via team_message before stopping.")
+  }
+
+  if (role === "lead") {
+    // Include recently completed tasks
+    const completedTasks = db.query(
+      "SELECT content, assignee FROM team_task WHERE team_id = ? AND status = 'completed' ORDER BY time_updated DESC LIMIT 5"
+    ).all(teamId) as Array<{ content: string; assignee: string | null }>
+    if (completedTasks.length > 0) {
+      lines.push("Recently completed:")
+      for (const t of completedTasks) {
+        lines.push(`  [completed] ${truncate(t.content, 120)}${t.assignee ? ` (by ${t.assignee})` : ""}`)
+      }
+    }
+  }
+
+  return lines.join("\n")
 }

package/src/tools/team-cleanup.ts

@@ -1,8 +1,64 @@
 import type { ToolDeps } from "../types"
 import { requireLead, checkWorktreeDirty } from "./shared"
 import type { IsDirtyFn } from "./shared"
+import { spawnFailures } from "./team-spawn"
 import { log } from "../log"
 
+/** Result of merging all branches. */
+export interface MergeAllResult {
+  merged: string[]
+  conflicted: string[]
+}
+
+/** Injectable function that merges all branches into the working directory. */
+export type MergeAllFn = (branches: string[], cwd: string) => Promise<MergeAllResult>
+
+/**
+ * Default merge implementation: stash user work, squash-merge each branch,
+ * unstage merged changes, restore user work. One stash/pop cycle for all branches.
+ */
+export async function mergeAllBranches(branches: string[], cwd: string): Promise<MergeAllResult> {
+  const merged: string[] = []
+  const conflicted: string[] = []
+
+  // Stash existing work to preserve staged/unstaged state
+  const stash = Bun.spawn(["git", "stash", "--include-untracked"], { cwd, stdout: "pipe", stderr: "pipe" })
+  const stashOut = await new Response(stash.stdout).text()
+  const stashExit = await stash.exited
+  const didStash = stashExit === 0 && !stashOut.includes("No local changes")
+
+  for (const branch of branches) {
+    const merge = Bun.spawn(["git", "merge", "--squash", branch], { cwd, stdout: "pipe", stderr: "pipe" })
+    const stderrPromise = new Response(merge.stderr).text()
+    const exit = await merge.exited
+    if (exit !== 0) {
+      const stderr = await stderrPromise
+      log(`cleanup:merge:conflict branch=${branch} err=${stderr.trim()}`)
+      const abort = Bun.spawn(["git", "merge", "--abort"], { cwd, stdout: "pipe", stderr: "pipe" })
+      await abort.exited
+      conflicted.push(branch)
+    } else {
+      const del = Bun.spawn(["git", "branch", "-D", branch], { cwd, stdout: "pipe", stderr: "pipe" })
+      await del.exited
+      merged.push(branch)
+    }
+  }
+
+  // Unstage merged changes so user reviews with `git diff`
+  if (merged.length > 0) {
+    const reset = Bun.spawn(["git", "reset", "HEAD"], { cwd, stdout: "pipe", stderr: "pipe" })
+    await reset.exited
+  }
+
+  // Restore user's original staged/unstaged work
+  if (didStash) {
+    const pop = Bun.spawn(["git", "stash", "pop", "--index"], { cwd, stdout: "pipe", stderr: "pipe" })
+    await pop.exited
+  }
+
+  return { merged, conflicted }
+}
+
 /**
  * Execute the team_cleanup tool. Archives the team and cleans up resources.
  * Checks for uncommitted changes BEFORE aborting sessions or removing worktrees.
@@ -14,6 +70,8 @@ export async function executeTeamCleanup(
   args: { force: boolean; acknowledge_uncommitted?: boolean },
   sessionId: string,
   isDirty: IsDirtyFn = checkWorktreeDirty,
+  mergeAll: MergeAllFn = mergeAllBranches,
+  mergeOnCleanup = true,
 ): Promise<string> {
   const teamInfo = requireLead(deps, sessionId)
 
@@ -57,8 +115,25 @@ export async function executeTeamCleanup(
     }
   }
 
-  // Remove workspaces, worktrees, and collect branches for merging
-  const branches: string[] = []
+  // Collect branches and merge BEFORE removing worktrees (worktree.remove may delete the branch ref)
+  const branches = members
+    .map(m => m.worktree_branch)
+    .filter((b): b is string => b !== null)
+
+  let mergeResult = ""
+  if (branches.length > 0 && mergeOnCleanup) {
+    const { merged, conflicted } = await mergeAll(branches, deps.directory)
+    const parts: string[] = []
+    if (merged.length > 0) {
+      parts.push(`Merged ${merged.length} branch(es) into working directory (unstaged). Review changes with: git diff`)
+    }
+    if (conflicted.length > 0) {
+      parts.push(`Could not auto-merge: ${conflicted.join(", ")}. Merge manually with: git merge <branch>`)
+    }
+    mergeResult = parts.join("\n")
+  }
+
+  // Remove workspaces and worktrees (after merging)
   for (const member of members) {
     if (member.workspace_id) {
       try {
@@ -72,16 +147,18 @@ export async function executeTeamCleanup(
         deps.db.run("UPDATE team_member SET worktree_dir = NULL WHERE team_id = ? AND name = ?", [teamInfo.teamId, member.name])
       } catch { /* best effort — worktree may already be gone */ }
     }
-    if (member.worktree_branch) {
-      branches.push(member.worktree_branch)
-    }
   }
 
   // Archive team
   deps.db.run("UPDATE team SET status = 'archived', time_updated = ? WHERE id = ?", [Date.now(), teamInfo.teamId])
 
-  // Clean up registry
+  // Clean up in-memory state
   deps.registry.unregisterTeam(teamInfo.teamId)
+  spawnFailures.delete(teamInfo.teamId)
+
+  if (mergeResult) {
+    return `Team "${teamInfo.teamName}" cleaned up.\n${mergeResult}`
+  }
 
   if (branches.length > 0) {
     const mergeCommands = branches.map(b => `  git merge ${b}`).join("\n")

package/src/tools/team-spawn.ts

@@ -4,6 +4,9 @@ import { requireLead } from "./shared"
 import { sendMessage } from "../messaging"
 import { log } from "../log"
 
+/** Tracks consecutive spawn failures per team for circuit breaker. */
+export const spawnFailures = new Map<string, { count: number; lastError: string }>()
+
 /** Timeout for worktree.create and session.create to prevent hanging on git lock contention. */
 function getSpawnTimeout(): number {
   return Number(process.env.SPAWN_TIMEOUT_MS) || 120_000
@@ -41,6 +44,12 @@ export async function executeTeamSpawn(
 
   const teamInfo = requireLead(deps, sessionId)
 
+  // Circuit breaker — stop retrying after 3 consecutive failures
+  const failures = spawnFailures.get(teamInfo.teamId)
+  if (failures && failures.count >= 3) {
+    throw new Error(`Spawn circuit breaker tripped for team "${teamInfo.teamName}": 3 consecutive failures. Last error: ${failures.lastError}. Investigate before retrying — the circuit breaker resets on the next successful spawn.`)
+  }
+
   // Check duplicate name
   const existing = deps.db.query("SELECT name FROM team_member WHERE team_id = ? AND name = ?")
     .get(teamInfo.teamId, args.name)
@@ -146,6 +155,10 @@ export async function executeTeamSpawn(
     log(`spawn:session:done name=${args.name} sessionId=${childSessionId}`)
   } catch (err) {
     log(`spawn:session:failed name=${args.name} err=${err instanceof Error ? err.message : String(err)}`)
+    // Track failure for circuit breaker
+    const errMsg = err instanceof Error ? err.message : String(err)
+    const prev = spawnFailures.get(teamInfo.teamId)
+    spawnFailures.set(teamInfo.teamId, { count: (prev?.count ?? 0) + 1, lastError: errMsg })
     // Rollback workspace and worktree if session creation failed
     if (workspaceId) {
       try { await deps.client.workspace.remove({ id: workspaceId }) } catch { /* best effort */ }
@@ -319,6 +332,8 @@ export async function executeTeamSpawn(
 
   const branchInfo = worktreeBranch ? ` (branch: ${worktreeBranch})` : ""
   const planInfo = usePlanApproval ? " [plan mode — will send plan for approval]" : ""
+  // Reset circuit breaker on success
+  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 ? "..." : ""}`
 }

package/src/tools/team-status.ts

@@ -6,6 +6,13 @@ export const lastCallTime = new Map<string, number>()
 
 const RATE_LIMIT_MS = 30_000
 
+/** Format a duration in ms to a human-readable string. */
+export function formatDuration(ms: number): string {
+  if (ms < 60_000) return `${Math.floor(ms / 1000)}s`
+  if (ms < 3_600_000) return `${Math.floor(ms / 60_000)}m`
+  return `${Math.floor(ms / 3_600_000)}h`
+}
+
 /**
  * Execute the team_status tool. Shows team overview with member statuses and task summary.
  */
@@ -23,9 +30,9 @@ export async function executeTeamStatus(
   lastCallTime.set(teamInfo.teamId, now)
 
   const members = deps.db.query(
-    "SELECT name, session_id, agent, status, execution_status, worktree_branch, worktree_dir, plan_approval FROM team_member WHERE team_id = ? ORDER BY time_created ASC"
+    "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) as Array<{
-    name: string; session_id: string; agent: string; status: string; execution_status: string; worktree_branch: string | null; worktree_dir: string | null; plan_approval: string
+    name: string; session_id: string; agent: string; status: string; execution_status: string; worktree_branch: string | null; worktree_dir: string | null; plan_approval: string; time_updated: number
   }>
 
   const tasks = deps.db.query(
@@ -42,9 +49,24 @@ export async function executeTeamStatus(
     lines.push("Members:")
     for (const m of members) {
       const statusIcon = m.status === "busy" ? "working" : m.status === "ready" ? "idle" : m.status
+      const duration = formatDuration(now - m.time_updated)
       const branch = m.worktree_branch ? `  branch: ${m.worktree_branch}` : ""
       const plan = m.plan_approval !== "none" ? `, plan: ${m.plan_approval}` : ""
-      lines.push(`  ${m.name}  [${statusIcon}${plan}]  agent: ${m.agent}${branch}  session: ${m.session_id}`)
+
+      // Last message time
+      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) as { last_msg: number | null } | null
+      const msgInfo = lastMsg?.last_msg ? `last msg: ${formatDuration(now - lastMsg.last_msg)} ago` : "no messages yet"
+
+      lines.push(`  ${m.name}  [${statusIcon} ${duration}, ${msgInfo}${plan}]  agent: ${m.agent}${branch}`)
+
+      // Current task
+      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) as { content: string } | null
+      if (task) {
+        const truncated = task.content.length > 80 ? `${task.content.slice(0, 80)}...` : task.content
+        lines.push(`    task: ${truncated}`)
+      }
       if (m.worktree_dir) {
         lines.push(`    worktree: ${m.worktree_dir}`)
       }

package/src/watchdog.ts

@@ -1,6 +1,8 @@
 import type { Database } from "bun:sqlite"
 import type { PluginClient } from "./types"
 import type { MemberRegistry } from "./state"
+import type { ProgressTracker } from "./progress"
+import { sendMessage } from "./messaging"
 
 interface WatchdogOpts {
   db: Database
@@ -10,6 +12,14 @@ interface WatchdogOpts {
   ttlMs: number
   /** How often to run the check. Defaults to 60s. */
   checkIntervalMs?: number
+  /** Progress tracker for stall detection. */
+  progressTracker?: ProgressTracker
+  /** Stall detection threshold in ms. 0 disables. */
+  stallThresholdMs?: number
+  /** Min steps before token-based stall check. */
+  stallMinSteps?: number
+  /** Output token threshold for stall detection. */
+  stallTokenThreshold?: number
 }
 
 /**
@@ -22,6 +32,10 @@ export class Watchdog {
   private readonly registry: MemberRegistry
   private readonly ttlMs: number
   private readonly checkIntervalMs: number
+  private readonly progressTracker?: ProgressTracker
+  private readonly stallThresholdMs: number
+  private readonly stallMinSteps: number
+  private readonly stallTokenThreshold: number
   private timer: ReturnType<typeof setInterval> | undefined
 
   constructor(opts: WatchdogOpts) {
@@ -30,6 +44,10 @@ export class Watchdog {
     this.registry = opts.registry
     this.ttlMs = opts.ttlMs
     this.checkIntervalMs = opts.checkIntervalMs ?? 60_000
+    this.progressTracker = opts.progressTracker
+    this.stallThresholdMs = opts.stallThresholdMs ?? 0
+    this.stallMinSteps = opts.stallMinSteps ?? 3
+    this.stallTokenThreshold = opts.stallTokenThreshold ?? 500
   }
 
   private static STALE_THRESHOLD_MS = Number(process.env.STALE_WORKTREE_THRESHOLD_MS) || 300_000
@@ -61,9 +79,58 @@ export class Watchdog {
     }
   }
 
+  /** Check for stalled busy members and escalate to lead + nudge teammate. */
+  async checkStalled(): Promise<void> {
+    if (!this.progressTracker || this.stallThresholdMs === 0) return
+
+    const busy = this.db.query(
+      `SELECT tm.team_id, tm.name, tm.session_id
+       FROM team_member tm
+       JOIN team t ON tm.team_id = t.id
+       WHERE t.status = 'active' AND tm.status = 'busy'`
+    ).all() as Array<{ team_id: string; name: string; session_id: string }>
+
+    for (const member of busy) {
+      if (this.progressTracker.isReported(member.session_id)) continue
+
+      const tokenStalled = this.progressTracker.isTokenStalled(member.session_id, this.stallMinSteps, this.stallTokenThreshold)
+      const timeStalled = this.progressTracker.isTimeStalled(member.session_id, this.stallThresholdMs)
+
+      if (!tokenStalled && !timeStalled) continue
+
+      this.progressTracker.markReported(member.session_id)
+      const reason = tokenStalled ? "low output tokens" : "no communication"
+
+      // Nudge the teammate directly
+      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(() => { /* best effort */ })
+
+      // Notify the lead
+      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.`,
+      })
+
+      // Toast for the user
+      try {
+        await this.client.tui.showToast({
+          title: "Team",
+          message: `${member.name} appears stalled`,
+          variant: "warning",
+          duration: 5000,
+        })
+      } catch { /* TUI may not be available */ }
+    }
+  }
+
   /** Run a single check for stale busy members. */
   async check(): Promise<void> {
     await this.cleanupStaleWorktrees()
+    await this.checkStalled()
     if (this.ttlMs === 0) return
 
     const cutoff = Date.now() - this.ttlMs