@hueyexe/opencode-ensemble 0.6.4 → 0.7.0

package/src/system-prompt.ts

@@ -75,6 +75,10 @@ export function buildLeadSystemPrompt(db: Database, teamId: string): string {
     "Do NOT poll team_status or team_tasks_list repeatedly — wait for messages.",
     "After spawning all teammates, tell the user what you've set up and wait.",
     "When all teammates finish, summarize results and suggest next steps.",
+    "",
+    "Before calling team_cleanup, verify teammates have committed their work.",
+    "team_shutdown will warn you if a teammate has uncommitted changes.",
+    "team_cleanup will block if any worktree has uncommitted changes — merge or commit first.",
   )
 
   return lines.join("\n")

package/src/tools/shared.ts

@@ -0,0 +1,39 @@
+import type { ToolDeps } from "../types"
+import { findTeamBySession } from "../types"
+
+/** Function type for dirty worktree check — injectable for testing. */
+export type IsDirtyFn = (dir: string) => Promise<boolean>
+
+/** 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
+  } catch {
+    return false // can't check — assume clean
+  }
+}
+
+/** Validate that the session belongs to the team lead. Throws if not. */
+export function requireLead(
+  deps: Pick<ToolDeps, "db" | "registry">,
+  sessionId: string,
+): { teamId: string; teamName: string } {
+  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
+  if (!teamInfo) throw new Error("This session is not in a team. Use team_create first.")
+  if (teamInfo.role !== "lead") throw new Error("Only the team lead can use this tool.")
+  return { teamId: teamInfo.teamId, teamName: teamInfo.teamName }
+}
+
+/** Validate that the session belongs to any team member (lead or teammate). Throws if not. */
+export function requireTeamMember(
+  deps: Pick<ToolDeps, "db" | "registry">,
+  sessionId: string,
+): { teamId: string; teamName: string; role: "lead" | "member"; memberName?: string } {
+  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
+  if (!teamInfo) throw new Error("This session is not in a team.")
+  return teamInfo
+}

package/src/tools/team-broadcast.ts

@@ -1,5 +1,5 @@
 import type { ToolDeps } from "../types"
-import { findTeamBySession } from "../types"
+import { requireTeamMember } from "./shared"
 import { broadcastMessage, markDelivered } from "../messaging"
 import { log } from "../log"
 
