lcclaude 1.0.0

package/dist/src/utils/swarm/spawnInProcess.js

@@ -0,0 +1,164 @@
+import sample from "lodash-es/sample.js";
+import { getSessionId } from "../../bootstrap/state.js";
+import { getSpinnerVerbs } from "../../constants/spinnerVerbs.js";
+import { TURN_COMPLETION_VERBS } from "../../constants/turnCompletionVerbs.js";
+import { createTaskStateBase, generateTaskId } from "../../Task.js";
+import { createAbortController } from "../abortController.js";
+import { formatAgentId } from "../agentId.js";
+import { registerCleanup } from "../cleanupRegistry.js";
+import { logForDebugging } from "../debug.js";
+import { emitTaskTerminatedSdk } from "../sdkEventQueue.js";
+import { evictTaskOutput } from "../task/diskOutput.js";
+import {
+  evictTerminalTask,
+  registerTask,
+  STOPPED_DISPLAY_MS
+} from "../task/framework.js";
+import { createTeammateContext } from "../teammateContext.js";
+import {
+  isPerfettoTracingEnabled,
+  registerAgent as registerPerfettoAgent,
+  unregisterAgent as unregisterPerfettoAgent
+} from "../telemetry/perfettoTracing.js";
+import { removeMemberByAgentId } from "./teamHelpers.js";
+export async function spawnInProcessTeammate(config, context) {
+  const { name, teamName, prompt, color, planModeRequired, model } = config;
+  const { setAppState } = context;
+  const agentId = formatAgentId(name, teamName);
+  const taskId = generateTaskId("in_process_teammate");
+  logForDebugging(`[spawnInProcessTeammate] Spawning ${agentId} (taskId: ${taskId})`);
+  try {
+    const abortController = createAbortController();
+    const parentSessionId = getSessionId();
+    const identity = {
+      agentId,
+      agentName: name,
+      teamName,
+      color,
+      planModeRequired,
+      parentSessionId
+    };
+    const teammateContext = createTeammateContext({
+      agentId,
+      agentName: name,
+      teamName,
+      color,
+      planModeRequired,
+      parentSessionId,
+      abortController
+    });
+    if (isPerfettoTracingEnabled()) {
+      registerPerfettoAgent(agentId, name, parentSessionId);
+    }
+    const description = `${name}: ${prompt.substring(0, 50)}${prompt.length > 50 ? "..." : ""}`;
+    const taskState = {
+      ...createTaskStateBase(taskId, "in_process_teammate", description, context.toolUseId),
+      type: "in_process_teammate",
+      status: "running",
+      identity,
+      prompt,
+      model,
+      abortController,
+      awaitingPlanApproval: false,
+      spinnerVerb: sample(getSpinnerVerbs()),
+      pastTenseVerb: sample(TURN_COMPLETION_VERBS),
+      permissionMode: planModeRequired ? "plan" : "default",
+      isIdle: false,
+      shutdownRequested: false,
+      lastReportedToolCount: 0,
+      lastReportedTokenCount: 0,
+      pendingUserMessages: [],
+      messages: []
+    };
+    const unregisterCleanup = registerCleanup(async () => {
+      logForDebugging(`[spawnInProcessTeammate] Cleanup called for ${agentId}`);
+      abortController.abort();
+    });
+    taskState.unregisterCleanup = unregisterCleanup;
+    registerTask(taskState, setAppState);
+    logForDebugging(`[spawnInProcessTeammate] Registered ${agentId} in AppState`);
+    return {
+      success: true,
+      agentId,
+      taskId,
+      abortController,
+      teammateContext
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error during spawn";
+    logForDebugging(`[spawnInProcessTeammate] Failed to spawn ${agentId}: ${errorMessage}`);
+    return {
+      success: false,
+      agentId,
+      error: errorMessage
+    };
+  }
+}
+export function killInProcessTeammate(taskId, setAppState) {
+  let killed = false;
+  let teamName = null;
+  let agentId = null;
+  let toolUseId;
+  let description;
+  setAppState((prev) => {
+    const task = prev.tasks[taskId];
+    if (!task || task.type !== "in_process_teammate") {
+      return prev;
+    }
+    const teammateTask = task;
+    if (teammateTask.status !== "running") {
+      return prev;
+    }
+    teamName = teammateTask.identity.teamName;
+    agentId = teammateTask.identity.agentId;
+    toolUseId = teammateTask.toolUseId;
+    description = teammateTask.description;
+    teammateTask.abortController?.abort();
+    teammateTask.unregisterCleanup?.();
+    killed = true;
+    teammateTask.onIdleCallbacks?.forEach((cb) => cb());
+    let updatedTeamContext = prev.teamContext;
+    if (prev.teamContext && prev.teamContext.teammates && agentId) {
+      const { [agentId]: _, ...remainingTeammates } = prev.teamContext.teammates;
+      updatedTeamContext = {
+        ...prev.teamContext,
+        teammates: remainingTeammates
+      };
+    }
+    return {
+      ...prev,
+      teamContext: updatedTeamContext,
+      tasks: {
+        ...prev.tasks,
+        [taskId]: {
+          ...teammateTask,
+          status: "killed",
+          notified: true,
+          endTime: Date.now(),
+          onIdleCallbacks: [],
+          messages: teammateTask.messages?.length ? [teammateTask.messages[teammateTask.messages.length - 1]] : undefined,
+          pendingUserMessages: [],
+          inProgressToolUseIDs: undefined,
+          abortController: undefined,
+          unregisterCleanup: undefined,
+          currentWorkAbortController: undefined
+        }
+      }
+    };
+  });
+  if (teamName && agentId) {
+    removeMemberByAgentId(teamName, agentId);
+  }
+  if (killed) {
+    evictTaskOutput(taskId);
+    emitTaskTerminatedSdk(taskId, "stopped", {
+      toolUseId,
+      summary: description
+    });
+    setTimeout(evictTerminalTask.bind(null, taskId, setAppState), STOPPED_DISPLAY_MS);
+  }
+  if (agentId) {
+    unregisterPerfettoAgent(agentId);
+  }
+  return killed;
+}

package/dist/src/utils/swarm/spawnUtils.js

@@ -0,0 +1,76 @@
+import {
+  getChromeFlagOverride,
+  getFlagSettingsPath,
+  getInlinePlugins,
+  getMainLoopModelOverride,
+  getSessionBypassPermissionsMode
+} from "../../bootstrap/state.js";
+import { quote } from "../bash/shellQuote.js";
+import { isInBundledMode } from "../bundledMode.js";
+import { getTeammateModeFromSnapshot } from "./backends/teammateModeSnapshot.js";
+import { TEAMMATE_COMMAND_ENV_VAR } from "./constants.js";
+export function getTeammateCommand() {
+  if (process.env[TEAMMATE_COMMAND_ENV_VAR]) {
+    return process.env[TEAMMATE_COMMAND_ENV_VAR];
+  }
+  return isInBundledMode() ? process.execPath : process.argv[1];
+}
+export function buildInheritedCliFlags(options) {
+  const flags = [];
+  const { planModeRequired, permissionMode } = options || {};
+  if (planModeRequired) {} else if (permissionMode === "bypassPermissions" || getSessionBypassPermissionsMode()) {
+    flags.push("--dangerously-skip-permissions");
+  } else if (permissionMode === "acceptEdits") {
+    flags.push("--permission-mode acceptEdits");
+  }
+  const modelOverride = getMainLoopModelOverride();
+  if (modelOverride) {
+    flags.push(`--model ${quote([modelOverride])}`);
+  }
+  const settingsPath = getFlagSettingsPath();
+  if (settingsPath) {
+    flags.push(`--settings ${quote([settingsPath])}`);
+  }
+  const inlinePlugins = getInlinePlugins();
+  for (const pluginDir of inlinePlugins) {
+    flags.push(`--plugin-dir ${quote([pluginDir])}`);
+  }
+  const sessionMode = getTeammateModeFromSnapshot();
+  flags.push(`--teammate-mode ${sessionMode}`);
+  const chromeFlagOverride = getChromeFlagOverride();
+  if (chromeFlagOverride === true) {
+    flags.push("--chrome");
+  } else if (chromeFlagOverride === false) {
+    flags.push("--no-chrome");
+  }
+  return flags.join(" ");
+}
+const TEAMMATE_ENV_VARS = [
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  "CLAUDE_CODE_USE_FOUNDRY",
+  "ANTHROPIC_BASE_URL",
+  "CLAUDE_CONFIG_DIR",
+  "CLAUDE_CODE_REMOTE",
+  "CLAUDE_CODE_REMOTE_MEMORY_DIR",
+  "HTTPS_PROXY",
+  "https_proxy",
+  "HTTP_PROXY",
+  "http_proxy",
+  "NO_PROXY",
+  "no_proxy",
+  "SSL_CERT_FILE",
+  "NODE_EXTRA_CA_CERTS",
+  "REQUESTS_CA_BUNDLE",
+  "CURL_CA_BUNDLE"
+];
+export function buildInheritedEnvVars() {
+  const envVars = ["CLAUDECODE=1", "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1"];
+  for (const key of TEAMMATE_ENV_VARS) {
+    const value = process.env[key];
+    if (value !== undefined && value !== "") {
+      envVars.push(`${key}=${quote([value])}`);
+    }
+  }
+  return envVars.join(" ");
+}

package/dist/src/utils/swarm/teamHelpers.js

@@ -0,0 +1,320 @@
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { join } from "path";
+import { z } from "zod/v4";
+import { getSessionCreatedTeams } from "../../bootstrap/state.js";
+import { logForDebugging } from "../debug.js";
+import { getTeamsDir } from "../envUtils.js";
+import { errorMessage, getErrnoCode } from "../errors.js";
+import { execFileNoThrowWithCwd } from "../execFileNoThrow.js";
+import { gitExe } from "../git.js";
+import { lazySchema } from "../lazySchema.js";
+import { jsonParse, jsonStringify } from "../slowOperations.js";
+import { getTasksDir, notifyTasksUpdated } from "../tasks.js";
+import { getAgentName, getTeamName, isTeammate } from "../teammate.js";
+import { isPaneBackend } from "./backends/types.js";
+import { TEAM_LEAD_NAME } from "./constants.js";
+export const inputSchema = lazySchema(() => z.strictObject({
+  operation: z.enum(["spawnTeam", "cleanup"]).describe("Operation: spawnTeam to create a team, cleanup to remove team and task directories."),
+  agent_type: z.string().optional().describe('Type/role of the team lead (e.g., "researcher", "test-runner"). ' + "Used for team file and inter-agent coordination."),
+  team_name: z.string().optional().describe("Name for the new team to create (required for spawnTeam)."),
+  description: z.string().optional().describe("Team description/purpose (only used with spawnTeam).")
+}));
+export function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase();
+}
+export function sanitizeAgentName(name) {
+  return name.replace(/@/g, "-");
+}
+export function getTeamDir(teamName) {
+  return join(getTeamsDir(), sanitizeName(teamName));
+}
+export function getTeamFilePath(teamName) {
+  return join(getTeamDir(teamName), "config.json");
+}
+export function readTeamFile(teamName) {
+  try {
+    const content = readFileSync(getTeamFilePath(teamName), "utf-8");
+    return jsonParse(content);
+  } catch (e) {
+    if (getErrnoCode(e) === "ENOENT")
+      return null;
+    logForDebugging(`[TeammateTool] Failed to read team file for ${teamName}: ${errorMessage(e)}`);
+    return null;
+  }
+}
+export async function readTeamFileAsync(teamName) {
+  try {
+    const content = await readFile(getTeamFilePath(teamName), "utf-8");
+    return jsonParse(content);
+  } catch (e) {
+    if (getErrnoCode(e) === "ENOENT")
+      return null;
+    logForDebugging(`[TeammateTool] Failed to read team file for ${teamName}: ${errorMessage(e)}`);
+    return null;
+  }
+}
+function writeTeamFile(teamName, teamFile) {
+  const teamDir = getTeamDir(teamName);
+  mkdirSync(teamDir, { recursive: true });
+  writeFileSync(getTeamFilePath(teamName), jsonStringify(teamFile, null, 2));
+}
+export async function writeTeamFileAsync(teamName, teamFile) {
+  const teamDir = getTeamDir(teamName);
+  await mkdir(teamDir, { recursive: true });
+  await writeFile(getTeamFilePath(teamName), jsonStringify(teamFile, null, 2));
+}
+export function removeTeammateFromTeamFile(teamName, identifier) {
+  const identifierStr = identifier.agentId || identifier.name;
+  if (!identifierStr) {
+    logForDebugging("[TeammateTool] removeTeammateFromTeamFile called with no identifier");
+    return false;
+  }
+  const teamFile = readTeamFile(teamName);
+  if (!teamFile) {
+    logForDebugging(`[TeammateTool] Cannot remove teammate ${identifierStr}: failed to read team file for "${teamName}"`);
+    return false;
+  }
+  const originalLength = teamFile.members.length;
+  teamFile.members = teamFile.members.filter((m) => {
+    if (identifier.agentId && m.agentId === identifier.agentId)
+      return false;
+    if (identifier.name && m.name === identifier.name)
+      return false;
+    return true;
+  });
+  if (teamFile.members.length === originalLength) {
+    logForDebugging(`[TeammateTool] Teammate ${identifierStr} not found in team file for "${teamName}"`);
+    return false;
+  }
+  writeTeamFile(teamName, teamFile);
+  logForDebugging(`[TeammateTool] Removed teammate from team file: ${identifierStr}`);
+  return true;
+}
+export function addHiddenPaneId(teamName, paneId) {
+  const teamFile = readTeamFile(teamName);
+  if (!teamFile) {
+    return false;
+  }
+  const hiddenPaneIds = teamFile.hiddenPaneIds ?? [];
+  if (!hiddenPaneIds.includes(paneId)) {
+    hiddenPaneIds.push(paneId);
+    teamFile.hiddenPaneIds = hiddenPaneIds;
+    writeTeamFile(teamName, teamFile);
+    logForDebugging(`[TeammateTool] Added ${paneId} to hidden panes for team ${teamName}`);
+  }
+  return true;
+}
+export function removeHiddenPaneId(teamName, paneId) {
+  const teamFile = readTeamFile(teamName);
+  if (!teamFile) {
+    return false;
+  }
+  const hiddenPaneIds = teamFile.hiddenPaneIds ?? [];
+  const index = hiddenPaneIds.indexOf(paneId);
+  if (index !== -1) {
+    hiddenPaneIds.splice(index, 1);
+    teamFile.hiddenPaneIds = hiddenPaneIds;
+    writeTeamFile(teamName, teamFile);
+    logForDebugging(`[TeammateTool] Removed ${paneId} from hidden panes for team ${teamName}`);
+  }
+  return true;
+}
+export function removeMemberFromTeam(teamName, tmuxPaneId) {
+  const teamFile = readTeamFile(teamName);
+  if (!teamFile) {
+    return false;
+  }
+  const memberIndex = teamFile.members.findIndex((m) => m.tmuxPaneId === tmuxPaneId);
+  if (memberIndex === -1) {
+    return false;
+  }
+  teamFile.members.splice(memberIndex, 1);
+  if (teamFile.hiddenPaneIds) {
+    const hiddenIndex = teamFile.hiddenPaneIds.indexOf(tmuxPaneId);
+    if (hiddenIndex !== -1) {
+      teamFile.hiddenPaneIds.splice(hiddenIndex, 1);
+    }
+  }
+  writeTeamFile(teamName, teamFile);
+  logForDebugging(`[TeammateTool] Removed member with pane ${tmuxPaneId} from team ${teamName}`);
+  return true;
+}
+export function removeMemberByAgentId(teamName, agentId) {
+  const teamFile = readTeamFile(teamName);
+  if (!teamFile) {
+    return false;
+  }
+  const memberIndex = teamFile.members.findIndex((m) => m.agentId === agentId);
+  if (memberIndex === -1) {
+    return false;
+  }
+  teamFile.members.splice(memberIndex, 1);
+  writeTeamFile(teamName, teamFile);
+  logForDebugging(`[TeammateTool] Removed member ${agentId} from team ${teamName}`);
+  return true;
+}
+export function setMemberMode(teamName, memberName, mode) {
+  const teamFile = readTeamFile(teamName);
+  if (!teamFile) {
+    return false;
+  }
+  const member = teamFile.members.find((m) => m.name === memberName);
+  if (!member) {
+    logForDebugging(`[TeammateTool] Cannot set member mode: member ${memberName} not found in team ${teamName}`);
+    return false;
+  }
+  if (member.mode === mode) {
+    return true;
+  }
+  const updatedMembers = teamFile.members.map((m) => m.name === memberName ? { ...m, mode } : m);
+  writeTeamFile(teamName, { ...teamFile, members: updatedMembers });
+  logForDebugging(`[TeammateTool] Set member ${memberName} in team ${teamName} to mode: ${mode}`);
+  return true;
+}
+export function syncTeammateMode(mode, teamNameOverride) {
+  if (!isTeammate())
+    return;
+  const teamName = teamNameOverride ?? getTeamName();
+  const agentName = getAgentName();
+  if (teamName && agentName) {
+    setMemberMode(teamName, agentName, mode);
+  }
+}
+export function setMultipleMemberModes(teamName, modeUpdates) {
+  const teamFile = readTeamFile(teamName);
+  if (!teamFile) {
+    return false;
+  }
+  const updateMap = new Map(modeUpdates.map((u) => [u.memberName, u.mode]));
+  let anyChanged = false;
+  const updatedMembers = teamFile.members.map((member) => {
+    const newMode = updateMap.get(member.name);
+    if (newMode !== undefined && member.mode !== newMode) {
+      anyChanged = true;
+      return { ...member, mode: newMode };
+    }
+    return member;
+  });
+  if (anyChanged) {
+    writeTeamFile(teamName, { ...teamFile, members: updatedMembers });
+    logForDebugging(`[TeammateTool] Set ${modeUpdates.length} member modes in team ${teamName}`);
+  }
+  return true;
+}
+export async function setMemberActive(teamName, memberName, isActive) {
+  const teamFile = await readTeamFileAsync(teamName);
+  if (!teamFile) {
+    logForDebugging(`[TeammateTool] Cannot set member active: team ${teamName} not found`);
+    return;
+  }
+  const member = teamFile.members.find((m) => m.name === memberName);
+  if (!member) {
+    logForDebugging(`[TeammateTool] Cannot set member active: member ${memberName} not found in team ${teamName}`);
+    return;
+  }
+  if (member.isActive === isActive) {
+    return;
+  }
+  member.isActive = isActive;
+  await writeTeamFileAsync(teamName, teamFile);
+  logForDebugging(`[TeammateTool] Set member ${memberName} in team ${teamName} to ${isActive ? "active" : "idle"}`);
+}
+async function destroyWorktree(worktreePath) {
+  const gitFilePath = join(worktreePath, ".git");
+  let mainRepoPath = null;
+  try {
+    const gitFileContent = (await readFile(gitFilePath, "utf-8")).trim();
+    const match = gitFileContent.match(/^gitdir:\s*(.+)$/);
+    if (match && match[1]) {
+      const worktreeGitDir = match[1];
+      const mainGitDir = join(worktreeGitDir, "..", "..");
+      mainRepoPath = join(mainGitDir, "..");
+    }
+  } catch {}
+  if (mainRepoPath) {
+    const result = await execFileNoThrowWithCwd(gitExe(), ["worktree", "remove", "--force", worktreePath], { cwd: mainRepoPath });
+    if (result.code === 0) {
+      logForDebugging(`[TeammateTool] Removed worktree via git: ${worktreePath}`);
+      return;
+    }
+    if (result.stderr?.includes("not a working tree")) {
+      logForDebugging(`[TeammateTool] Worktree already removed: ${worktreePath}`);
+      return;
+    }
+    logForDebugging(`[TeammateTool] git worktree remove failed, falling back to rm: ${result.stderr}`);
+  }
+  try {
+    await rm(worktreePath, { recursive: true, force: true });
+    logForDebugging(`[TeammateTool] Removed worktree directory manually: ${worktreePath}`);
+  } catch (error) {
+    logForDebugging(`[TeammateTool] Failed to remove worktree ${worktreePath}: ${errorMessage(error)}`);
+  }
+}
+export function registerTeamForSessionCleanup(teamName) {
+  getSessionCreatedTeams().add(teamName);
+}
+export function unregisterTeamForSessionCleanup(teamName) {
+  getSessionCreatedTeams().delete(teamName);
+}
+export async function cleanupSessionTeams() {
+  const sessionCreatedTeams = getSessionCreatedTeams();
+  if (sessionCreatedTeams.size === 0)
+    return;
+  const teams = Array.from(sessionCreatedTeams);
+  logForDebugging(`cleanupSessionTeams: removing ${teams.length} orphan team dir(s): ${teams.join(", ")}`);
+  await Promise.allSettled(teams.map((name) => killOrphanedTeammatePanes(name)));
+  await Promise.allSettled(teams.map((name) => cleanupTeamDirectories(name)));
+  sessionCreatedTeams.clear();
+}
+async function killOrphanedTeammatePanes(teamName) {
+  const teamFile = readTeamFile(teamName);
+  if (!teamFile)
+    return;
+  const paneMembers = teamFile.members.filter((m) => m.name !== TEAM_LEAD_NAME && m.tmuxPaneId && m.backendType && isPaneBackend(m.backendType));
+  if (paneMembers.length === 0)
+    return;
+  const [{ ensureBackendsRegistered, getBackendByType }, { isInsideTmux }] = await Promise.all([
+    import("./backends/registry.js"),
+    import("./backends/detection.js")
+  ]);
+  await ensureBackendsRegistered();
+  const useExternalSession = !await isInsideTmux();
+  await Promise.allSettled(paneMembers.map(async (m) => {
+    if (!m.tmuxPaneId || !m.backendType || !isPaneBackend(m.backendType)) {
+      return;
+    }
+    const ok = await getBackendByType(m.backendType).killPane(m.tmuxPaneId, useExternalSession);
+    logForDebugging(`cleanupSessionTeams: killPane ${m.name} (${m.backendType} ${m.tmuxPaneId}) → ${ok}`);
+  }));
+}
+export async function cleanupTeamDirectories(teamName) {
+  const sanitizedName = sanitizeName(teamName);
+  const teamFile = readTeamFile(teamName);
+  const worktreePaths = [];
+  if (teamFile) {
+    for (const member of teamFile.members) {
+      if (member.worktreePath) {
+        worktreePaths.push(member.worktreePath);
+      }
+    }
+  }
+  for (const worktreePath of worktreePaths) {
+    await destroyWorktree(worktreePath);
+  }
+  const teamDir = getTeamDir(teamName);
+  try {
+    await rm(teamDir, { recursive: true, force: true });
+    logForDebugging(`[TeammateTool] Cleaned up team directory: ${teamDir}`);
+  } catch (error) {
+    logForDebugging(`[TeammateTool] Failed to clean up team directory ${teamDir}: ${errorMessage(error)}`);
+  }
+  const tasksDir = getTasksDir(sanitizedName);
+  try {
+    await rm(tasksDir, { recursive: true, force: true });
+    logForDebugging(`[TeammateTool] Cleaned up tasks directory: ${tasksDir}`);
+    notifyTasksUpdated();
+  } catch (error) {
+    logForDebugging(`[TeammateTool] Failed to clean up tasks directory ${tasksDir}: ${errorMessage(error)}`);
+  }
+}

