@hueyexe/opencode-ensemble 0.8.0 → 0.9.1

package/src/tools/team-results.ts

@@ -1,5 +1,6 @@
 import type { ToolDeps } from "../types"
 import { requireTeamMember } from "./shared"
+import { parseTaskResult, formatTaskResult } from "../result-parser"
 
 /** Row shape for unread messages query. */
 interface UnreadMessageRow {
@@ -39,6 +40,10 @@ export async function executeTeamResults(
   const placeholders = ids.map(() => "?").join(", ")
   deps.db.run(`UPDATE team_message SET read = 1 WHERE id IN (${placeholders})`, ids)
 
-  // Format output
-  return rows.map((r) => `[Message from ${r.from_name}]:\n${r.content}\n`).join("\n")
+  // Format output — parse structured task results when present
+  return rows.map((r) => {
+    const parsed = parseTaskResult(r.content)
+    if (parsed) return formatTaskResult(r.from_name, parsed)
+    return `[Message from ${r.from_name}]:\n${r.content}`
+  }).join("\n\n")
 }

package/src/tools/team-shutdown.ts

@@ -1,23 +1,22 @@
 import type { ToolDeps } from "../types"
 import { requireLead, checkWorktreeDirty } from "./shared"
 import type { IsDirtyFn } from "./shared"
+import { preserveBranch, preservedBranchName } from "./merge-helper"
+import type { PreserveBranchFn } from "./merge-helper"
+import { log } from "../log"
 
 /**
  * Execute the team_shutdown tool. Requests a teammate to shut down.
  *
- * Graceful negotiation flow:
- * - If member is already shutdown_requested, treat as force (second call).
- * - If member is idle or force=true, abort immediately and set status='shutdown'.
- * - If member is busy and force=false, send a shutdown message via promptAsync
- *   and set status='shutdown_requested'. The member finishes work and reports back.
- *
- * Warns if the member's worktree has uncommitted changes.
+ * Before aborting, preserves the worktree branch to a safe ref so
+ * session.abort() cannot destroy the agent's committed work.
  */
 export async function executeTeamShutdown(
   deps: ToolDeps,
   args: { member: string; force?: boolean },
   sessionId: string,
   isDirty: IsDirtyFn = checkWorktreeDirty,
+  preserve: PreserveBranchFn = preserveBranch,
 ): Promise<string> {
   const teamInfo = requireLead(deps, sessionId)
 
@@ -30,8 +29,8 @@ export async function executeTeamShutdown(
 
   // Second call on an already-requested member → force abort
   if (member.status === "shutdown_requested") {
-    await abortAndShutdown(deps, teamInfo.teamId, args.member, member.session_id)
-    const branchInfo = member.worktree_branch ? ` Changes on branch: ${member.worktree_branch}` : ""
+    await preserveAndAbort(deps, teamInfo.teamId, teamInfo.teamName, args.member, member.session_id, member.worktree_branch, preserve)
+    const branchInfo = getBranchInfo(deps, teamInfo.teamId, args.member)
     const dirtyWarning = await getDirtyWarning(member.worktree_dir, args.member, isDirty)
     return `Force shut down "${args.member}".${branchInfo}${dirtyWarning}`
   }
@@ -47,21 +46,35 @@ export async function executeTeamShutdown(
   }
 
   if (isIdle || force) {
-    await abortAndShutdown(deps, teamInfo.teamId, args.member, member.session_id)
-    const branchInfo = member.worktree_branch ? ` Changes on branch: ${member.worktree_branch}` : ""
+    await preserveAndAbort(deps, teamInfo.teamId, teamInfo.teamName, args.member, member.session_id, member.worktree_branch, preserve)
+    const branchInfo = getBranchInfo(deps, teamInfo.teamId, args.member)
     const dirtyWarning = await getDirtyWarning(member.worktree_dir, args.member, isDirty)
     return `Teammate "${args.member}" has been shut down.${branchInfo}${dirtyWarning}`
   }
 
-  // Busy + not force → graceful: send shutdown message, set shutdown_requested
+  // Busy + not force → graceful: preserve branch first, then send shutdown message
+  // Branch must be preserved NOW — if the session crashes during shutdown_requested,
+  // the worktree and branch could be lost before force-abort ever runs.
+  if (member.worktree_branch) {
+    const safeBranch = preservedBranchName(teamInfo.teamName, args.member)
+    const ok = await preserve(member.worktree_branch, safeBranch, deps.directory)
+    if (ok) {
+      deps.db.run(
+        "UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?",
+        [safeBranch, teamInfo.teamId, args.member],
+      )
+      log(`shutdown:branch:preserved-graceful src=${member.worktree_branch} target=${safeBranch}`)
+    }
+  }
+
   try {
-    await deps.client.session.promptAsync({
+    deps.client.session.promptAsync({
       sessionID: member.session_id,
       parts: [{
         type: "text",
         text: `[Shutdown requested]: The lead has requested you shut down. Finish your current task, send your final findings to the lead via team_message, then stop.`,
       }],
-    })
+    }).catch(() => { /* fire-and-forget */ })
   } catch {
     // promptAsync failed — best effort
   }
@@ -75,15 +88,35 @@ export async function executeTeamShutdown(
 }
 
 /**
- * Abort a member's session and set their status to shutdown.
- * Best-effort: if abort fails, we still mark them as shutdown.
+ * Preserve the worktree branch, then abort the session and mark shutdown.
+ * The branch is copied to ensemble/preserved/{team}/{name} BEFORE abort,
+ * so session.abort() cannot destroy the agent's committed work.
  */
-async function abortAndShutdown(
+async function preserveAndAbort(
   deps: ToolDeps,
   teamId: string,
+  teamName: string,
   memberName: string,
   sessionId: string,
+  worktreeBranch: string | null,
+  preserve: PreserveBranchFn,
 ): Promise<void> {
+  // Preserve the branch BEFORE aborting — session.abort() may delete the worktree + branch
+  if (worktreeBranch && !worktreeBranch.startsWith("ensemble/preserved/")) {
+    const safeBranch = preservedBranchName(teamName, memberName)
+    const ok = await preserve(worktreeBranch, safeBranch, deps.directory)
+    if (ok) {
+      deps.db.run(
+        "UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?",
+        [safeBranch, teamId, memberName],
+      )
+      log(`shutdown:branch:preserved src=${worktreeBranch} target=${safeBranch}`)
+    } else {
+      log(`shutdown:branch:preserve-failed src=${worktreeBranch} target=${safeBranch}`)
+    }
+  }
+
+  // Now safe to abort — the branch is preserved
   try {
     await deps.client.session.abort({ sessionID: sessionId })
   } catch {
@@ -96,6 +129,13 @@ async function abortAndShutdown(
   )
 }
 
+/** Read the current branch from DB (may have been updated to preserved name). */
+function getBranchInfo(deps: ToolDeps, teamId: string, memberName: string): string {
+  const row = deps.db.query("SELECT worktree_branch FROM team_member WHERE team_id = ? AND name = ?")
+    .get(teamId, memberName) as { worktree_branch: string | null } | null
+  return row?.worktree_branch ? ` Changes preserved on branch: ${row.worktree_branch}. Use team_merge to merge.` : ""
+}
+
 /** Build a warning suffix if the member's worktree has uncommitted changes. */
 async function getDirtyWarning(worktreeDir: string | null, memberName: string, isDirty: IsDirtyFn): Promise<string> {
   if (!worktreeDir) return ""

package/src/tools/team-spawn.ts

@@ -197,6 +197,14 @@ export async function executeTeamSpawn(
     `Your agent type is "${args.agent}".`,
   ]
 
+  // Show other teammates so this agent knows who to message
+  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) as Array<{ name: string }>
+  if (otherMembers.length > 0) {
+    context.push(`Other teammates: ${otherMembers.map(m => m.name).join(", ")}`)
+  }
+
   if (worktreeBranch && worktreeDir && !workspaceId) {
     // Workspace binding failed — fallback to prompt-based CWD instruction
     context.push(
@@ -276,7 +284,9 @@ export async function executeTeamSpawn(
   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 describing the specific blocker.",
+    "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.",
   )

package/src/watchdog.ts

@@ -2,7 +2,9 @@ import type { Database } from "bun:sqlite"
 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 { log } from "./log"
 
 interface WatchdogOpts {
   db: Database
@@ -20,6 +22,8 @@ interface WatchdogOpts {
   stallMinSteps?: number
   /** Output token threshold for stall detection. */
   stallTokenThreshold?: number
+  /** Project directory for git operations. */
+  cwd?: string
 }
 
 /**
@@ -36,6 +40,7 @@ export class Watchdog {
   private readonly stallThresholdMs: number
   private readonly stallMinSteps: number
   private readonly stallTokenThreshold: number
+  private readonly cwd?: string
   private timer: ReturnType<typeof setInterval> | undefined
 
   constructor(opts: WatchdogOpts) {
@@ -48,6 +53,7 @@ export class Watchdog {
     this.stallThresholdMs = opts.stallThresholdMs ?? 0
     this.stallMinSteps = opts.stallMinSteps ?? 3
     this.stallTokenThreshold = opts.stallTokenThreshold ?? 500
+    this.cwd = opts.cwd
   }
 
   private static STALE_THRESHOLD_MS = Number(process.env.STALE_WORKTREE_THRESHOLD_MS) || 300_000
@@ -135,15 +141,26 @@ export class Watchdog {
 
     const cutoff = Date.now() - this.ttlMs
     const stale = this.db.query(
-      `SELECT tm.team_id, tm.name, tm.session_id
+      `SELECT tm.team_id, tm.name, tm.session_id, tm.worktree_branch, t.name as team_name
        FROM team_member tm
        JOIN team t ON tm.team_id = t.id
        WHERE t.status = 'active'
          AND tm.status = 'busy'
          AND tm.time_updated < ?`
-    ).all(cutoff) as Array<{ team_id: string; name: string; session_id: string }>
+    ).all(cutoff) as Array<{ team_id: string; name: string; session_id: string; worktree_branch: string | null; team_name: string }>
 
     for (const member of stale) {
+      // Preserve branch BEFORE abort — session.abort() may destroy the worktree + branch
+      if (this.cwd && member.worktree_branch && !member.worktree_branch.startsWith("ensemble/preserved/")) {
+        const safeBranch = preservedBranchName(member.team_name, member.name)
+        const ok = await preserveBranch(member.worktree_branch, safeBranch, this.cwd)
+        if (ok) {
+          this.db.run("UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?",
+            [safeBranch, member.team_id, member.name])
+          log(`watchdog:branch:preserved src=${member.worktree_branch} target=${safeBranch}`)
+        }
+      }
+
       // Mark as timed out
       this.db.run(
         "UPDATE team_member SET status = 'error', execution_status = 'timed_out', time_updated = ? WHERE team_id = ? AND name = ?",