@@ -11,8 +11,7 @@ export async function executeTeamBroadcast(
   args: { text: string },
   sessionId: string,
 ): Promise<string> {
-  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
-  if (!teamInfo) throw new Error("This session is not in a team. Use team_create first.")
+  const teamInfo = requireTeamMember(deps, sessionId)
 
   const senderName = teamInfo.role === "lead" ? "lead" : (teamInfo.memberName ?? "unknown")
 

package/src/tools/team-claim.ts

@@ -1,5 +1,5 @@
 import type { ToolDeps } from "../types"
-import { findTeamBySession } from "../types"
+import { requireTeamMember } from "./shared"
 
 /**
  * Execute the team_claim tool. Atomically claims a pending task.
@@ -10,8 +10,7 @@ export async function executeTeamClaim(
   args: { task_id: string },
   sessionId: string,
 ): Promise<string> {
-  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
-  if (!teamInfo) throw new Error("This session is not in a team.")
+  const teamInfo = requireTeamMember(deps, sessionId)
 
   const claimerName = teamInfo.role === "lead" ? "lead" : (teamInfo.memberName ?? "unknown")
 

package/src/tools/team-cleanup.ts

@@ -1,22 +1,24 @@
 import type { ToolDeps } from "../types"
-import { findTeamBySession } from "../types"
+import { requireLead, checkWorktreeDirty } from "./shared"
+import type { IsDirtyFn } from "./shared"
+import { log } from "../log"
 
 /**
  * Execute the team_cleanup tool. Archives the team and cleans up resources.
- * Removes worktrees and lists branches for the lead to merge.
- * If force=true, aborts all active member sessions first.
+ * 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.
  */
 export async function executeTeamCleanup(
   deps: ToolDeps,
-  args: { force: boolean },
+  args: { force: boolean; acknowledge_uncommitted?: boolean },
   sessionId: string,
+  isDirty: IsDirtyFn = checkWorktreeDirty,
 ): Promise<string> {
-  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
-  if (!teamInfo) throw new Error("This session is not in a team.")
-  if (teamInfo.role !== "lead") throw new Error("Only the team lead can clean up the team.")
+  const teamInfo = requireLead(deps, sessionId)
 
-  const members = deps.db.query("SELECT name, session_id, status, worktree_dir, worktree_branch FROM team_member WHERE team_id = ?")
-    .all(teamInfo.teamId) as Array<{ name: string; session_id: string; status: string; worktree_dir: string | null; worktree_branch: string | null }>
+  const members = deps.db.query("SELECT name, session_id, status, worktree_dir, worktree_branch, workspace_id FROM team_member WHERE team_id = ?")
+    .all(teamInfo.teamId) as Array<{ name: string; session_id: string; status: string; worktree_dir: string | null; worktree_branch: string | null; workspace_id: string | null }>
 
   const active = members.filter(m => m.status !== "shutdown" && m.status !== "shutdown_requested" && m.status !== "error")
 
@@ -25,7 +27,28 @@ 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.`)
   }
 
-  // Force-abort active members
+  // Check for uncommitted changes BEFORE aborting sessions — agents can still commit if warned
+  if (!args.acknowledge_uncommitted) {
+    const dirty: Array<{ name: string; branch: string }> = []
+    for (const member of members) {
+      if (member.worktree_dir) {
+        try {
+          if (await isDirty(member.worktree_dir)) {
+            dirty.push({ name: member.name, branch: member.worktree_branch ?? "unknown" })
+          }
+        } catch {
+          log(`cleanup:dirty-check:failed name=${member.name}`)
+        }
+      }
+    }
+
+    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)
   if (args.force) {
     for (const member of active) {
       try {
@@ -34,12 +57,19 @@ export async function executeTeamCleanup(
     }
   }
 
-  // Remove worktrees and collect branches for merging
+  // Remove workspaces, worktrees, and collect branches for merging
   const branches: string[] = []
   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 */ }
+    }
     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 */ }
     }
     if (member.worktree_branch) {

package/src/tools/team-message.ts

@@ -1,5 +1,6 @@
 import type { ToolDeps } from "../types"
-import { findTeamBySession, resolveRecipientSession } from "../types"
+import { resolveRecipientSession } from "../types"
+import { requireTeamMember } from "./shared"
 import { sendMessage, markDelivered } from "../messaging"
 import { log } from "../log"
 
@@ -12,8 +13,7 @@ export async function executeTeamMessage(
   args: { to: string; text: string; approve?: boolean; reject?: string },
   sessionId: string,
 ): Promise<string> {
-  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
-  if (!teamInfo) throw new Error("This session is not in a team. Use team_create first.")
+  const teamInfo = requireTeamMember(deps, sessionId)
 
   const senderName = teamInfo.role === "lead" ? "lead" : (teamInfo.memberName ?? "unknown")
 

package/src/tools/team-results.ts

@@ -1,5 +1,5 @@
 import type { ToolDeps } from "../types"
-import { findTeamBySession } from "../types"
+import { requireTeamMember } from "./shared"
 
 /** Row shape for unread messages query. */
 interface UnreadMessageRow {
@@ -18,8 +18,7 @@ export async function executeTeamResults(
   args: { from?: string },
   sessionId: string,
 ): Promise<string> {
-  const team = findTeamBySession(deps.db, deps.registry, sessionId)
-  if (!team) throw new Error("not in a team")
+  const team = requireTeamMember(deps, sessionId)
 
   const rows = args.from
     ? (deps.db

package/src/tools/team-shutdown.ts

@@ -1,5 +1,6 @@
 import type { ToolDeps } from "../types"
-import { findTeamBySession } from "../types"
+import { requireLead, checkWorktreeDirty } from "./shared"
+import type { IsDirtyFn } from "./shared"
 
 /**
  * Execute the team_shutdown tool. Requests a teammate to shut down.
@@ -9,18 +10,19 @@ import { findTeamBySession } from "../types"
  * - 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.
  */
 export async function executeTeamShutdown(
   deps: ToolDeps,
   args: { member: string; force?: boolean },
   sessionId: string,
+  isDirty: IsDirtyFn = checkWorktreeDirty,
 ): Promise<string> {
-  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
-  if (!teamInfo) throw new Error("This session is not in a team.")
-  if (teamInfo.role !== "lead") throw new Error("Only the team lead can shut down teammates.")
+  const teamInfo = requireLead(deps, sessionId)
 
-  const member = deps.db.query("SELECT session_id, status, worktree_branch FROM team_member WHERE team_id = ? AND name = ?")
-    .get(teamInfo.teamId, args.member) as { session_id: string; status: string; worktree_branch: string | null } | null
+  const member = deps.db.query("SELECT session_id, status, worktree_branch, worktree_dir FROM team_member WHERE team_id = ? AND name = ?")
+    .get(teamInfo.teamId, args.member) as { session_id: string; status: string; worktree_branch: string | null; worktree_dir: string | null } | null
   if (!member) throw new Error(`Teammate "${args.member}" not found in team "${teamInfo.teamName}"`)
   if (member.status === "shutdown") throw new Error(`Teammate "${args.member}" is already shut down`)
 
@@ -30,7 +32,8 @@ export async function executeTeamShutdown(
   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}` : ""
-    return `Force shut down "${args.member}".${branchInfo}`
+    const dirtyWarning = await getDirtyWarning(member.worktree_dir, args.member, isDirty)
+    return `Force shut down "${args.member}".${branchInfo}${dirtyWarning}`
   }
 
   // Determine if member is idle or busy
@@ -46,7 +49,8 @@ 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}` : ""
-    return `Teammate "${args.member}" has been shut down.${branchInfo}`
+    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
@@ -91,3 +95,14 @@ async function abortAndShutdown(
     [Date.now(), teamId, memberName],
   )
 }
+
+/** 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 ""
+  try {
+    if (await isDirty(worktreeDir)) {
+      return `\n\nWarning: ${memberName} has uncommitted changes in their worktree. Commit or merge before calling team_cleanup.`
+    }
+  } catch { /* best effort */ }
+  return ""
+}

package/src/tools/team-spawn.ts

@@ -1,6 +1,6 @@
 import type { ToolDeps, PermissionRule } from "../types"
 import { validateMemberName } from "../util"
-import { findTeamBySession } from "../types"
+import { requireLead } from "./shared"
 import { sendMessage } from "../messaging"
 import { log } from "../log"
 
@@ -9,6 +9,11 @@ function getSpawnTimeout(): number {
   return Number(process.env.SPAWN_TIMEOUT_MS) || 120_000
 }
 
+/** Returns true if the directory is already inside an OpenCode worktree. */
+function isWorktreeDirectory(dir: string): boolean {
+  return dir.includes("/opencode/worktree/")
+}
+
 /** Race a promise against a timeout. Throws if the timeout fires first. Cleans up timer on resolution. */
 function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {
   let timer: ReturnType<typeof setTimeout>
@@ -34,16 +39,14 @@ export async function executeTeamSpawn(
   const nameError = validateMemberName(args.name)
   if (nameError) throw new Error(nameError)
 
-  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
-  if (!teamInfo) throw new Error("This session is not in a team. Use team_create first.")
-  if (teamInfo.role !== "lead") throw new Error("Only the team lead can spawn teammates.")
+  const teamInfo = requireLead(deps, sessionId)
 
   // Check duplicate name
   const existing = deps.db.query("SELECT name FROM team_member WHERE team_id = ? AND name = ?")
     .get(teamInfo.teamId, args.name)
   if (existing) throw new Error(`Teammate "${args.name}" already exists in team "${teamInfo.teamName}"`)
 
-  const useWorktree = args.worktree !== false
+  const useWorktree = args.worktree !== false && !isWorktreeDirectory(deps.directory)
   const usePlanApproval = args.plan_approval === true
 
   log(`spawn:start name=${args.name} agent=${args.agent} worktree=${useWorktree}`)
@@ -78,20 +81,55 @@ export async function executeTeamSpawn(
     }
   }
 
+  // Create workspace from worktree branch — links session to worktree directory.
+  // OQ-workspace: assumes workspace.create({ branch }) auto-links to the worktree at that branch.
+  let workspaceId: string | null = null
+  if (worktreeDir && worktreeBranch) {
+    try {
+      log(`spawn:workspace:start name=${args.name}`)
+      const wsResult = await withTimeout(
+        deps.client.workspace.create({ branch: worktreeBranch }),
+        getSpawnTimeout(), `workspace.create for "${args.name}"`
+      )
+      if (wsResult.data) {
+        workspaceId = wsResult.data.id
+      }
+      log(`spawn:workspace:done name=${args.name} id=${workspaceId}`)
+    } catch (err) {
+      log(`spawn:workspace:failed name=${args.name} err=${err instanceof Error ? err.message : String(err)}`)
+      // Non-fatal — prompt-based CWD instruction is the fallback
+    }
+  }
+
   // Permission rules on session.create are the hard gate (server-enforced).
-  // For read-only agents, deny write tools and explicitly allow team tools
-  // so the agent's built-in restrictive permissions don't block them.
+  // For read-only agents, deny write tools and explicitly allow team tools.
+  // For all agents with worktrees, allowlist the worktree path for edit/bash.
   const isReadOnly = args.agent === "plan" || args.agent === "explore"
   const TEAM_TOOLS = ["team_message", "team_broadcast", "team_tasks_list", "team_tasks_add", "team_tasks_complete", "team_claim"] as const
-  const permission: PermissionRule[] | undefined = isReadOnly
-    ? [
-        { permission: "edit", pattern: "*", action: "deny" },
-        { permission: "bash", pattern: "*", action: "deny" },
-        ...TEAM_TOOLS.map(t => ({ permission: t, pattern: "*", action: "allow" as const })),
-      ]
-    : undefined
-
-  // Create child session — use worktree directory if available
+  const permission: PermissionRule[] = []
+
+  if (worktreeDir) {
+    permission.push(
+      { permission: "edit", pattern: `${worktreeDir}/**`, action: "allow" },
+    )
+    if (!isReadOnly) {
+      permission.push({ permission: "bash", pattern: "*", action: "allow" })
+    }
+  }
+
+  if (isReadOnly) {
+    permission.push(
+      { permission: "edit", pattern: "*", action: "deny" },
+      { permission: "bash", pattern: "*", action: "deny" },
+    )
+  }
+
+  permission.push(
+    ...TEAM_TOOLS.map(t => ({ permission: t, pattern: "*", action: "allow" as const })),
+  )
+
+  // Create child session — bind to workspace if available (server-enforced CWD isolation).
+  // Falls back to no workspace binding if workspace.create failed.
   let childSessionId: string | undefined
   try {
     log(`spawn:session:start name=${args.name}`)
@@ -99,8 +137,8 @@ export async function executeTeamSpawn(
       deps.client.session.create({
         parentID: sessionId,
         title: `${args.name} (@${args.agent} teammate)`,
-        ...(permission ? { permission } : {}),
-        ...(worktreeDir ? { directory: worktreeDir } : {}),
+        permission,
+        ...(workspaceId ? { workspaceID: workspaceId } : {}),
       }),
       getSpawnTimeout(), `session.create for "${args.name}"`
     )
@@ -108,7 +146,10 @@ export async function executeTeamSpawn(
     log(`spawn:session:done name=${args.name} sessionId=${childSessionId}`)
   } catch (err) {
     log(`spawn:session:failed name=${args.name} err=${err instanceof Error ? err.message : String(err)}`)
-    // Rollback worktree if session creation failed
+    // Rollback workspace and worktree if session creation failed
+    if (workspaceId) {
+      try { await deps.client.workspace.remove({ id: workspaceId }) } catch { /* best effort */ }
+    }
     if (worktreeDir) {
       try { await deps.client.worktree.remove({ worktreeRemoveInput: { directory: worktreeDir } }) } catch { /* best effort */ }
     }