package/dist/src/utils/swarm/teammateInit.js

@@ -0,0 +1,65 @@
+import { logForDebugging } from "../debug.js";
+import { addFunctionHook } from "../hooks/sessionHooks.js";
+import { applyPermissionUpdate } from "../permissions/PermissionUpdate.js";
+import { jsonStringify } from "../slowOperations.js";
+import { getTeammateColor } from "../teammate.js";
+import {
+  createIdleNotification,
+  getLastPeerDmSummary,
+  writeToMailbox
+} from "../teammateMailbox.js";
+import { readTeamFile, setMemberActive } from "./teamHelpers.js";
+export function initializeTeammateHooks(setAppState, sessionId, teamInfo) {
+  const { teamName, agentId, agentName } = teamInfo;
+  const teamFile = readTeamFile(teamName);
+  if (!teamFile) {
+    logForDebugging(`[TeammateInit] Team file not found for team: ${teamName}`);
+    return;
+  }
+  const leadAgentId = teamFile.leadAgentId;
+  if (teamFile.teamAllowedPaths && teamFile.teamAllowedPaths.length > 0) {
+    logForDebugging(`[TeammateInit] Found ${teamFile.teamAllowedPaths.length} team-wide allowed path(s)`);
+    for (const allowedPath of teamFile.teamAllowedPaths) {
+      const ruleContent = allowedPath.path.startsWith("/") ? `/${allowedPath.path}/**` : `${allowedPath.path}/**`;
+      logForDebugging(`[TeammateInit] Applying team permission: ${allowedPath.toolName} allowed in ${allowedPath.path} (rule: ${ruleContent})`);
+      setAppState((prev) => ({
+        ...prev,
+        toolPermissionContext: applyPermissionUpdate(prev.toolPermissionContext, {
+          type: "addRules",
+          rules: [
+            {
+              toolName: allowedPath.toolName,
+              ruleContent
+            }
+          ],
+          behavior: "allow",
+          destination: "session"
+        })
+      }));
+    }
+  }
+  const leadMember = teamFile.members.find((m) => m.agentId === leadAgentId);
+  const leadAgentName = leadMember?.name || "team-lead";
+  if (agentId === leadAgentId) {
+    logForDebugging("[TeammateInit] This agent is the team leader - skipping idle notification hook");
+    return;
+  }
+  logForDebugging(`[TeammateInit] Registering Stop hook for teammate ${agentName} to notify leader ${leadAgentName}`);
+  addFunctionHook(setAppState, sessionId, "Stop", "", async (messages, _signal) => {
+    setMemberActive(teamName, agentName, false);
+    const notification = createIdleNotification(agentName, {
+      idleReason: "available",
+      summary: getLastPeerDmSummary(messages)
+    });
+    await writeToMailbox(leadAgentName, {
+      from: agentName,
+      text: jsonStringify(notification),
+      timestamp: new Date().toISOString(),
+      color: getTeammateColor()
+    });
+    logForDebugging(`[TeammateInit] Sent idle notification to leader ${leadAgentName}`);
+    return true;
+  }, "Failed to send idle notification to team leader", {
+    timeout: 1e4
+  });
+}

