@kendoo.agentdesk/agentdesk 0.6.9 → 0.7.1

package/README.md

@@ -69,6 +69,7 @@ agentdesk logout                       Sign out and remove credentials
 agentdesk init                         Set up project and configure tracker
 agentdesk team <TASK-ID>               Run a team session on an existing task
 agentdesk team -d "..."                Describe what you want — task created automatically
+agentdesk daemon                       Start daemon for remote sessions
 agentdesk update                       Update to the latest version
 ```
 
@@ -121,6 +122,33 @@ AgentDesk also auto-discovers agents from `.claude/agents/`, `.claude/commands/`
 5. For UI tasks, the team captures screenshots (desktop + mobile) and uploads them to your task tracker
 6. Token usage is tracked and displayed per session
 
+## Daemon (Remote Sessions)
+
+The daemon lets you trigger team sessions from the web dashboard instead of the terminal.
+
+```bash
+agentdesk daemon
+```
+
+Once running, a "Start Session" button appears on [agentdesk.live](https://agentdesk.live). Select a project, optionally provide a prompt, and the daemon spawns a Claude session on your machine. Output streams back to the dashboard in real-time.
+
+### Security
+
+- **Outbound only** — no ports opened on your machine
+- **Project allowlist** — only runs on projects registered via `agentdesk init`
+- **No arbitrary commands** — only spawns Claude with a fixed set of allowed tools
+- **Metadata-only logs** — session logs in `~/.agentdesk/logs/` contain timestamps and file paths, never sensitive data
+- **Fail closed** — unknown projects or exceeded session limits are rejected
+
+### How it works
+
+1. The daemon connects to the server via WebSocket
+2. You click "Start Session" in the dashboard
+3. The server relays the request to your daemon
+4. The daemon spawns `claude` in the project directory
+5. Output streams through the server to the dashboard
+6. If the connection drops, output is buffered locally and replayed on reconnect
+
 ## Dashboard Features
 
 - **Live sessions** — watch agents collaborate in real-time

package/bin/agentdesk.mjs

@@ -59,6 +59,7 @@ if (!command || command === "help" || command === "--help") {
     agentdesk init                         Set up project and configure tracker
     agentdesk team <TASK-ID>               Run a team session on an existing task
     agentdesk team -d "..."                Create a task and run a session
+    agentdesk daemon                       Start daemon for remote sessions
     agentdesk update                       Update to the latest version
 
   Options:
@@ -126,6 +127,11 @@ else if (command === "team") {
   process.exit(code);
 }
 
+else if (command === "daemon") {
+  const { runDaemon } = await import("../cli/daemon.mjs");
+  await runDaemon();
+}
+
 else if (command === "update") {
   const { execSync } = await import("child_process");
   console.log(`\n  Updating ${pkg.name}...\n`);

package/cli/daemon.mjs

@@ -0,0 +1,468 @@
+// `agentdesk daemon` — local background daemon for UI-triggered sessions
+
+import { spawn } from "child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { createInterface } from "readline";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import WebSocket from "ws";
+import { detectProject } from "./detect.mjs";
+import { loadConfig } from "./config.mjs";
+import { getStoredApiKey } from "./login.mjs";
+import { resolveTeam, generateTeamPrompt } from "./agents.mjs";
+import { buildPrompt } from "./prompt.mjs";
+import { createStreamParser } from "./stream-parser.mjs";
+import { getRegisteredProjects, registerLocalProject } from "./projects.mjs";
+
+const CONFIG_DIR = join(process.env.HOME || process.env.USERPROFILE, ".agentdesk");
+const LOGS_DIR = join(CONFIG_DIR, "logs");
+
+// --- Ring buffer for disconnect resilience ---
+
+class RingBuffer {
+  constructor(maxBytes = 10 * 1024 * 1024) {
+    this.maxBytes = maxBytes;
+    this.items = [];
+    this.currentBytes = 0;
+    this.seq = 0;
+  }
+
+  push(data) {
+    const json = JSON.stringify(data);
+    const bytes = Buffer.byteLength(json, "utf-8");
+
+    // Drop oldest items until we have room
+    while (this.items.length > 0 && this.currentBytes + bytes > this.maxBytes) {
+      const removed = this.items.shift();
+      this.currentBytes -= removed.bytes;
+    }
+
+    this.seq++;
+    this.items.push({ seq: this.seq, data, json, bytes });
+    this.currentBytes += bytes;
+    return this.seq;
+  }
+
+  drain() {
+    const items = this.items.splice(0);
+    this.currentBytes = 0;
+    return items.map(i => ({ seq: i.seq, data: i.data }));
+  }
+
+  get size() { return this.currentBytes; }
+  get length() { return this.items.length; }
+}
+
+// --- Dot-env loader ---
+
+function loadDotEnv(dir) {
+  const envPath = join(dir, ".env");
+  if (!existsSync(envPath)) return {};
+  const vars = {};
+  for (const line of readFileSync(envPath, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    vars[trimmed.slice(0, eq)] = trimmed.slice(eq + 1);
+  }
+  return vars;
+}
+
+// --- Metadata logger ---
+
+function logSessionMetadata(sessionId, metadata) {
+  try {
+    if (!existsSync(LOGS_DIR)) {
+      mkdirSync(LOGS_DIR, { recursive: true, mode: 0o700 });
+    }
+    const logPath = join(LOGS_DIR, `session-${sessionId}.json`);
+    writeFileSync(logPath, JSON.stringify(metadata, null, 2) + "\n", { mode: 0o600 });
+  } catch {
+    // Non-fatal — don't crash daemon for logging failures
+  }
+}
+
+// --- Main daemon ---
+
+export async function runDaemon() {
+  const dim = "\x1b[2m";
+  const green = "\x1b[32m";
+  const yellow = "\x1b[33m";
+  const red = "\x1b[31m";
+  const cyan = "\x1b[36m";
+  const reset = "\x1b[0m";
+
+  // 1. Load credentials
+  const apiKey = getStoredApiKey();
+  if (!apiKey) {
+    console.log(`\n  ${red}Not authenticated.${reset} Run ${cyan}agentdesk login${reset} first.\n`);
+    process.exit(1);
+  }
+
+  // 2. Load registered projects — local registry first, then server fallback
+  const agentdeskServer = process.env.AGENTDESK_SERVER || "https://agentdesk.live";
+  let allProjects = getRegisteredProjects();
+
+  // Fallback: fetch from server if local registry is empty (pre-0.7.0 projects)
+  if (allProjects.length === 0) {
+    try {
+      const res = await fetch(`${agentdeskServer}/api/projects`, {
+        headers: { "x-api-key": apiKey },
+        signal: AbortSignal.timeout(5000),
+      });
+      if (res.ok) {
+        const serverProjects = await res.json();
+        if (Array.isArray(serverProjects) && serverProjects.length > 0) {
+          console.log(`  ${dim}Syncing ${serverProjects.length} project(s) from server...${reset}`);
+          for (const sp of serverProjects) {
+            if (sp.path && existsSync(sp.path)) {
+              registerLocalProject(sp.id || sp.name, sp.name, sp.path);
+            }
+          }
+          allProjects = getRegisteredProjects();
+        }
+      }
+    } catch {
+      // Server not reachable — continue with local only
+    }
+  }
+
+  const projects = allProjects.filter(p => {
+    if (!existsSync(p.path)) return false;
+    if (!existsSync(join(p.path, ".agentdesk.json"))) return false;
+    return true;
+  });
+
+  if (projects.length === 0) {
+    console.log(`\n  ${red}No registered projects found.${reset} Run ${cyan}agentdesk init${reset} in a project directory.\n`);
+    process.exit(1);
+  }
+
+  console.log("");
+  console.log(`  ${green}AgentDesk Daemon${reset}`);
+  console.log("  ━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log("");
+  console.log(`  Projects:`);
+  for (const p of projects) {
+    console.log(`    ${dim}•${reset} ${p.name} ${dim}(${p.path})${reset}`);
+  }
+  console.log("");
+
+  // 3. Connect WebSocket
+  const DAEMON_URL = process.env.AGENTDESK_URL
+    ? process.env.AGENTDESK_URL.replace("/ws/agent", "/ws/daemon")
+    : "wss://agentdesk.live/ws/daemon";
+
+  // Enforce TLS in production — API key must not travel in cleartext
+  if (!DAEMON_URL.startsWith("wss://") && !DAEMON_URL.startsWith("ws://localhost") && !DAEMON_URL.startsWith("ws://127.0.0.1")) {
+    console.log(`\n  ${red}Refusing to connect:${reset} daemon URL must use wss:// (got ${DAEMON_URL})\n`);
+    process.exit(1);
+  }
+
+  let ws = null;
+  let connected = false;
+  let reconnectTimer = null;
+  let heartbeatTimer = null;
+  const buffer = new RingBuffer();
+
+  // Active session state
+  let activeSession = null; // { sessionId, projectId, child, startedAt, filePathsTouched }
+
+  function send(data) {
+    if (connected && ws?.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(data));
+      return true;
+    }
+    return false;
+  }
+
+  function sendBuffered(sessionId, event) {
+    const seq = buffer.push({ sessionId, event });
+    const msg = { type: "daemon:session-output", sessionId, event, seq };
+    if (!send(msg)) {
+      // Already buffered — will replay on reconnect
+    }
+  }
+
+  function connectWs() {
+    try {
+      ws = new WebSocket(DAEMON_URL);
+
+      ws.on("open", () => {
+        send({ type: "auth", apiKey });
+      });
+
+      ws.on("message", (raw) => {
+        let msg;
+        try { msg = JSON.parse(raw.toString()); } catch { return; }
+
+        if (msg.type === "auth:ok") {
+          connected = true;
+          console.log(`  ${green}Connected${reset} to ${dim}${DAEMON_URL}${reset}`);
+
+          // Announce projects — do NOT send local paths to the server
+          send({
+            type: "daemon:connect",
+            projects: projects.map(p => ({ id: p.id, name: p.name })),
+          });
+
+          // Replay buffered items
+          const buffered = buffer.drain();
+          if (buffered.length > 0) {
+            console.log(`  ${dim}Replaying ${buffered.length} buffered events...${reset}`);
+            for (const item of buffered) {
+              send({ type: "daemon:session-output", sessionId: item.data.sessionId, event: item.data.event, seq: item.seq });
+            }
+          }
+
+          // Start heartbeat
+          clearInterval(heartbeatTimer);
+          heartbeatTimer = setInterval(() => send({ type: "daemon:heartbeat" }), 30000);
+
+          console.log(`  ${dim}Waiting for sessions...${reset}\n`);
+        }
+
+        if (msg.type === "auth:error") {
+          console.log(`  ${red}Authentication failed.${reset} Run ${cyan}agentdesk login${reset} to re-authenticate.`);
+          connected = false;
+          ws.close();
+          process.exit(1);
+        }
+
+        if (msg.type === "daemon:start-session") {
+          handleStartSession(msg);
+        }
+
+        if (msg.type === "daemon:cancel-session") {
+          handleCancelSession(msg);
+        }
+      });
+
+      ws.on("error", () => { connected = false; });
+
+      ws.on("close", (code) => {
+        connected = false;
+        clearInterval(heartbeatTimer);
+
+        if (code === 4001) {
+          console.log(`  ${red}Authentication required.${reset} Run ${cyan}agentdesk login${reset}.`);
+          process.exit(1);
+        }
+
+        console.log(`  ${yellow}Disconnected.${reset} Reconnecting in 5s...`);
+        clearTimeout(reconnectTimer);
+        reconnectTimer = setTimeout(connectWs, 5000);
+      });
+    } catch {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = setTimeout(connectWs, 10000);
+    }
+  }
+
+  // 4. Session handling
+
+  async function handleStartSession({ sessionId, projectId, prompt }) {
+    // Validate project against local allowlist
+    const project = projects.find(p => p.id === projectId);
+    if (!project) {
+      console.log(`  ${red}Rejected:${reset} unknown project ${dim}${projectId}${reset}`);
+      send({ type: "daemon:error", sessionId, error: `Project "${projectId}" not registered with this daemon` });
+      return;
+    }
+
+    // Enforce max 1 concurrent session — set flag BEFORE any async work to prevent race
+    if (activeSession) {
+      console.log(`  ${red}Rejected:${reset} session already running ${dim}(${activeSession.sessionId})${reset}`);
+      send({ type: "daemon:error", sessionId, error: "Max concurrent sessions reached (1). Try again after the current session completes." });
+      return;
+    }
+    // Claim the slot immediately (before any await) to prevent race conditions
+    activeSession = { sessionId, projectId, child: null, startedAt: Date.now(), filePathsTouched: new Set() };
+
+    console.log(`  ${green}Starting session${reset} ${dim}${sessionId}${reset}`);
+    console.log(`  Project: ${project.name} ${dim}(${project.path})${reset}`);
+
+    const startedAt = activeSession.startedAt;
+    const filePathsTouched = activeSession.filePathsTouched;
+
+    try {
+      // Load project config
+      const detected = detectProject(project.path);
+      const projectEnv = loadDotEnv(project.path);
+      const projectApiKey = projectEnv.AGENTDESK_API_KEY || process.env.AGENTDESK_API_KEY || apiKey;
+      const config = await loadConfig(project.path, { apiKey: projectApiKey, serverUrl: agentdeskServer, projectName: project.name });
+      const tracker = config.tracker || (detected.hasLinear ? "linear" : null);
+
+      // Generate task ID
+      const taskId = prompt
+        ? prompt.toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").slice(0, 40) || `task-${Date.now().toString(36)}`
+        : `daemon-${Date.now().toString(36)}`;
+
+      // Build task link
+      let taskLink = null;
+
+      // Resolve team
+      const team = resolveTeam(config);
+      const teamSections = generateTeamPrompt(team);
+
+      const inboxUrl = `${agentdeskServer}/api/sessions/${sessionId}/inbox`;
+      const sessionUrl = `${agentdeskServer}/sessions/${sessionId}`;
+
+      // Build prompt
+      const fullPrompt = buildPrompt({
+        taskId, taskLink,
+        description: prompt || "",
+        createTask: false,
+        tracker, config,
+        project: detected,
+        teamSections, inboxUrl, sessionUrl,
+      });
+
+      // Send session:start
+      sendBuffered(sessionId, {
+        type: "session:start",
+        taskId, taskLink,
+        title: prompt || taskId,
+        project: project.name,
+        sessionNumber: 1,
+        agents: teamSections.names,
+      });
+
+      sendBuffered(sessionId, { type: "phase:change", phase: "INTAKE" });
+
+      // Spawn Claude — NEVER uses --dangerously-skip-permissions
+      const child = spawn(
+        "claude",
+        [
+          "-p", fullPrompt,
+          "--allowedTools", "Bash,Read,Edit,Write,Glob,Grep",
+          "--verbose",
+          "--output-format", "stream-json",
+        ],
+        {
+          stdio: ["pipe", "pipe", "inherit"],
+          shell: false,
+          env: { ...process.env, ...loadDotEnv(project.path) },
+          cwd: project.path,
+        }
+      );
+
+      // Close stdin so claude doesn't wait for input
+      child.stdin.end();
+
+      activeSession.child = child;
+
+      // Parse stream
+      const { parseLine } = createStreamParser({
+        teamNames: teamSections.names,
+        callbacks: {
+          onPhaseChange({ phase }) {
+            sendBuffered(sessionId, { type: "phase:change", phase });
+          },
+          onAgentMessage({ agent, tag, message }) {
+            sendBuffered(sessionId, { type: "agent:message", agent, tag, message });
+          },
+          onToolUse({ agent, tool, description }) {
+            sendBuffered(sessionId, { type: "tool:use", agent, tool, description });
+            // Track file paths for metadata logging
+            const pathMatch = description.match(/(?:Reading|Editing|Writing)\s+(.+)/);
+            if (pathMatch) filePathsTouched.add(pathMatch[1]);
+          },
+          onToolResult({ success, summary }) {
+            sendBuffered(sessionId, { type: "tool:result", success, summary });
+          },
+          onSessionUpdate({ taskId: newTaskId }) {
+            sendBuffered(sessionId, { type: "session:update", taskId: newTaskId });
+          },
+          onSessionEnd({ duration, steps, inputTokens, outputTokens }) {
+            sendBuffered(sessionId, { type: "session:end", duration, steps, inputTokens, outputTokens });
+            console.log(`  ${green}Session complete${reset} ${dim}${sessionId}${reset} (${duration}, ${steps} steps)`);
+
+            // Log metadata
+            logSessionMetadata(sessionId, {
+              sessionId, projectId,
+              startedAt, endedAt: Date.now(),
+              duration, exitCode: 0, steps,
+              filePathsTouched: [...filePathsTouched],
+            });
+
+            activeSession = null;
+          },
+        },
+      });
+
+      const rl = createInterface({ input: child.stdout });
+      for await (const line of rl) {
+        parseLine(line);
+      }
+
+      // Handle unexpected exit (no "result" event)
+      child.on("close", (code) => {
+        if (activeSession?.sessionId === sessionId) {
+          const duration = `${((Date.now() - startedAt) / 1000).toFixed(1)}s`;
+          console.log(`  ${code ? red : yellow}Session exited${reset} ${dim}${sessionId}${reset} (code ${code})`);
+
+          sendBuffered(sessionId, { type: "session:end", duration, steps: 0, inputTokens: 0, outputTokens: 0 });
+
+          logSessionMetadata(sessionId, {
+            sessionId, projectId,
+            startedAt, endedAt: Date.now(),
+            duration, exitCode: code || 0, steps: 0,
+            filePathsTouched: [...filePathsTouched],
+          });
+
+          activeSession = null;
+        }
+      });
+
+    } catch (err) {
+      console.log(`  ${red}Failed to start session:${reset} ${err.message}`);
+      // Send generic error to server — don't leak internal details (paths, config, etc.)
+      send({ type: "daemon:error", sessionId, error: "Failed to start session on daemon" });
+      activeSession = null;
+    }
+  }
+
+  function killChild(child) {
+    if (!child) return;
+    try { child.kill("SIGTERM"); } catch {}
+    // Force kill if SIGTERM doesn't work within 5 seconds
+    setTimeout(() => {
+      try { if (!child.killed) child.kill("SIGKILL"); } catch {}
+    }, 5000);
+  }
+
+  function handleCancelSession({ sessionId }) {
+    if (activeSession?.sessionId === sessionId) {
+      console.log(`  ${yellow}Cancelling session${reset} ${dim}${sessionId}${reset}`);
+      killChild(activeSession.child);
+      activeSession = null;
+    }
+  }
+
+  // 5. Graceful shutdown
+
+  function shutdown() {
+    console.log(`\n  ${dim}Shutting down...${reset}`);
+    clearInterval(heartbeatTimer);
+    clearTimeout(reconnectTimer);
+
+    if (activeSession) {
+      killChild(activeSession.child);
+    }
+
+    send({ type: "daemon:disconnect" });
+    try { ws?.close(); } catch {}
+    process.exit(0);
+  }
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  // 6. Start
+  connectWs();
+
+  // Keep process alive
+  await new Promise(() => {});
+}

