@hueyexe/opencode-ensemble 0.14.2 → 0.15.0

package/src/tools/merge-helper.ts

@@ -1,3 +1,4 @@
+import type { Database } from "../db"
 import { log } from "../log"
 import { runCommand } from "../process"
 
@@ -19,6 +20,49 @@ 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.
@@ -99,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/team-cleanup.ts

@@ -2,18 +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
 }
 
@@ -29,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
@@ -73,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))
 }
 
@@ -116,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,
@@ -123,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 {
@@ -300,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)
@@ -473,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/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

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