@hueyexe/opencode-ensemble 0.9.0 → 0.10.0

package/src/tools/team-cleanup.ts

@@ -2,75 +2,22 @@ import type { ToolDeps } from "../types"
 import { requireLead, checkWorktreeDirty } from "./shared"
 import type { IsDirtyFn } from "./shared"
 import { spawnFailures } from "./team-spawn"
+import { mergeBranch, deleteBranch, preserveBranch, preservedBranchName } from "./merge-helper"
+import type { MergeBranchFn, DeleteBranchFn, PreserveBranchFn } from "./merge-helper"
 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.
- * If force=true, aborts active sessions but still blocks on dirty worktrees.
- * Pass acknowledge_uncommitted=true to remove dirty worktrees.
+ * Acts as a safety net: merges any remaining unmerged preserved branches
+ * that the lead forgot to merge with team_merge.
  */
 export async function executeTeamCleanup(
   deps: ToolDeps,
   args: { force: boolean; acknowledge_uncommitted?: boolean },
   sessionId: string,
   isDirty: IsDirtyFn = checkWorktreeDirty,
-  mergeAll: MergeAllFn = mergeAllBranches,
+  merge: MergeBranchFn = mergeBranch,
+  delBranch: DeleteBranchFn = deleteBranch,
   mergeOnCleanup = true,
 ): Promise<string> {
   const teamInfo = requireLead(deps, sessionId)
@@ -85,7 +32,7 @@ export async function executeTeamCleanup(
     throw new Error(`Cannot clean up team "${teamInfo.teamName}": ${active.length} member(s) still active: ${names}. Use team_shutdown on each member first, or call team_cleanup with force: true to abort them immediately.`)
   }
 
-  // Check for uncommitted changes BEFORE aborting sessions — agents can still commit if warned
+  // Check for uncommitted changes BEFORE aborting sessions
   if (!args.acknowledge_uncommitted) {
     const dirty: Array<{ name: string; branch: string }> = []
     for (const member of members) {
@@ -99,53 +46,64 @@ export async function executeTeamCleanup(
         }
       }
     }
-
     if (dirty.length > 0) {
       const warnings = dirty.map(d => `  - ${d.name} (branch: ${d.branch})`).join("\n")
       return `Warning: ${dirty.length} teammate(s) have uncommitted changes in their worktrees:\n${warnings}\n\nCommit or merge their work first, then call team_cleanup with acknowledge_uncommitted: true to proceed.`
     }
   }
 
-  // Force-abort active members (only reached if worktrees are clean or acknowledged)
+  // Force-abort active members — preserve branches BEFORE aborting
   if (args.force) {
     for (const member of active) {
+      // Preserve branch before abort — session.abort() may destroy the worktree + branch
+      if (member.worktree_branch && !member.worktree_branch.startsWith("ensemble/preserved/")) {
+        const safeBranch = preservedBranchName(teamInfo.teamName, member.name)
+        const ok = await preserveBranch(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, member.name])
+          member.worktree_branch = safeBranch
+        }
+      }
       try {
         await deps.client.session.abort({ sessionID: member.session_id })
       } catch { /* best effort */ }
     }
   }
 
-  // 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)
+  // Safety net: merge any remaining unmerged preserved branches
+  const unmerged = members.filter(m => m.worktree_branch !== null)
+  const merged: string[] = []
+  const conflicted: string[] = []
 