package/cli/init.mjs

@@ -6,6 +6,7 @@ import { createInterface } from "readline";
 import { detectProject } from "./detect.mjs";
 import { loadConfig } from "./config.mjs";
 import { getStoredApiKey } from "./login.mjs";
+import { registerLocalProject } from "./projects.mjs";
 
 const SERVER = process.env.AGENTDESK_SERVER || "https://agentdesk.live";
 
@@ -122,6 +123,9 @@ export async function runInit(cwd) {
   writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n");
   console.log(`  Saved .agentdesk.json`);
 
+  // Register in local project index (for daemon discovery)
+  registerLocalProject(projectId, project.name || projectId, project.dir);
+
   // --- Register with server ---
   try {
     const res = await fetch(`${SERVER}/api/projects`, {

package/cli/projects.mjs

@@ -0,0 +1,34 @@
+// Local project registry — tracks which projects have been initialized with `agentdesk init`
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+
+const CONFIG_DIR = join(process.env.HOME || process.env.USERPROFILE, ".agentdesk");
+const PROJECTS_PATH = join(CONFIG_DIR, "projects.json");
+
+export function getRegisteredProjects() {
+  try {
+    if (!existsSync(PROJECTS_PATH)) return [];
+    const data = JSON.parse(readFileSync(PROJECTS_PATH, "utf-8"));
+    return Array.isArray(data.projects) ? data.projects : [];
+  } catch {
+    return [];
+  }
+}
+
+export function registerLocalProject(id, name, path) {
+  const projects = getRegisteredProjects();
+  const existing = projects.findIndex(p => p.id === id);
+  const entry = { id, name, path, registeredAt: Date.now() };
+
+  if (existing >= 0) {
+    projects[existing] = entry;
+  } else {
+    projects.push(entry);
+  }
+
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+  writeFileSync(PROJECTS_PATH, JSON.stringify({ projects }, null, 2) + "\n", { mode: 0o600 });
+}

package/cli/prompt.mjs

@@ -0,0 +1,98 @@
+// Shared prompt builder — used by both `agentdesk team` and `agentdesk daemon`
+
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { generateContext } from "./detect.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROMPT_PATH = resolve(__dirname, "../prompts/team.md");
+
+export function buildPrompt({ taskId, taskLink, description, createTask, tracker, config, project, teamSections, inboxUrl, sessionUrl }) {
+  let prompt = readFileSync(PROMPT_PATH, "utf-8");
+
+  // Team substitution
+  prompt = prompt.replace(/\{\{AGENT_COUNT\}\}/g, String(teamSections.count));
+  prompt = prompt.replace(/\{\{AGENT_LIST\}\}/g, teamSections.agentList);
+  prompt = prompt.replace(/\{\{SPEAKING_ORDER\}\}/g, teamSections.speakingOrder);
+  prompt = prompt.replace(/\{\{GROUND_RULES\}\}/g, teamSections.groundRules);
+  prompt = prompt.replace(/\{\{CODE_PRINCIPLES\}\}/g, teamSections.codePrinciples);
+  prompt = prompt.replace(/\{\{BRAINSTORM_ORDER\}\}/g, teamSections.brainstormOrder);
+  prompt = prompt.replace(/\{\{PLANNING_ORDER\}\}/g, teamSections.planningOrder);
+  prompt = prompt.replace(/\{\{EXECUTION_STEPS\}\}/g, teamSections.executionSteps);
+
+  // Template substitution
+  prompt = prompt.replace(/\{\{TASK_ID\}\}/g, taskId);
+  prompt = prompt.replace(/\{\{TASK_LINK\}\}/g, taskLink || "");
+
+  // Task description
+  if (description) {
+    prompt = prompt.replace(/\{\{#TASK_DESCRIPTION\}\}([\s\S]*?)\{\{\/TASK_DESCRIPTION\}\}/g, "$1");
+    prompt = prompt.replace(/\{\{TASK_DESCRIPTION\}\}/g, description);
+  } else {
+    prompt = prompt.replace(/\{\{#TASK_DESCRIPTION\}\}[\s\S]*?\{\{\/TASK_DESCRIPTION\}\}/g, "");
+  }
+
+  // Create task instruction
+  if (createTask && description) {
+    let createInstr = "\n\n## CREATE TASK\n\nNo task ID was provided. Before starting work, Jane MUST create a new task in the tracker:\n\n";
+    if (tracker === "linear") {
+      createInstr += `Create a Linear issue using the GraphQL API:\n- Endpoint: https://api.linear.app/graphql\n- Auth: Authorization: $LINEAR_API_KEY\n- Set the title based on the description below\n- After creation, use the returned identifier (e.g., KEN-530) as the task ID for the rest of the session\n`;
+    } else if (tracker === "jira") {
+      createInstr += `Create a Jira issue:\n- Endpoint: ${config.jira?.baseUrl || ""}/rest/api/3/issue\n- Auth: Basic auth with $JIRA_EMAIL and $JIRA_API_TOKEN\n- Set the summary based on the description below\n- After creation, use the returned key (e.g., PROJ-42) as the task ID for the rest of the session\n`;
+    } else if (tracker === "github") {
+      createInstr += `Create a GitHub issue:\n- Run: gh issue create --title "..." --body "..."\n- After creation, use the returned issue number as the task ID for the rest of the session\n`;
+    }
+    createInstr += `\nTask description: ${description}\n`;
+    createInstr += `\nIMPORTANT: After creating the task, Jane MUST immediately announce the new task ID on its own line in this exact format:\nTASK_ID: <identifier>\nExample: TASK_ID: KEN-530\nThis is required so the session can be linked to the correct task.\n`;
+    prompt += createInstr;
+  }
+
+  // Tracker integration — enable the matching section, strip the rest
+  const trackers = ["LINEAR", "JIRA", "GITHUB"];
+  for (const t of trackers) {
+    const enabled = tracker === t.toLowerCase();
+    if (enabled) {
+      prompt = prompt.replace(new RegExp(`\\{\\{#${t}\\}\\}([\\s\\S]*?)\\{\\{\\/${t}\\}\\}`, "g"), "$1");
+    } else {
+      prompt = prompt.replace(new RegExp(`\\{\\{#${t}\\}\\}[\\s\\S]*?\\{\\{\\/${t}\\}\\}`, "g"), "");
+    }
+  }
+
+  // NO_TRACKER
+  if (!tracker) {
+    prompt = prompt.replace(/\{\{#NO_TRACKER\}\}([\s\S]*?)\{\{\/NO_TRACKER\}\}/g, "$1");
+  } else {
+    prompt = prompt.replace(/\{\{#NO_TRACKER\}\}[\s\S]*?\{\{\/NO_TRACKER\}\}/g, "");
+  }
+
+  // Jira-specific variables
+  if (config.jira?.baseUrl) {
+    prompt = prompt.replace(/\{\{JIRA_BASE_URL\}\}/g, config.jira.baseUrl);
+  }
+
+  // Append custom instructions from config
+  if (config.instructions) {
+    prompt += `\n\n## ADDITIONAL INSTRUCTIONS\n\n${config.instructions}\n`;
+  }
+
+  // Inject URLs into prompt
+  prompt = prompt.replace(/\{\{AGENTDESK_INBOX_URL\}\}/g, inboxUrl);
+  prompt = prompt.replace(/\{\{SESSION_URL\}\}/g, sessionUrl);
+
+  // Merge declared agents from config into project for context generation
+  if (config.projectAgents?.length) {
+    project.configAgents = config.projectAgents.map(a => ({
+      ...a,
+      type: a.type || "declared",
+      source: ".agentdesk.json",
+    }));
+  }
+
+  // Append project context and current time
+  const context = generateContext(project);
+  const now = new Date();
+  const timeInfo = `Current date/time: ${now.toLocaleDateString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric" })} ${now.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" })}`;
+
+  return `${prompt}\n\n---\n\n## PROJECT CONTEXT\n\n${context}\n\n${timeInfo}`;
+}

package/cli/stream-parser.mjs

@@ -0,0 +1,174 @@
+// Shared Claude stream-json parser — used by both `agentdesk team` and `agentdesk daemon`
+
+const PHASE_NAMES = ["INTAKE", "BRAINSTORM", "PLANNING", "EXECUTION", "REVIEW"];
+
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function createStreamParser({ teamNames, callbacks }) {
+  // callbacks: { onAgentMessage, onPhaseChange, onToolUse, onToolResult, onSessionEnd, onSessionUpdate, onTokenUsage }
+
+  const agentPattern = teamNames.map(escapeRegex).join("|");
+  const agentRegex = new RegExp(`^(${agentPattern})\\s*[●◆▲■◈☾✦*]*\\s*:?\\s*`, "i");
+
+  let lastAgent = teamNames[0] || "Jane";
+  let stepCount = 0;
+  const startTime = Date.now();
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+
+  function detectAgent(text) {
+    const stripped = text.replace(/^[●◆▲■◈☾✦*\-─—\s]+/, "");
+    const match = stripped.match(agentRegex);
+    if (match) {
+      const raw = match[1];
+      const name = teamNames.find(n => n.toLowerCase() === raw.toLowerCase()) || raw;
+      return { name, rest: stripped.slice(match[0].length) };
+    }
+    return null;
+  }
+
+  function detectTag(text) {
+    if (/\[ARGUE\]/i.test(text)) return "ARGUE";
+    if (/\[AGREE\]/i.test(text)) return "AGREE";
+    if (/\[THINK\]/i.test(text)) return "THINK";
+    if (/\[ACT\]/i.test(text)) return "ACT";
+    return "SAY";
+  }
+
+  function detectPhase(text) {
+    const upper = text.trim().toUpperCase();
+    if (upper.startsWith("PHASE") || upper.startsWith("---") || upper.startsWith("#")) {
+      for (const p of PHASE_NAMES) {
+        if (upper.includes(p)) return p;
+      }
+    }
+    return null;
+  }
+
+  function timestamp() {
+    const d = new Date();
+    return [d.getHours(), d.getMinutes(), d.getSeconds()]
+      .map(n => String(n).padStart(2, "0")).join(":");
+  }
+
+  function parseLine(line) {
+    try {
+      const event = JSON.parse(line);
+
+      // Track token usage
+      if (event.usage) {
+        if (event.usage.input_tokens) totalInputTokens = Math.max(totalInputTokens, event.usage.input_tokens);
+        if (event.usage.output_tokens) totalOutputTokens += (event.usage.output_tokens_delta || 0);
+      }
+      if (event.message?.usage) {
+        if (event.message.usage.input_tokens) totalInputTokens = Math.max(totalInputTokens, event.message.usage.input_tokens);
+        if (event.message.usage.output_tokens) totalOutputTokens = Math.max(totalOutputTokens, event.message.usage.output_tokens);
+      }
+
+      if (event.type === "assistant" && event.message?.content) {
+        for (const block of event.message.content) {
+          if (block.type === "text" && block.text.trim()) {
+            const text = block.text.trim().replace(/\*+/g, "");
+
+            const phase = detectPhase(text);
+            if (phase) {
+              callbacks.onPhaseChange?.({ phase, timestamp: timestamp() });
+              continue;
+            }
+
+            // Detect TASK_ID announcement
+            const taskIdMatch = text.match(/TASK_ID:\s*(\S+)/);
+            if (taskIdMatch) {
+              callbacks.onSessionUpdate?.({ taskId: taskIdMatch[1] });
+            }
+
+            const textLines = text.split("\n");
+            let i = 0;
+            while (i < textLines.length) {
+              const currentLine = textLines[i].trim();
+              if (!currentLine) { i++; continue; }
+
+              const detected = detectAgent(currentLine);
+              if (detected) {
+                let msg = detected.rest;
+                while (i + 1 < textLines.length && !detectAgent(textLines[i + 1].trim())) {
+                  i++;
+                  const next = textLines[i].trim();
+                  if (next) msg += "\n" + next;
+                }
+                const tag = detectTag(msg);
+                const cleanMsg = msg.replace(/\[(SAY|ACT|THINK|AGREE|ARGUE)\]\s*/gi, "");
+                lastAgent = detected.name;
+                callbacks.onAgentMessage?.({ agent: detected.name, tag, message: cleanMsg, timestamp: timestamp() });
+              } else {
+                callbacks.onAgentMessage?.({ agent: lastAgent, tag: "SAY", message: currentLine, timestamp: timestamp() });
+              }
+              i++;
+            }
+          }
+        }
+      }
+
+      if (event.type === "tool_use") {
+        const name = event.name || event.tool_name;
+        stepCount++;
+
+        let description = "Running command...";
+        if (name === "Bash") {
+          const cmd = event.input?.command || "";
+          if (cmd.includes("curl") && cmd.includes("linear")) description = "Calling Linear API...";
+          else if (cmd.includes("curl")) description = "Making API request...";
+          else {
+            const shortCmd = cmd.length > 80 ? cmd.slice(0, 80) + "..." : cmd;
+            description = `$ ${shortCmd}`;
+          }
+        } else if (name === "Read") {
+          const shortPath = (event.input?.file_path || "").split("/").slice(-3).join("/");
+          description = `Reading ${shortPath}`;
+        } else if (name === "Edit" || name === "Write") {
+          const shortPath = (event.input?.file_path || "").split("/").slice(-3).join("/");
+          description = `${name === "Edit" ? "Editing" : "Writing"} ${shortPath}`;
+        } else if (name === "Glob" || name === "Grep") {
+          description = `Searching ${event.input?.pattern || ""}`;
+        }
+
+        callbacks.onToolUse?.({ agent: lastAgent, tool: name, description, timestamp: timestamp() });
+      }
+
+      if (event.type === "tool_result") {
+        const output = event.content || event.output;
+        let text = "";
+        if (typeof output === "string") text = output.trim();
+        else if (Array.isArray(output)) {
+          text = output.filter(b => b.type === "text").map(b => b.text.trim()).join("\n");
+        }
+
+        const hasError = text && (text.toLowerCase().includes("error") || text.toLowerCase().includes("failed"));
+        const summary = text?.length > 300 ? `Done (${text.length} chars)` : text || "Done";
+
+        callbacks.onToolResult?.({ success: !hasError, summary, timestamp: timestamp() });
+      }
+
+      if (event.type === "result") {
+        if (event.usage) {
+          if (event.usage.input_tokens) totalInputTokens = Math.max(totalInputTokens, event.usage.input_tokens);
+          if (event.usage.output_tokens) totalOutputTokens = Math.max(totalOutputTokens, event.usage.output_tokens);
+        }
+        const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
+        callbacks.onSessionEnd?.({
+          duration: `${totalTime}s`,
+          steps: stepCount,
+          inputTokens: totalInputTokens,
+          outputTokens: totalOutputTokens,
+          timestamp: timestamp(),
+        });
+      }
+    } catch {
+      // skip non-JSON lines
+    }
+  }
+
+  return { parseLine, getLastAgent: () => lastAgent, getStepCount: () => stepCount };
+}

package/cli/team.mjs

@@ -3,14 +3,15 @@
 import { spawn } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import { createInterface } from "readline";
-import { resolve, dirname, join } from "path";
-import { fileURLToPath } from "url";
+import { join } from "path";
 import { randomUUID } from "crypto";
 import WebSocket from "ws";
-import { detectProject, generateContext } from "./detect.mjs";
+import { detectProject } from "./detect.mjs";
 import { loadConfig } from "./config.mjs";
 import { getStoredApiKey } from "./login.mjs";
 import { resolveTeam, generateTeamPrompt } from "./agents.mjs";
+import { buildPrompt } from "./prompt.mjs";
+import { createStreamParser } from "./stream-parser.mjs";
 
 function loadDotEnv(dir) {
   const envPath = join(dir, ".env");
@@ -26,9 +27,6 @@ function loadDotEnv(dir) {
   return vars;
 }
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const PROMPT_PATH = resolve(__dirname, "../prompts/team.md");
-
 export async function runTeam(taskId, opts = {}) {
   const cwd = opts.cwd || process.cwd();
   const description = opts.description || "";
@@ -86,98 +84,18 @@ export async function runTeam(taskId, opts = {}) {
   const team = resolveTeam(config);
   const teamSections = generateTeamPrompt(team);
 
-  // Build prompt
-  let prompt = readFileSync(PROMPT_PATH, "utf-8");
-
-  // Team substitution
-  prompt = prompt.replace(/\{\{AGENT_COUNT\}\}/g, String(teamSections.count));
-  prompt = prompt.replace(/\{\{AGENT_LIST\}\}/g, teamSections.agentList);
-  prompt = prompt.replace(/\{\{SPEAKING_ORDER\}\}/g, teamSections.speakingOrder);
-  prompt = prompt.replace(/\{\{GROUND_RULES\}\}/g, teamSections.groundRules);
-  prompt = prompt.replace(/\{\{CODE_PRINCIPLES\}\}/g, teamSections.codePrinciples);
-  prompt = prompt.replace(/\{\{BRAINSTORM_ORDER\}\}/g, teamSections.brainstormOrder);
-  prompt = prompt.replace(/\{\{PLANNING_ORDER\}\}/g, teamSections.planningOrder);
-  prompt = prompt.replace(/\{\{EXECUTION_STEPS\}\}/g, teamSections.executionSteps);
-
-  // Template substitution
-  prompt = prompt.replace(/\{\{TASK_ID\}\}/g, taskId);
-  prompt = prompt.replace(/\{\{TASK_LINK\}\}/g, taskLink || "");
-
-  // Task description
-  if (description) {
-    prompt = prompt.replace(/\{\{#TASK_DESCRIPTION\}\}([\s\S]*?)\{\{\/TASK_DESCRIPTION\}\}/g, "$1");
-    prompt = prompt.replace(/\{\{TASK_DESCRIPTION\}\}/g, description);
-  } else {
-    prompt = prompt.replace(/\{\{#TASK_DESCRIPTION\}\}[\s\S]*?\{\{\/TASK_DESCRIPTION\}\}/g, "");
-  }
-
-  // Create task instruction — when -d is used without a task ID and a tracker is configured
-  if (createTask && description) {
-    let createInstr = "\n\n## CREATE TASK\n\nNo task ID was provided. Before starting work, Jane MUST create a new task in the tracker:\n\n";
-    if (tracker === "linear") {
-      createInstr += `Create a Linear issue using the GraphQL API:\n- Endpoint: https://api.linear.app/graphql\n- Auth: Authorization: $LINEAR_API_KEY\n- Set the title based on the description below\n- After creation, use the returned identifier (e.g., KEN-530) as the task ID for the rest of the session\n`;
-    } else if (tracker === "jira") {
-      createInstr += `Create a Jira issue:\n- Endpoint: ${config.jira?.baseUrl || ""}/rest/api/3/issue\n- Auth: Basic auth with $JIRA_EMAIL and $JIRA_API_TOKEN\n- Set the summary based on the description below\n- After creation, use the returned key (e.g., PROJ-42) as the task ID for the rest of the session\n`;
-    } else if (tracker === "github") {
-      createInstr += `Create a GitHub issue:\n- Run: gh issue create --title "..." --body "..."\n- After creation, use the returned issue number as the task ID for the rest of the session\n`;
-    }
-    createInstr += `\nTask description: ${description}\n`;
-    createInstr += `\nIMPORTANT: After creating the task, Jane MUST immediately announce the new task ID on its own line in this exact format:\nTASK_ID: <identifier>\nExample: TASK_ID: KEN-530\nThis is required so the session can be linked to the correct task.\n`;
-    prompt += createInstr;
-  }
-
-  // Tracker integration — enable the matching section, strip the rest
-  const trackers = ["LINEAR", "JIRA", "GITHUB"];
-  for (const t of trackers) {
-    const enabled = tracker === t.toLowerCase();
-    if (enabled) {
-      prompt = prompt.replace(new RegExp(`\\{\\{#${t}\\}\\}([\\s\\S]*?)\\{\\{\\/${t}\\}\\}`, "g"), "$1");
-    } else {
-      prompt = prompt.replace(new RegExp(`\\{\\{#${t}\\}\\}[\\s\\S]*?\\{\\{\\/${t}\\}\\}`, "g"), "");
-    }
-  }
-
-  // NO_TRACKER — enable if no tracker configured
-  if (!tracker) {
-    prompt = prompt.replace(/\{\{#NO_TRACKER\}\}([\s\S]*?)\{\{\/NO_TRACKER\}\}/g, "$1");
-  } else {
-    prompt = prompt.replace(/\{\{#NO_TRACKER\}\}[\s\S]*?\{\{\/NO_TRACKER\}\}/g, "");
-  }
-
-  // Jira-specific variables
-  if (config.jira?.baseUrl) {
-    prompt = prompt.replace(/\{\{JIRA_BASE_URL\}\}/g, config.jira.baseUrl);
-  }
-
-  // Append custom instructions from config
-  if (config.instructions) {
-    prompt += `\n\n## ADDITIONAL INSTRUCTIONS\n\n${config.instructions}\n`;
-  }
-
   // --- AgentDesk WebSocket config ---
   const AGENTDESK_URL = process.env.AGENTDESK_URL || "wss://agentdesk.live/ws/agent";
   const sessionId = `${taskId}-${randomUUID().slice(0, 8)}`;
   const inboxUrl = `${agentdeskServer}/api/sessions/${sessionId}/inbox`;
   const sessionUrl = `${agentdeskServer}/sessions/${sessionId}`;
 
-  // Inject URLs into prompt
-  prompt = prompt.replace(/\{\{AGENTDESK_INBOX_URL\}\}/g, inboxUrl);
-  prompt = prompt.replace(/\{\{SESSION_URL\}\}/g, sessionUrl);
-
-  // Merge declared agents from config into project for context generation
-  if (config.projectAgents?.length) {
-    project.configAgents = config.projectAgents.map(a => ({
-      ...a,
-      type: a.type || "declared",
-      source: ".agentdesk.json",
-    }));
-  }
+  // Build prompt using shared builder
+  const fullPrompt = buildPrompt({
+    taskId, taskLink, description, createTask, tracker, config, project,
+    teamSections, inboxUrl, sessionUrl,
+  });
 
-  // Append project context and current time
-  const context = generateContext(project);
-  const now = new Date();
-  const timeInfo = `Current date/time: ${now.toLocaleDateString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric" })} ${now.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" })}`;
-  const fullPrompt = `${prompt}\n\n---\n\n## PROJECT CONTEXT\n\n${context}\n\n${timeInfo}`;
   let vizWs = null;
   let vizConnected = false;
   const vizQueue = [];
@@ -275,48 +193,9 @@ export async function runTeam(taskId, opts = {}) {
   process.on("SIGINT", () => { try { child.kill(); } catch {} process.exit(1); });
   process.on("SIGTERM", () => { try { child.kill(); } catch {} process.exit(1); });
 
-  // --- Stream parsing ---
-  const PHASE_NAMES = ["INTAKE", "BRAINSTORM", "PLANNING", "EXECUTION", "REVIEW"];
-
-  // Build agent name regex dynamically from resolved team
-  const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const agentNames = teamSections.names.map(escapeRegex).join("|");
-  const agentRegex = new RegExp(`^(${agentNames})\\s*[●◆▲■◈☾✦*]*\\s*:?\\s*`, "i");
-
-  function detectAgent(text) {
-    // Strip all badge decoration characters from the start
-    const stripped = text.replace(/^[●◆▲■◈☾✦*\-─—\s]+/, '');
-    const match = stripped.match(agentRegex);
-    if (match) {
-      const raw = match[1];
-      // Preserve original casing from team config
-      const name = teamSections.names.find(n => n.toLowerCase() === raw.toLowerCase()) || raw;
-      return { name, rest: stripped.slice(match[0].length) };
-    }
-    return null;
-  }
-
-  function detectTag(text) {
-    if (/\[ARGUE\]/i.test(text)) return "ARGUE";
-    if (/\[AGREE\]/i.test(text)) return "AGREE";
-    if (/\[THINK\]/i.test(text)) return "THINK";
-    if (/\[ACT\]/i.test(text)) return "ACT";
-    return "SAY";
-  }
-
-  function detectPhase(text) {
-    const upper = text.trim().toUpperCase();
-    if (upper.startsWith("PHASE") || upper.startsWith("---") || upper.startsWith("#")) {
-      for (const p of PHASE_NAMES) {
-        if (upper.includes(p)) return p;
-      }
-    }
-    return null;
-  }
-
-  let stepCount = 0;
-  const startTime = Date.now();
-  let lastAgent = "Jane";
+  // --- Stream parsing via shared parser ---
+  console.log("\n━━━ INTAKE ━━━\n");
+  vizSend({ type: "phase:change", phase: "INTAKE" });
 
   function timestamp() {
     const d = new Date();
@@ -324,150 +203,58 @@ export async function runTeam(taskId, opts = {}) {
       .map(n => String(n).padStart(2, "0")).join(":");
   }
 
-  console.log("\n━━━ INTAKE ━━━\n");
-  vizSend({ type: "phase:change", phase: "INTAKE" });
-
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-
-  const rl = createInterface({ input: child.stdout });
-
-  for await (const line of rl) {
-    try {
-      const event = JSON.parse(line);
-
-      // Track token usage from any event that reports it
-      if (event.usage) {
-        if (event.usage.input_tokens) totalInputTokens = Math.max(totalInputTokens, event.usage.input_tokens);
-        if (event.usage.output_tokens) totalOutputTokens += (event.usage.output_tokens_delta || 0);
-      }
-      if (event.message?.usage) {
-        if (event.message.usage.input_tokens) totalInputTokens = Math.max(totalInputTokens, event.message.usage.input_tokens);
-        if (event.message.usage.output_tokens) totalOutputTokens = Math.max(totalOutputTokens, event.message.usage.output_tokens);
-      }
-
-      if (event.type === "assistant" && event.message?.content) {
-        for (const block of event.message.content) {
-          if (block.type === "text" && block.text.trim()) {
-            const text = block.text.trim().replace(/\*+/g, "");
-
-            const phase = detectPhase(text);
-            if (phase) {
-              console.log(`\n━━━ ${phase} ━━━\n`);
-              vizSend({ type: "phase:change", phase });
-              continue;
-            }
-
-            // Detect TASK_ID announcement from Jane
-            const taskIdMatch = text.match(/TASK_ID:\s*(\S+)/);
-            if (taskIdMatch && createTask) {
-              const newTaskId = taskIdMatch[1];
-              taskId = newTaskId;
-              // Build task link for the real task
-              if (tracker === "linear" && config.linear?.workspace) {
-                taskLink = `https://linear.app/${config.linear.workspace}/issue/${newTaskId}`;
-              } else if (tracker === "jira" && config.jira?.baseUrl) {
-                taskLink = `${config.jira.baseUrl}/browse/${newTaskId}`;
-              } else if (tracker === "github") {
-                const repo = config.github?.repo || "";
-                if (repo) taskLink = `https://github.com/${repo}/issues/${newTaskId}`;
-              }
-              console.log(`\n  # Task: ${newTaskId}${taskLink ? ` (${taskLink})` : ""}\n`);
-              vizSend({ type: "session:update", taskId: newTaskId, taskLink, title: description || newTaskId });
-            }
-
-            const textLines = text.split("\n");
-            let i = 0;
-            while (i < textLines.length) {
-              const currentLine = textLines[i].trim();
-              if (!currentLine) { i++; continue; }
-
-              const detected = detectAgent(currentLine);
-              if (detected) {
-                let msg = detected.rest;
-                while (i + 1 < textLines.length && !detectAgent(textLines[i + 1].trim())) {
-                  i++;
-                  const next = textLines[i].trim();
-                  if (next) msg += "\n" + next;
-                }
-                const tag = detectTag(msg);
-                const cleanMsg = msg.replace(/\[(SAY|ACT|THINK|AGREE|ARGUE)\]\s*/gi, "");
-                lastAgent = detected.name;
-
-                console.log(`${timestamp()}  ${detected.name} [${tag}]  ${cleanMsg}\n`);
-                vizSend({ type: "agent:message", agent: detected.name, tag, message: cleanMsg });
-              } else {
-                console.log(`  ${currentLine}`);
-                vizSend({ type: "agent:message", agent: lastAgent, tag: "SAY", message: currentLine });
-              }
-              i++;
-            }
-          }
-        }
-      }
-
-      if (event.type === "tool_use") {
-        const name = event.name || event.tool_name;
-        stepCount++;
-
-        let description = "Running command...";
-        if (name === "Bash") {
-          const cmd = event.input?.command || "";
-          if (cmd.includes("curl") && cmd.includes("linear")) description = "Calling Linear API...";
-          else if (cmd.includes("curl")) description = "Making API request...";
-          const shortCmd = cmd.length > 80 ? cmd.slice(0, 80) + "..." : cmd;
-          console.log(`  ${lastAgent} [ACT] ${description}\n  $ ${shortCmd}`);
-        } else if (name === "Read") {
-          const shortPath = (event.input?.file_path || "").split("/").slice(-3).join("/");
-          description = `Reading ${shortPath}`;
-          console.log(`  ${lastAgent} [ACT] ${description}`);
-        } else if (name === "Edit" || name === "Write") {
-          const shortPath = (event.input?.file_path || "").split("/").slice(-3).join("/");
-          description = `${name === "Edit" ? "Editing" : "Writing"} ${shortPath}`;
-          console.log(`  ${lastAgent} [ACT] ${description}`);
-        } else if (name === "Glob" || name === "Grep") {
-          description = `Searching ${event.input?.pattern || ""}`;
-          console.log(`  ${lastAgent} [ACT] ${description}`);
-        }
-
-        vizSend({ type: "tool:use", agent: lastAgent, tool: name, description });
-      }
-
-      if (event.type === "tool_result") {
-        const output = event.content || event.output;
-        let text = "";
-        if (typeof output === "string") text = output.trim();
-        else if (Array.isArray(output)) {
-          text = output.filter(b => b.type === "text").map(b => b.text.trim()).join("\n");
-        }
-
-        const hasError = text && (text.toLowerCase().includes("error") || text.toLowerCase().includes("failed"));
-        if (text && text.length <= 300) {
-          console.log(`  ${hasError ? "✗" : "✓"} ${text}`);
+  const { parseLine } = createStreamParser({
+    teamNames: teamSections.names,
+    callbacks: {
+      onPhaseChange({ phase }) {
+        console.log(`\n━━━ ${phase} ━━━\n`);
+        vizSend({ type: "phase:change", phase });
+      },
+      onAgentMessage({ agent, tag, message }) {
+        console.log(`${timestamp()}  ${agent} [${tag}]  ${message}\n`);
+        vizSend({ type: "agent:message", agent, tag, message });
+      },
+      onToolUse({ agent, tool, description }) {
+        if (tool === "Bash") {
+          console.log(`  ${agent} [ACT] ${description}`);
         } else {
-          console.log(`  ${hasError ? "✗" : "✓"} Done${text ? ` (${text.length} chars)` : ""}`);
+          console.log(`  ${agent} [ACT] ${description}`);
         }
-
-        vizSend({ type: "tool:result", success: !hasError, summary: text?.length > 300 ? `Done (${text.length} chars)` : text || "Done" });
-      }
-
-      if (event.type === "result") {
-        // Final usage from result event
-        if (event.usage) {
-          if (event.usage.input_tokens) totalInputTokens = Math.max(totalInputTokens, event.usage.input_tokens);
-          if (event.usage.output_tokens) totalOutputTokens = Math.max(totalOutputTokens, event.usage.output_tokens);
+        vizSend({ type: "tool:use", agent, tool, description });
+      },
+      onToolResult({ success, summary }) {
+        console.log(`  ${success ? "✓" : "✗"} ${summary}`);
+        vizSend({ type: "tool:result", success, summary });
+      },
+      onSessionUpdate({ taskId: newTaskId }) {
+        if (createTask) {
+          taskId = newTaskId;
+          if (tracker === "linear" && config.linear?.workspace) {
+            taskLink = `https://linear.app/${config.linear.workspace}/issue/${newTaskId}`;
+          } else if (tracker === "jira" && config.jira?.baseUrl) {
+            taskLink = `${config.jira.baseUrl}/browse/${newTaskId}`;
+          } else if (tracker === "github") {
+            const repo = config.github?.repo || "";
+            if (repo) taskLink = `https://github.com/${repo}/issues/${newTaskId}`;
+          }
+          console.log(`\n  # Task: ${newTaskId}${taskLink ? ` (${taskLink})` : ""}\n`);
+          vizSend({ type: "session:update", taskId: newTaskId, taskLink, title: description || newTaskId });
         }
-        const totalTokens = totalInputTokens + totalOutputTokens;
-        const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
+      },
+      onSessionEnd({ duration, steps, inputTokens, outputTokens }) {
+        const totalTokens = inputTokens + outputTokens;
         console.log(`\n━━━ DONE ━━━`);
-        console.log(`  ${totalTime}s  |  ${stepCount} steps${totalTokens ? `  |  ${totalTokens.toLocaleString()} tokens` : ""}\n`);
-        vizSend({ type: "session:end", duration: `${totalTime}s`, steps: stepCount, inputTokens: totalInputTokens, outputTokens: totalOutputTokens });
-        clearInterval(inboxTimer);
+        console.log(`  ${duration}  |  ${steps} steps${totalTokens ? `  |  ${totalTokens.toLocaleString()} tokens` : ""}\n`);
+        vizSend({ type: "session:end", duration, steps, inputTokens, outputTokens });
         setTimeout(() => { try { vizWs?.close(); } catch {} }, 500);
-      }
-    } catch {
-      // skip non-JSON lines
-    }
+      },
+    },
+  });
+
+  const rl = createInterface({ input: child.stdout });
+
+  for await (const line of rl) {
+    parseLine(line);
   }
 
   return new Promise(resolve => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kendoo.agentdesk/agentdesk",
-  "version": "0.6.9",
+  "version": "0.7.1",
   "description": "AI team orchestrator for Claude Code — run collaborative agent sessions from your terminal",
   "type": "module",
   "bin": {