@hueyexe/opencode-ensemble 0.16.0 → 0.17.0

package/src/tools/team-status.ts

@@ -4,8 +4,28 @@ import { requireTeamMember } from "./shared"
 /** Tracks the last time team_status was called per team ID (epoch ms). */
 export const lastCallTime = new Map<string, number>()
 
+/** Tracks the state marker (see computeStateMarker) observed at the last real read per team. */
+export const lastKnownState = new Map<string, number>()
+
 const RATE_LIMIT_MS = 30_000
 
+/**
+ * Cheap per-team "has anything changed" fingerprint — the max time_updated/time_created
+ * across the three tables team_status reports on. One MAX() query, no hashing: the
+ * throttle only needs to detect "something changed," not what, so this is deliberately
+ * the simplest sufficient version (see Fix 3 in the spec).
+ */
+function computeStateMarker(deps: ToolDeps, teamId: string): number {
+  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) as { marker: number | null } | null
+  return row?.marker ?? 0
+}
+
 /** 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`
@@ -24,15 +44,20 @@ export async function executeTeamStatus(
 
   const now = Date.now()
   const last = lastCallTime.get(teamInfo.teamId)
-  if (last !== undefined && (now - last) < RATE_LIMIT_MS) {
+  const currentMarker = computeStateMarker(deps, teamInfo.teamId)
+  // The 30s throttle's purpose is preventing hammering, not lying about state — only
+  // short-circuit when nothing has actually changed since the last real read.
+  if (last !== undefined && (now - last) < RATE_LIMIT_MS && lastKnownState.get(teamInfo.teamId) === currentMarker) {
     return "No changes since last check."
   }
   lastCallTime.set(teamInfo.teamId, now)
+  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 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, last_nudged_at, retry_until, retry_attempt 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; time_updated: number
+    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; last_nudged_at: number | null
+    retry_until: number | null; retry_attempt: number | null
   }>
 
   const tasks = deps.db.query(
@@ -52,13 +77,22 @@ export async function executeTeamStatus(
       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}` : ""
+      // Additive display-staleness annotation (Fix 1) — surfaces a soft stall-nudge
+      // without inventing a new status value. Annotates the existing status, doesn't
+      // replace it.
+      const nudged = m.last_nudged_at ? `, nudged ${formatDuration(now - m.last_nudged_at)} ago` : ""
+      // Additive provider-retry annotation (Fix 4) — derived at read time from the
+      // retry_until TTL (Fix 3), same annotation pattern as `nudged` above. Generic
+      // "retrying" label, no rate-limit-specific wording (Fix 2).
+      const isRetrying = m.retry_until !== null && m.retry_until > now
+      const retrying = isRetrying ? `, retrying (attempt ${m.retry_attempt}, ~${formatDuration(m.retry_until! - now)})` : ""
 
       // 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}`)
+      lines.push(`  ${m.name}  [${statusIcon} ${duration}, ${msgInfo}${plan}${nudged}${retrying}]  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")

package/src/tools/team-tasks-complete.ts

@@ -5,6 +5,12 @@ import { log } from "../log"
 /**
  * Execute the team_tasks_complete tool. Marks a task as completed
  * and unblocks any dependent tasks.
+ *
+ * Enforces task-board accuracy (issue #27):
+ * - Rejects completing an already-completed or cancelled task.
+ * - Rejects completing a blocked task (dependencies must resolve first).
+ * - Only the assignee (or the lead) may complete a claimed task.
+ * - Completing an unclaimed task attributes it to the caller atomically.
  */
 export async function executeTeamTasksComplete(
   deps: ToolDeps,
@@ -12,13 +18,31 @@ export async function executeTeamTasksComplete(
   sessionId: string,
 ): Promise<string> {
   const teamInfo = requireTeamMember(deps, sessionId)
+  const caller = 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) as Record<string, unknown> | null
+  const task = deps.db.query("SELECT id, content, status, assignee FROM team_task WHERE id = ? AND team_id = ?")
+    .get(args.task_id, teamInfo.teamId) as { id: string; content: string; status: string; assignee: string | null } | null
   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 {
+    // Attribute an unclaimed task to the caller so the board reflects who did it.
+    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`)
+    }
+  }
 
   // Unblock dependent tasks
   const allTasks = deps.db.query("SELECT id, depends_on, status FROM team_task WHERE team_id = ?")

package/src/types.ts

@@ -1,6 +1,7 @@
 import type { Database } from "./db"
 import type { MemberRegistry, DescendantTracker, PendingPurgeApprovals } from "./state"
 import type { EnsembleConfig } from "./config"
+import type { ProgressTracker } from "./progress"
 
 /**
  * Shared dependencies injected into every tool's execute function.
@@ -17,6 +18,8 @@ export interface ToolDeps {
   directory: string
   /** Plugin configuration. */
   config: Required<EnsembleConfig>
+  /** Stall/activity tracker — shared with the Watchdog. */
+  progressTracker: ProgressTracker
 }
 
 /** A single permission rule for session-level enforcement. */

package/src/watchdog.ts

@@ -3,7 +3,10 @@ import type { PluginClient } from "./types"
 import type { MemberRegistry } from "./state"
 import type { ProgressTracker } from "./progress"
 import { preserveBranch, preservedBranchName } from "./tools/merge-helper"
-import { sendMessage } from "./messaging"
+import { releaseMemberTasks } from "./tasks"
+import { hasReportedCompletion } from "./messaging"
+import { getMemberModel } from "./member-model"
+import { notifyLead } from "./notify"
 import { log } from "./log"
 
 interface WatchdogOpts {
@@ -112,22 +115,69 @@ export class Watchdog {
 
       if (!tokenStalled && !timeStalled) continue
 
-      this.progressTracker.markReported(member.session_id)
+      // hasReportedCompletion() is the documented invariant every promptAsync delivery
+      // path must honor (see hooks.ts:63). The in-memory isReported() check above only
+      // catches this watchdog's own prior nudges — it doesn't know if the member reported
+      // completion by some other path while still transiently 'busy' in the DB.
+      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"
 
-      // Nudge the teammate directly
+      // Re-nudge suppression: markReported is deferred until promptAsync delivery
+      // succeeds, so a persistently failing nudge (session deleted mid-run while the
+      // DB row stays busy, bad stored model) would otherwise re-fire this whole
+      // block on every tick — a fresh last_nudged_at write, lead wake, and toast
+      // forever. Skip while the previous nudge is recent AND the member has shown
+      // no activity since it; genuine activity after a nudge makes them eligible
+      // for a fresh evaluation (and a fresh stall verdict) immediately.
+      const recentNudgeRow = this.db.query(
+        "SELECT last_nudged_at FROM team_member WHERE team_id = ? AND name = ?"
+      ).get(member.team_id, member.name) as { last_nudged_at: number | null } | null
+      if (recentNudgeRow?.last_nudged_at) {
+        const nudgedAt = recentNudgeRow.last_nudged_at
+        // >= because Date.now() has ms resolution: activity recorded in the same
+        // tick as the nudge write must count as post-nudge, or a member that went
+        // idle, worked, and stalled again would stay suppressed forever.
+        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
+        }
+      }
+
+      // Additive display-staleness signal (does not change team_member.status) — lets
+      // the dashboard/team_status annotate "busy, nudged Xs ago" so a soft nudge is
+      // visible without inventing a new status value.
+      this.db.run(
+        "UPDATE team_member SET last_nudged_at = ? WHERE team_id = ? AND name = ?",
+        [Date.now(), member.team_id, member.name]
+      )
+
+      // Nudge the teammate directly. markReported() only fires once delivery is
+      // confirmed — marking it before delivery is known would permanently and silently
+      // orphan the stall state if promptAsync throws (aborted session, invalid ID),
+      // since ProgressTracker.reported is in-memory and only cleared by new activity.
+      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(() => { /* best effort */ })
+        ...(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)}`)
+      })
 
       // 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.`,