-  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>`)
+  if (unmerged.length > 0 && mergeOnCleanup) {
+    for (const member of unmerged) {
+      const branch = member.worktree_branch!
+      const result = await merge(branch, deps.directory)
+      if (result.ok) {
+        await delBranch(branch, deps.directory)
+        deps.db.run("UPDATE team_member SET worktree_branch = NULL WHERE team_id = ? AND name = ?", [teamInfo.teamId, member.name])
+        merged.push(`${member.name} (${branch})`)
+      } else {
+        log(`cleanup:merge:conflict member=${member.name} branch=${branch} err=${result.error}`)
+        conflicted.push(`${member.name} (${branch})`)
+      }
     }
-    mergeResult = parts.join("\n")
   }
 
-  // Remove workspaces and worktrees (after merging)
+  // Remove workspaces and worktrees
   for (const member of members) {
     if (member.workspace_id) {
       try {
         await deps.client.workspace.remove({ id: member.workspace_id })
         deps.db.run("UPDATE team_member SET workspace_id = NULL WHERE team_id = ? AND name = ?", [teamInfo.teamId, member.name])
-      } catch { /* best effort — workspace may already be gone */ }
+      } catch { /* best effort */ }
     }
     if (member.worktree_dir) {
       try {
         await deps.client.worktree.remove({ worktreeRemoveInput: { directory: member.worktree_dir } })
         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 */ }
+      } catch { /* best effort */ }
     }
   }
 
@@ -156,14 +114,13 @@ export async function executeTeamCleanup(
   deps.registry.unregisterTeam(teamInfo.teamId)
   spawnFailures.delete(teamInfo.teamId)
 
-  if (mergeResult) {
-    return `Team "${teamInfo.teamName}" cleaned up.\n${mergeResult}`
+  // Build response
+  const parts: string[] = [`Team "${teamInfo.teamName}" cleaned up.`]
+  if (merged.length > 0) {
+    parts.push(`Safety-net merged ${merged.length} unmerged branch(es): ${merged.join(", ")}. Review with: git diff`)
   }
-
-  if (branches.length > 0) {
-    const mergeCommands = branches.map(b => `  git merge ${b}`).join("\n")
-    return `Team "${teamInfo.teamName}" cleaned up. Worktrees removed.\n\nMerge teammate branches:\n${mergeCommands}`
+  if (conflicted.length > 0) {
+    parts.push(`Could not auto-merge: ${conflicted.join(", ")}. Merge manually.`)
   }
-
-  return `Team "${teamInfo.teamName}" cleaned up.`
+  return parts.join("\n")
 }

package/src/tools/team-merge.ts

@@ -0,0 +1,49 @@
+import type { ToolDeps } from "../types"
+import { requireLead } from "./shared"
+import { mergeBranch, deleteBranch } from "./merge-helper"
+import type { MergeBranchFn, DeleteBranchFn } from "./merge-helper"
+import { log } from "../log"
+
+/**
+ * Execute the team_merge tool. Merges a shutdown teammate's preserved
+ * branch into the working directory as unstaged changes.
+ */
+export async function executeTeamMerge(
+  deps: ToolDeps,
+  args: { member: string },
+  sessionId: string,
+  merge: MergeBranchFn = mergeBranch,
+  delBranch: DeleteBranchFn = deleteBranch,
+): Promise<string> {
+  const teamInfo = requireLead(deps, sessionId)
+
+  const member = deps.db.query("SELECT status, worktree_branch FROM team_member WHERE team_id = ? AND name = ?")
+    .get(teamInfo.teamId, args.member) as { status: string; worktree_branch: string | null } | null
+  if (!member) throw new Error(`Teammate "${args.member}" not found in team "${teamInfo.teamName}"`)
+
+  if (member.status !== "shutdown" && member.status !== "error") {
+    throw new Error(`Teammate "${args.member}" is still active (status: ${member.status}). Shut them down first with team_shutdown.`)
+  }
+
+  if (!member.worktree_branch) {
+    throw new Error(`No branch to merge for "${args.member}". They may not have a worktree, or their work was already merged.`)
+  }
+
+  const branch = member.worktree_branch
+  log(`merge:start member=${args.member} branch=${branch}`)
+
+  const result = await merge(branch, deps.directory)
+  if (!result.ok) {
+    return `Merge conflict with ${args.member}'s branch (${branch}). Resolve manually:\n  git merge --squash ${branch}\n\nError: ${result.error}`
+  }
+
+  // Merge succeeded — delete the preserved branch and clear DB
+  await delBranch(branch, deps.directory)
+  deps.db.run(
+    "UPDATE team_member SET worktree_branch = NULL WHERE team_id = ? AND name = ?",
+    [teamInfo.teamId, args.member],
+  )
+
+  log(`merge:done member=${args.member} branch=${branch}`)
+  return `Merged ${args.member}'s changes into working directory (unstaged). Review with: git diff`
+}

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/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 = ?",