claudedesk 4.1.1 → 4.3.0

package/CLAUDE.md

@@ -0,0 +1,96 @@
+# ClaudeDesk
+
+Electron desktop app wrapping Claude Code CLI with multi-session terminals, split views, and agent team visualization.
+
+## Tech Stack
+
+Electron 28 | React 18 | TypeScript | xterm.js | node-pty | Tailwind CSS | reactflow
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────┐
+│  Main Process (Node.js)                     │
+│  8 managers + IPC handlers + session pool   │
+└──────────────────┬──────────────────────────┘
+                   │ IPC (80 methods)
+┌──────────────────┴──────────────────────────┐
+│  Preload (auto-derived context bridge)      │
+└──────────────────┬──────────────────────────┘
+                   │
+┌──────────────────┴──────────────────────────┐
+│  Renderer (React 18)                        │
+│  Hooks → Components → UI                   │
+└─────────────────────────────────────────────┘
+```
+
+**3-layer pattern per domain:** Manager (main) → Hook (renderer) → Components (renderer)
+
+**IPC contract** (`src/shared/ipc-contract.ts`) is the single source of truth — 80 methods. The preload bridge and `ElectronAPI` type are auto-derived from it.
+
+## Domain Map
+
+| Domain | Main (manager) | Renderer (hook + UI) | Shared types | IPC prefix |
+|--------|---------------|---------------------|-------------|------------|
+| Sessions | session-manager, cli-manager, session-pool, session-persistence | useSessionManager, Terminal | ipc-types.ts | `session:*` |
+| Split View | settings-persistence | useSplitView, SplitLayout, PaneHeader, PaneSessionPicker | ipc-types.ts | `settings:*` |
+| Agent Teams | agent-team-manager | useAgentTeams, useAutoTeamLayout, useMessageStream, TeamPanel, TaskBoard, MessageStream, AgentGraph | ipc-types.ts, message-parser.ts | `teams:*` |
+| Templates | prompt-templates-manager, built-in-actions | useCommandPalette, CommandPalette, TemplateEditor | types/prompt-templates.ts | `template:*` |
+| History | history-manager | useHistory, HistoryPanel | types/history-types.ts | `history:*` |
+| Checkpoints | checkpoint-manager, checkpoint-persistence | useCheckpoints, CheckpointPanel, CheckpointDialog | types/checkpoint-types.ts | `checkpoint:*` |
+| Quota | quota-service | useQuota, BudgetPanel, BudgetSettings | ipc-types.ts | `quota:*`, `burnRate:*` |
+| Drag-Drop | file-dragdrop-handler, file-utils | useDragDrop, DragDropOverlay, DragDropContextMenu, DragDropSettings | ipc-types.ts | `dragdrop:*` |
+| Workspaces | settings-persistence | SettingsDialog | ipc-types.ts | `workspace:*` |
+| Atlas | atlas-manager | useAtlas, AtlasPanel | types/atlas-types.ts | `atlas:*` |
+| Window | index.ts | ConfirmDialog, SettingsDialog, AboutDialog, TitleBarBranding | ipc-types.ts | `window:*`, `dialog:*` |
+
+## Adding a New IPC Method
+
+1. Add entry to `src/shared/ipc-contract.ts` (in `IPCContractMap`)
+2. Add handler in `src/main/ipc-handlers.ts` using `registry.handle()` / `registry.on()`
+
+That's it. The preload bridge and types auto-derive.
+
+## Adding a New Domain
+
+1. Create `src/main/<domain>-manager.ts`
+2. Create `src/renderer/hooks/use<Domain>.ts`
+3. Create component(s) in `src/renderer/components/`
+4. Add IPC methods to `ipc-contract.ts` with `<domain>:*` prefix
+5. Wire manager in `src/main/index.ts` (import, instantiate, pass to `setupIPCHandlers`)
+6. Update `docs/repo-index.md`
+
+## Critical Implementation Patterns
+
+- **Directory locking**: Shell overrides in `cli-manager.ts:64-100` prevent `cd` in sessions. PowerShell needs `\r` line endings, paths need `\\` escaping.
+- **Output buffering**: 16ms batches in `CLIManager` prevent IPC flooding (~60fps).
+- **Claude readiness**: Pattern detection ("Claude Code", "Sonnet", "Tips for getting started") + 5s fallback timeout in `Terminal.tsx`.
+- **Ctrl+C interception**: Caught in `terminal.onData()`, shows `ConfirmDialog`. Never forward `\x03` to Claude (it exits).
+- **Session pool**: Pre-warmed shells in `session-pool.ts` for faster session creation. Delayed init (2.5s after app start).
+- **IPC contract**: One entry in `IPCContractMap` = auto-derived channel, kind, preload bridge method, and TypeScript type. No manual wiring needed.
+- **Split view**: `useSplitView` manages a tree of leaf/branch nodes. Max 4 panes. State persisted in settings.
+- **Agent team detection**: `AgentTeamManager` watches `~/.claude/teams/` and `~/.claude/tasks/` via `fs.watch()`. Auto-links sessions within 30s of team creation.
+
+## Pitfalls
+
+- PowerShell needs `\r` not `\n` line endings (`.replace(/\n/g, '\r')`)
+- Windows paths need `.replace(/\\/g, '\\\\')`
+- Never send Ctrl+C (`\x03`) to Claude — it exits immediately
+- Never use React hooks inside callbacks (caused SplitLayout crash — see `useSplitView.ts`)
+- Always batch PTY output (16ms `FLUSH_INTERVAL` in CLIManager)
+- `transformTree` in `useSplitView.ts` must recurse children BEFORE applying transformation (infinite recursion otherwise)
+- Reuse existing UI components from `components/ui/` for consistency
+- No global state library — React hooks only
+
+## Design Language
+
+Dark theme (Tokyo Night): bg `#1a1b26`, accent `#7aa2f7`, danger `#f7768e`, border `#292e42`
+Font: JetBrains Mono. Monospace everywhere.
+
+## Docs
+
+- [Repo Index](docs/repo-index.md) — detailed domain-to-file mapping
+- [Agent Teams Guide](docs/AGENT_TEAMS.md)
+- [Quick Start: Agent Teams](docs/QUICKSTART_AGENT_TEAMS.md)
+- [Contributing](CONTRIBUTING.md)
+- [Repository Atlas Evaluation](docs/REPO_ATLAS_EVALUATION.md)