-      })
+      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.`,
+      )
 
       // Toast for the user
       try {
@@ -156,21 +206,31 @@ export class Watchdog {
       if (this.progressTracker.isChattyReported(member.session_id)) continue
       if (!this.progressTracker.isChatty(member.session_id, this.peerMessageLimit, this.peerMessageWindowMs)) continue
 
+      // hasReportedCompletion() guard — same invariant/rationale as checkStalled() above.
+      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)
 
       // Nudge the agent
+      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(() => { /* best effort */ })
+        ...(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)}`)
+      })
 
       // Notify the lead
-      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.`,
-      })
+      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}`)
     }
@@ -212,6 +272,20 @@ export class Watchdog {
         [Date.now(), member.team_id, member.name]
       )
 
+      // Release the timed-out member's in_progress tasks back to the pool (issue #27)
+      const released = releaseMemberTasks(this.db, member.team_id, member.name)
+      if (released > 0) log(`watchdog:tasks:released name=${member.name} count=${released}`)
+
+      // Notify AND wake the lead — a timed-out teammate is otherwise a silent
+      // failure. This is the "leave recovery to the lead" path: we surface the
+      // timeout, we do not auto-resume the teammate.
+      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.`,
+      )
+
       // Abort session (best effort)
       try {
         await this.client.session.abort({ sessionID: member.session_id })