@hueyexe/opencode-ensemble 0.20.0 → 0.21.0

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

@@ -1,6 +1,7 @@
 import type { ToolDeps } from "../types"
 import { requireTeamMember } from "./shared"
 import { generateId } from "../util"
+import { inspectTaskGraph, parseTaskDependencies, depthForDependencies } from "../task-graph"
 
 interface TaskInput {
   content: string
@@ -18,13 +19,17 @@ export async function executeTeamTasksAdd(
   sessionId: string,
 ): Promise<string> {
   const teamInfo = requireTeamMember(deps, sessionId)
+  const tasks = args.tasks.map(task => ({
+    ...task,
+    depends_on: [...new Set(task.depends_on ?? [])],
+  }))
 
   // Reject unknown dependency IDs before inserting anything: a task blocked on
   // an ID that never existed can never unblock (issue #40). IDs are generated
   // here, so new tasks can only depend on existing ones and no cycle can form.
   const unknown = new Set<string>()
-  for (const task of args.tasks) {
-    for (const depId of task.depends_on ?? []) {
+  for (const task of tasks) {
+    for (const depId of task.depends_on) {
       const exists = deps.db.query("SELECT 1 FROM team_task WHERE id = ? AND team_id = ?").get(depId, teamInfo.teamId)
       if (!exists) unknown.add(depId)
     }
@@ -36,16 +41,47 @@ export async function executeTeamTasksAdd(
     )
   }
 
+  // Optional depth guard (issue #42). Default is unlimited; when configured,
+  // reject the whole batch before any insert so a failed add is atomic.
+  const depthLimit = deps.config.taskDepthLimit
+  if (depthLimit > 0) {
+    const existing = deps.db.query("SELECT id, status, depends_on FROM team_task WHERE team_id = ?")
+      .all(teamInfo.teamId) as Array<{ id: string; status: string; depends_on: string | null }>
+    const graph = inspectTaskGraph(existing.map(row => ({
+      id: row.id,
+      status: row.status,
+      dependsOn: parseTaskDependencies(row.depends_on),
+    })), { activeOnly: true })
+
+    if (graph.cyclic.length > 0) {
+      throw new Error(
+        `Task graph has a dependency cycle (${graph.cyclic.join(", ")}). Repair it before adding more tasks.`,
+      )
+    }
+
+    for (const task of tasks) {
+      const depth = depthForDependencies(task.depends_on, graph)
+      if (depth <= depthLimit) continue
+      const resolution = deps.config.taskDepthLimitOverflowAction === "user_resolve"
+        ? "Ask the user whether to split the work into a shallower chain, then retry."
+        : "Split the work into shallower batches, add an independent task, or raise taskDepthLimit."
+      throw new Error(
+        `Task depth ${depth} exceeds taskDepthLimit ${depthLimit}. ` +
+          `The new task depends on ${task.depends_on.join(", ")}. ${resolution}`,
+      )
+    }
+  }
+
   const ids: string[] = []
   const now = Date.now()
 
-  for (const task of args.tasks) {
+  for (const task of tasks) {
     const id = generateId("task")
-    const depsJson = task.depends_on?.length ? JSON.stringify(task.depends_on) : null
+    const depsJson = task.depends_on.length ? JSON.stringify(task.depends_on) : null
 
     // Determine initial status — blocked if has unresolved dependencies
     let status = "pending"
-    if (task.depends_on?.length) {
+    if (task.depends_on.length) {
       const resolved = task.depends_on.every(depId => {
         const dep = deps.db.query("SELECT status FROM team_task WHERE id = ? AND team_id = ?")
           .get(depId, teamInfo.teamId) as { status: string } | null

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

@@ -1,5 +1,6 @@
 import type { ToolDeps } from "../types"
 import { requireTeamMember } from "./shared"
+import { parseTaskDependencies } from "../task-graph"
 import { log } from "../log"
 
 /**
@@ -51,7 +52,7 @@ export async function executeTeamTasksComplete(
   let unblocked = 0
   for (const t of allTasks) {
     if (t.status !== "blocked" || !t.depends_on) continue
-    const depIds: string[] = JSON.parse(t.depends_on)
+    const depIds = parseTaskDependencies(t.depends_on)
     if (!depIds.includes(args.task_id)) continue
 
     const allResolved = depIds.every(depId => {

package/src/types.ts

@@ -50,7 +50,7 @@ export interface PluginClient {
     promptAsync(options: {
       sessionID: string
       parts: Array<{ type: "text"; text: string }>
-      model?: { providerID: string; modelID: string }
+      model?: { providerID: string; modelID: string; variant?: string }
       agent?: string
       tools?: Record<string, boolean>
       system?: string

package/src/v2-client.ts

@@ -215,7 +215,11 @@ export function createV2Client(ctx: V2Context, deps: V2ClientDeps = {}): PluginC
         if (options.model) {
           await ctx.session.switchModel({
             sessionID: options.sessionID,
-            model: { providerID: options.model.providerID, id: options.model.modelID },
+            model: {
+              providerID: options.model.providerID,
+              id: options.model.modelID,
+              ...(options.model.variant ? { variant: options.model.variant } : {}),
+            },
           })
         }
         const text = joinParts(options.parts)

package/src/v2-setup.ts

@@ -294,7 +294,7 @@ export async function setupEnsemble(
     const prompt =
       teamInfo.role === "lead"
         ? buildLeadSystemPrompt(db, teamInfo.teamId, config)
-        : buildTeammateSystemPrompt(db, teamInfo.teamId, teamInfo.memberName ?? "unknown")
+        : buildTeammateSystemPrompt(db, teamInfo.teamId, teamInfo.memberName ?? "unknown", config)
     vlog(`system-prompt:injected role=${teamInfo.role} len=${prompt.length}`)
     event.system.push({ type: "text", text: prompt })
     if (teamInfo.role === "member") {
@@ -343,7 +343,7 @@ export async function setupEnsemble(
   let dashboard: DashboardServer | null = null
   const dashboardPort = options.dashboardPort ?? config.dashboardPort
   if (dashboardPort !== 0 && !isWorktreeInstance(ctx.location.directory)) {
-    dashboard = await startDashboard(db, dashboardPort, { activityBuffer, client }).catch((err) => {
+    dashboard = await startDashboard(db, dashboardPort, { activityBuffer, client, host: config.dashboardHost }).catch((err) => {
       vlog(`init:dashboard:failed err=${err instanceof Error ? err.message : String(err)}`)
       return null
     })

package/src/wake.ts

@@ -0,0 +1,198 @@
+import type { Database } from "./db"
+import type { PluginClient } from "./types"
+import { getSessionSelection } from "./member-model"
+import { log } from "./log"
+
+/** Options for a lead wake. */
+export interface WakeLeadOptions {
+  /** Send even when the lead session is busy, and skip the cooldown (system/error notifications). */
+  force?: boolean
+  /** Coalescing window override (tests); defaults to {@link WAKE_COOLDOWN_MS}. */
+  cooldownMs?: number
+}
+
+/** Per-database coalescing state, so separate plugin instances/DBs don't share it. */
+interface WakeState {
+  /** Teams with a wake currently being resolved/sent. */
+  inFlight: Set<string>
+  /** Trailing retries scheduled after a cooldown skip. */
+  timers: Map<string, ReturnType<typeof setTimeout>>
+}
+
+const states = new WeakMap<Database, WakeState>()
+const WAKE_COOLDOWN_MS = 5000
+
+function stateFor(db: Database): WakeState {
+  let state = states.get(db)
+  if (!state) {
+    state = { inFlight: new Set(), timers: new Map() }
+    states.set(db, state)
+  }
+  return state
+}
+
+interface PendingLeadWake {
+  leadSessionID: string
+  count: number
+  senders: string[]
+  lastWakeAt: number
+}
+
+/**
+ * Resolve whether a team still has messages the lead has neither seen in the
+ * system prompt (delivered) nor read via team_results (read). Resolving from
+ * the DB at fire time is what prevents wakes from landing in an archived or
+ * purged team (#48) or after the inbox was drained (#57).
+ */
+function pendingLeadWake(db: Database, teamId: string): PendingLeadWake | undefined {
+  const team = db.query("SELECT lead_session_id, last_wake_at FROM team WHERE id = ? AND status = 'active'")
+    .get(teamId) as { lead_session_id: string; last_wake_at: number } | null
+  if (!team?.lead_session_id) return undefined
+
+  const row = db.query(
+    `SELECT COUNT(*) as c, GROUP_CONCAT(DISTINCT from_name) as senders
+     FROM team_message
+     WHERE team_id = ? AND to_name = 'lead' AND read = 0 AND delivered = 0`,
+  ).get(teamId) as { c: number; senders: string | null }
+  if (row.c === 0) return undefined
+
+  return {
+    leadSessionID: team.lead_session_id,
+    count: row.c,
+    senders: row.senders ? row.senders.split(",").filter(Boolean) : [],
+    lastWakeAt: team.last_wake_at,
+  }
+}
+
+/** Schedule one trailing re-check after a cooldown skip. */
+function scheduleCooldownRetry(
+  client: PluginClient,
+  db: Database,
+  teamId: string,
+  options: WakeLeadOptions,
+  delayMs: number,
+): void {
+  const state = stateFor(db)
+  if (state.timers.has(teamId)) return
+  const timer = setTimeout(() => {
+    state.timers.delete(teamId)
+    wakeLeadIfPending(client, db, teamId, options).catch((err) => {
+      log(`wake:retry:failed team=${teamId} err=${err instanceof Error ? err.message : String(err)}`)
+    })
+  }, Math.max(0, delayMs))
+  ;(timer as { unref?: () => void }).unref?.()
+  state.timers.set(teamId, timer)
+}
+
+/** Best-effort busy check. Unknown status is treated as idle so wakes are not lost. */
+async function isSessionBusy(client: PluginClient, sessionID: string): Promise<boolean> {
+  try {
+    const status = await client.session.status()
+    const entry = status.data?.[sessionID]
+    return entry?.type === "busy" || entry?.type === "retry"
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Wake a team's lead only when the team is still active and has genuinely
+ * unseen messages. The team and pending count are resolved at fire time, so a
+ * wake scheduled before team_cleanup cannot wake the lead into a dead team.
+ *
+ * Coalesces bursts: concurrent calls for the same team collapse into one, and
+ * a successful wake suppresses further wakes for {@link WAKE_COOLDOWN_MS}.
+ * A busy lead is left alone (the idle backstop will wake it) unless
+ * `force` is set for system/error notifications.
+ *
+ * Fire-and-forget by design: callers should not await this in delivery paths.
+ * Returns true when a wake was actually sent.
+ */
+export async function wakeLeadIfPending(
+  client: PluginClient,
+  db: Database,
+  teamId: string,
+  options: WakeLeadOptions = {},
+): Promise<boolean> {
+  const state = stateFor(db)
+  if (state.inFlight.has(teamId)) return false
+
+  const before = pendingLeadWake(db, teamId)
+  if (!before) {
+    log(`wake:skip team=${teamId} reason=no-unseen`)
+    return false
+  }
+
+  const cooldownMs = options.cooldownMs ?? WAKE_COOLDOWN_MS
+  const now = Date.now()
+  if (!options.force && now - before.lastWakeAt < cooldownMs) {
+    const remaining = cooldownMs - (now - before.lastWakeAt)
+    scheduleCooldownRetry(client, db, teamId, options, remaining)
+    log(`wake:skip team=${teamId} reason=cooldown retryIn=${remaining}ms`)
+    return false
+  }
+
+  state.inFlight.add(teamId)
+  try {
+    // V2 synthetic wakes use queue delivery and are designed to wait for a busy
+    // session; V2 also has no lead-idle backstop, so skipping here would strand
+    // the message. On V1 the passive idle path retries, so a busy lead is left
+    // alone unless the caller forces the wake (system/error notifications).
+    const isV2 = Boolean(client.agent)
+    if (!options.force && !isV2 && await isSessionBusy(client, before.leadSessionID)) {
+      log(`wake:skip team=${teamId} reason=lead-busy`)
+      return false
+    }
+
+    // On V1 a wake is a normal user turn, so pass the lead's current agent and
+    // model explicitly to stop OpenCode falling back to Build/default (#37).
+    // V2 wakes are synthetic and ignore both, so skip the lookup there.
+    const selection = client.agent
+      ? {}
+      : await getSessionSelection(client, before.leadSessionID).catch(() => ({}))
+
+    // Re-check after the async lookups: the team may have been archived or
+    // purged, or the lead may have drained the inbox in the meantime.
+    const after = pendingLeadWake(db, teamId)
+    if (!after) {
+      log(`wake:skip team=${teamId} reason=drained`)
+      return false
+    }
+
+    const pendingTimer = state.timers.get(teamId)
+    if (pendingTimer) {
+      clearTimeout(pendingTimer)
+      state.timers.delete(teamId)
+    }
+    // Persisted, not in-memory: worktree teammate instances share this DB.
+    db.run("UPDATE team SET last_wake_at = ? WHERE id = ? AND status = 'active'", [Date.now(), teamId])
+    const senderText = after.senders.length > 0 ? ` from ${after.senders.join(", ")}` : ""
+    client.session.promptAsync({
+      sessionID: after.leadSessionID,
+      parts: [{ type: "text", text: `[System: ${after.count} new team message(s)${senderText}] — use team_results to read them` }],
+      synthetic: true,
+      ...(selection.agent ? { agent: selection.agent } : {}),
+      ...(selection.model ? { model: selection.model } : {}),
+    }).catch((err) => {
+      log(`wake:send:failed team=${teamId} err=${err instanceof Error ? err.message : String(err)}`)
+    })
+    log(`wake:sent team=${teamId} count=${after.count}`)
+    return true
+  } finally {
+    state.inFlight.delete(teamId)
+  }
+}
+
+/** Clear wake coalescing state for a database (tests). */
+export function resetWakeState(db: Database): void {
+  const state = states.get(db)
+  if (state) {
+    for (const timer of state.timers.values()) clearTimeout(timer)
+    states.delete(db)
+  }
+  try {
+    db.run("UPDATE team SET last_wake_at = 0")
+  } catch {
+    // The table may not exist yet in a partially initialized test DB.
+  }
+}