package/dist/src/utils/swarm/teammateLayoutManager.js

@@ -0,0 +1,40 @@
+import { AGENT_COLORS } from "../../tools/AgentTool/agentColorManager.js";
+import { detectAndGetBackend } from "./backends/registry.js";
+const teammateColorAssignments = new Map;
+let colorIndex = 0;
+async function getBackend() {
+  return (await detectAndGetBackend()).backend;
+}
+export function assignTeammateColor(teammateId) {
+  const existing = teammateColorAssignments.get(teammateId);
+  if (existing) {
+    return existing;
+  }
+  const color = AGENT_COLORS[colorIndex % AGENT_COLORS.length];
+  teammateColorAssignments.set(teammateId, color);
+  colorIndex++;
+  return color;
+}
+export function getTeammateColor(teammateId) {
+  return teammateColorAssignments.get(teammateId);
+}
+export function clearTeammateColors() {
+  teammateColorAssignments.clear();
+  colorIndex = 0;
+}
+export async function isInsideTmux() {
+  const { isInsideTmux: checkTmux } = await import("./backends/detection.js");
+  return checkTmux();
+}
+export async function createTeammatePaneInSwarmView(teammateName, teammateColor) {
+  const backend = await getBackend();
+  return backend.createTeammatePaneInSwarmView(teammateName, teammateColor);
+}
+export async function enablePaneBorderStatus(windowTarget, useSwarmSocket = false) {
+  const backend = await getBackend();
+  return backend.enablePaneBorderStatus(windowTarget, useSwarmSocket);
+}
+export async function sendCommandToPane(paneId, command, useSwarmSocket = false) {
+  const backend = await getBackend();
+  return backend.sendCommandToPane(paneId, command, useSwarmSocket);
+}

package/dist/src/utils/swarm/teammateModel.js

@@ -0,0 +1,5 @@
+import { CLAUDE_OPUS_4_6_CONFIG } from "../model/configs.js";
+import { getAPIProvider } from "../model/providers.js";
+export function getHardcodedTeammateModelFallback() {
+  return CLAUDE_OPUS_4_6_CONFIG[getAPIProvider()];
+}

package/dist/src/utils/swarm/teammatePromptAddendum.js

@@ -0,0 +1,11 @@
+export const TEAMMATE_SYSTEM_PROMPT_ADDENDUM = `
+# Agent Teammate Communication
+
+IMPORTANT: You are running as an agent in a team. To communicate with anyone on your team:
+- Use the SendMessage tool with \`to: "<name>"\` to send messages to specific teammates
+- Use the SendMessage tool with \`to: "*"\` sparingly for team-wide broadcasts
+
+Just writing a response in text is not visible to others on your team - you MUST use the SendMessage tool.
+
+The user interacts primarily with the team lead. Your work is coordinated through the task system and teammate messaging.
+`;