@foothill/agent-move 1.0.6

package/packages/server/dist/state/agent-state-manager.js

@@ -0,0 +1,1622 @@
+// dist/state/agent-state-manager.js
+import { EventEmitter as EventEmitter2 } from "events";
+import { homedir } from "os";
+import { join } from "path";
+import { EventEmitter } from "events";
+import { execSync } from "child_process";
+var DEFAULT_ANOMALY_CONFIG = {
+  tokenVelocityThreshold: 1e5,
+  retryLoopThreshold: 5,
+  stuckTimeoutSeconds: 120
+};
+var TOOL_ZONE_MAP = {
+  // Files zone
+  Read: "files",
+  Write: "files",
+  Edit: "files",
+  Patch: "files",
+  Glob: "files",
+  NotebookEdit: "files",
+  // Terminal zone
+  Bash: "terminal",
+  // Search zone
+  Grep: "search",
+  WebSearch: "search",
+  // Web zone
+  WebFetch: "web",
+  mcp__chrome_devtools__navigate_page: "web",
+  mcp__chrome_devtools__click: "web",
+  mcp__chrome_devtools__fill: "web",
+  mcp__chrome_devtools__take_screenshot: "web",
+  mcp__chrome_devtools__take_snapshot: "web",
+  mcp__chrome_devtools__evaluate_script: "web",
+  // Thinking zone
+  EnterPlanMode: "thinking",
+  ExitPlanMode: "thinking",
+  AskUserQuestion: "thinking",
+  // Messaging zone
+  SendMessage: "messaging",
+  // Tasks zone
+  TaskCreate: "tasks",
+  TaskUpdate: "tasks",
+  TaskList: "tasks",
+  TaskGet: "tasks",
+  TodoRead: "tasks",
+  TodoWrite: "tasks",
+  // Spawn zone
+  Agent: "spawn",
+  TeamCreate: "spawn",
+  TeamDelete: "spawn"
+};
+function getZoneForTool(toolName) {
+  if (toolName.startsWith("mcp__"))
+    return "web";
+  return TOOL_ZONE_MAP[toolName] ?? "thinking";
+}
+var ZONES = [
+  // Row 0
+  {
+    id: "search",
+    label: "Search",
+    description: "Grep, WebSearch \u2014 Research & lookup",
+    icon: "\u{1F4DA}",
+    color: 15381256,
+    colStart: 0,
+    colSpan: 5,
+    rowStart: 0,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "terminal",
+    label: "Terminal",
+    description: "Bash commands \u2014 Server room",
+    icon: "\u{1F4BB}",
+    color: 2278750,
+    colStart: 5,
+    colSpan: 3,
+    rowStart: 0,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "web",
+    label: "Web",
+    description: "WebFetch, Browser \u2014 Network hub",
+    icon: "\u{1F310}",
+    color: 9133302,
+    colStart: 8,
+    colSpan: 4,
+    rowStart: 0,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  // Row 1
+  {
+    id: "files",
+    label: "Files",
+    description: "Read, Write, Edit, Glob \u2014 File storage",
+    icon: "\u{1F4C1}",
+    color: 3900150,
+    colStart: 0,
+    colSpan: 4,
+    rowStart: 1,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "thinking",
+    label: "Thinking",
+    description: "Planning, Questions \u2014 Conference area",
+    icon: "\u{1F4AD}",
+    color: 16347926,
+    colStart: 4,
+    colSpan: 5,
+    rowStart: 1,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "messaging",
+    label: "Messaging",
+    description: "SendMessage, Teams \u2014 Chat & relax",
+    icon: "\u{1F4AC}",
+    color: 15485081,
+    colStart: 9,
+    colSpan: 3,
+    rowStart: 1,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  // Row 2
+  {
+    id: "spawn",
+    label: "Spawn",
+    description: "Agent spawn/despawn \u2014 Entry portal",
+    icon: "\u{1F300}",
+    color: 11032055,
+    colStart: 0,
+    colSpan: 3,
+    rowStart: 2,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "idle",
+    label: "Idle",
+    description: "Idle agents rest here \u2014 Kitchen & lounge",
+    icon: "\u2615",
+    color: 7041664,
+    colStart: 3,
+    colSpan: 5,
+    rowStart: 2,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "tasks",
+    label: "Tasks",
+    description: "TaskCreate, TaskUpdate \u2014 Kanban & planning",
+    icon: "\u{1F4CB}",
+    color: 1357990,
+    colStart: 8,
+    colSpan: 4,
+    rowStart: 2,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  }
+];
+var ZONE_MAP = new Map(ZONES.map((z) => [z.id, z]));
+var AGENT_PALETTES = [
+  { name: "blue", body: 4886745, outline: 2906762, highlight: 8042741, eye: 16777215, skin: 16767916 },
+  { name: "green", body: 5025616, outline: 3046706, highlight: 8505220, eye: 16777215, skin: 16767916 },
+  { name: "red", body: 15037299, outline: 12986408, highlight: 16764370, eye: 16777215, skin: 16767916 },
+  { name: "purple", body: 11225020, outline: 6953882, highlight: 13538264, eye: 16777215, skin: 16767916 },
+  { name: "orange", body: 16750592, outline: 15094016, highlight: 16764032, eye: 16777215, skin: 16767916 },
+  { name: "cyan", body: 2541274, outline: 33679, highlight: 8445674, eye: 16777215, skin: 16767916 },
+  { name: "pink", body: 15753874, outline: 12720219, highlight: 16301008, eye: 16777215, skin: 16767916 },
+  { name: "teal", body: 2533018, outline: 26972, highlight: 8440772, eye: 16777215, skin: 16767916 },
+  { name: "amber", body: 16761095, outline: 16748288, highlight: 16769154, eye: 3355443, skin: 16767916 },
+  { name: "indigo", body: 6056896, outline: 2635155, highlight: 10463450, eye: 16777215, skin: 16767916 },
+  { name: "lime", body: 10275941, outline: 5606191, highlight: 12968357, eye: 3355443, skin: 16767916 },
+  { name: "brown", body: 9268835, outline: 5125166, highlight: 12364452, eye: 16777215, skin: 16767916 }
+];
+function getProjectColorIndex(projectPath) {
+  let hash = 0;
+  for (let i = 0; i < projectPath.length; i++) {
+    hash = (hash << 5) - hash + projectPath.charCodeAt(i) | 0;
+  }
+  return Math.abs(hash) % AGENT_PALETTES.length;
+}
+var config = {
+  port: parseInt(process.env.AGENT_MOVE_PORT || "3333", 10),
+  claudeHome: join(homedir(), ".claude"),
+  idleTimeoutMs: 45e3,
+  /** How long after going idle before an agent is automatically shutdown/removed */
+  shutdownTimeoutMs: 30 * 60 * 1e3,
+  // 30 minutes
+  /** How recently a session file must be modified to be considered "active" on startup */
+  activeThresholdMs: 10 * 60 * 1e3,
+  // 10 minutes
+  /** Enable OpenCode session watching (auto-detected if storage dir exists) */
+  enableOpenCode: process.env.AGENT_MOVE_OPENCODE !== "false"
+};
+var COOLDOWN_MS = 6e4;
+var TOKEN_WINDOW_MS = 6e4;
+var anomalyIdCounter = 0;
+var AnomalyDetector = class extends EventEmitter {
+  agents = /* @__PURE__ */ new Map();
+  agentNames = /* @__PURE__ */ new Map();
+  config;
+  stuckInterval = null;
+  constructor(config2) {
+    super();
+    this.config = { ...DEFAULT_ANOMALY_CONFIG, ...config2 };
+  }
+  getState(agentId) {
+    let state = this.agents.get(agentId);
+    if (!state) {
+      state = {
+        lastTools: [],
+        tokenSamples: [],
+        lastActivityAt: Date.now(),
+        lastAlertAt: /* @__PURE__ */ new Map()
+      };
+      this.agents.set(agentId, state);
+    }
+    return state;
+  }
+  setAgentName(agentId, name) {
+    this.agentNames.set(agentId, name);
+  }
+  checkToolUse(agentId, toolName) {
+    const state = this.getState(agentId);
+    state.lastActivityAt = Date.now();
+    state.lastTools.push(toolName);
+    if (state.lastTools.length > 20)
+      state.lastTools.shift();
+    const threshold = this.config.retryLoopThreshold;
+    if (state.lastTools.length >= threshold) {
+      const recent = state.lastTools.slice(-threshold);
+      if (recent.every((t) => t === recent[0])) {
+        this.alert(agentId, "retry-loop", `${recent[0]} called ${threshold}+ times consecutively`, "warning", {
+          tool: recent[0],
+          consecutiveCount: threshold
+        });
+      }
+    }
+  }
+  checkTokenUsage(agentId, inputTokens, outputTokens) {
+    const state = this.getState(agentId);
+    state.lastActivityAt = Date.now();
+    const now = Date.now();
+    const total = inputTokens + outputTokens;
+    state.tokenSamples.push({ ts: now, total });
+    const cutoff = now - TOKEN_WINDOW_MS;
+    while (state.tokenSamples.length > 0 && state.tokenSamples[0].ts < cutoff) {
+      state.tokenSamples.shift();
+    }
+    if (state.tokenSamples.length >= 2) {
+      const totalTokens = state.tokenSamples.reduce((sum, s) => sum + s.total, 0);
+      const elapsed = (state.tokenSamples[state.tokenSamples.length - 1].ts - state.tokenSamples[0].ts) / 6e4;
+      if (elapsed > 0.1) {
+        const velocity = totalTokens / elapsed;
+        if (velocity >= this.config.tokenVelocityThreshold) {
+          this.alert(agentId, "token-spike", `Token velocity ${Math.round(velocity)}/min exceeds threshold`, "critical", {
+            velocity: Math.round(velocity),
+            threshold: this.config.tokenVelocityThreshold
+          });
+        }
+      }
+    }
+  }
+  checkStuck(agentId, lastActivityAt) {
+    const state = this.getState(agentId);
+    const elapsed = (Date.now() - lastActivityAt) / 1e3;
+    if (elapsed >= this.config.stuckTimeoutSeconds) {
+      this.alert(agentId, "stuck-agent", `No activity for ${Math.round(elapsed)}s`, "warning", {
+        idleSeconds: Math.round(elapsed),
+        threshold: this.config.stuckTimeoutSeconds
+      });
+    }
+    state.lastActivityAt = lastActivityAt;
+  }
+  startStuckDetection(getActiveAgents) {
+    if (this.stuckInterval)
+      return;
+    this.stuckInterval = setInterval(() => {
+      for (const agent of getActiveAgents()) {
+        if (!agent.isIdle) {
+          this.checkStuck(agent.id, agent.lastActivityAt);
+        }
+      }
+    }, 3e4);
+  }
+  removeAgent(agentId) {
+    this.agents.delete(agentId);
+    this.agentNames.delete(agentId);
+  }
+  alert(agentId, kind, message, severity, details) {
+    const state = this.getState(agentId);
+    const now = Date.now();
+    const lastAlert = state.lastAlertAt.get(kind) ?? 0;
+    if (now - lastAlert < COOLDOWN_MS)
+      return;
+    state.lastAlertAt.set(kind, now);
+    const anomaly = {
+      id: `anomaly-${++anomalyIdCounter}`,
+      agentId,
+      agentName: this.agentNames.get(agentId) ?? agentId.slice(0, 10),
+      kind,
+      message,
+      severity,
+      timestamp: now,
+      details
+    };
+    this.emit("anomaly", anomaly);
+  }
+  dispose() {
+    if (this.stuckInterval) {
+      clearInterval(this.stuckInterval);
+      this.stuckInterval = null;
+    }
+  }
+};
+var MAX_DURATION_SAMPLES = 50;
+var ToolChainTracker = class {
+  lastTool = /* @__PURE__ */ new Map();
+  transitions = /* @__PURE__ */ new Map();
+  toolCounts = /* @__PURE__ */ new Map();
+  // Hook-sourced outcome tracking
+  toolSuccesses = /* @__PURE__ */ new Map();
+  toolFailures = /* @__PURE__ */ new Map();
+  toolDurationSamples = /* @__PURE__ */ new Map();
+  /** Per-agent pending tool start: agentId → {tool, startTime} */
+  pendingStart = /* @__PURE__ */ new Map();
+  recordToolUse(agentId, toolName) {
+    this.toolCounts.set(toolName, (this.toolCounts.get(toolName) ?? 0) + 1);
+    const prev = this.lastTool.get(agentId);
+    this.lastTool.set(agentId, toolName);
+    if (prev && prev !== toolName) {
+      const key = `${prev}\u2192${toolName}`;
+      this.transitions.set(key, (this.transitions.get(key) ?? 0) + 1);
+    }
+  }
+  /** Called from hookPreToolUse — records when a tool started for duration tracking */
+  recordToolStart(agentId, toolName) {
+    this.pendingStart.set(agentId, { tool: toolName, startTime: Date.now() });
+  }
+  /** Called from hookPostToolUse — records outcome and duration */
+  recordToolOutcome(agentId, success) {
+    const pending = this.pendingStart.get(agentId);
+    if (!pending)
+      return;
+    this.pendingStart.delete(agentId);
+    const { tool, startTime } = pending;
+    const duration = Date.now() - startTime;
+    if (success) {
+      this.toolSuccesses.set(tool, (this.toolSuccesses.get(tool) ?? 0) + 1);
+    } else {
+      this.toolFailures.set(tool, (this.toolFailures.get(tool) ?? 0) + 1);
+    }
+    let samples = this.toolDurationSamples.get(tool);
+    if (!samples) {
+      samples = [];
+      this.toolDurationSamples.set(tool, samples);
+    }
+    samples.push(duration);
+    if (samples.length > MAX_DURATION_SAMPLES)
+      samples.shift();
+  }
+  resetAgent(agentId) {
+    this.lastTool.delete(agentId);
+    this.pendingStart.delete(agentId);
+  }
+  /** Migrate per-agent state from an old ID to a new canonical ID (used on agent merge). */
+  migrateAgent(fromId, toId) {
+    const last = this.lastTool.get(fromId);
+    if (last !== void 0) {
+      if (!this.lastTool.has(toId))
+        this.lastTool.set(toId, last);
+      this.lastTool.delete(fromId);
+    }
+    const pending = this.pendingStart.get(fromId);
+    if (pending !== void 0) {
+      if (!this.pendingStart.has(toId))
+        this.pendingStart.set(toId, pending);
+      this.pendingStart.delete(fromId);
+    }
+  }
+  reset() {
+    this.lastTool.clear();
+    this.transitions.clear();
+    this.toolCounts.clear();
+    this.toolSuccesses.clear();
+    this.toolFailures.clear();
+    this.toolDurationSamples.clear();
+    this.pendingStart.clear();
+  }
+  hasActiveAgents() {
+    return this.lastTool.size > 0;
+  }
+  getSnapshot() {
+    const transitions = [];
+    for (const [key, count] of this.transitions) {
+      const [from, to] = key.split("\u2192");
+      transitions.push({ from, to, count });
+    }
+    transitions.sort((a, b) => b.count - a.count);
+    const toolCounts = {};
+    for (const [tool, count] of this.toolCounts)
+      toolCounts[tool] = count;
+    const toolSuccesses = {};
+    for (const [tool, count] of this.toolSuccesses)
+      toolSuccesses[tool] = count;
+    const toolFailures = {};
+    for (const [tool, count] of this.toolFailures)
+      toolFailures[tool] = count;
+    const toolAvgDuration = {};
+    for (const [tool, samples] of this.toolDurationSamples) {
+      if (samples.length > 0) {
+        toolAvgDuration[tool] = Math.round(samples.reduce((a, b) => a + b, 0) / samples.length);
+      }
+    }
+    return {
+      transitions,
+      tools: Array.from(this.toolCounts.keys()).sort(),
+      toolCounts,
+      toolSuccesses,
+      toolFailures,
+      toolAvgDuration
+    };
+  }
+};
+var TaskGraphManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  /** Per-agent-root counters to match Claude's sequential task IDs per team */
+  counters = /* @__PURE__ */ new Map();
+  /**
+   * Build a scoped key from rootSessionId + short task ID.
+   * This prevents cross-team ID collisions in the global map.
+   */
+  scopedKey(root, shortId) {
+    return `${root}::${shortId}`;
+  }
+  /**
+   * Process a tool use that may affect the task graph.
+   * Returns true if the graph changed.
+   */
+  processToolUse(agentId, agentName, toolName, toolInput, projectName, rootSessionId) {
+    const root = rootSessionId ?? agentId;
+    if (toolName === "TaskCreate") {
+      return this.handleCreate(agentId, agentName, toolInput, projectName, root);
+    }
+    if (toolName === "TaskUpdate") {
+      return this.handleUpdate(agentId, agentName, toolInput, projectName, root);
+    }
+    return false;
+  }
+  handleCreate(agentId, agentName, toolInput, projectName, root) {
+    const input = toolInput;
+    if (!input)
+      return false;
+    const count = (this.counters.get(root) ?? 0) + 1;
+    this.counters.set(root, count);
+    const shortId = String(count);
+    const key = this.scopedKey(root, shortId);
+    const subject = input.subject ?? `Task ${shortId}`;
+    const description = input.description;
+    const node = {
+      id: shortId,
+      subject,
+      description,
+      status: "pending",
+      owner: void 0,
+      agentId,
+      agentName,
+      projectName,
+      blocks: [],
+      blockedBy: [],
+      timestamp: Date.now(),
+      _rootKey: key
+    };
+    this.tasks.set(key, node);
+    return true;
+  }
+  handleUpdate(agentId, agentName, toolInput, projectName, root) {
+    const input = toolInput;
+    if (!input)
+      return false;
+    const taskId = input.taskId;
+    if (!taskId)
+      return false;
+    const key = this.scopedKey(root, taskId);
+    let task = this.tasks.get(key);
+    if (!task) {
+      task = {
+        id: taskId,
+        subject: `Task ${taskId}`,
+        status: "pending",
+        agentId,
+        agentName,
+        projectName,
+        blocks: [],
+        blockedBy: [],
+        timestamp: Date.now(),
+        _rootKey: key
+      };
+      this.tasks.set(key, task);
+    }
+    let changed = false;
+    if (input.status !== void 0) {
+      const newStatus = input.status;
+      if (["pending", "in_progress", "completed", "deleted"].includes(newStatus)) {
+        task.status = newStatus;
+        changed = true;
+      }
+    }
+    if (input.owner !== void 0) {
+      task.owner = input.owner;
+      changed = true;
+    }
+    if (input.subject !== void 0) {
+      task.subject = input.subject;
+      changed = true;
+    }
+    if (input.description !== void 0) {
+      task.description = input.description;
+      changed = true;
+    }
+    if (input.addBlocks) {
+      const blocks = input.addBlocks;
+      for (const id of blocks) {
+        if (!task.blocks.includes(id)) {
+          task.blocks.push(id);
+          changed = true;
+        }
+        const otherKey = this.scopedKey(root, id);
+        const other = this.tasks.get(otherKey);
+        if (other && !other.blockedBy.includes(taskId)) {
+          other.blockedBy.push(taskId);
+          changed = true;
+        }
+      }
+    }
+    if (input.addBlockedBy) {
+      const blockedBy = input.addBlockedBy;
+      for (const id of blockedBy) {
+        if (!task.blockedBy.includes(id)) {
+          task.blockedBy.push(id);
+          changed = true;
+        }
+        const otherKey = this.scopedKey(root, id);
+        const other = this.tasks.get(otherKey);
+        if (other && !other.blocks.includes(taskId)) {
+          other.blocks.push(taskId);
+          changed = true;
+        }
+      }
+    }
+    return changed;
+  }
+  /**
+   * Mark a task as completed (hook-sourced — TaskCompleted event).
+   * Returns true if the status actually changed.
+   */
+  processTaskCompleted(taskId, root) {
+    const key = this.scopedKey(root, taskId);
+    const task = this.tasks.get(key);
+    if (!task || task.status === "completed")
+      return false;
+    task.status = "completed";
+    return true;
+  }
+  /**
+   * Remove all tasks created by a given agent.
+   * Cleans up dependency references from remaining tasks.
+   * Returns true if any tasks were removed.
+   */
+  removeAgentTasks(agentId) {
+    const toRemove = /* @__PURE__ */ new Set();
+    for (const [key, task] of this.tasks) {
+      if (task.agentId === agentId)
+        toRemove.add(key);
+    }
+    if (toRemove.size === 0)
+      return false;
+    const removedKeys = /* @__PURE__ */ new Set();
+    for (const key of toRemove) {
+      removedKeys.add(key);
+      this.tasks.delete(key);
+    }
+    for (const [taskKey, task] of this.tasks) {
+      const root = taskKey.split("::")[0];
+      task.blocks = task.blocks.filter((id) => !removedKeys.has(`${root}::${id}`));
+      task.blockedBy = task.blockedBy.filter((id) => !removedKeys.has(`${root}::${id}`));
+    }
+    return true;
+  }
+  getSnapshot() {
+    const live = Array.from(this.tasks.values()).filter((t) => t.status !== "deleted");
+    const rootOf = (key) => key.split("::")[0];
+    const shortToRoot = /* @__PURE__ */ new Map();
+    for (const t of live) {
+      const root = rootOf(t._rootKey);
+      if (!shortToRoot.has(root))
+        shortToRoot.set(root, /* @__PURE__ */ new Map());
+      shortToRoot.get(root).set(t.id, t._rootKey);
+    }
+    return {
+      tasks: live.map((t) => {
+        const lookup = shortToRoot.get(rootOf(t._rootKey));
+        return {
+          ...t,
+          blocks: t.blocks.map((id) => lookup?.get(id) ?? id),
+          blockedBy: t.blockedBy.map((id) => lookup?.get(id) ?? id)
+        };
+      })
+    };
+  }
+};
+function resolveAgentId(sessionToAgent, sessionId) {
+  return sessionToAgent.get(sessionId) ?? sessionId;
+}
+function transferAndRemove(deps, sourceId, target, redirectSessionId) {
+  const { agents, hiddenAgents, sessionToAgent, toolChainTracker, clearTimers } = deps;
+  const source = agents.get(sourceId);
+  if (source) {
+    target.totalInputTokens += source.totalInputTokens;
+    target.totalOutputTokens += source.totalOutputTokens;
+    target.cacheReadTokens += source.cacheReadTokens;
+    target.cacheCreationTokens += source.cacheCreationTokens;
+  }
+  agents.delete(sourceId);
+  hiddenAgents.delete(sourceId);
+  clearTimers(sourceId);
+  toolChainTracker.migrateAgent(sourceId, target.id);
+  sessionToAgent.set(redirectSessionId, target.id);
+  target.isIdle = false;
+  target.isDone = false;
+  target.lastActivityAt = Date.now();
+}
+function mergeIntoNamed(deps, hiddenId, agentName) {
+  const { agents, namedAgentMap } = deps;
+  const hidden = agents.get(hiddenId);
+  if (!hidden)
+    return null;
+  const key = `${hidden.rootSessionId}:${agentName}`;
+  const existingId = namedAgentMap.get(key);
+  if (!existingId || existingId === hiddenId)
+    return null;
+  const existing = agents.get(existingId);
+  if (!existing)
+    return null;
+  transferAndRemove(deps, hiddenId, existing, hiddenId);
+  console.log(`Merged session ${hiddenId.slice(0, 12)}\u2026 into agent "${agentName}" (${existingId.slice(0, 12)}\u2026)`);
+  return existing;
+}
+function promoteAgent(deps, agentId) {
+  const { agents, hiddenAgents, identityTimers, recordTimeline, emit } = deps;
+  hiddenAgents.delete(agentId);
+  const idTimer = identityTimers.get(agentId);
+  if (idTimer)
+    clearTimeout(idTimer);
+  identityTimers.delete(agentId);
+  const agent = agents.get(agentId);
+  if (!agent)
+    return;
+  console.log(`Promoting hidden agent ${agentId.slice(0, 12)}\u2026 (name: ${agent.agentName ?? "unknown"})`);
+  const now = Date.now();
+  const spawnEvent = { type: "agent:spawn", agent: { ...agent }, timestamp: now };
+  recordTimeline(spawnEvent);
+  emit("agent:spawn", spawnEvent);
+  const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: now };
+  recordTimeline(updateEvent);
+  emit("agent:update", updateEvent);
+}
+function determineRole(_activity, sessionInfo) {
+  if (sessionInfo.isSubagent)
+    return "subagent";
+  return "main";
+}
+function determineRoleForNamed(_parentId, pendingTeam) {
+  if (pendingTeam)
+    return "team-member";
+  return "subagent";
+}
+function findParentId(agents, projectDir) {
+  for (const [id, agent] of agents) {
+    if (agent.projectPath === projectDir && agent.role === "team-lead") {
+      return id;
+    }
+  }
+  for (const [id, agent] of agents) {
+    if (agent.projectPath === projectDir && agent.role === "main") {
+      return id;
+    }
+  }
+  for (const [id, agent] of agents) {
+    if (agent.projectPath === projectDir && agent.role !== "subagent" && agent.role !== "team-member") {
+      return id;
+    }
+  }
+  return null;
+}
+function getParentTeamName(agents, rootSessionId) {
+  for (const agent of agents.values()) {
+    if (agent.rootSessionId === rootSessionId && agent.teamName) {
+      return agent.teamName;
+    }
+  }
+  return null;
+}
+var branchCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 3e4;
+var MAX_CACHE_SIZE = 100;
+function getGitBranch(projectPath) {
+  const cached = branchCache.get(projectPath);
+  if (cached && Date.now() - cached.ts < CACHE_TTL)
+    return cached.branch;
+  try {
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd: projectPath,
+      timeout: 5e3,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim() || null;
+    branchCache.set(projectPath, { branch, ts: Date.now() });
+    pruneCache();
+    return branch;
+  } catch {
+    branchCache.set(projectPath, { branch: null, ts: Date.now() });
+    return null;
+  }
+}
+function pruneCache() {
+  if (branchCache.size <= MAX_CACHE_SIZE)
+    return;
+  const entries = [...branchCache.entries()].sort((a, b) => a[1].ts - b[1].ts);
+  const toRemove = entries.slice(0, branchCache.size - MAX_CACHE_SIZE);
+  for (const [key] of toRemove)
+    branchCache.delete(key);
+}
+var LONG_RUNNING_TOOLS = /* @__PURE__ */ new Set([
+  "Bash",
+  "Agent",
+  "WebFetch",
+  "WebSearch",
+  // Tools that block waiting for user input
+  "AskUserQuestion",
+  // Reasoning / extended thinking pseudo-tool (emitted for OpenCode reasoning parts)
+  "thinking",
+  // Browser/playwright tools that wait for navigation or network
+  "mcp__playwright__browser_navigate",
+  "mcp__playwright__browser_wait_for",
+  "mcp__playwright__browser_run_code",
+  "mcp__chrome-devtools__navigate_page",
+  "mcp__chrome-devtools__wait_for",
+  "mcp__chrome-devtools__evaluate_script",
+  "mcp__chrome-devtools__performance_start_trace",
+  "mcp__chrome-devtools__performance_stop_trace"
+]);
+var USER_BLOCKING_TOOLS = /* @__PURE__ */ new Set([
+  "AskUserQuestion"
+]);
+function processToolUseActivity(deps, agent, activity, now) {
+  const { pendingTool, anomalyDetector, toolChainTracker, taskGraphManager, namedAgentMap, addHistory, summarizeToolInput, queuePendingInfo, queueRecipient, emit } = deps;
+  const agentId = agent.id;
+  const toolName = activity.toolName ?? "";
+  if (LONG_RUNNING_TOOLS.has(toolName)) {
+    pendingTool.add(agentId);
+  } else {
+    pendingTool.delete(agentId);
+  }
+  agent.isWaitingForUser = USER_BLOCKING_TOOLS.has(toolName);
+  const prevZone = agent.currentZone;
+  agent.currentTool = activity.toolName ?? null;
+  agent.currentActivity = summarizeToolInput(activity.toolInput) || null;
+  agent.currentZone = getZoneForTool(activity.toolName ?? "");
+  agent.toolUseCount++;
+  anomalyDetector.setAgentName(agentId, agent.agentName ?? agent.projectName ?? agentId.slice(0, 10));
+  anomalyDetector.checkToolUse(agentId, toolName);
+  toolChainTracker.recordToolUse(agentId, toolName);
+  if (toolName === "TaskCreate" || toolName === "TaskUpdate") {
+    const graphChanged = taskGraphManager.processToolUse(agentId, agent.agentName ?? agentId.slice(0, 10), toolName, activity.toolInput, agent.projectName, agent.rootSessionId);
+    if (graphChanged) {
+      emit("taskgraph:changed", { data: taskGraphManager.getSnapshot(), timestamp: Date.now() });
+    }
+  }
+  if (agent.projectPath) {
+    agent.gitBranch = getGitBranch(agent.projectPath);
+  }
+  if (activity.toolInput) {
+    const input = activity.toolInput;
+    const filePath = input.file_path;
+    if (filePath) {
+      agent.recentFiles = [filePath, ...agent.recentFiles.filter((f) => f !== filePath)].slice(0, 10);
+    }
+  }
+  if (activity.toolName === "EnterPlanMode") {
+    agent.isPlanning = true;
+  } else if (activity.toolName === "ExitPlanMode") {
+    agent.isPlanning = false;
+  }
+  if (activity.toolName === "TeamCreate" && activity.toolInput) {
+    agent.teamName = activity.toolInput.team_name ?? null;
+    agent.role = "team-lead";
+    if (!agent.agentName) {
+      agent.agentName = "team-lead";
+    }
+    namedAgentMap.set(`${agent.rootSessionId}:team-lead`, agentId);
+  }
+  if (activity.toolName === "SendMessage") {
+    agent.currentZone = "messaging";
+    if (activity.toolInput) {
+      const input = activity.toolInput;
+      const recipient = input.recipient;
+      agent.messageTarget = recipient ?? null;
+      const senderIdentity = agent.agentName || (agent.role === "team-lead" ? "team-lead" : null);
+      if (recipient && senderIdentity) {
+        queueRecipient(agent.rootSessionId, senderIdentity, recipient);
+      }
+    }
+  } else {
+    agent.messageTarget = null;
+  }
+  if (activity.toolName === "Agent" && activity.toolInput) {
+    const input = activity.toolInput;
+    const desc = input.description ?? input.prompt ?? "";
+    const name = input.name ?? null;
+    const teamName = input.team_name ?? null;
+    queuePendingInfo(agentId, {
+      name,
+      task: desc ? desc.length > 80 ? desc.slice(0, 77) + "..." : desc : null,
+      team: teamName
+    });
+  }
+  let diffData;
+  if (activity.toolName === "Edit" && activity.toolInput) {
+    const input = activity.toolInput;
+    const fp = input.file_path ?? "";
+    const oldStr = input.old_string ?? "";
+    const newStr = input.new_string ?? "";
+    if (fp && (oldStr || newStr)) {
+      diffData = {
+        filePath: fp,
+        oldText: oldStr.length > 500 ? oldStr.slice(0, 500) + "..." : oldStr,
+        newText: newStr.length > 500 ? newStr.slice(0, 500) + "..." : newStr
+      };
+    }
+  }
+  if (diffData) {
+    agent.recentDiffs.unshift({ ...diffData, timestamp: now });
+    if (agent.recentDiffs.length > 10)
+      agent.recentDiffs.pop();
+  }
+  addHistory(agentId, {
+    timestamp: now,
+    kind: "tool",
+    tool: activity.toolName ?? void 0,
+    toolArgs: summarizeToolInput(activity.toolInput),
+    zone: agent.currentZone,
+    diff: diffData
+  });
+  if (prevZone !== agent.currentZone) {
+    addHistory(agentId, {
+      timestamp: now,
+      kind: "zone-change",
+      zone: agent.currentZone,
+      prevZone
+    });
+  }
+  if (activity.inputTokens !== void 0 || activity.outputTokens !== void 0) {
+    agent.totalInputTokens += activity.inputTokens ?? 0;
+    agent.totalOutputTokens += activity.outputTokens ?? 0;
+    agent.cacheReadTokens += activity.cacheReadTokens ?? 0;
+    agent.cacheCreationTokens += activity.cacheCreationTokens ?? 0;
+    if (activity.inputTokens !== void 0) {
+      agent.contextTokens = activity.inputTokens + (activity.cacheReadTokens ?? 0);
+      agent.contextCacheTokens = activity.cacheReadTokens ?? 0;
+    }
+  }
+}
+function processToolActivity(deps, agent, activity, now) {
+  const { pendingTool, anomalyDetector, addHistory } = deps;
+  const agentId = agent.id;
+  switch (activity.type) {
+    case "tool_use": {
+      processToolUseActivity(deps, agent, activity, now);
+      break;
+    }
+    case "text":
+      pendingTool.delete(agentId);
+      agent.isWaitingForUser = false;
+      if (activity.text) {
+        agent.speechText = activity.text;
+        agent.currentActivity = activity.text;
+        if (!agent.taskDescription) {
+          agent.taskDescription = activity.text;
+        }
+        addHistory(agentId, {
+          timestamp: now,
+          kind: "text",
+          text: activity.text
+        });
+      }
+      if (activity.inputTokens !== void 0 || activity.outputTokens !== void 0) {
+        agent.totalInputTokens += activity.inputTokens ?? 0;
+        agent.totalOutputTokens += activity.outputTokens ?? 0;
+        agent.cacheReadTokens += activity.cacheReadTokens ?? 0;
+        agent.cacheCreationTokens += activity.cacheCreationTokens ?? 0;
+        if (activity.inputTokens !== void 0) {
+          agent.contextTokens = activity.inputTokens + (activity.cacheReadTokens ?? 0);
+          agent.contextCacheTokens = activity.cacheReadTokens ?? 0;
+        }
+      }
+      break;
+    case "token_usage":
+      pendingTool.delete(agentId);
+      agent.isWaitingForUser = false;
+      agent.totalInputTokens += activity.inputTokens ?? 0;
+      agent.totalOutputTokens += activity.outputTokens ?? 0;
+      agent.cacheReadTokens += activity.cacheReadTokens ?? 0;
+      agent.cacheCreationTokens += activity.cacheCreationTokens ?? 0;
+      if (activity.inputTokens !== void 0) {
+        agent.contextTokens = activity.inputTokens + (activity.cacheReadTokens ?? 0);
+        agent.contextCacheTokens = activity.cacheReadTokens ?? 0;
+      }
+      anomalyDetector.checkTokenUsage(agentId, activity.inputTokens ?? 0, activity.outputTokens ?? 0);
+      addHistory(agentId, {
+        timestamp: now,
+        kind: "tokens",
+        inputTokens: activity.inputTokens ?? 0,
+        outputTokens: activity.outputTokens ?? 0
+      });
+      break;
+  }
+}
+var MAX_HISTORY_PER_AGENT = 500;
+var MAX_HISTORY_AGE_MS = 30 * 60 * 1e3;
+var MAX_TIMELINE_EVENTS = 5e3;
+var IDENTITY_TIMEOUT_MS = 15e3;
+var AgentStateManager = class extends EventEmitter2 {
+  agents = /* @__PURE__ */ new Map();
+  idleTimers = /* @__PURE__ */ new Map();
+  shutdownTimers = /* @__PURE__ */ new Map();
+  /** Agents with a pending tool call (waiting for result) */
+  pendingTool = /* @__PURE__ */ new Set();
+  activityHistory = /* @__PURE__ */ new Map();
+  timelineBuffer = [];
+  /** Compound queue of subagent metadata from Agent tool calls, keyed by parent agent ID */
+  pendingSubagentInfo = /* @__PURE__ */ new Map();
+  /** Maps sessionId → canonical agent ID (for merging multiple sessions into one agent) */
+  sessionToAgent = /* @__PURE__ */ new Map();
+  /** Maps rootSessionId:agentName → canonical agent ID (scoped per terminal session) */
+  namedAgentMap = /* @__PURE__ */ new Map();
+  /** Agents that are hidden pending identity confirmation — no events emitted */
+  hiddenAgents = /* @__PURE__ */ new Set();
+  /** Timers to promote hidden agents after timeout */
+  identityTimers = /* @__PURE__ */ new Map();
+  /** Queued recipient names from SendMessage calls: rootSessionId → [{sender, recipient}] */
+  pendingRecipients = /* @__PURE__ */ new Map();
+  /** Anomaly detection for token spikes, retry loops, stuck agents */
+  anomalyDetector = new AnomalyDetector();
+  /** Tool chain transition tracking */
+  toolChainTracker = new ToolChainTracker();
+  /** Task dependency graph tracking */
+  taskGraphManager = new TaskGraphManager();
+  constructor() {
+    super();
+    this.anomalyDetector.startStuckDetection(() => Array.from(this.agents.values()).filter((a) => !this.hiddenAgents.has(a.id)).map((a) => ({ id: a.id, lastActivityAt: a.lastActivityAt, isIdle: a.isIdle })));
+  }
+  getAll() {
+    return Array.from(this.agents.values()).filter((a) => !this.hiddenAgents.has(a.id));
+  }
+  get(id) {
+    return this.agents.get(id);
+  }
+  /** Flush pending subagent/recipient queues — call after initial replay to prevent stale matches */
+  flushPendingQueues() {
+    const infoCount = Array.from(this.pendingSubagentInfo.values()).reduce((n, q) => n + q.length, 0);
+    const recipientCount = Array.from(this.pendingRecipients.values()).reduce((n, q) => n + q.length, 0);
+    this.pendingSubagentInfo.clear();
+    this.pendingRecipients.clear();
+    if (infoCount + recipientCount > 0) {
+      console.log(`Flushed ${infoCount} pending subagent infos, ${recipientCount} pending recipients from replay`);
+    }
+  }
+  getHistory(agentId) {
+    return this.activityHistory.get(agentId) ?? [];
+  }
+  getTimeline() {
+    return this.timelineBuffer;
+  }
+  getToolChainSnapshot() {
+    return this.toolChainTracker.getSnapshot();
+  }
+  getTaskGraphSnapshot() {
+    return this.taskGraphManager.getSnapshot();
+  }
+  /** Check if any named agents exist for a given root session */
+  hasNamedAgentsForRoot(rootSessionId) {
+    for (const key of this.namedAgentMap.keys()) {
+      if (key.startsWith(rootSessionId + ":"))
+        return true;
+    }
+    return false;
+  }
+  recordTimeline(event) {
+    this.timelineBuffer.push({
+      type: event.type,
+      agent: { ...event.agent },
+      timestamp: event.timestamp
+    });
+    const cutoff = Date.now() - MAX_HISTORY_AGE_MS;
+    while (this.timelineBuffer.length > 0 && this.timelineBuffer[0].timestamp < cutoff) {
+      this.timelineBuffer.shift();
+    }
+    while (this.timelineBuffer.length > MAX_TIMELINE_EVENTS) {
+      this.timelineBuffer.shift();
+    }
+  }
+  addHistory(agentId, entry) {
+    let entries = this.activityHistory.get(agentId);
+    if (!entries) {
+      entries = [];
+      this.activityHistory.set(agentId, entries);
+    }
+    entries.push(entry);
+    const cutoff = Date.now() - MAX_HISTORY_AGE_MS;
+    while (entries.length > 0 && entries[0].timestamp < cutoff) {
+      entries.shift();
+    }
+    while (entries.length > MAX_HISTORY_PER_AGENT) {
+      entries.shift();
+    }
+  }
+  summarizeToolInput(input) {
+    if (!input)
+      return "";
+    try {
+      const obj = input;
+      const summary = obj.command ?? obj.file_path ?? obj.pattern ?? obj.query ?? obj.url ?? obj.content;
+      if (typeof summary === "string") {
+        return summary.length > 120 ? summary.slice(0, 117) + "..." : summary;
+      }
+      const json = JSON.stringify(input);
+      return json.length > 120 ? json.slice(0, 117) + "..." : json;
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Resolve a sessionId to its canonical agent ID.
+   */
+  resolveAgentId(sessionId) {
+    return resolveAgentId(this.sessionToAgent, sessionId);
+  }
+  /**
+   * Compute the rootSessionId for a new agent.
+   * - Main agents are their own root.
+   * - Subagents inherit from their parent (or fallback to parentId/own sessionId).
+   */
+  computeRootSessionId(sessionId, parentId, sessionInfo) {
+    if (!sessionInfo.isSubagent)
+      return sessionId;
+    if (parentId) {
+      const parent = this.agents.get(parentId);
+      return parent?.rootSessionId ?? parentId;
+    }
+    return sessionId;
+  }
+  /** Build the deps object required by identity-manager functions. */
+  get identityDeps() {
+    return {
+      agents: this.agents,
+      hiddenAgents: this.hiddenAgents,
+      sessionToAgent: this.sessionToAgent,
+      namedAgentMap: this.namedAgentMap,
+      identityTimers: this.identityTimers,
+      toolChainTracker: this.toolChainTracker,
+      clearTimers: (id) => this.clearTimers(id),
+      recordTimeline: (e) => this.recordTimeline(e),
+      emit: (event, ...args) => this.emit(event, ...args)
+    };
+  }
+  /** Build the deps object required by activity-processor functions. */
+  get activityDeps() {
+    return {
+      pendingTool: this.pendingTool,
+      anomalyDetector: this.anomalyDetector,
+      toolChainTracker: this.toolChainTracker,
+      taskGraphManager: this.taskGraphManager,
+      namedAgentMap: this.namedAgentMap,
+      addHistory: (id, entry) => this.addHistory(id, entry),
+      summarizeToolInput: (input) => this.summarizeToolInput(input),
+      queuePendingInfo: (parentId, info) => this.queuePendingInfo(parentId, info),
+      queueRecipient: (rootSessionId, sender, recipient) => this.queueRecipient(rootSessionId, sender, recipient),
+      emit: (event, ...args) => this.emit(event, ...args)
+    };
+  }
+  /**
+   * Called when ANY new bytes appear in a session's JSONL file,
+   * even if the parser doesn't extract a meaningful activity.
+   * This keeps the agent alive during long-running tool executions
+   * (e.g. Bash commands) where the tool result writes to the file
+   * but doesn't produce a ParsedActivity.
+   */
+  heartbeat(sessionId) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    if (!agent || this.hiddenAgents.has(canonicalId))
+      return;
+    if (this.pendingTool.has(canonicalId)) {
+      agent.lastActivityAt = Date.now();
+      this.resetIdleTimer(canonicalId);
+    }
+  }
+  processMessage(sessionId, activity, sessionInfo) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    if (canonicalId !== sessionId) {
+      const agent2 = this.agents.get(canonicalId);
+      if (agent2) {
+        this.applyActivity(agent2, activity, Date.now(), sessionInfo);
+        return;
+      }
+    }
+    let agent = this.agents.get(canonicalId);
+    const now = Date.now();
+    if (agent && this.hiddenAgents.has(canonicalId)) {
+      let discoveredName = activity.agentName ?? null;
+      if (!discoveredName && activity.messageSender) {
+        discoveredName = this.popRecipientBySender(agent.rootSessionId, activity.messageSender);
+      }
+      if (discoveredName) {
+        const merged = mergeIntoNamed(this.identityDeps, canonicalId, discoveredName);
+        if (merged) {
+          this.applyActivity(merged, activity, now, sessionInfo);
+          return;
+        }
+        agent.agentName = discoveredName;
+        const role = determineRoleForNamed(agent.parentId, null);
+        agent.role = role;
+        agent.teamName = role === "team-member" ? agent.teamName || getParentTeamName(this.agents, agent.rootSessionId) : null;
+        this.namedAgentMap.set(`${agent.rootSessionId}:${discoveredName}`, canonicalId);
+        promoteAgent(this.identityDeps, canonicalId);
+        this.applyActivity(agent, activity, now, sessionInfo);
+        return;
+      }
+      this.applyActivitySilent(agent, activity, now, sessionInfo);
+      return;
+    }
+    if (agent && activity.agentName && !agent.agentName) {
+      const key = `${agent.rootSessionId}:${activity.agentName}`;
+      const existingId = this.namedAgentMap.get(key);
+      if (existingId && existingId !== canonicalId) {
+        const existing = this.agents.get(existingId);
+        if (existing) {
+          transferAndRemove(this.identityDeps, canonicalId, existing, sessionId);
+          this.emit("agent:shutdown", {
+            type: "agent:shutdown",
+            agent: { id: canonicalId },
+            timestamp: now
+          });
+          console.log(`Late-merged agent ${canonicalId.slice(0, 12)}\u2026 into "${activity.agentName}" (${existingId.slice(0, 12)}\u2026)`);
+          this.applyActivity(existing, activity, now, sessionInfo);
+          return;
+        }
+      }
+      agent.agentName = activity.agentName;
+      const role = determineRoleForNamed(agent.parentId, null);
+      agent.role = role;
+      agent.teamName = role === "team-member" ? agent.teamName || getParentTeamName(this.agents, agent.rootSessionId) : agent.teamName;
+      this.namedAgentMap.set(key, canonicalId);
+      console.log(`Agent ${canonicalId.slice(0, 12)}\u2026 identified as "${activity.agentName}"`);
+    }
+    if (!agent) {
+      const parentId = sessionInfo.isSubagent ? sessionInfo.parentSessionId ? this.resolveAgentId(sessionInfo.parentSessionId) : findParentId(this.agents, sessionInfo.projectDir) : null;
+      const rootSessionId = this.computeRootSessionId(sessionId, parentId, sessionInfo);
+      const pendingInfo = parentId ? this.popPendingInfo(parentId) : null;
+      const taskDescription = pendingInfo?.task ?? null;
+      const pendingTeam = pendingInfo?.team ?? null;
+      let agentName = pendingInfo?.name ?? activity.agentName ?? null;
+      if (!agentName && activity.messageSender) {
+        agentName = this.popRecipientBySender(rootSessionId, activity.messageSender);
+      }
+      if (agentName) {
+        const key = `${rootSessionId}:${agentName}`;
+        const existingId = this.namedAgentMap.get(key);
+        if (existingId) {
+          const existing = this.agents.get(existingId);
+          if (existing) {
+            this.sessionToAgent.set(sessionId, existingId);
+            existing.isIdle = false;
+            existing.isDone = false;
+            existing.lastActivityAt = now;
+            console.log(`Immediate merge: session ${sessionId.slice(0, 12)}\u2026 \u2192 agent "${agentName}" (${existingId.slice(0, 12)}\u2026)`);
+            this.applyActivity(existing, activity, now, sessionInfo);
+            return;
+          }
+        }
+      }
+      const role = agentName ? determineRoleForNamed(parentId, pendingTeam) : determineRole(activity, sessionInfo);
+      const teamName = role === "team-member" ? pendingTeam || getParentTeamName(this.agents, rootSessionId) : null;
+      agent = {
+        id: sessionId,
+        sessionId,
+        rootSessionId,
+        projectPath: sessionInfo.projectPath,
+        projectName: sessionInfo.projectName,
+        agentName,
+        role,
+        parentId,
+        teamName,
+        currentZone: "spawn",
+        currentTool: null,
+        currentActivity: null,
+        messageTarget: null,
+        taskDescription,
+        speechText: null,
+        lastActivityAt: now,
+        spawnedAt: now,
+        isIdle: false,
+        isDone: false,
+        isPlanning: false,
+        isWaitingForUser: false,
+        phase: "running",
+        lastToolOutcome: null,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        contextTokens: 0,
+        contextCacheTokens: 0,
+        model: activity.model ?? null,
+        colorIndex: getProjectColorIndex(sessionId),
+        toolUseCount: 0,
+        gitBranch: null,
+        recentFiles: [],
+        recentDiffs: []
+      };
+      this.agents.set(sessionId, agent);
+      this.sessionToAgent.set(sessionId, sessionId);
+      const shouldHide = sessionInfo.isSubagent && !agentName && this.hasNamedAgentsForRoot(rootSessionId);
+      if (shouldHide) {
+        this.hiddenAgents.add(sessionId);
+        console.log(`Hiding new session ${sessionId.slice(0, 12)}\u2026 (pending identity)`);
+        const timer = setTimeout(() => {
+          if (this.hiddenAgents.has(sessionId)) {
+            console.log(`Identity timeout for ${sessionId.slice(0, 12)}\u2026 \u2014 promoting with fallback name`);
+            promoteAgent(this.identityDeps, sessionId);
+          }
+        }, IDENTITY_TIMEOUT_MS);
+        this.identityTimers.set(sessionId, timer);
+        this.applyActivitySilent(agent, activity, now, sessionInfo);
+        return;
+      }
+      if (agentName) {
+        this.namedAgentMap.set(`${rootSessionId}:${agentName}`, sessionId);
+      }
+      this.addHistory(sessionId, { timestamp: now, kind: "spawn", zone: "spawn" });
+      const spawnEvent = { type: "agent:spawn", agent: { ...agent }, timestamp: now };
+      this.recordTimeline(spawnEvent);
+      this.emit("agent:spawn", spawnEvent);
+    }
+    this.applyActivity(agent, activity, now, sessionInfo);
+  }
+  /** Apply activity and emit update event (for visible agents) */
+  applyActivity(agent, activity, now, sessionInfo) {
+    this.mutateAgentState(agent, activity, now, sessionInfo);
+    this.resetIdleTimer(agent.id);
+    const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: now };
+    this.recordTimeline(updateEvent);
+    this.emit("agent:update", updateEvent);
+  }
+  /** Apply activity silently — no events emitted (for hidden agents) */
+  applyActivitySilent(agent, activity, now, sessionInfo) {
+    this.mutateAgentState(agent, activity, now, sessionInfo);
+  }
+  /** Mutate agent state based on activity (shared between silent and loud paths) */
+  mutateAgentState(agent, activity, now, _sessionInfo) {
+    agent.lastActivityAt = now;
+    agent.isIdle = false;
+    agent.isDone = false;
+    if (agent.phase === "idle")
+      agent.phase = "running";
+    if (activity.model) {
+      agent.model = activity.model;
+    }
+    processToolActivity(this.activityDeps, agent, activity, now);
+  }
+  queuePendingInfo(parentId, info) {
+    let queue = this.pendingSubagentInfo.get(parentId);
+    if (!queue) {
+      queue = [];
+      this.pendingSubagentInfo.set(parentId, queue);
+    }
+    queue.push(info);
+  }
+  popPendingInfo(parentId) {
+    const queue = this.pendingSubagentInfo.get(parentId);
+    if (!queue || queue.length === 0)
+      return null;
+    return queue.shift();
+  }
+  queueRecipient(rootSessionId, sender, recipient) {
+    let queue = this.pendingRecipients.get(rootSessionId);
+    if (!queue) {
+      queue = [];
+      this.pendingRecipients.set(rootSessionId, queue);
+    }
+    queue.push({ sender, recipient });
+    if (queue.length > 50)
+      queue.shift();
+  }
+  /** Pop a queued recipient name matching a specific sender */
+  popRecipientBySender(rootSessionId, sender) {
+    const queue = this.pendingRecipients.get(rootSessionId);
+    if (!queue)
+      return null;
+    const idx = queue.findIndex((e) => e.sender === sender);
+    if (idx === -1)
+      return null;
+    const entry = queue.splice(idx, 1)[0];
+    return entry.recipient;
+  }
+  clearTimers(agentId) {
+    const idle = this.idleTimers.get(agentId);
+    if (idle)
+      clearTimeout(idle);
+    this.idleTimers.delete(agentId);
+    const shutdown = this.shutdownTimers.get(agentId);
+    if (shutdown)
+      clearTimeout(shutdown);
+    this.shutdownTimers.delete(agentId);
+    const identity = this.identityTimers.get(agentId);
+    if (identity)
+      clearTimeout(identity);
+    this.identityTimers.delete(agentId);
+  }
+  resetIdleTimer(agentId) {
+    const existing = this.idleTimers.get(agentId);
+    if (existing)
+      clearTimeout(existing);
+    const existingShutdown = this.shutdownTimers.get(agentId);
+    if (existingShutdown)
+      clearTimeout(existingShutdown);
+    const timer = setTimeout(() => {
+      const agent = this.agents.get(agentId);
+      if (agent && !this.hiddenAgents.has(agentId)) {
+        if (this.pendingTool.has(agentId)) {
+          this.resetIdleTimer(agentId);
+          return;
+        }
+        agent.isIdle = true;
+        agent.isPlanning = false;
+        agent.isWaitingForUser = false;
+        agent.phase = "idle";
+        agent.currentZone = "idle";
+        agent.currentTool = null;
+        agent.currentActivity = null;
+        agent.speechText = null;
+        const ts = Date.now();
+        this.addHistory(agentId, { timestamp: ts, kind: "idle", zone: "idle" });
+        const idleEvent = {
+          type: "agent:idle",
+          agent: { ...agent },
+          timestamp: ts
+        };
+        this.recordTimeline(idleEvent);
+        this.emit("agent:idle", idleEvent);
+        this.startShutdownTimer(agentId);
+      }
+    }, config.idleTimeoutMs);
+    this.idleTimers.set(agentId, timer);
+  }
+  startShutdownTimer(agentId) {
+    const existing = this.shutdownTimers.get(agentId);
+    if (existing)
+      clearTimeout(existing);
+    const timer = setTimeout(() => {
+      const agent = this.agents.get(agentId);
+      if (agent && agent.isIdle && !agent.isDone) {
+        agent.isDone = true;
+        console.log(`Agent marked done: ${agentId} (idle for ${config.shutdownTimeoutMs / 1e3}s)`);
+        const ts = Date.now();
+        const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: ts };
+        this.recordTimeline(updateEvent);
+        this.emit("agent:update", updateEvent);
+      }
+    }, config.shutdownTimeoutMs);
+    this.shutdownTimers.set(agentId, timer);
+  }
+  removeDone() {
+    const removed = [];
+    const doneIds = [...this.agents.entries()].filter(([, a]) => a.isDone).map(([id]) => id);
+    for (const id of doneIds) {
+      if (this.agents.has(id)) {
+        removed.push(id);
+        this.shutdown(id);
+      }
+    }
+    return removed;
+  }
+  shutdown(sessionId) {
+    const childIds = [...this.agents.entries()].filter(([id, a]) => a.parentId === sessionId && id !== sessionId).map(([id]) => id);
+    this.clearTimers(sessionId);
+    this.hiddenAgents.delete(sessionId);
+    this.pendingTool.delete(sessionId);
+    const ts = Date.now();
+    this.addHistory(sessionId, { timestamp: ts, kind: "shutdown" });
+    const agent = this.agents.get(sessionId);
+    const shutdownEvent = {
+      type: "agent:shutdown",
+      agent: agent ? { ...agent } : { id: sessionId },
+      timestamp: ts
+    };
+    this.recordTimeline(shutdownEvent);
+    this.emit("agent:shutdown", shutdownEvent);
+    if (agent?.agentName) {
+      const key = `${agent.rootSessionId}:${agent.agentName}`;
+      if (this.namedAgentMap.get(key) === sessionId) {
+        this.namedAgentMap.delete(key);
+      }
+    }
+    for (const [sid, target] of this.sessionToAgent) {
+      if (target === sessionId) {
+        this.sessionToAgent.delete(sid);
+      }
+    }
+    this.agents.delete(sessionId);
+    this.activityHistory.delete(sessionId);
+    this.pendingSubagentInfo.delete(sessionId);
+    this.anomalyDetector.removeAgent(sessionId);
+    this.toolChainTracker.resetAgent(sessionId);
+    if (!this.toolChainTracker.hasActiveAgents() && this.agents.size === 0) {
+      this.toolChainTracker.reset();
+    }
+    this.emit("toolchain:changed", { data: this.toolChainTracker.getSnapshot(), timestamp: Date.now() });
+    if (agent?.rootSessionId) {
+      const rootId = agent.rootSessionId;
+      const hasRelated = [...this.agents.values()].some((a) => a.rootSessionId === rootId);
+      if (!hasRelated) {
+        this.pendingRecipients.delete(rootId);
+      }
+    }
+    if (this.taskGraphManager.removeAgentTasks(sessionId)) {
+      this.emit("taskgraph:changed", { data: this.taskGraphManager.getSnapshot(), timestamp: Date.now() });
+    }
+    for (const childId of childIds) {
+      if (this.agents.has(childId)) {
+        console.log(`Cascading shutdown: child ${childId.slice(0, 12)}\u2026 (parent ${sessionId.slice(0, 12)}\u2026 removed)`);
+        this.shutdown(childId);
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Hook-based lifecycle methods (Phase B: merge event sources)
+  // ---------------------------------------------------------------------------
+  /** Hook: new Claude Code session started */
+  hookSessionStart(sessionId, _cwd) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    if (agent) {
+      agent.isIdle = false;
+      agent.isDone = false;
+      agent.phase = "running";
+      agent.lastActivityAt = Date.now();
+      this.resetIdleTimer(canonicalId);
+    }
+  }
+  /** Hook: session ended — definitively shut down the agent */
+  hookSessionEnd(sessionId) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    if (this.agents.has(canonicalId)) {
+      this.shutdown(canonicalId);
+    }
+  }
+  /** Hook: user submitted a prompt — agent is now running */
+  hookUserPromptSubmit(sessionId) {
+    this.setPhase(sessionId, "running");
+  }
+  /** Hook: agent finished responding (Stop event) */
+  hookStop(sessionId, lastMessage) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    if (!agent || this.hiddenAgents.has(canonicalId))
+      return;
+    agent.phase = "idle";
+    agent.isIdle = true;
+    agent.isPlanning = false;
+    agent.isWaitingForUser = false;
+    agent.currentZone = "idle";
+    agent.currentTool = null;
+    agent.currentActivity = null;
+    if (lastMessage) {
+      agent.speechText = lastMessage.length > 200 ? lastMessage.slice(0, 197) + "..." : lastMessage;
+    }
+    const now = Date.now();
+    this.addHistory(canonicalId, { timestamp: now, kind: "idle", zone: "idle" });
+    const idleEvent = { type: "agent:idle", agent: { ...agent }, timestamp: now };
+    this.recordTimeline(idleEvent);
+    this.emit("agent:idle", idleEvent);
+    this.resetIdleTimer(canonicalId);
+  }
+  /** Hook: context compaction is starting */
+  hookPreCompact(sessionId) {
+    this.setPhase(sessionId, "compacting");
+  }
+  /** Hook: tool is about to execute (PreToolUse) */
+  hookPreToolUse(sessionId, toolName, toolInput, _toolUseId) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    if (!agent || this.hiddenAgents.has(canonicalId))
+      return;
+    agent.phase = "running";
+    agent.lastToolOutcome = null;
+    agent.currentTool = toolName;
+    agent.currentZone = getZoneForTool(toolName);
+    if (toolInput) {
+      agent.currentActivity = this.summarizeToolInput(toolInput);
+    }
+    agent.lastActivityAt = Date.now();
+    this.resetIdleTimer(canonicalId);
+    this.toolChainTracker.recordToolStart(canonicalId, toolName);
+    const now = Date.now();
+    const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: now };
+    this.recordTimeline(updateEvent);
+    this.emit("agent:update", updateEvent);
+  }
+  /** Hook: background task completed (TaskCompleted event) */
+  hookTaskCompleted(sessionId, taskId, taskSubject) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    const root = agent?.rootSessionId ?? canonicalId;
+    const changed = this.taskGraphManager.processTaskCompleted(taskId, root);
+    if (changed) {
+      this.emit("taskgraph:changed", { data: this.taskGraphManager.getSnapshot(), timestamp: Date.now() });
+    }
+    this.emit("task:completed", {
+      taskId,
+      taskSubject: taskSubject ?? `Task ${taskId}`,
+      agentId: canonicalId
+    });
+  }
+  /** Hook: tool completed (PostToolUse = success, PostToolUseFailure = failure) */
+  hookPostToolUse(sessionId, _toolName, _toolUseId, success) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    if (!agent || this.hiddenAgents.has(canonicalId))
+      return;
+    agent.lastToolOutcome = success ? "success" : "failure";
+    this.toolChainTracker.recordToolOutcome(canonicalId, success);
+    agent.lastActivityAt = Date.now();
+    this.resetIdleTimer(canonicalId);
+    const now = Date.now();
+    const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: now };
+    this.recordTimeline(updateEvent);
+    this.emit("agent:update", updateEvent);
+  }
+  setPhase(sessionId, phase) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    if (!agent || this.hiddenAgents.has(canonicalId))
+      return;
+    agent.phase = phase;
+    if (phase === "running" || phase === "compacting") {
+      agent.isIdle = false;
+      agent.isDone = false;
+      agent.lastActivityAt = Date.now();
+      this.resetIdleTimer(canonicalId);
+    }
+    const now = Date.now();
+    const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: now };
+    this.recordTimeline(updateEvent);
+    this.emit("agent:update", updateEvent);
+  }
+  dispose() {
+    this.anomalyDetector.dispose();
+    this.clearAllTimers();
+  }
+  clearAllTimers() {
+    for (const timer of this.idleTimers.values())
+      clearTimeout(timer);
+    this.idleTimers.clear();
+    for (const timer of this.shutdownTimers.values())
+      clearTimeout(timer);
+    this.shutdownTimers.clear();
+    for (const timer of this.identityTimers.values())
+      clearTimeout(timer);
+    this.identityTimers.clear();
+  }
+};
+export {
+  AgentStateManager
+};