package/CONTRIBUTING.md

@@ -284,6 +284,12 @@ describe('fuzzySearch', () => {
 
 5. **Ensure CI passes** - Once CI is set up, all checks must pass
 
+### Keeping the Atlas Current
+
+If your PR adds, removes, or renames source files:
+- Update `docs/repo-index.md` with the new file(s)
+- If a new domain is introduced, add it to the Domain Map in `CLAUDE.md`
+
 ### PR Title Format
 
 Use conventional commit style:

package/README.md

@@ -2,7 +2,7 @@
 
 ![License](https://img.shields.io/badge/license-MIT-blue.svg)
 ![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey.svg)
-![Version](https://img.shields.io/badge/version-4.1.1-green.svg)
+![Version](https://img.shields.io/badge/version-4.3.0-green.svg)
 
 > A powerful desktop terminal for Claude Code CLI with multi-session management, split-view layouts, and advanced productivity features.
 
@@ -66,6 +66,24 @@ _Screenshots coming soon! For now, see [Features](#-features) for a detailed ove
 - **Custom theme** - Tokyo Night inspired dark theme
 - **Monospace font** - JetBrains Mono for optimal readability
 
+### Agent Teams
+- **Automatic team detection** - recursively monitors `~/.claude/teams/` directories for agent team activity
+- **Team Panel** - sidebar showing team hierarchy, members with color badges, and status
+- **Task Board** - Kanban-style visualization with per-team task directories
+- **Message Stream** - real-time inter-agent communication feed (parses `@agent>` messages, strips ANSI codes)
+- **Agent Graph** - interactive node-based relationship visualization
+- **Auto-layout** - automatically arranges panes when teammates join
+- **Lifecycle management** - stale teams auto-cleaned on startup; teams removed when sessions end
+- See [Agent Teams Guide](docs/AGENT_TEAMS.md) and [Quick Start](docs/QUICKSTART_AGENT_TEAMS.md)
+
+### Repository Atlas Engine
+- **Automated codebase mapping** - scans files, analyzes imports, infers domain boundaries
+- **CLAUDE.md generation** - creates architectural atlas for AI tools to navigate the repo
+- **Domain-to-file index** - generates `docs/repo-index.md` with per-domain file tables
+- **Inline entrypoint tags** - suggests `@atlas-entrypoint` comments for key files
+- **Preview and approve** - review generated content before writing to disk
+- **Configurable settings** - domain sensitivity, max inline tags, exclude patterns
+
 ### Session Control
 - **Permission modes** - control Claude's access level per session
 - **Ctrl+C handling** - graceful session termination with confirmation

package/dist/main/agent-team-manager.js

@@ -0,0 +1,500 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentTeamManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const electron_1 = require("electron");
+const ipc_emitter_1 = require("./ipc-emitter");
+const CLAUDE_DIR = path.join(electron_1.app.getPath('home'), '.claude');
+const TEAMS_DIR = path.join(CLAUDE_DIR, 'teams');
+const TASKS_DIR = path.join(CLAUDE_DIR, 'tasks');
+const DEBOUNCE_MS = 200;
+const WATCHER_RETRY_COUNT = 3;
+const WATCHER_RETRY_DELAY_MS = 2000;
+const AUTO_LINK_WINDOW_MS = 30000; // 30 seconds
+const STALE_TEAM_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes — skip teams older than this on startup
+/**
+ * Map real Claude Code agent types to our internal types.
+ * Real values: "team-lead", "general-purpose"
+ * Our values: "lead", "teammate"
+ */
+function normalizeAgentType(raw) {
+    if (raw === 'team-lead')
+        return 'lead';
+    return 'teammate';
+}
+class AgentTeamManager {
+    constructor() {
+        this.teams = new Map();
+        this.sessionTeamMap = new Map(); // sessionId → teamName
+        this.teamsWatcher = null;
+        this.tasksWatcher = null;
+        this.debounceTimers = new Map();
+        this.emitter = null;
+        this.getSessionsFn = null;
+        this.updateSessionMetadataFn = null;
+        this.closeSessionFn = null;
+    }
+    setMainWindow(window) {
+        this.emitter = new ipc_emitter_1.IPCEmitter(window);
+    }
+    setSessionAccessors(getSessions, updateMetadata, closeSession) {
+        this.getSessionsFn = getSessions;
+        this.updateSessionMetadataFn = updateMetadata;
+        this.closeSessionFn = closeSession;
+    }
+    async initialize() {
+        // Ensure directories exist
+        this.ensureDir(TEAMS_DIR);
+        this.ensureDir(TASKS_DIR);
+        // Scan existing directories
+        await this.scanTeams();
+        await this.scanTasks();
+        // Start watchers
+        this.startTeamsWatcher();
+        this.startTasksWatcher();
+    }
+    destroy() {
+        if (this.teamsWatcher) {
+            this.teamsWatcher.close();
+            this.teamsWatcher = null;
+        }
+        if (this.tasksWatcher) {
+            this.tasksWatcher.close();
+            this.tasksWatcher = null;
+        }
+        for (const timer of this.debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
+        this.teams.clear();
+        this.sessionTeamMap.clear();
+    }
+    // ── Public API ──
+    getTeams() {
+        return Array.from(this.teams.values());
+    }
+    getTeamForSession(sessionId) {
+        const teamName = this.sessionTeamMap.get(sessionId);
+        if (!teamName)
+            return null;
+        return this.teams.get(teamName) || null;
+    }
+    getTeamSessions(teamName) {
+        if (!this.getSessionsFn)
+            return [];
+        const sessions = this.getSessionsFn();
+        return sessions.filter(s => s.teamName === teamName);
+    }
+    linkSessionToTeam(sessionId, teamName, agentId) {
+        const team = this.teams.get(teamName);
+        if (!team)
+            return false;
+        const member = team.members.find(m => m.agentId === agentId);
+        if (!member)
+            return false;
+        this.sessionTeamMap.set(sessionId, teamName);
+        if (this.updateSessionMetadataFn) {
+            this.updateSessionMetadataFn(sessionId, {
+                teamName,
+                agentId,
+                agentType: member.agentType,
+                isTeammate: member.agentType === 'teammate',
+            });
+        }
+        return true;
+    }
+    unlinkSessionFromTeam(sessionId) {
+        const hadTeam = this.sessionTeamMap.has(sessionId);
+        this.sessionTeamMap.delete(sessionId);
+        if (this.updateSessionMetadataFn) {
+            this.updateSessionMetadataFn(sessionId, {
+                teamName: undefined,
+                agentId: undefined,
+                agentType: undefined,
+                isTeammate: undefined,
+            });
+        }
+        return hadTeam;
+    }
+    async closeTeam(teamName) {
+        const team = this.teams.get(teamName);
+        if (!team || !this.closeSessionFn || !this.getSessionsFn)
+            return false;
+        const sessions = this.getSessionsFn().filter(s => s.teamName === teamName);
+        for (const session of sessions) {
+            await this.closeSessionFn(session.id);
+            this.sessionTeamMap.delete(session.id);
+        }
+        return true;
+    }
+    /**
+     * Called when a session is closed or exits.
+     * Removes the session→team mapping and cleans up the team
+     * if it has no remaining linked sessions.
+     */
+    onSessionClosed(sessionId) {
+        const teamName = this.sessionTeamMap.get(sessionId);
+        if (!teamName)
+            return;
+        this.sessionTeamMap.delete(sessionId);
+        // Check if any sessions still belong to this team
+        const hasRemaining = Array.from(this.sessionTeamMap.values()).some(t => t === teamName);
+        if (!hasRemaining) {
+            // No more sessions for this team — remove it from memory
+            this.teams.delete(teamName);
+            this.emitter?.emit('onTeamRemoved', { teamName });
+        }
+    }
+    // ── Auto-linking ──
+    autoLinkSessions(teamName) {
+        if (!this.getSessionsFn || !this.updateSessionMetadataFn)
+            return;
+        const team = this.teams.get(teamName);
+        if (!team)
+            return;
+        const now = Date.now();
+        const sessions = this.getSessionsFn();
+        // Find sessions created recently that haven't been linked
+        const recentUnlinked = sessions
+            .filter(s => !s.teamName && (now - s.createdAt) < AUTO_LINK_WINDOW_MS)
+            .sort((a, b) => a.createdAt - b.createdAt); // oldest first
+        if (recentUnlinked.length === 0)
+            return;
+        // Find the lead member
+        const leadMember = team.members.find(m => m.agentType === 'lead');
+        if (!leadMember)
+            return;
+        // Link the oldest recent session as lead
+        const leadSession = recentUnlinked.find(s => s.status === 'running') || recentUnlinked[0];
+        if (leadSession) {
+            this.linkSessionToTeam(leadSession.id, teamName, leadMember.agentId);
+            team.leadSessionId = leadSession.id;
+        }
+    }
+    // ── Directory & File Helpers ──
+    ensureDir(dir) {
+        try {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+        catch (err) {
+            console.error(`Failed to create directory ${dir}:`, err);
+        }
+    }
+    /**
+     * Scan ~/.claude/teams/ for team directories.
+     * Each team is a directory containing config.json.
+     * On startup, skip stale teams (config not modified recently).
+     */
+    async scanTeams() {
+        try {
+            const entries = fs.readdirSync(TEAMS_DIR, { withFileTypes: true });
+            const now = Date.now();
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                // Check config.json freshness — skip stale teams from previous runs
+                const configPath = path.join(TEAMS_DIR, entry.name, 'config.json');
+                try {
+                    const stat = fs.statSync(configPath);
+                    if (now - stat.mtimeMs > STALE_TEAM_THRESHOLD_MS) {
+                        continue; // Stale team from a previous session
+                    }
+                }
+                catch {
+                    continue; // No config.json
+                }
+                this.loadTeamConfig(entry.name);
+            }
+        }
+        catch (err) {
+            console.error('Failed to scan teams directory:', err);
+        }
+    }
+    /**
+     * Load a team's config from ~/.claude/teams/<teamName>/config.json
+     */
+    loadTeamConfig(teamName) {
+        try {
+            const configPath = path.join(TEAMS_DIR, teamName, 'config.json');
+            if (!fs.existsSync(configPath))
+                return;
+            const content = fs.readFileSync(configPath, 'utf-8');
+            const config = JSON.parse(content);
+            if (!config.members || !Array.isArray(config.members))
+                return;
+            const existing = this.teams.get(teamName);
+            const members = config.members.map((m) => ({
+                name: m.name || m.agentId || 'Unknown',
+                agentId: m.agentId || m.name || 'unknown',
+                agentType: normalizeAgentType(m.agentType || ''),
+                color: m.color,
+                model: m.model,
+            }));
+            const team = {
+                name: teamName,
+                description: config.description,
+                leadSessionId: config.leadSessionId || existing?.leadSessionId,
+                members,
+                tasks: existing?.tasks || [],
+                createdAt: existing?.createdAt || Date.now(),
+                updatedAt: Date.now(),
+            };
+            const isNew = !existing;
+            this.teams.set(teamName, team);
+            if (isNew) {
+                this.emitter?.emit('onTeamDetected', team);
+                // Try auto-linking
+                this.autoLinkSessions(teamName);
+            }
+            // Check for new teammates
+            if (existing) {
+                const existingIds = new Set(existing.members.map(m => m.agentId));
+                for (const member of team.members) {
+                    if (!existingIds.has(member.agentId)) {
+                        this.emitter?.emit('onTeammateAdded', {
+                            teamName,
+                            member,
+                        });
+                    }
+                }
+            }
+        }
+        catch (err) {
+            // Skip malformed configs silently
+            console.warn(`Failed to parse team config for ${teamName}:`, err);
+        }
+    }
+    /**
+     * Scan ~/.claude/tasks/ for per-team task directories.
+     */
+    async scanTasks() {
+        try {
+            const entries = fs.readdirSync(TASKS_DIR, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    this.loadTeamTasks(entry.name);
+                }
+            }
+        }
+        catch (err) {
+            console.error('Failed to scan tasks directory:', err);
+        }
+    }
+    /**
+     * Load all task files from ~/.claude/tasks/<teamName>/*.json
+     * Skips .lock files.
+     */
+    loadTeamTasks(teamName) {
+        try {
+            const taskDir = path.join(TASKS_DIR, teamName);
+            if (!fs.existsSync(taskDir))
+                return;
+            const files = fs.readdirSync(taskDir);
+            const tasks = [];
+            for (const file of files) {
+                // Skip non-JSON and lock files
+                if (!file.endsWith('.json') || file === '.lock')
+                    continue;
+                try {
+                    const filePath = path.join(taskDir, file);
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    const data = JSON.parse(content);
+                    const task = this.normalizeTask(data);
+                    if (task)
+                        tasks.push(task);
+                }
+                catch (err) {
+                    // Skip individual malformed task files
+                    console.warn(`Failed to parse task file ${teamName}/${file}:`, err);
+                }
+            }
+            // Find the matching team (or any team if name doesn't match directly)
+            let team = this.teams.get(teamName);
+            if (!team) {
+                // Try to find team by checking task owners against team members
+                for (const [, t] of this.teams) {
+                    const memberIds = new Set(t.members.map(m => m.agentId));
+                    if (tasks.some(task => task.owner && memberIds.has(task.owner))) {
+                        team = t;
+                        break;
+                    }
+                }
+            }
+            if (team && tasks.length > 0) {
+                team.tasks = tasks;
+                team.updatedAt = Date.now();
+                this.emitter?.emit('onTasksUpdated', { teamName: team.name, tasks });
+            }
+        }
+        catch (err) {
+            console.warn(`Failed to load tasks for team ${teamName}:`, err);
+        }
+    }
+    normalizeTask(data) {
+        if (!data || typeof data !== 'object')
+            return null;
+        if (!data.id && !data.taskId && !data.subject)
+            return null;
+        return {
+            taskId: String(data.id || data.taskId || `task-${Date.now()}`),
+            subject: String(data.subject || data.title || 'Untitled'),
+            description: String(data.description || ''),
+            status: this.normalizeTaskStatus(data.status),
+            owner: data.owner ? String(data.owner) : undefined,
+            blockedBy: Array.isArray(data.blockedBy) ? data.blockedBy.map(String) : undefined,
+            blocks: Array.isArray(data.blocks) ? data.blocks.map(String) : undefined,
+        };
+    }
+    normalizeTaskStatus(status) {
+        const s = String(status || '').toLowerCase();
+        if (s === 'in_progress' || s === 'in-progress' || s === 'active' || s === 'running')
+            return 'in_progress';
+        if (s === 'completed' || s === 'done' || s === 'finished')
+            return 'completed';
+        return 'pending';
+    }
+    // ── File Watchers ──
+    /**
+     * Watch ~/.claude/teams/ recursively.
+     * Parses relative paths to determine what changed:
+     *   <team-name>/config.json → reload team config
+     *   new directory at top level → check for config.json
+     *   team directory deleted → remove team
+     */
+    startTeamsWatcher(retryCount = 0) {
+        try {
+            this.teamsWatcher = fs.watch(TEAMS_DIR, { recursive: true }, (_eventType, filename) => {
+                if (!filename)
+                    return;
+                // Normalize path separators (Windows uses backslashes)
+                const normalized = filename.replace(/\\/g, '/');
+                const parts = normalized.split('/');
+                if (parts.length === 0)
+                    return;
+                const teamName = parts[0];
+                this.debounce(`team:${teamName}`, () => {
+                    const teamDir = path.join(TEAMS_DIR, teamName);
+                    if (!fs.existsSync(teamDir)) {
+                        // Team directory was deleted
+                        if (this.teams.has(teamName)) {
+                            this.teams.delete(teamName);
+                            this.emitter?.emit('onTeamRemoved', { teamName });
+                        }
+                        return;
+                    }
+                    // Check if it's a directory (new or updated team)
+                    try {
+                        const stat = fs.statSync(teamDir);
+                        if (stat.isDirectory()) {
+                            this.loadTeamConfig(teamName);
+                        }
+                    }
+                    catch {
+                        // Stat failed, directory may have been removed between check and stat
+                    }
+                });
+            });
+            this.teamsWatcher.on('error', (err) => {
+                console.error('Teams watcher error:', err);
+                this.teamsWatcher?.close();
+                this.teamsWatcher = null;
+                if (retryCount < WATCHER_RETRY_COUNT) {
+                    setTimeout(() => this.startTeamsWatcher(retryCount + 1), WATCHER_RETRY_DELAY_MS);
+                }
+            });
+        }
+        catch (err) {
+            console.error('Failed to start teams watcher:', err);
+            if (retryCount < WATCHER_RETRY_COUNT) {
+                setTimeout(() => this.startTeamsWatcher(retryCount + 1), WATCHER_RETRY_DELAY_MS);
+            }
+        }
+    }
+    /**
+     * Watch ~/.claude/tasks/ recursively.
+     * Parses relative paths: <team-name>/<id>.json → reload that team's tasks.
+     * Skips .lock files.
+     */
+    startTasksWatcher(retryCount = 0) {
+        try {
+            this.tasksWatcher = fs.watch(TASKS_DIR, { recursive: true }, (_eventType, filename) => {
+                if (!filename)
+                    return;
+                // Normalize path separators
+                const normalized = filename.replace(/\\/g, '/');
+                const parts = normalized.split('/');
+                // We expect <team-name>/<file>.json
+                if (parts.length < 2)
+                    return;
+                const teamName = parts[0];
+                const file = parts[parts.length - 1];
+                // Skip non-JSON and lock files
+                if (!file.endsWith('.json') || file === '.lock')
+                    return;
+                this.debounce(`tasks:${teamName}`, () => {
+                    this.loadTeamTasks(teamName);
+                });
+            });
+            this.tasksWatcher.on('error', (err) => {
+                console.error('Tasks watcher error:', err);
+                this.tasksWatcher?.close();
+                this.tasksWatcher = null;
+                if (retryCount < WATCHER_RETRY_COUNT) {
+                    setTimeout(() => this.startTasksWatcher(retryCount + 1), WATCHER_RETRY_DELAY_MS);
+                }
+            });
+        }
+        catch (err) {
+            console.error('Failed to start tasks watcher:', err);
+            if (retryCount < WATCHER_RETRY_COUNT) {
+                setTimeout(() => this.startTasksWatcher(retryCount + 1), WATCHER_RETRY_DELAY_MS);
+            }
+        }
+    }
+    debounce(key, fn) {
+        const existing = this.debounceTimers.get(key);
+        if (existing)
+            clearTimeout(existing);
+        this.debounceTimers.set(key, setTimeout(() => {
+            this.debounceTimers.delete(key);
+            fn();
+        }, DEBOUNCE_MS));
+    }
+}
+exports.AgentTeamManager = AgentTeamManager;