@hueyexe/opencode-ensemble 0.18.0 → 0.21.0

package/src/messaging.ts

@@ -62,11 +62,13 @@ export function broadcastMessage(db: Database, input: BroadcastMessageInput): st
 }
 
 /**
- * Get all undelivered messages for a team.
+ * Get all undelivered messages for a team. Messages already read via
+ * team_results are excluded — re-injecting or re-sending them would duplicate
+ * content the recipient has already seen.
  */
 export function getUndeliveredMessages(db: Database, teamId: string): MessageRow[] {
   return db.query(
-    "SELECT * FROM team_message WHERE team_id = ? AND delivered = 0 ORDER BY time_created ASC"
+    "SELECT * FROM team_message WHERE team_id = ? AND read = 0 AND delivered = 0 ORDER BY time_created ASC"
   ).all(teamId) as MessageRow[]
 }
 

package/src/notify.ts

@@ -1,6 +1,7 @@
 import type { Database } from "./db"
 import type { PluginClient } from "./types"
 import { sendMessage } from "./messaging"
+import { wakeLeadIfPending } from "./wake"
 import { log } from "./log"
 
 type TeamEventType = "spawn" | "message" | "completed" | "error" | "shutdown"
@@ -90,16 +91,14 @@ export async function notifyWorkingProgress(
  * so the message is delivered on the lead's next turn.
  *
  * This is the delivery path for system events (teammate errors, timeouts,
- * stalls, spawn failures). Unlike the passive wake-lead path in the event
- * hook, this ALWAYS fires a promptAsync regardless of whether teammates are
- * still busy — an errored/aborted teammate is precisely the case where the
- * "all teammates done" gate would otherwise suppress the wake and strand the
- * message in the DB with delivered=0.
+ * stalls, spawn failures). The wake is forced past the busy check and the
+ * coalescing cooldown so an errored/aborted teammate is not stranded while
+ * the lead is working; the wake itself is still guarded against
+ * archived/purged teams (#48, #57).
  *
- * The message is persisted first; the promptAsync wake is fire-and-forget
- * (never awaited, per the plugin's promptAsync invariant). If the wake fails,
- * the message is still in the DB and the passive backstop / recovery paths
- * remain available.
+ * The message is persisted first; the wake is fire-and-forget (never awaited,
+ * per the plugin's promptAsync invariant). If the wake fails, the message is
+ * still in the DB and the passive backstop / recovery paths remain available.
  *
  * Returns the persisted message id.
  */
@@ -111,18 +110,10 @@ export function notifyLead(
 ): string {
   const id = sendMessage(db, { teamId, from: "system", to: "lead", content })
 
-  const team = db.query("SELECT lead_session_id FROM team WHERE id = ?")
-    .get(teamId) as { lead_session_id: string } | null
-  if (!team?.lead_session_id) return id
-
   // Fire-and-forget wake — the system prompt transform delivers the actual
   // content on the lead's next turn. Synthetic: renders as a persistent
   // system entry, not a fake user turn.
-  client.session.promptAsync({
-    sessionID: team.lead_session_id,
-    parts: [{ type: "text", text: "[System: New team message from system]" }],
-    synthetic: true,
-  }).catch((err) => {
+  wakeLeadIfPending(client, db, teamId, { force: true }).catch((err) => {
     log(`notifyLead:wake:failed team=${teamId} err=${err instanceof Error ? err.message : String(err)}`)
   })
 

package/src/recovery.ts

@@ -192,20 +192,25 @@ export async function recoverOrphanedWorktrees(db: Database, client: PluginClien
 }
 
 /**
- * Redeliver undelivered messages (delivered=0) via promptAsync.
+ * Schedule redelivery of undelivered messages (delivered=0) via promptAsync.
  * Resolves recipient session IDs from the member registry or team lead.
- * Continues on partial failure — logs but doesn't abort.
+ *
+ * Delivery is fire-and-forget: promptAsync is never awaited (AGENTS.md
+ * invariant), so a slow or broken transport cannot block recovery/init.
+ * Messages are marked delivered only after promptAsync resolves; failures
+ * leave them undelivered for the next recovery pass. The returned count is
+ * the number of deliveries scheduled, not confirmed.
  */
 export async function recoverUndeliveredMessages(
   db: Database,
   client: PluginClient,
   registry: MemberRegistry,
-): Promise<{ redelivered: number }> {
+): Promise<{ scheduled: number }> {
   // Get all active teams
   const teams = db.query("SELECT id, lead_session_id FROM team WHERE status = 'active'")
     .all() as Array<{ id: string; lead_session_id: string }>
 
-  let redelivered = 0
+  let scheduled = 0
 
   for (const team of teams) {
     const messages = getUndeliveredMessages(db, team.id)
@@ -233,22 +238,24 @@ export async function recoverUndeliveredMessages(
         continue
       }
 
-      try {
-        const recipientModel = getMemberModel(db, team.id, msg.to_name)
-        await client.session.promptAsync({
-          sessionID: recipientSessionId,
-          parts: [{ type: "text", text: `[Recovered team message from ${msg.from_name}]: ${msg.content}` }],
-          ...(recipientModel ? { model: recipientModel } : {}),
-        })
+      const recipientModel = getMemberModel(db, team.id, msg.to_name)
+      // Fire-and-forget, NOT awaited: recovery must not block on transport.
+      // Mark delivered only on success; failures stay undelivered for the
+      // next recovery pass.
+      client.session.promptAsync({
+        sessionID: recipientSessionId,
+        parts: [{ type: "text", text: `[Recovered team message from ${msg.from_name}]: ${msg.content}` }],
+        ...(recipientModel ? { model: recipientModel } : {}),
+      }).then(() => {
         markDelivered(db, msg.id)
-        redelivered++
-      } catch {
-        // Continue on failure — message stays undelivered for next recovery
-      }
+      }).catch((err) => {
+        log(`recovery:redeliver:failed team=${team.id} msg=${msg.id} err=${err instanceof Error ? err.message : String(err)}`)
+      })
+      scheduled++
     }
   }
 
-  return { redelivered }
+  return { scheduled }
 }
 
 /**

package/src/schema.ts

@@ -204,6 +204,10 @@ export const MIGRATIONS: string[] = [
    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;`,
+  // Migration 11: Persist the last lead-wake time on the team. Worktree
+  // teammate instances share the SQLite file but not module state, so an
+  // in-memory cooldown cannot coalesce wakes across instances (issue #57).
+  `ALTER TABLE team ADD COLUMN last_wake_at INTEGER NOT NULL DEFAULT 0;`,
 ]
 
 /**

package/src/system-prompt.ts

@@ -49,54 +49,72 @@ export function buildLeadSystemPrompt(db: Database, teamId: string, config?: Req
     : "Teammates: none"
 
   const pendingMessages = db.query(
-    "SELECT id, from_name, content FROM team_message WHERE team_id = ? AND to_name = 'lead' AND delivered = 0 ORDER BY time_created ASC"
+    "SELECT id, from_name, content FROM team_message WHERE team_id = ? AND to_name = 'lead' AND read = 0 AND delivered = 0 ORDER BY time_created ASC"
   ).all(teamId) as Array<{ id: string; from_name: string; content: string }>
 
-  const lines = [
-    `You are leading team "${team.name}" with ${members.length} active teammates.`,
-    teammateLine,
-    `Tasks: ${completed} completed, ${inProgress} in progress, ${pending} pending`,
-  ]
+  const teamStateMode = config?.systemPromptTeamState ?? "full"
+  const lines: string[] = []
+
+  if (teamStateMode === "off") {
+    // Stable role line only. Everything else in this block would churn on
+    // status/task/message changes and invalidate the provider prefix cache.
+    lines.push(`You are leading team "${team.name}".`)
+  } else {
+    lines.push(
+      `You are leading team "${team.name}" with ${members.length} active teammates.`,
+      teammateLine,
+      `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 }>
+    // 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 }>
+    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 (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 (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
-    for (const msg of pendingMessages) {
-      const parsed = parseTaskResult(msg.content)
-      if (parsed) {
-        // Truncate details for system prompt — full content available via team_results
-        const truncatedResult = { ...parsed, details: truncate(parsed.details, 500) }
-        lines.push(formatTaskResult(msg.from_name, truncatedResult))
-      } else if (msg.content.length > MAX_MSG) {
-        lines.push(`[From ${msg.from_name}]: ${msg.content.slice(0, MAX_MSG)}... (use team_results to read full message)`)
-      } else {
-        lines.push(`[From ${msg.from_name}]: ${msg.content}`)
+    if (teamStateMode === "full") {
+      lines.push("", "--- Team Messages ---")
+      const MAX_MSG = 500
+      for (const msg of pendingMessages) {
+        const parsed = parseTaskResult(msg.content)
+        if (parsed) {
+          // Truncate details for system prompt — full content available via team_results
+          const truncatedResult = { ...parsed, details: truncate(parsed.details, 500) }
+          lines.push(formatTaskResult(msg.from_name, truncatedResult))
+        } else if (msg.content.length > MAX_MSG) {
+          lines.push(`[From ${msg.from_name}]: ${msg.content.slice(0, MAX_MSG)}... (use team_results to read full message)`)
+        } else {
+          lines.push(`[From ${msg.from_name}]: ${msg.content}`)
+        }
       }
-      markDelivered(db, msg.id)
+      lines.push("--- End Messages ---")
+    } else {
+      // state-only and off both surface the count (not the payload) so a
+      // message arriving mid-turn cannot be silently consumed by the transform.
+      lines.push("", `Unread messages: ${pendingMessages.length} — use team_results to read them.`)
     }
-    lines.push("--- End Messages ---")
+    // Mark delivered in every mode so the wake path does not re-fire for
+    // content the lead has already been told about. team_results still
+    // returns these until they are read.
+    for (const msg of pendingMessages) markDelivered(db, msg.id)
   }
 
   // Model selection guidance (only when promptForModels is enabled)
@@ -140,6 +158,7 @@ export function buildLeadSystemPrompt(db: Database, teamId: string, config?: Req
     "",
     "Teammates work asynchronously and message you when done.",
     "Do NOT poll team_status or team_tasks_list repeatedly — wait for messages.",
+    "When woken about new team messages, call team_results to read them.",
     "After spawning all teammates, tell the user what you've set up and wait.",
     "When all teammates finish, summarize results and suggest next steps.",
     "",
@@ -166,34 +185,44 @@ export function buildLeadSystemPrompt(db: Database, teamId: string, config?: Req
  * Build the system prompt injected into a teammate's session.
  * Includes role reminder and delivers any pending peer messages.
  */
-export function buildTeammateSystemPrompt(db: Database, teamId: string, memberName: string): string {
+export function buildTeammateSystemPrompt(
+  db: Database,
+  teamId: string,
+  memberName: string,
+  config?: Required<EnsembleConfig>,
+): string {
   const team = db.query("SELECT name FROM team WHERE id = ?").get(teamId) as { name: string } | null
   if (!team) return ""
 
+  const teamStateMode = config?.systemPromptTeamState ?? "full"
   const lines = [
     `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.`,
   ]
 
   // Deliver pending peer messages addressed to this teammate
   const pendingMessages = db.query(
-    "SELECT id, from_name, content FROM team_message WHERE team_id = ? AND to_name = ? AND delivered = 0 ORDER BY time_created ASC"
+    "SELECT id, from_name, content FROM team_message WHERE team_id = ? AND to_name = ? AND read = 0 AND delivered = 0 ORDER BY time_created ASC"
   ).all(teamId, memberName) as Array<{ id: string; from_name: string; content: string }>
 
   if (pendingMessages.length > 0) {
-    lines.push("", "--- Messages for you ---")
-    const MAX_MSG = 500
-    for (const msg of pendingMessages) {
-      const parsed = parseTaskResult(msg.content)
-      if (parsed) {
-        lines.push(formatTaskResult(msg.from_name, { ...parsed, details: truncate(parsed.details, MAX_MSG) }))
-      } else if (msg.content.length > MAX_MSG) {
-        lines.push(`[From ${msg.from_name}]: ${msg.content.slice(0, MAX_MSG)}... (truncated)`)
-      } else {
-        lines.push(`[From ${msg.from_name}]: ${msg.content}`)
+    if (teamStateMode === "full") {
+      lines.push("", "--- Messages for you ---")
+      const MAX_MSG = 500
+      for (const msg of pendingMessages) {
+        const parsed = parseTaskResult(msg.content)
+        if (parsed) {
+          lines.push(formatTaskResult(msg.from_name, { ...parsed, details: truncate(parsed.details, MAX_MSG) }))
+        } else if (msg.content.length > MAX_MSG) {
+          lines.push(`[From ${msg.from_name}]: ${msg.content.slice(0, MAX_MSG)}... (truncated)`)
+        } else {
+          lines.push(`[From ${msg.from_name}]: ${msg.content}`)
+        }
       }
-      markDelivered(db, msg.id)
+      lines.push("--- End Messages ---")
+    } else {
+      lines.push("", `Unread messages: ${pendingMessages.length} — use team_results to read them.`)
     }
-    lines.push("--- End Messages ---")
+    for (const msg of pendingMessages) markDelivered(db, msg.id)
   }
 
   return lines.join("\n")

package/src/task-graph.ts

@@ -0,0 +1,116 @@
+/** A task node as needed for dependency graph inspection. */
+export interface TaskGraphNode {
+  id: string
+  status: string
+  dependsOn: string[]
+}
+
+/** Result of inspecting a team's task dependency graph. */
+export interface TaskGraphInfo {
+  /** Longest-prerequisite-path depth per task (roots are 1). */
+  depthByTask: Map<string, number>
+  /** Tasks that are part of a dependency cycle. */
+  cyclic: string[]
+  /** Dependency IDs that do not resolve to a task in the graph. */
+  missing: string[]
+}
+
+/**
+ * Parse a `depends_on` column into a deduplicated list of task IDs.
+ * Tolerates malformed/legacy values instead of throwing, so one bad row
+ * cannot break task completion or graph rendering.
+ */
+export function parseTaskDependencies(value: string | null): string[] {
+  if (!value) return []
+  try {
+    const parsed: unknown = JSON.parse(value)
+    if (Array.isArray(parsed)) {
+      return [...new Set(parsed.filter((item): item is string => typeof item === "string" && item.length > 0))]
+    }
+    if (typeof parsed === "string" && parsed.length > 0) return [parsed]
+  } catch {
+    // Legacy/hand-edited plain string.
+    return [value]
+  }
+  return []
+}
+
+/** Options for graph inspection. */
+export interface TaskGraphOptions {
+  /**
+   * Ignore edges whose prerequisite is already completed/cancelled. Use this
+   * for depth-limit enforcement so finished work does not accumulate into a
+   * lifetime chain that blocks follow-up tasks.
+   */
+  activeOnly?: boolean
+}
+
+/**
+ * Inspect a task graph. Depth is the longest prerequisite path, with roots at
+ * 1 (a four-task chain has depth 4). Cyclic/cycle-affected tasks are reported
+ * and omitted from depthByTask so callers can reject additions that would
+ * build on corrupt data.
+ */
+export function inspectTaskGraph(tasks: TaskGraphNode[], options: TaskGraphOptions = {}): TaskGraphInfo {
+  const byId = new Map(tasks.map(task => [task.id, task]))
+  const deps = new Map<string, string[]>()
+  const children = new Map<string, string[]>()
+  const indegree = new Map<string, number>()
+  const missing = new Set<string>()
+
+  tasks.forEach(task => {
+    children.set(task.id, [])
+    indegree.set(task.id, 0)
+  })
+
+  tasks.forEach(task => {
+    const valid: string[] = []
+    for (const depId of task.dependsOn) {
+      const dependency = byId.get(depId)
+      if (!dependency) {
+        missing.add(depId)
+        continue
+      }
+      if (options.activeOnly && (dependency.status === "completed" || dependency.status === "cancelled")) continue
+      if (valid.includes(depId)) continue
+      valid.push(depId)
+      children.get(depId)?.push(task.id)
+    }
+    deps.set(task.id, valid)
+    indegree.set(task.id, valid.length)
+  })
+
+  const queue = tasks.filter(task => indegree.get(task.id) === 0).map(task => task.id)
+  const depthByTask = new Map<string, number>()
+  let head = 0
+  while (head < queue.length) {
+    const id = queue[head]
+    head++
+    if (!id) continue
+    const task = byId.get(id)
+    const parents = deps.get(id) ?? []
+    const resolved = options.activeOnly && (task?.status === "completed" || task?.status === "cancelled")
+    depthByTask.set(
+      id,
+      resolved
+        ? 0
+        : parents.length === 0
+          ? 1
+          : Math.max(...parents.map(parent => depthByTask.get(parent) ?? 1)) + 1,
+    )
+    for (const child of children.get(id) ?? []) {
+      const next = (indegree.get(child) ?? 1) - 1
+      indegree.set(child, next)
+      if (next === 0) queue.push(child)
+    }
+  }
+
+  const cyclic = tasks.filter(task => !depthByTask.has(task.id)).map(task => task.id)
+  return { depthByTask, cyclic, missing: [...missing] }
+}
+
+/** Depth a new task would have if it depended on `dependencyIds`. */
+export function depthForDependencies(dependencyIds: string[], graph: TaskGraphInfo): number {
+  if (dependencyIds.length === 0) return 1
+  return Math.max(...dependencyIds.map(id => graph.depthByTask.get(id) ?? 1)) + 1
+}

package/src/tool-arg-hint.ts

@@ -0,0 +1,71 @@
+/**
+ * Weak-model tool-argument fumble detection and error hints (issue #39).
+ *
+ * Some models trained on other harness conventions call OpenCode's built-in
+ * tools with aliased parameter names (e.g. `cmd` instead of the `shell`
+ * tool's `command`). OpenCode V2 rejects the call with a generic validation
+ * error that the model may fail to act on. This module detects that exact
+ * dead-call shape and produces an explicit hint appended to the error so
+ * the model can self-correct. Arguments are never rewritten — the model
+ * stays in the correction loop.
+ *
+ * V2 only: on V1, argument validation happens at the model-stream parse
+ * level, so tool hooks never see the failed call (see issue #39 triage).
+ */
+
+/**
+ * Canonical parameter plus the aliases weak models emit for it. Only the
+ * confirmed failure mode is listed; extend per-tool as reports come in.
+ */
+const ARG_ALIASES: Readonly<Record<string, { param: string; aliases: readonly string[] }>> = {
+  shell: { param: "command", aliases: ["cmd", "bash", "script"] },
+}
+
+/**
+ * Return the alias a weak model used instead of the tool's canonical
+ * parameter, or null when the input is not a recognized fumble. A fumble is
+ * only recognized when the canonical parameter is absent and a known alias
+ * is present as a non-empty string — i.e. only on calls that are already
+ * guaranteed to fail validation.
+ */
+export function detectArgFumble(tool: string, input: unknown): string | null {
+  const entry = ARG_ALIASES[tool]
+  if (!entry) return null
+  if (input === null || typeof input !== "object" || Array.isArray(input)) return null
+  const args = input as Record<string, unknown>
+  if (entry.param in args) return null
+  for (const alias of entry.aliases) {
+    const value = args[alias]
+    if (typeof value === "string" && value !== "") return alias
+  }
+  return null
+}
+
+/**
+ * Build the hint text for a fumbled tool call, or null when the input is
+ * not a recognized fumble.
+ */
+export function buildArgHint(tool: string, input: unknown): string | null {
+  const entry = ARG_ALIASES[tool]
+  if (!entry) return null
+  const alias = detectArgFumble(tool, input)
+  if (!alias) return null
+  return (
+    `Hint: the "${tool}" tool has no "${alias}" parameter. The correct parameter ` +
+    `name is "${entry.param}" — call the tool again with the same arguments, ` +
+    `moving the "${alias}" value into "${entry.param}".`
+  )
+}
+
+/**
+ * Append the fumble hint to a failed tool call's error message in place.
+ * Returns true when the message was modified. Never throws — a malformed
+ * error or input leaves the original message untouched.
+ */
+export function enrichToolError(tool: string, error: { message?: unknown }, input: unknown): boolean {
+  if (typeof error.message !== "string") return false
+  const hint = buildArgHint(tool, input)
+  if (!hint) return false
+  error.message = `${error.message}\n\n${hint}`
+  return true
+}

package/src/tools/team-broadcast.ts

@@ -1,6 +1,7 @@
 import type { ToolDeps } from "../types"
 import { requireTeamMember } from "./shared"
 import { broadcastMessage, markDelivered, hasReportedCompletion } from "../messaging"
+import { getSessionSelection } from "../member-model"
 import { log } from "../log"
 
 /**
@@ -24,11 +25,19 @@ export async function executeTeamBroadcast(
   // Collect all recipient session IDs (excluding sender)
   const recipients: Array<{ name: string; sessionId: string }> = []
 
-  // Add lead if sender is not lead
+  // Add lead if sender is not lead. Resolve from the DB fresh: the team may
+  // have been archived since requireTeamMember() ran.
+  let leadSelection: Awaited<ReturnType<typeof getSessionSelection>> = {}
   if (teamInfo.role !== "lead") {
-    const leadSession = deps.db.query("SELECT lead_session_id FROM team WHERE id = ?")
+    const leadSession = deps.db.query("SELECT lead_session_id FROM team WHERE id = ? AND status = 'active'")
       .get(teamInfo.teamId) as { lead_session_id: string } | null
-    if (leadSession) recipients.push({ name: "lead", sessionId: leadSession.lead_session_id })
+    if (leadSession?.lead_session_id) {
+      recipients.push({ name: "lead", sessionId: leadSession.lead_session_id })
+      // V1 broadcasts are normal user turns; preserve the lead's agent/model (#37).
+      if (!deps.client.agent) {
+        leadSelection = await getSessionSelection(deps.client, leadSession.lead_session_id).catch(() => ({}))
+      }
+    }
   }
 
   // Add all members except sender
@@ -48,9 +57,18 @@ export async function executeTeamBroadcast(
       skipped++
       continue
     }
+    if (recipient.name === "lead") {
+      const active = deps.db.query("SELECT 1 FROM team WHERE id = ? AND status = 'active'").get(teamInfo.teamId)
+      if (!active) {
+        skipped++
+        continue
+      }
+    }
     deps.client.session.promptAsync({
       sessionID: recipient.sessionId,
       parts: [{ type: "text", text: `[Team broadcast from ${senderName}]: ${args.text}` }],
+      ...(recipient.name === "lead" && leadSelection.agent ? { agent: leadSelection.agent } : {}),
+      ...(recipient.name === "lead" && leadSelection.model ? { model: leadSelection.model } : {}),
     }).then(() => {
       delivered++
       if (delivered === 1) markDelivered(deps.db, msgId)

package/src/tools/team-message.ts

@@ -3,6 +3,7 @@ import { resolveRecipientSession } from "../types"
 import { requireTeamMember } from "./shared"
 import { sendMessage, markDelivered, hasReportedCompletion } from "../messaging"
 import { parseModelId, getMemberModel } from "../member-model"
+import { wakeLeadIfPending } from "../wake"
 import { log } from "../log"
 
 /**
@@ -122,11 +123,9 @@ export async function executeTeamMessage(
   // because session.idle events are scoped per-instance.
   if (isToLead) {
     log(`team_message:wake-lead from=${senderName} recipientSession=${recipientSessionId}`)
-    deps.client.session.promptAsync({
-      sessionID: recipientSessionId,
-      parts: [{ type: "text", text: `[System: New team message from ${senderName}]` }],
-      synthetic: true,
-    }).catch((err) => {
+    // Coalesced, guarded wake: skips when the team is gone or the lead has
+    // already drained the inbox, and never queues behind a busy lead (#48, #57).
+    wakeLeadIfPending(deps.client, deps.db, teamInfo.teamId).catch((err) => {
       log(`team_message:wake-lead:failed from=${senderName} err=${err instanceof Error ? err.message : String(err)}`)
     })
     return `Message sent to ${args.to}.`

package/src/tools/team-results.ts

@@ -11,8 +11,13 @@ interface UnreadMessageRow {
 }
 
 /**
- * Retrieve unread messages from the team message store.
+ * Retrieve unread messages from the caller's inbox.
  * Optionally filter by sender name. Marks returned messages as read.
+ *
+ * The query is recipient-scoped: a teammate calling team_results must not
+ * drain messages addressed to the lead (or to another teammate), or those
+ * messages would disappear from the recipient's system prompt and wake path.
+ * Broadcast rows (to_name IS NULL) are visible to every team member.
  */
 export async function executeTeamResults(
   deps: ToolDeps,
@@ -20,18 +25,23 @@ export async function executeTeamResults(
   sessionId: string,
 ): Promise<string> {
   const team = requireTeamMember(deps, sessionId)
+  const inbox = team.role === "lead" ? "lead" : (team.memberName ?? "")
 
   const rows = args.from
     ? (deps.db
         .query(
-          "SELECT id, from_name, content, time_created FROM team_message WHERE team_id = ? AND read = 0 AND from_name = ? ORDER BY time_created ASC",
+          `SELECT id, from_name, content, time_created FROM team_message
+           WHERE team_id = ? AND read = 0 AND (to_name = ? OR to_name IS NULL) AND from_name = ?
+           ORDER BY time_created ASC`,
         )
-        .all(team.teamId, args.from) as UnreadMessageRow[])
+        .all(team.teamId, inbox, args.from) as UnreadMessageRow[])
     : (deps.db
         .query(
-          "SELECT id, from_name, content, time_created FROM team_message WHERE team_id = ? AND read = 0 ORDER BY time_created ASC",
+          `SELECT id, from_name, content, time_created FROM team_message
+           WHERE team_id = ? AND read = 0 AND (to_name = ? OR to_name IS NULL)
+           ORDER BY time_created ASC`,
         )
-        .all(team.teamId) as UnreadMessageRow[])
+        .all(team.teamId, inbox) as UnreadMessageRow[])
 
   if (rows.length === 0) return "No unread messages."