@hueyexe/opencode-ensemble 0.14.0 → 0.14.2

package/src/tools/merge-helper.ts

@@ -1,4 +1,5 @@
 import { log } from "../log"
+import { runCommand } from "../process"
 
 /** Result of merging a single branch. */
 export interface MergeResult {
@@ -24,11 +25,9 @@ export type DeleteBranchFn = (branch: string, cwd: string) => Promise<boolean>
  * Returns true if the branch was successfully copied.
  */
 export async function preserveBranch(sourceBranch: string, targetBranch: string, cwd: string): Promise<boolean> {
-  const proc = Bun.spawn(["git", "branch", targetBranch, sourceBranch], { cwd, stdout: "pipe", stderr: "pipe" })
-  const exit = await proc.exited
-  if (exit !== 0) {
-    const stderr = await new Response(proc.stderr).text()
-    log(`merge-helper:preserve:failed src=${sourceBranch} target=${targetBranch} err=${stderr.trim()}`)
+  const result = await runCommand(["git", "branch", targetBranch, sourceBranch], { cwd })
+  if (result.exitCode !== 0) {
+    log(`merge-helper:preserve:failed src=${sourceBranch} target=${targetBranch} err=${result.stderr.trim()}`)
     return false
   }
   return true
@@ -38,9 +37,8 @@ export async function preserveBranch(sourceBranch: string, targetBranch: string,
  * Delete a git branch. Returns true if successful.
  */
 export async function deleteBranch(branch: string, cwd: string): Promise<boolean> {
-  const proc = Bun.spawn(["git", "branch", "-D", branch], { cwd, stdout: "pipe", stderr: "pipe" })
-  const exit = await proc.exited
-  if (exit !== 0) {
+  const result = await runCommand(["git", "branch", "-D", branch], { cwd })
+  if (result.exitCode !== 0) {
     log(`merge-helper:delete:failed branch=${branch}`)
     return false
   }
@@ -52,16 +50,13 @@ export async function deleteBranch(branch: string, cwd: string): Promise<boolean
  * Used by mergeBranch (single) and mergeMultipleBranches (batch).
  */
 export async function mergeBranchRaw(branch: string, cwd: string): Promise<MergeResult> {
-  const merge = Bun.spawn(["git", "merge", "--squash", branch], { cwd, stdout: "pipe", stderr: "pipe" })
-  const stderrPromise = new Response(merge.stderr).text()
-  const mergeExit = await merge.exited
+  const result = await runCommand(["git", "merge", "--squash", branch], { cwd })
 
-  if (mergeExit !== 0) {
-    const stderr = await stderrPromise
-    log(`merge-helper:merge:conflict branch=${branch} err=${stderr.trim()}`)
-    const abort = Bun.spawn(["git", "merge", "--abort"], { cwd, stdout: "pipe", stderr: "pipe" })
-    await abort.exited
-    return { ok: false, error: stderr.trim() || `merge exited with code ${mergeExit}` }
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.trim()
+    log(`merge-helper:merge:conflict branch=${branch} err=${stderr}`)
+    await runCommand(["git", "merge", "--abort"], { cwd })
+    return { ok: false, error: stderr || `merge exited with code ${result.exitCode}` }
   }
 
   return { ok: true }
@@ -69,8 +64,7 @@ export async function mergeBranchRaw(branch: string, cwd: string): Promise<Merge
 
 /** Unstage all changes so merge results appear as unstaged. */
 export async function gitReset(cwd: string): Promise<void> {
-  const reset = Bun.spawn(["git", "reset", "HEAD"], { cwd, stdout: "pipe", stderr: "pipe" })
-  await reset.exited
+  await runCommand(["git", "reset", "HEAD"], { cwd })
 }
 
 /**
@@ -91,11 +85,9 @@ export async function mergeBranch(branch: string, cwd: string): Promise<MergeRes
  */
 export async function getOverlappingFiles(branch: string, cwd: string): Promise<string[]> {
   const run = async (args: string[]) => {
-    const proc = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "pipe" })
-    const out = await new Response(proc.stdout).text()
-    const exit = await proc.exited
-    if (exit !== 0) throw new Error(`git ${args.join(" ")} failed with exit code ${exit}`)
-    return out.split("\n").filter(Boolean)
+    const result = await runCommand(["git", ...args], { cwd })
+    if (result.exitCode !== 0) throw new Error(`git ${args.join(" ")} failed with exit code ${result.exitCode}`)
+    return result.stdout.split("\n").filter(Boolean)
   }
   const agentFiles = new Set(await run(["diff", "--name-only", "HEAD", branch]))
   const localChanged = await run(["diff", "--name-only", "HEAD"])

package/src/tools/shared.ts

@@ -1,5 +1,6 @@
 import type { ToolDeps } from "../types"
 import { findTeamBySession } from "../types"
+import { runCommand } from "../process"
 
 /** Function type for dirty worktree check — injectable for testing. */
 export type IsDirtyFn = (dir: string) => Promise<boolean>
@@ -10,11 +11,9 @@ export type CommitCountFn = (branch: string, cwd: string) => Promise<number>
 /** Count commits a branch has ahead of HEAD. Approximate — may include base divergence. Returns -1 if check fails. */
 export async function countBranchCommits(branch: string, cwd: string): Promise<number> {
   try {
-    const proc = Bun.spawn(["git", "rev-list", "--count", `HEAD..${branch}`], { cwd, stdout: "pipe", stderr: "pipe" })
-    const out = await new Response(proc.stdout).text()
-    const exit = await proc.exited
-    if (exit !== 0) return -1
-    const n = Number.parseInt(out.trim(), 10)
+    const result = await runCommand(["git", "rev-list", "--count", `HEAD..${branch}`], { cwd })
+    if (result.exitCode !== 0) return -1
+    const n = Number.parseInt(result.stdout.trim(), 10)
     return Number.isNaN(n) ? -1 : n
   } catch { return -1 }
 }
@@ -22,11 +21,9 @@ export async function countBranchCommits(branch: string, cwd: string): Promise<n
 /** Check if a worktree directory has uncommitted changes via git status. */
 export async function checkWorktreeDirty(dir: string): Promise<boolean> {
   try {
-    const proc = Bun.spawn(["git", "-C", dir, "status", "--porcelain"], { stdout: "pipe", stderr: "pipe" })
-    const output = await new Response(proc.stdout).text()
-    const exitCode = await proc.exited
-    if (exitCode !== 0) return false // git failed — assume clean
-    return output.trim().length > 0
+    const result = await runCommand(["git", "-C", dir, "status", "--porcelain"])
+    if (result.exitCode !== 0) return false // git failed — assume clean
+    return result.stdout.trim().length > 0
   } catch {
     return false // can't check — assume clean
   }

package/src/tools/team-cleanup.ts

@@ -5,6 +5,7 @@ import { spawnFailures } from "./team-spawn"
 import { mergeBranch, deleteBranch, preserveBranch, preservedBranchName, getOverlappingFiles } from "./merge-helper"
 import type { MergeBranchFn, DeleteBranchFn, PreserveBranchFn, OverlapCheckFn } from "./merge-helper"
 import { log } from "../log"
+import { runCommand } from "../process"
 
 type PurgeApprovalFn = (preview: string) => Promise<void>
 type ListBranchesFn = (teamName: string, cwd: string) => Promise<string[]>
@@ -36,12 +37,9 @@ interface PurgeMemberResource {
 
 async function listPreservedBranches(teamName: string, cwd: string): Promise<string[]> {
   try {
-    const proc = Bun.spawn(["git", "branch", "--list", `ensemble/preserved/${teamName}/*`, "--format", "%(refname:short)"], { cwd, stdout: "pipe", stderr: "pipe" })
-    const out = await new Response(proc.stdout).text()
-    const stderr = await new Response(proc.stderr).text()
-    const exit = await proc.exited
-    if (exit !== 0) throw new Error(stderr.trim() || `git branch exited with code ${exit}`)
-    return out.split("\n").map(branch => branch.trim()).filter(Boolean)
+    const result = await runCommand(["git", "branch", "--list", `ensemble/preserved/${teamName}/*`, "--format", "%(refname:short)"], { cwd })
+    if (result.exitCode !== 0) throw new Error(result.stderr.trim() || `git branch exited with code ${result.exitCode}`)
+    return result.stdout.split("\n").map(branch => branch.trim()).filter(Boolean)
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err)
     if (message.includes("not a git repository")) return []
@@ -51,15 +49,12 @@ async function listPreservedBranches(teamName: string, cwd: string): Promise<str
 
 async function branchExists(branch: string, cwd: string): Promise<boolean> {
   try {
-    const proc = Bun.spawn(["git", "branch", "--list", branch, "--format", "%(refname:short)"], { cwd, stdout: "pipe", stderr: "pipe" })
-    const out = await new Response(proc.stdout).text()
-    const stderr = await new Response(proc.stderr).text()
-    const exit = await proc.exited
-    if (exit !== 0) {
-      if (stderr.includes("not a git repository")) return false
-      throw new Error(stderr.trim() || `git branch exited with code ${exit}`)
+    const result = await runCommand(["git", "branch", "--list", branch, "--format", "%(refname:short)"], { cwd })
+    if (result.exitCode !== 0) {
+      if (result.stderr.includes("not a git repository")) return false
+      throw new Error(result.stderr.trim() || `git branch exited with code ${result.exitCode}`)
     }
-    return out.split("\n").map(item => item.trim()).includes(branch)
+    return result.stdout.split("\n").map(item => item.trim()).includes(branch)
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err)
     if (message.includes("not a git repository")) return false

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { Database } from "bun:sqlite"
+import type { Database } from "./db"
 import type { MemberRegistry, DescendantTracker, PendingPurgeApprovals } from "./state"
 import type { EnsembleConfig } from "./config"
 
@@ -76,20 +76,54 @@ export interface PluginClient {
 /**
  * Look up which team a session belongs to (as lead or member).
  * Returns team info or undefined.
+ *
+ * Lookup order for member sessions:
+ *   1. Registry fast-path (in-memory cache)
+ *   2. SQLite fallback (canonical source)
+ *
+ * The SQLite fallback is critical when multiple Plugin instances run in the
+ * same process (e.g. opencode Desktop's local sidecar plus a connected
+ * `opencode serve` sharing the same DB). Each instance has its own
+ * MemberRegistry; without a SQLite fallback, a tool call dispatched to
+ * a Plugin instance whose registry never saw the spawn fails with
+ * "This session is not in a team."
+ *
+ * Only members in active teams with non-terminal status are resolved.
  */
 export function findTeamBySession(
   db: Database,
   registry: MemberRegistry,
   sessionId: string,
 ): { teamId: string; teamName: string; role: "lead" | "member"; memberName?: string } | undefined {
-  // Check if session is a team member
+  // Fast path: registry cache
   const entry = registry.getBySession(sessionId)
   if (entry) {
     const team = db.query("SELECT name FROM team WHERE id = ? AND status = 'active'").get(entry.teamId) as { name: string } | null
     if (team) return { teamId: entry.teamId, teamName: team.name, role: "member", memberName: entry.memberName }
   }
 
-  // Check if session is a team lead
+  // SQLite fallback: another Plugin instance may have registered this teammate
+  if (!entry) {
+    const memberRow = db.query(
+      `SELECT tm.team_id, tm.name as member_name, t.name as team_name
+       FROM team_member tm
+       JOIN team t ON tm.team_id = t.id
+       WHERE tm.session_id = ?
+         AND t.status = 'active'
+         AND tm.status NOT IN ('shutdown', 'error')`
+    ).get(sessionId) as { team_id: string; member_name: string; team_name: string } | null
+    if (memberRow) {
+      // Populate the cache so subsequent lookups skip the SQL query.
+      // Safe without TTL: session IDs are server-generated UUIDs and are
+      // never reused across team_spawn invocations, so a session ID maps
+      // to at most one (teamId, memberName) for the life of the process.
+      // team_cleanup explicitly invalidates via registry.unregisterTeam.
+      registry.register(memberRow.team_id, memberRow.member_name, sessionId)
+      return { teamId: memberRow.team_id, teamName: memberRow.team_name, role: "member", memberName: memberRow.member_name }
+    }
+  }
+
+  // Check if session is a team lead (already SQLite-backed, naturally cross-instance)
   const leadTeam = db.query("SELECT id, name FROM team WHERE lead_session_id = ? AND status = 'active'").get(sessionId) as { id: string; name: string } | null
   if (leadTeam) return { teamId: leadTeam.id, teamName: leadTeam.name, role: "lead" }
 
@@ -99,7 +133,8 @@ export function findTeamBySession(
 /**
  * Get the session ID for a recipient by name.
  * "lead" resolves to the team's lead_session_id.
- * Otherwise looks up the member registry.
+ * Otherwise looks up the member via the registry, then falls back to SQLite
+ * (covers the multi-Plugin-instance scenario — see findTeamBySession).
  */
 export function resolveRecipientSession(
   db: Database,
@@ -112,5 +147,16 @@ export function resolveRecipientSession(
     return team?.lead_session_id
   }
   const entry = registry.getByName(teamId, recipientName)
-  return entry?.sessionId
+  if (entry) return entry.sessionId
+
+  // SQLite fallback: another Plugin instance may have registered this teammate
+  const memberRow = db.query(
+    `SELECT session_id FROM team_member
+     WHERE team_id = ? AND name = ? AND status NOT IN ('shutdown', 'error')`
+  ).get(teamId, recipientName) as { session_id: string } | null
+  if (!memberRow) return undefined
+
+  // Populate the cache
+  registry.register(teamId, recipientName, memberRow.session_id)
+  return memberRow.session_id
 }

package/src/watchdog.ts

@@ -1,4 +1,4 @@
-import type { Database } from "bun:sqlite"
+import type { Database } from "./db"
 import type { PluginClient } from "./types"
 import type { MemberRegistry } from "./state"
 import type { ProgressTracker } from "./progress"