@hueyexe/opencode-ensemble 0.14.1 → 0.15.0

package/src/tools/merge-helper.ts

@@ -1,4 +1,6 @@
+import type { Database } from "../db"
 import { log } from "../log"
+import { runCommand } from "../process"
 
 /** Result of merging a single branch. */
 export interface MergeResult {
@@ -18,17 +20,58 @@ export type PreserveBranchFn = (sourceBranch: string, targetBranch: string, cwd:
 /** Injectable function for deleting a branch. */
 export type DeleteBranchFn = (branch: string, cwd: string) => Promise<boolean>
 
+/** Human-readable resource identity for a team. */
+export interface TeamResourceParts {
+  projectName: string
+  teamName: string
+  teamId: string
+}
+
+function shortTeamId(teamId: string): string {
+  return (teamId.split("_").at(-1) || teamId).slice(0, 6)
+}
+
+function resourcePart(value: string): string {
+  const part = value.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "")
+  return part || "unnamed"
+}
+
+/** Load the human-readable pieces used to build team resource names. */
+export function getTeamResourceParts(db: Database, teamId: string): TeamResourceParts {
+  const row = db.query(
+    `SELECT t.id as team_id, t.name as team_name, p.name as project_name
+     FROM team t
+     JOIN project p ON t.project_id = p.id
+     WHERE t.id = ?`
+  ).get(teamId) as { team_id: string; team_name: string; project_name: string } | null
+  if (!row) throw new Error(`Team not found: ${teamId}`)
+  return { projectName: row.project_name, teamName: row.team_name, teamId: row.team_id }
+}
+
+/** Build the readable namespace used for team-owned resources. */
+export function teamResourceSlug(projectName: string, teamName: string, teamId: string): string {
+  return `${resourcePart(projectName)}-${resourcePart(teamName)}#${shortTeamId(teamId)}`
+}
+
+/** Build the team-only resource segment used under project-scoped namespaces. */
+export function teamResourceSegment(teamName: string, teamId: string): string {
+  return `${resourcePart(teamName)}#${shortTeamId(teamId)}`
+}
+
+/** Build an OpenCode worktree name for a team member. */
+export function teamWorktreeName(projectName: string, teamName: string, teamId: string, memberName: string): string {
+  return `ensemble-${teamResourceSlug(projectName, teamName, teamId)}-${memberName}`
+}
+
 /**
  * Copy a git branch to a new ref. Used to preserve worktree branches
  * before session.abort() which may delete the worktree and its branch.
  * 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 +81,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 +94,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
-
-  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}` }
+  const result = await runCommand(["git", "merge", "--squash", branch], { cwd })
+
+  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 +108,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 +129,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"])
@@ -107,6 +143,6 @@ export async function getOverlappingFiles(branch: string, cwd: string): Promise<
 /**
  * Build the preserved branch name for a team member.
  */
-export function preservedBranchName(teamName: string, memberName: string): string {
-  return `ensemble/preserved/${teamName}/${memberName}`
+export function preservedBranchName(projectName: string, teamName: string, teamId: string, memberName: string): string {
+  return `ensemble/preserved/${resourcePart(projectName)}/${teamResourceSegment(teamName, teamId)}/${resourcePart(memberName)}`
 }

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

@@ -2,17 +2,20 @@ import type { ToolDeps } from "../types"
 import { requireLead, requireCanPurgeArchivedTeams, checkWorktreeDirty } from "./shared"
 import type { IsDirtyFn } from "./shared"
 import { spawnFailures } from "./team-spawn"
-import { mergeBranch, deleteBranch, preserveBranch, preservedBranchName, getOverlappingFiles } from "./merge-helper"
+import { getTeamResourceParts, mergeBranch, deleteBranch, preserveBranch, preservedBranchName, getOverlappingFiles, teamResourceSegment } 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[]>
+type ListBranchesFn = (namespace: string, cwd: string) => Promise<string[]>
 type BranchExistsFn = (branch: string, cwd: string) => Promise<boolean>
 
 interface PurgeTarget {
   id: string
   name: string
+  project_id: string
+  project_name: string
   time_updated: number
 }
 
@@ -28,6 +31,7 @@ interface PurgeStats extends PurgeTarget {
 interface PurgeMemberResource {
   team_id: string
   team_name: string
+  project_name: string
   member_name: string
   worktree_dir: string | null
   workspace_id: string | null
@@ -36,12 +40,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 +52,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
@@ -78,24 +76,25 @@ function resolvePurgeTargets(deps: ToolDeps, purge: string[]): PurgeTarget[] {
   }
 
   if (purge.includes("*")) {
-    return deps.db.query("SELECT id, name, time_updated FROM team WHERE status = 'archived' ORDER BY time_updated DESC, name ASC")
-      .all() as PurgeTarget[]
+    return deps.db.query("SELECT t.id, t.name, t.project_id, p.name as project_name, t.time_updated FROM team t JOIN project p ON t.project_id = p.id WHERE t.status = 'archived' AND t.project_id = ? ORDER BY t.time_updated DESC, t.name ASC")
+      .all(deps.directory) as PurgeTarget[]
   }
 
   const uniqueNames = [...new Set(purge)]
   const rows = uniqueNames.map(name => ({
     name,
-    team: deps.db.query("SELECT id, name, status, time_updated FROM team WHERE name = ?").get(name) as { id: string; name: string; status: string; time_updated: number } | null,
+    teams: deps.db.query("SELECT t.id, t.name, t.project_id, p.name as project_name, t.status, t.time_updated FROM team t JOIN project p ON t.project_id = p.id WHERE t.name = ? AND t.project_id = ? ORDER BY t.time_updated DESC")
+      .all(name, deps.directory) as Array<{ id: string; name: string; project_id: string; project_name: string; status: string; time_updated: number }>,
   }))
 
-  const missing = rows.filter(row => row.team === null).map(row => row.name)
+  const missing = rows.filter(row => row.teams.length === 0).map(row => row.name)
   if (missing.length > 0) throw new Error(`Team not found: ${missing.join(", ")}`)
 
-  const active = rows.filter(row => row.team?.status === "active").map(row => row.name)
+  const active = rows.filter(row => row.teams.some(team => team.status === "active")).map(row => row.name)
   if (active.length > 0) throw new Error(`Cannot purge active team: ${active.join(", ")}`)
 
   return rows
-    .map(row => row.team!)
+    .map(row => row.teams[0]!)
     .sort((a, b) => b.time_updated - a.time_updated || a.name.localeCompare(b.name))
 }
 
@@ -121,6 +120,7 @@ function deleteArchivedTeams(deps: ToolDeps, targets: PurgeTarget[]): void {
 function getPurgeMemberResources(deps: ToolDeps, targets: PurgeTarget[]): PurgeMemberResource[] {
   return targets.flatMap(target => deps.db.query(
     `SELECT t.name as team_name,
+            p.name as project_name,
             tm.team_id,
             tm.name as member_name,
             tm.worktree_dir,
@@ -128,23 +128,32 @@ function getPurgeMemberResources(deps: ToolDeps, targets: PurgeTarget[]): PurgeM
             tm.worktree_branch
      FROM team_member tm
      JOIN team t ON tm.team_id = t.id
+     JOIN project p ON t.project_id = p.id
      WHERE tm.team_id = ?`
   ).all(target.id) as PurgeMemberResource[])
 }
 
 function preservedBranchPrefix(resource: PurgeMemberResource): string {
+  return `ensemble/preserved/${resource.project_name}/${teamResourceSegment(resource.team_name, resource.team_id)}/`
+}
+
+function legacyPreservedBranchPrefix(resource: PurgeMemberResource): string {
   return `ensemble/preserved/${resource.team_name}/`
 }
 
 function staleEnsembleBranchNames(resource: PurgeMemberResource): string[] {
   return [
+    `ensemble-${resource.team_id}-${resource.member_name}`,
     `ensemble-${resource.team_name}-${resource.member_name}`,
     `opencode/ensemble-${resource.team_name}-${resource.member_name}`,
   ]
 }
 
 function isPreservedBranch(resource: PurgeMemberResource): boolean {
-  return resource.worktree_branch !== null && resource.worktree_branch.startsWith(preservedBranchPrefix(resource))
+  return resource.worktree_branch !== null && (
+    resource.worktree_branch.startsWith(preservedBranchPrefix(resource)) ||
+    resource.worktree_branch.startsWith(legacyPreservedBranchPrefix(resource))
+  )
 }
 
 function isStaleEnsembleBranch(resource: PurgeMemberResource): boolean {
@@ -305,16 +314,16 @@ async function collectPreservedBranches(
   listBranches: ListBranchesFn,
 ): Promise<Map<string, string[]>> {
   const entries: Array<[string, string[]]> = await Promise.all(targets.map(async target => {
-    const prefix = `ensemble/preserved/${target.name}/`
+    const prefixes = [`ensemble/preserved/${target.project_name}/${teamResourceSegment(target.name, target.id)}/`, `ensemble/preserved/${target.name}/`]
     let listed: string[]
     try {
-      listed = await listBranches(target.name, cwd)
+      listed = [...await listBranches(target.project_name, cwd), ...await listBranches(target.name, cwd)]
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err)
       if (message.includes("not a git repository")) listed = []
-      else throw new Error(`Failed to list preserved branches for ${target.name}: ${message}`)
+      else throw new Error(`Failed to list preserved branches for ${target.id}: ${message}`)
     }
-    const branches = listed.map(normalizeBranchName).filter(branch => branch.startsWith(prefix))
+    const branches = listed.map(normalizeBranchName).filter(branch => prefixes.some(prefix => branch.startsWith(prefix)))
     return [target.id, [...new Set(branches)]]
   }))
   return new Map(entries)
@@ -478,7 +487,8 @@ export async function executeTeamCleanup(
     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 resource = getTeamResourceParts(deps.db, teamInfo.teamId)
+        const safeBranch = preservedBranchName(resource.projectName, resource.teamName, resource.teamId, 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 = ?",

package/src/tools/team-create.ts

@@ -1,5 +1,5 @@
 import type { ToolDeps } from "../types"
-import { generateId, validateTeamName } from "../util"
+import { generateId, generateProjectName, validateProjectName, validateTeamName } from "../util"
 import { findTeamBySession } from "../types"
 
 /**
@@ -7,14 +7,19 @@ import { findTeamBySession } from "../types"
  */
 export async function executeTeamCreate(
   deps: ToolDeps,
-  args: { name: string },
+  args: { name: string; project_name?: string },
   sessionId: string,
 ): Promise<string> {
   const nameError = validateTeamName(args.name)
   if (nameError) throw new Error(nameError)
+  if (args.project_name) {
+    const projectNameError = validateProjectName(args.project_name)
+    if (projectNameError) throw new Error(projectNameError)
+  }
 
   // Check if team name already exists
-  const existing = deps.db.query("SELECT id FROM team WHERE name = ? AND status = 'active'").get(args.name)
+  const projectId = deps.directory
+  const existing = deps.db.query("SELECT id FROM team WHERE name = ? AND project_id = ? AND status = 'active'").get(args.name, projectId)
   if (existing) throw new Error(`Team "${args.name}" already exists`)
 
   // Check if session already leads a team
@@ -23,9 +28,16 @@ export async function executeTeamCreate(
 
   const id = generateId("team")
   const now = Date.now()
+  const projectName = args.project_name ?? generateProjectName()
   deps.db.run(
-    "INSERT INTO team (id, name, lead_session_id, status, delegate, time_created, time_updated) VALUES (?, ?, ?, 'active', 0, ?, ?)",
-    [id, args.name, sessionId, now, now]
+    `INSERT INTO project (id, name, path, status, time_created, time_updated)
+     VALUES (?, ?, ?, 'active', ?, ?)
+     ON CONFLICT(id) DO UPDATE SET time_updated = excluded.time_updated`,
+    [projectId, projectName, projectId, now, now]
+  )
+  deps.db.run(
+    "INSERT INTO team (id, name, project_id, lead_session_id, status, delegate, time_created, time_updated) VALUES (?, ?, ?, ?, 'active', 0, ?, ?)",
+    [id, args.name, projectId, sessionId, now, now]
   )
 
   return `Team "${args.name}" created. You are the lead. Use team_spawn to add teammates.`

package/src/tools/team-shutdown.ts

@@ -1,7 +1,7 @@
 import type { ToolDeps } from "../types"
 import { requireLead, checkWorktreeDirty, countBranchCommits } from "./shared"
 import type { IsDirtyFn, CommitCountFn } from "./shared"
-import { preserveBranch, preservedBranchName } from "./merge-helper"
+import { getTeamResourceParts, preserveBranch, preservedBranchName } from "./merge-helper"
 import type { PreserveBranchFn } from "./merge-helper"
 import { log } from "../log"
 
@@ -30,7 +30,7 @@ export async function executeTeamShutdown(
 
   // Second call on an already-requested member → force abort
   if (member.status === "shutdown_requested") {
-    await preserveAndAbort(deps, teamInfo.teamId, teamInfo.teamName, args.member, member.session_id, member.worktree_branch, preserve)
+    await preserveAndAbort(deps, teamInfo.teamId, args.member, member.session_id, member.worktree_branch, preserve)
     const status = await getBranchStatus(deps, teamInfo.teamId, args.member, member.worktree_dir, isDirty, commitCount)
     return `Force shut down "${args.member}".${status}`
   }
@@ -46,7 +46,7 @@ export async function executeTeamShutdown(
   }
 
   if (isIdle || force) {
-    await preserveAndAbort(deps, teamInfo.teamId, teamInfo.teamName, args.member, member.session_id, member.worktree_branch, preserve)
+    await preserveAndAbort(deps, teamInfo.teamId, args.member, member.session_id, member.worktree_branch, preserve)
     const status = await getBranchStatus(deps, teamInfo.teamId, args.member, member.worktree_dir, isDirty, commitCount)
     return `Teammate "${args.member}" has been shut down.${status}`
   }
@@ -55,7 +55,8 @@ export async function executeTeamShutdown(
   // 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 resource = getTeamResourceParts(deps.db, teamInfo.teamId)
+    const safeBranch = preservedBranchName(resource.projectName, resource.teamName, resource.teamId, args.member)
     const ok = await preserve(member.worktree_branch, safeBranch, deps.directory)
     if (ok) {
       deps.db.run(
@@ -88,13 +89,12 @@ export async function executeTeamShutdown(
 
 /**
  * Preserve the worktree branch, then abort the session and mark shutdown.
- * The branch is copied to ensemble/preserved/{team}/{name} BEFORE abort,
+ * The branch is copied to ensemble/preserved/{team_id}/{name} BEFORE abort,
  * so session.abort() cannot destroy the agent's committed work.
  */
 async function preserveAndAbort(
   deps: ToolDeps,
   teamId: string,
-  teamName: string,
   memberName: string,
   sessionId: string,
   worktreeBranch: string | null,
@@ -102,7 +102,8 @@ async function preserveAndAbort(
 ): 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 resource = getTeamResourceParts(deps.db, teamId)
+    const safeBranch = preservedBranchName(resource.projectName, resource.teamName, resource.teamId, memberName)
     const ok = await preserve(worktreeBranch, safeBranch, deps.directory)
     if (ok) {
       deps.db.run(

package/src/tools/team-spawn.ts

@@ -4,6 +4,7 @@ import { requireLead } from "./shared"
 import { sendMessage } from "../messaging"
 import { log } from "../log"
 import type { EnsembleConfig } from "../config"
+import { getTeamResourceParts, teamWorktreeName } from "./merge-helper"
 
 /** Tracks consecutive spawn failures per team for circuit breaker. */
 export const spawnFailures = new Map<string, { count: number; lastError: string }>()
@@ -96,7 +97,8 @@ export async function executeTeamSpawn(
   let worktreeBranch: string | null = null
 
   if (useWorktree) {
-    const worktreeName = `ensemble-${teamInfo.teamName}-${args.name}`
+    const resource = getTeamResourceParts(deps.db, teamInfo.teamId)
+    const worktreeName = teamWorktreeName(resource.projectName, resource.teamName, resource.teamId, args.name)
     try {
       log(`spawn:worktree:start name=${args.name}`)
       const result = await withTimeout(

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/util.ts

@@ -23,6 +23,23 @@ export function validateTeamName(name: string): string | undefined {
   return undefined
 }
 
+const PROJECT_ADJECTIVES = ["amber", "brave", "calm", "copper", "crisp", "dark", "ember", "frost", "quiet", "silver", "steady", "swift"]
+const PROJECT_NOUNS = ["atlas", "beacon", "comet", "harbor", "lab", "orbit", "river", "signal", "sparrow", "summit", "vector", "voyage"]
+
+/** Generate a short human-readable project name for implicit project creation. */
+export function generateProjectName(): string {
+  const adjective = PROJECT_ADJECTIVES[Math.floor(Math.random() * PROJECT_ADJECTIVES.length)] ?? "quiet"
+  const noun = PROJECT_NOUNS[Math.floor(Math.random() * PROJECT_NOUNS.length)] ?? "project"
+  return `${adjective}-${noun}`
+}
+
+/** Validate a project display name. Returns an error if invalid. */
+export function validateProjectName(name: string): string | undefined {
+  if (name.length < 1 || name.length > 64) return "Project name must be 1-64 characters"
+  if (!NAME_PATTERN.test(name)) return "Project name must be lowercase alphanumeric with hyphens only"
+  return undefined
+}
+
 /**
  * Detect if the plugin is loading inside a teammate's worktree instance.
  * Worktree instances should skip recovery to avoid deadlocking the server.

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"
@@ -185,18 +185,19 @@ export class Watchdog {
 
     const cutoff = Date.now() - this.ttlMs
     const stale = this.db.query(
-      `SELECT tm.team_id, tm.name, tm.session_id, tm.worktree_branch, t.name as team_name
+      `SELECT tm.team_id, tm.name, tm.session_id, tm.worktree_branch, t.name as team_name, p.name as project_name
        FROM team_member tm
        JOIN team t ON tm.team_id = t.id
+       JOIN project p ON t.project_id = p.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; worktree_branch: string | null; team_name: string }>
+    ).all(cutoff) as Array<{ team_id: string; name: string; session_id: string; worktree_branch: string | null; team_name: string; project_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 safeBranch = preservedBranchName(member.project_name, member.team_name, member.team_id, 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 = ?",