@@ -116,6 +157,9 @@ export async function executeTeamSpawn(
   }
 
   if (!childSessionId) {
+    if (workspaceId) {
+      try { await deps.client.workspace.remove({ id: workspaceId }) } catch { /* best effort */ }
+    }
     if (worktreeDir) {
       try { await deps.client.worktree.remove({ worktreeRemoveInput: { directory: worktreeDir } }) } catch { /* best effort */ }
     }
@@ -126,9 +170,9 @@ export async function executeTeamSpawn(
   const planApproval = usePlanApproval ? "pending" : "none"
   const now = Date.now()
   deps.db.run(
-    `INSERT INTO team_member (team_id, name, session_id, agent, status, execution_status, model, prompt, worktree_dir, worktree_branch, plan_approval, time_created, time_updated)
-     VALUES (?, ?, ?, ?, 'busy', 'starting', ?, ?, ?, ?, ?, ?, ?)`,
-    [teamInfo.teamId, args.name, childSessionId, args.agent, args.model ?? null, args.prompt, worktreeDir, worktreeBranch, planApproval, now, now]
+    `INSERT INTO team_member (team_id, name, session_id, agent, status, execution_status, model, prompt, worktree_dir, worktree_branch, workspace_id, plan_approval, time_created, time_updated)
+     VALUES (?, ?, ?, ?, 'busy', 'starting', ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [teamInfo.teamId, args.name, childSessionId, args.agent, args.model ?? null, args.prompt, worktreeDir, worktreeBranch, workspaceId, planApproval, now, now]
   )
 
   // Register in memory
@@ -140,8 +184,22 @@ export async function executeTeamSpawn(
     `Your agent type is "${args.agent}".`,
   ]
 
-  if (worktreeBranch) {
-    context.push(`You are working on branch "${worktreeBranch}" in your own worktree. Your changes are isolated from other teammates.`)
+  if (worktreeBranch && worktreeDir && !workspaceId) {
+    // Workspace binding failed — fallback to prompt-based CWD instruction
+    context.push(
+      `You are working on branch "${worktreeBranch}" in your own worktree at: ${worktreeDir}`,
+      `Your changes are isolated from other teammates.`,
+      `IMPORTANT: All file operations and shell commands MUST target your worktree directory.`,
+      `Before running shell commands, cd to: ${worktreeDir}`,
+    )
+  } else if (worktreeBranch && worktreeDir) {
+    // Workspace binding active — server handles CWD
+    context.push(
+      `You are working on branch "${worktreeBranch}" in your own isolated worktree.`,
+      `Your changes are isolated from other teammates.`,
+    )
+  } else if (worktreeBranch) {
+    context.push(`You are working on branch "${worktreeBranch}". Your changes are isolated from other teammates.`)
   }
 
   // Plan approval mode — teammate must send plan before writing
@@ -155,20 +213,55 @@ export async function executeTeamSpawn(
     )
   }
 
+  if (isReadOnly) {
+    context.push(
+      "", "Tools available to you:",
+      "- team_message: send a message to the lead or another teammate",
+      "- team_broadcast: send a message to all team members",
+      "- team_tasks_list: view the shared team task board",
+    )
+  } else {
+    context.push(
+      "", "Tools available to you:",
+      "- team_message: send a message to the lead or another teammate",
+      "- team_broadcast: send a message to all team members",
+      "- team_tasks_list: view the shared team task board",
+      "- team_tasks_add: add tasks to the shared board",
+      "- team_tasks_complete: mark a task complete on the shared board",
+      "- team_claim: claim a pending task from the shared board",
+    )
+  }
+
+  context.push("", "When you finish your task:")
+  if (!isReadOnly && worktreeBranch) {
+    context.push(`1. Commit your changes: git add -A && git commit -m "your summary"`)
+    context.push("2. If you claimed a task, mark it complete using team_tasks_complete.")
+    context.push(
+      "3. Send ONE message to the lead using team_message with this format:",
+    )
+  } else if (!isReadOnly) {
+    context.push("1. If you claimed a task, mark it complete using team_tasks_complete.")
+    context.push(
+      "2. Send ONE message to the lead using team_message with this format:",
+    )
+  } else {
+    context.push(
+      "1. Send ONE message to the lead using team_message with this format:",
+    )
+  }
   context.push(
-    "",
-    "Tools available to you:",
-    "- team_message: send a message to the lead or another teammate",
-    "- team_broadcast: send a message to all team members",
-    "- team_tasks_list: view the shared team task board",
-    "- team_tasks_add: add tasks to the shared board",
-    "- team_tasks_complete: mark a task complete on the shared board",
-    "- team_claim: claim a pending task from the shared board",
-    "",
-    "When you finish your task:",
-    "1. If you claimed a task, mark it complete using team_tasks_complete.",
-    "2. Send ONE message to the lead with your findings using team_message.",
-    "3. STOP. Do not send follow-up confirmations, status updates, or 'standing by' messages.",
+    "<task-result>",
+    "<status>completed or failed</status>",
+    "<summary>One-line summary of what you did</summary>",
+    "<details>Full findings or changes made</details>",
+  )
+  if (worktreeBranch) {
+    context.push(`<branch>${worktreeBranch}</branch>`)
+  }
+  context.push("</task-result>")
+  const lastStep = !isReadOnly && worktreeBranch ? "4" : !isReadOnly ? "3" : "2"
+  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.",
     "",
@@ -200,6 +293,9 @@ export async function executeTeamSpawn(
       deps.db.run("DELETE FROM team_member WHERE team_id = ? AND session_id = ?", [teamInfo.teamId, childSessionId])
       deps.registry.unregister(childSessionId)
       deps.client.session.abort({ sessionID: childSessionId }).catch(() => { /* best effort */ })
+      if (workspaceId) {
+        deps.client.workspace.remove({ id: workspaceId }).catch(() => { /* best effort */ })
+      }
       if (worktreeDir) {
         deps.client.worktree.remove({ worktreeRemoveInput: { directory: worktreeDir } }).catch(() => { /* best effort */ })
       }

package/src/tools/team-status.ts

@@ -1,5 +1,5 @@
 import type { ToolDeps } from "../types"
-import { findTeamBySession } from "../types"
+import { requireTeamMember } from "./shared"
 
 /** Tracks the last time team_status was called per team ID (epoch ms). */
 export const lastCallTime = new Map<string, number>()
@@ -13,8 +13,7 @@ export async function executeTeamStatus(
   deps: ToolDeps,
   sessionId: string,
 ): Promise<string> {
-  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
-  if (!teamInfo) throw new Error("This session is not in a team.")
+  const teamInfo = requireTeamMember(deps, sessionId)
 
   const now = Date.now()
   const last = lastCallTime.get(teamInfo.teamId)
@@ -24,9 +23,9 @@ export async function executeTeamStatus(
   lastCallTime.set(teamInfo.teamId, now)
 
   const members = deps.db.query(
-    "SELECT name, session_id, agent, status, execution_status, worktree_branch, plan_approval FROM team_member WHERE team_id = ? ORDER BY time_created ASC"
+    "SELECT name, session_id, agent, status, execution_status, worktree_branch, worktree_dir, plan_approval FROM team_member WHERE team_id = ? ORDER BY time_created ASC"
   ).all(teamInfo.teamId) as Array<{
-    name: string; session_id: string; agent: string; status: string; execution_status: string; worktree_branch: string | null; plan_approval: string
+    name: string; session_id: string; agent: string; status: string; execution_status: string; worktree_branch: string | null; worktree_dir: string | null; plan_approval: string
   }>
 
   const tasks = deps.db.query(
@@ -46,6 +45,9 @@ export async function executeTeamStatus(
       const branch = m.worktree_branch ? `  branch: ${m.worktree_branch}` : ""
       const plan = m.plan_approval !== "none" ? `, plan: ${m.plan_approval}` : ""
       lines.push(`  ${m.name}  [${statusIcon}${plan}]  agent: ${m.agent}${branch}  session: ${m.session_id}`)
+      if (m.worktree_dir) {
+        lines.push(`    worktree: ${m.worktree_dir}`)
+      }
     }
   }
 

package/src/tools/team-tasks-add.ts

@@ -1,5 +1,5 @@
 import type { ToolDeps } from "../types"
-import { findTeamBySession } from "../types"
+import { requireTeamMember } from "./shared"
 import { generateId } from "../util"
 
 interface TaskInput {
@@ -17,8 +17,7 @@ export async function executeTeamTasksAdd(
   args: { tasks: TaskInput[] },
   sessionId: string,
 ): Promise<string> {
-  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
-  if (!teamInfo) throw new Error("This session is not in a team.")
+  const teamInfo = requireTeamMember(deps, sessionId)
 
   const ids: string[] = []
   const now = Date.now()

package/src/tools/team-tasks-complete.ts

@@ -1,5 +1,5 @@
 import type { ToolDeps } from "../types"
-import { findTeamBySession } from "../types"
+import { requireTeamMember } from "./shared"
 
 /**
  * Execute the team_tasks_complete tool. Marks a task as completed
@@ -10,8 +10,7 @@ export async function executeTeamTasksComplete(
   args: { task_id: string },
   sessionId: string,
 ): Promise<string> {
-  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
-  if (!teamInfo) throw new Error("This session is not in a team.")
+  const teamInfo = requireTeamMember(deps, sessionId)
 
   const task = deps.db.query("SELECT * FROM team_task WHERE id = ? AND team_id = ?")
     .get(args.task_id, teamInfo.teamId) as Record<string, unknown> | null

package/src/tools/team-tasks-list.ts

@@ -1,5 +1,5 @@
 import type { ToolDeps } from "../types"
-import { findTeamBySession } from "../types"
+import { requireTeamMember } from "./shared"
 
 /**
  * Execute the team_tasks_list tool. Shows all tasks on the shared board.
@@ -8,8 +8,7 @@ export async function executeTeamTasksList(
   deps: ToolDeps,
   sessionId: string,
 ): Promise<string> {
-  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
-  if (!teamInfo) throw new Error("This session is not in a team.")
+  const teamInfo = requireTeamMember(deps, sessionId)
 
   const tasks = deps.db.query(
     "SELECT * FROM team_task WHERE team_id = ? ORDER BY time_created ASC"

package/src/tools/team-view.ts

@@ -1,5 +1,5 @@
 import type { ToolDeps } from "../types"
-import { findTeamBySession } from "../types"
+import { requireTeamMember } from "./shared"
 
 /**
  * Execute the team_view tool. Navigates the TUI to a teammate's session
@@ -10,8 +10,7 @@ export async function executeTeamView(
   args: { member: string },
   sessionId: string,
 ): Promise<string> {
-  const teamInfo = findTeamBySession(deps.db, deps.registry, sessionId)
-  if (!teamInfo) throw new Error("This session is not in a team.")
+  const teamInfo = requireTeamMember(deps, sessionId)
 
   const member = deps.db.query("SELECT session_id, status, agent FROM team_member WHERE team_id = ? AND name = ?")
     .get(teamInfo.teamId, args.member) as { session_id: string; status: string; agent: string } | null

package/src/types.ts

@@ -62,6 +62,11 @@ export interface PluginClient {
     list(): Promise<{ data?: Array<{ name: string; branch: string; directory: string }> }>
     reset(options: { worktreeResetInput?: { directory: string } }): Promise<unknown>
   }
+  workspace: {
+    create(options: { id?: string; type?: string; branch?: string | null; extra?: unknown | null }): Promise<{ data?: { id: string; type: string; branch: string | null; directory: string | null; projectID: string } }>
+    remove(options: { id: string }): Promise<unknown>
+    list(): Promise<{ data?: Array<{ id: string; type: string; branch: string | null; directory: string | null; projectID: string }> }>
+  }
 }
 
 /**