@kendoo.agentdesk/agentdesk 0.1.0

package/bin/agentdesk.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+// AgentDesk CLI — AI team orchestrator for Claude Code
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+if (!command || command === "help" || command === "--help") {
+  console.log(`
+  AgentDesk — AI team orchestrator for Claude Code
+
+  Getting started:
+    1. Sign up at https://agentdesk.live and copy your API key from Settings
+    2. Add to your project's .env:  AGENTDESK_API_KEY=<your-key>
+    3. Run: agentdesk init
+    4. Run: agentdesk team <TASK-ID>
+
+  Usage:
+    agentdesk init                         Detect project and show setup info
+    agentdesk team <TASK-ID>               Run a team session on a task
+    agentdesk team <TASK-ID> -d "..."      Run with a task description
+
+  Options:
+    --description, -d    Task description (for projects without a task tracker)
+    --cwd                Working directory (defaults to current)
+
+  Configuration:
+    Create .agentdesk.json in your project root:
+    {
+      "tracker": "linear",              // "linear" | "jira" | "github"
+      "linear": { "workspace": "..." }  // for task links in the dashboard
+    }
+
+  Examples:
+    agentdesk init
+    agentdesk team KEN-517
+    agentdesk team BUG-42 -d "Fix the checkout total calculation"
+
+  Dashboard: https://agentdesk.live
+`);
+  process.exit(0);
+}
+
+if (command === "init") {
+  const { runInit } = await import("../cli/init.mjs");
+  await runInit(process.cwd());
+}
+
+else if (command === "team") {
+  const taskId = args[1];
+  if (!taskId) {
+    console.error("Usage: agentdesk team <TASK-ID>");
+    process.exit(1);
+  }
+
+  // Parse options
+  let description = "";
+  let cwd = process.cwd();
+  for (let i = 2; i < args.length; i++) {
+    if ((args[i] === "--description" || args[i] === "-d") && args[i + 1]) {
+      description = args[++i];
+    } else if (args[i] === "--cwd" && args[i + 1]) {
+      cwd = args[++i];
+    }
+  }
+
+  const { runTeam } = await import("../cli/team.mjs");
+  const code = await runTeam(taskId, { description, cwd });
+  process.exit(code);
+}
+
+else if (command === "server") {
+  try {
+    await import("../server/index.mjs");
+  } catch {
+    console.error("The server is not available in the CLI package.");
+    console.error("Visit https://agentdesk.live to use the dashboard.");
+    process.exit(1);
+  }
+}
+
+else {
+  console.error(`Unknown command: ${command}`);
+  console.error("Run 'agentdesk help' for usage.");
+  process.exit(1);
+}

package/cli/config.mjs

@@ -0,0 +1,76 @@
+// .agentdesk.json config loader
+// Place this file in your project root to customize agent behavior
+
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+const DEFAULTS = {
+  // Task tracker integration
+  tracker: null,  // "linear" | "jira" | "github" | null
+
+  // Tracker-specific settings
+  linear: {
+    teamKey: null,  // e.g., "KEN"
+    workspace: null, // e.g., "kendoo" — the slug in linear.app/<workspace>/issue/...
+  },
+  jira: {
+    baseUrl: null,  // e.g., "https://mycompany.atlassian.net"
+    project: null,  // e.g., "PROJ"
+  },
+  github: {
+    repo: null,     // e.g., "owner/repo" — auto-detected from git if null
+  },
+
+  // Agent customization
+  agents: {
+    Jane:   { role: "Product Analyst / Team Lead" },
+    Dennis: { role: "Senior Developer" },
+    Bart:   { role: "QA Engineer" },
+    Vera:   { role: "Test Engineer" },
+    Sam:    { role: "Architecture Auditor" },
+  },
+
+  // Commands — auto-detected if null
+  commands: {
+    test: null,
+    build: null,
+    lint: null,
+  },
+
+  // Existing agents/bots in the project — declare them so the team knows about them
+  // Each entry: { name, role, when, how }
+  // - name: Agent/bot name (e.g., "ReviewBot", "DataSync Agent")
+  // - role: What it does (e.g., "Automated code review on PR creation")
+  // - when: When to use or expect it (e.g., "Triggers on every PR", "Run manually via npm run agent:sync")
+  // - how: How to interact with it (e.g., "Comment /review on a PR", "Set INPUT_MODE=dry-run for testing")
+  projectAgents: [],
+
+  // Extra prompt instructions appended to the team prompt
+  instructions: null,
+};
+
+export function loadConfig(dir) {
+  const configPath = join(dir, ".agentdesk.json");
+
+  if (!existsSync(configPath)) return { ...DEFAULTS };
+
+  try {
+    const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+    return deepMerge(DEFAULTS, raw);
+  } catch (err) {
+    console.error(`Warning: Failed to parse .agentdesk.json: ${err.message}`);
+    return { ...DEFAULTS };
+  }
+}
+
+function deepMerge(defaults, overrides) {
+  const result = { ...defaults };
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value && typeof value === "object" && !Array.isArray(value) && defaults[key] && typeof defaults[key] === "object") {
+      result[key] = deepMerge(defaults[key], value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}

package/cli/detect.mjs

@@ -0,0 +1,291 @@
+// Detect project type, existing agents, and gather context for agent prompts
+
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join, basename } from "path";
+
+const PROJECT_TYPES = [
+  { file: "package.json", field: "dependencies", check: d => d?.next, type: "nextjs", label: "Next.js" },
+  { file: "package.json", field: "dependencies", check: d => d?.react, type: "react", label: "React" },
+  { file: "package.json", field: "dependencies", check: d => d?.express, type: "express", label: "Express" },
+  { file: "package.json", field: null, check: null, type: "node", label: "Node.js" },
+  { file: "requirements.txt", type: "python", label: "Python" },
+  { file: "pyproject.toml", type: "python", label: "Python" },
+  { file: "Cargo.toml", type: "rust", label: "Rust" },
+  { file: "go.mod", type: "go", label: "Go" },
+  { file: "Gemfile", type: "ruby", label: "Ruby" },
+  { file: "pom.xml", type: "java", label: "Java" },
+  { file: "build.gradle", type: "java", label: "Java/Gradle" },
+  { file: "composer.json", type: "php", label: "PHP" },
+];
+
+export function detectProject(dir) {
+  const result = {
+    dir,
+    type: "unknown",
+    label: "Unknown",
+    name: null,
+    hasClaudeMd: false,
+    claudeMd: null,
+    hasGit: false,
+    hasLinear: false,
+    hasGithub: false,
+    taskTracker: null,
+    testCommand: null,
+    buildCommand: null,
+    lintCommand: null,
+  };
+
+  // Detect project type
+  for (const pt of PROJECT_TYPES) {
+    const filePath = join(dir, pt.file);
+    if (!existsSync(filePath)) continue;
+
+    if (pt.field) {
+      try {
+        const content = JSON.parse(readFileSync(filePath, "utf-8"));
+        if (pt.check && !pt.check(content[pt.field])) continue;
+      } catch { continue; }
+    }
+
+    result.type = pt.type;
+    result.label = pt.label;
+    break;
+  }
+
+  // Read project name
+  try {
+    const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+    result.name = pkg.name;
+    if (pkg.scripts?.test) result.testCommand = "npm test";
+    if (pkg.scripts?.build) result.buildCommand = "npm run build";
+    if (pkg.scripts?.lint) result.lintCommand = "npm run lint";
+  } catch {}
+
+  // Check for CLAUDE.md
+  if (existsSync(join(dir, "CLAUDE.md"))) {
+    result.hasClaudeMd = true;
+    result.claudeMd = readFileSync(join(dir, "CLAUDE.md"), "utf-8");
+  }
+
+  // Check git
+  result.hasGit = existsSync(join(dir, ".git"));
+
+  // Check for Linear (env or config)
+  if (existsSync(join(dir, ".env"))) {
+    try {
+      const env = readFileSync(join(dir, ".env"), "utf-8");
+      result.hasLinear = env.includes("LINEAR_API_KEY");
+    } catch {}
+  }
+
+  // Check for GitHub CLI
+  result.hasGithub = existsSync(join(dir, ".git"));
+
+  // Detect task tracker
+  if (result.hasLinear) {
+    result.taskTracker = "linear";
+  }
+
+  // Discover existing agents in the project
+  result.agents = detectAgents(dir);
+
+  return result;
+}
+
+/**
+ * Discover existing AI agents, bots, and automation in the project.
+ * Returns an array of { name, type, role, source, config } objects.
+ */
+function detectAgents(dir) {
+  const agents = [];
+
+  // 1. MCP servers (.mcp.json or .claude/mcp.json)
+  for (const mcpPath of [".mcp.json", ".claude/mcp.json"]) {
+    const fullPath = join(dir, mcpPath);
+    if (existsSync(fullPath)) {
+      try {
+        const mcp = JSON.parse(readFileSync(fullPath, "utf-8"));
+        const servers = mcp.mcpServers || mcp.servers || mcp;
+        for (const [name, config] of Object.entries(servers)) {
+          agents.push({
+            name,
+            type: "mcp-server",
+            role: config.description || `MCP server providing tools via ${config.command || "unknown"}`,
+            source: mcpPath,
+            config: { command: config.command, args: config.args },
+          });
+        }
+      } catch {}
+    }
+  }
+
+  // 2. Claude agents (.claude/agents/)
+  const agentsDir = join(dir, ".claude", "agents");
+  if (existsSync(agentsDir)) {
+    try {
+      for (const file of readdirSync(agentsDir)) {
+        if (!file.endsWith(".md")) continue;
+        const name = basename(file, ".md");
+        const content = readFileSync(join(agentsDir, file), "utf-8");
+        // Parse YAML frontmatter if present
+        let role = "Claude agent";
+        let description = "";
+        const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (fmMatch) {
+          const descMatch = fmMatch[1].match(/description:\s*(.+)/);
+          const nameMatch = fmMatch[1].match(/name:\s*(.+)/);
+          description = descMatch?.[1]?.trim() || "";
+          role = description || `Claude agent "${nameMatch?.[1]?.trim() || name}"`;
+        } else {
+          const firstLine = content.split("\n").find(l => l.trim() && !l.startsWith("---")) || "";
+          role = firstLine.replace(/^#\s*/, "").slice(0, 120) || role;
+        }
+        agents.push({
+          name,
+          type: "claude-agent",
+          role,
+          source: `.claude/agents/${file}`,
+        });
+      }
+    } catch {}
+  }
+
+  // 3. Claude slash commands (.claude/commands/)
+  const commandsDir = join(dir, ".claude", "commands");
+  if (existsSync(commandsDir)) {
+    try {
+      for (const file of readdirSync(commandsDir)) {
+        if (!file.endsWith(".md")) continue;
+        const name = basename(file, ".md");
+        const content = readFileSync(join(commandsDir, file), "utf-8");
+        const firstLine = content.split("\n").find(l => l.trim()) || "";
+        agents.push({
+          name: `/${name}`,
+          type: "claude-command",
+          role: firstLine.replace(/^#\s*/, "").slice(0, 120),
+          source: `.claude/commands/${file}`,
+        });
+      }
+    } catch {}
+  }
+
+  // 4. GitHub Actions bots (dependabot, renovate, custom bot workflows)
+  const workflowsDir = join(dir, ".github", "workflows");
+  if (existsSync(workflowsDir)) {
+    try {
+      for (const file of readdirSync(workflowsDir)) {
+        if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
+        const content = readFileSync(join(workflowsDir, file), "utf-8");
+        // Detect AI/bot-related workflows
+        if (/\b(bot|agent|auto|copilot|claude|openai|gpt|ai-)\b/i.test(file) ||
+            /\b(anthropic|openai|claude|gpt|langchain|ai-review|auto-fix)\b/i.test(content)) {
+          const nameMatch = content.match(/^name:\s*(.+)/m);
+          agents.push({
+            name: nameMatch?.[1]?.trim() || basename(file, file.endsWith(".yml") ? ".yml" : ".yaml"),
+            type: "github-action",
+            role: `GitHub Actions workflow`,
+            source: `.github/workflows/${file}`,
+          });
+        }
+      }
+    } catch {}
+  }
+
+  // 5. Dependabot
+  const dependabotPath = join(dir, ".github", "dependabot.yml");
+  const dependabotPath2 = join(dir, ".github", "dependabot.yaml");
+  if (existsSync(dependabotPath) || existsSync(dependabotPath2)) {
+    agents.push({
+      name: "Dependabot",
+      type: "dependency-bot",
+      role: "Automated dependency updates — creates PRs for outdated packages",
+      source: ".github/dependabot.yml",
+    });
+  }
+
+  // 6. Renovate
+  for (const renovatePath of ["renovate.json", "renovate.json5", ".renovaterc", ".renovaterc.json"]) {
+    if (existsSync(join(dir, renovatePath))) {
+      agents.push({
+        name: "Renovate",
+        type: "dependency-bot",
+        role: "Automated dependency updates — creates PRs for outdated packages",
+        source: renovatePath,
+      });
+      break;
+    }
+  }
+
+  // 7. Custom agent directories (agents/, bots/, ai/)
+  for (const agentDir of ["agents", "bots", "ai"]) {
+    const fullDir = join(dir, agentDir);
+    if (!existsSync(fullDir)) continue;
+    try {
+      for (const entry of readdirSync(fullDir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+          // Check for a manifest or README
+          const manifest = join(fullDir, entry.name, "agent.json");
+          const readme = join(fullDir, entry.name, "README.md");
+          let role = "Custom agent";
+          if (existsSync(manifest)) {
+            try {
+              const m = JSON.parse(readFileSync(manifest, "utf-8"));
+              role = m.description || m.role || role;
+            } catch {}
+          } else if (existsSync(readme)) {
+            const first = readFileSync(readme, "utf-8").split("\n").find(l => l.trim() && !l.startsWith("#")) || "";
+            role = first.slice(0, 120) || role;
+          }
+          agents.push({
+            name: entry.name,
+            type: "custom-agent",
+            role,
+            source: `${agentDir}/${entry.name}/`,
+          });
+        }
+      }
+    } catch {}
+  }
+
+  // 8. Agents declared in .agentdesk.json (loaded separately, merged in team.mjs)
+  // This is handled via config.projectAgents
+
+  return agents;
+}
+
+export function generateContext(project) {
+  const lines = [];
+  lines.push(`# Project: ${project.name || "Unknown"}`);
+  lines.push(`Type: ${project.label}`);
+  lines.push(`Directory: ${project.dir}`);
+  lines.push("");
+
+  if (project.testCommand) lines.push(`Test command: ${project.testCommand}`);
+  if (project.buildCommand) lines.push(`Build command: ${project.buildCommand}`);
+  if (project.lintCommand) lines.push(`Lint command: ${project.lintCommand}`);
+  if (project.testCommand || project.buildCommand || project.lintCommand) lines.push("");
+
+  if (project.hasClaudeMd) {
+    lines.push("## Project Instructions (from CLAUDE.md)");
+    lines.push("");
+    lines.push(project.claudeMd);
+  } else {
+    lines.push("No CLAUDE.md found. The agents will explore the codebase to understand conventions.");
+  }
+
+  // Include discovered agents
+  const allAgents = [...(project.agents || []), ...(project.configAgents || [])];
+  if (allAgents.length > 0) {
+    lines.push("");
+    lines.push("## Existing Agents & Automation");
+    lines.push("");
+    for (const agent of allAgents) {
+      lines.push(`- **${agent.name}** (${agent.type}) — ${agent.role}`);
+      if (agent.source) lines.push(`  Source: \`${agent.source}\``);
+      if (agent.when) lines.push(`  When to use: ${agent.when}`);
+      if (agent.how) lines.push(`  How to use: ${agent.how}`);
+    }
+  }
+
+  return lines.join("\n");
+}

package/cli/init.mjs

@@ -0,0 +1,77 @@
+// `agentdesk init` — detect project and register with AgentDesk server
+
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { detectProject } from "./detect.mjs";
+import { loadConfig } from "./config.mjs";
+
+const SERVER = process.env.AGENTDESK_SERVER || "https://agentdesk.live";
+
+function loadApiKey(dir) {
+  const envPath = join(dir, ".env");
+  if (!existsSync(envPath)) return null;
+  const match = readFileSync(envPath, "utf-8").match(/AGENTDESK_API_KEY=(.+)/);
+  return match?.[1]?.trim() || null;
+}
+
+export async function runInit(cwd) {
+  const project = detectProject(cwd);
+  const config = loadConfig(cwd);
+  const tracker = config.tracker || (project.hasLinear ? "linear" : null);
+  const projectId = project.name || cwd.split("/").pop();
+
+  console.log("");
+  console.log("  AgentDesk — Project Setup");
+  console.log("  ━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log("");
+  console.log(`  Project:      ${project.name || "unknown"}`);
+  console.log(`  Type:         ${project.label}`);
+  console.log(`  Directory:    ${project.dir}`);
+  console.log(`  Git:          ${project.hasGit ? "✓" : "✗"}`);
+  console.log(`  CLAUDE.md:    ${project.hasClaudeMd ? "✓" : "✗ (recommended — run 'claude' to generate one)"}`);
+  console.log(`  Tracker:      ${tracker || "— (none)"}`);
+  console.log("");
+
+  if (project.testCommand) console.log(`  Test:         ${project.testCommand}`);
+  if (project.buildCommand) console.log(`  Build:        ${project.buildCommand}`);
+  if (project.lintCommand) console.log(`  Lint:         ${project.lintCommand}`);
+  if (project.testCommand || project.buildCommand || project.lintCommand) console.log("");
+
+  // Register with AgentDesk server
+  try {
+    const res = await fetch(`${SERVER}/api/projects`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(loadApiKey(cwd) ? { "x-api-key": loadApiKey(cwd) } : {}),
+      },
+      body: JSON.stringify({
+        id: projectId,
+        name: project.name || projectId,
+        path: project.dir,
+        type: project.type,
+        tracker,
+      }),
+    });
+    if (res.ok) {
+      console.log("  ✓ Registered with AgentDesk server");
+    } else {
+      console.log("  ⚠ AgentDesk server not available — project will register on first session");
+    }
+  } catch {
+    console.log("  ⚠ AgentDesk server not running — start it with: agentdesk server");
+  }
+
+  console.log("");
+  console.log("  Ready. Run a team session with:");
+  console.log("");
+  console.log(`    agentdesk team TASK-123`);
+  console.log(`    agentdesk team TASK-123 --description "Fix the login bug"`);
+  console.log("");
+
+  if (!project.hasClaudeMd) {
+    console.log("  Tip: Create a CLAUDE.md in your project root to help the agents");
+    console.log("  understand your codebase conventions, architecture, and commands.");
+    console.log("");
+  }
+}

package/cli/team.mjs

@@ -0,0 +1,337 @@
+// `agentdesk team <TASK-ID> [--description "..."]` — run a team session
+
+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 { randomUUID } from "crypto";
+import WebSocket from "ws";
+import { detectProject, generateContext } from "./detect.mjs";
+import { loadConfig } from "./config.mjs";
+
+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;
+}
+
+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 || "";
+
+  // Detect project and load config
+  const project = detectProject(cwd);
+  const config = loadConfig(cwd);
+  console.log(`Project: ${project.name || "unknown"} (${project.label})`);
+  console.log(`Task: ${taskId}`);
+
+  // Determine tracker and build task link
+  const tracker = config.tracker || (project.hasLinear ? "linear" : null);
+  let taskLink = null;
+  if (tracker === "linear" && config.linear?.workspace) {
+    taskLink = `https://linear.app/${config.linear.workspace}/issue/${taskId}`;
+  } else if (tracker === "jira" && config.jira?.baseUrl) {
+    taskLink = `${config.jira.baseUrl}/browse/${taskId}`;
+  } else if (tracker === "github") {
+    const repo = config.github?.repo || "";
+    if (repo) taskLink = `https://github.com/${repo}/issues/${taskId}`;
+  }
+  if (tracker) console.log(`Tracker: ${tracker}`);
+  if (taskLink) console.log(`Task: ${taskLink}`);
+
+  // Build prompt
+  let prompt = readFileSync(PROMPT_PATH, "utf-8");
+
+  // 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, "");
+  }
+
+  // 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 config ---
+  const projectEnv = loadDotEnv(cwd);
+  const apiKey = projectEnv.AGENTDESK_API_KEY || process.env.AGENTDESK_API_KEY || null;
+  const agentdeskServer = process.env.AGENTDESK_SERVER || "https://agentdesk.live";
+  const baseUrl = process.env.AGENTDESK_URL || "wss://agentdesk.live/ws/agent";
+  const AGENTDESK_URL = apiKey ? `${baseUrl}?api_key=${apiKey}` : baseUrl;
+  const sessionId = `${taskId}-${randomUUID().slice(0, 8)}`;
+  const inboxUrl = `${agentdeskServer}/api/sessions/${sessionId}/inbox`;
+
+  // Inject inbox URL into prompt
+  prompt = prompt.replace(/\{\{AGENTDESK_INBOX_URL\}\}/g, inboxUrl);
+
+  // 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" })}`;
+  const fullPrompt = `${prompt}\n\n---\n\n## PROJECT CONTEXT\n\n${context}\n\n${timeInfo}`;
+  let vizWs = null;
+  let vizConnected = false;
+  const vizQueue = [];
+
+  function vizSend(event) {
+    const data = JSON.stringify({ ...event, sessionId });
+    if (vizConnected && vizWs?.readyState === WebSocket.OPEN) {
+      vizWs.send(data);
+    } else {
+      vizQueue.push(data);
+    }
+  }
+
+  try {
+    vizWs = new WebSocket(AGENTDESK_URL);
+    vizWs.on("open", () => {
+      vizConnected = true;
+      console.log("AgentDesk: connected");
+      vizSend({
+        type: "session:start",
+        taskId,
+        taskLink,
+        title: description || taskId,
+        project: project.name || null,
+        sessionNumber: 1,
+        agents: ["Jane", "Dennis", "Bart", "Vera", "Sam", "Luna", "Mark"],
+      });
+      while (vizQueue.length > 0 && vizWs.readyState === WebSocket.OPEN) {
+        vizWs.send(vizQueue.shift());
+      }
+    });
+    vizWs.on("error", () => { vizConnected = false; });
+    vizWs.on("close", () => { vizConnected = false; });
+  } catch {
+    // AgentDesk not running
+  }
+
+  // --- Spawn Claude ---
+  const child = spawn(
+    "claude",
+    [
+      "-p",
+      fullPrompt,
+      "--allowedTools",
+      "Bash,Read,Edit,Write,Glob,Grep",
+      "--verbose",
+      "--output-format",
+      "stream-json",
+    ],
+    {
+      stdio: ["inherit", "pipe", "inherit"],
+      shell: false,
+      env: { ...process.env, ...loadDotEnv(cwd) },
+      cwd,
+    }
+  );
+
+  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 = ["BRAINSTORM", "PLANNING", "EXECUTION", "REVIEW"];
+
+  function detectAgent(text) {
+    // Strip all badge decoration characters from the start
+    const stripped = text.replace(/^[●◆▲■◈☾✦\-─—\s]+/, '');
+    const match = stripped.match(/^(Dennis|Bart|Vera|Sam|Jane|Luna|Mark|Smokey)\s*[●◆▲■◈☾✦]*\s*:?\s*/i);
+    if (match) {
+      const raw = match[1];
+      const name = raw.charAt(0).toUpperCase() + raw.slice(1).toLowerCase();
+      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";
+
+  function timestamp() {
+    const d = new Date();
+    return [d.getHours(), d.getMinutes(), d.getSeconds()]
+      .map(n => String(n).padStart(2, "0")).join(":");
+  }
+
+  console.log("\n━━━ BRAINSTORM ━━━\n");
+
+  const rl = createInterface({ input: child.stdout });
+
+  for await (const line of rl) {
+    try {
+      const event = JSON.parse(line);
+
+      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;
+            }
+
+            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}`);
+        } else {
+          console.log(`  ${hasError ? "✗" : "✓"} Done${text ? ` (${text.length} chars)` : ""}`);
+        }
+
+        vizSend({ type: "tool:result", success: !hasError, summary: text?.length > 300 ? `Done (${text.length} chars)` : text || "Done" });
+      }
+
+      if (event.type === "result") {
+        const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(`\n━━━ DONE ━━━`);
+        console.log(`  ${totalTime}s  |  ${stepCount} steps\n`);
+        vizSend({ type: "session:end", duration: `${totalTime}s`, steps: stepCount });
+        clearInterval(inboxTimer);
+        setTimeout(() => { try { vizWs?.close(); } catch {} }, 500);
+      }
+    } catch {
+      // skip non-JSON lines
+    }
+  }
+
+  return new Promise(resolve => {
+    child.on("close", (code) => resolve(code || 0));
+  });
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@kendoo.agentdesk/agentdesk",
+  "version": "0.1.0",
+  "description": "AI team orchestrator for Claude Code — run collaborative agent sessions from your terminal",
+  "type": "module",
+  "bin": {
+    "agentdesk": "./bin/agentdesk.mjs"
+  },
+  "files": [
+    "bin/",
+    "cli/",
+    "prompts/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "dev": "concurrently \"node server/index.mjs\" \"vite\"",
+    "start": "node server/index.mjs",
+    "server": "node server/index.mjs",
+    "build": "vite build",
+    "preview": "vite preview",
+    "test": "node --test tests/server.test.mjs"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@logto/react": "^4.0.13",
+    "@vitejs/plugin-react": "^4.5.2",
+    "autoprefixer": "^10.4.21",
+    "bcryptjs": "^3.0.3",
+    "concurrently": "^9.2.0",
+    "express": "^5.1.0",
+    "jose": "^6.2.2",
+    "jsonwebtoken": "^9.0.3",
+    "lucide-react": "^0.577.0",
+    "postcss": "^8.5.4",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "sql.js": "^1.14.1",
+    "tailwindcss": "^3.4.17",
+    "vite": "^6.3.5",
+    "ws": "^8.18.0"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "claude",
+    "cli",
+    "orchestrator",
+    "team"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kendoo-rd/agentdesk.git"
+  }
+}

package/prompts/team.md

@@ -0,0 +1,315 @@
+You are running a team session with seven AI agents collaborating on a task.
+
+The task identifier is: {{TASK_ID}}
+{{TASK_LINK}}
+
+{{#TASK_DESCRIPTION}}
+Task description:
+{{TASK_DESCRIPTION}}
+{{/TASK_DESCRIPTION}}
+
+The agents are:
+
+- Jane (Product Analyst / Team Lead) — facilitates discussion, clarifies requirements, keeps the team focused, evaluates team performance at the end
+- Sam (Architecture Auditor) — scans for separation-of-concerns violations, guards code architecture
+- Bart (QA Engineer) — identifies edge cases, test plans, acceptance criteria, quality risks
+- Dennis (Senior Developer) — assesses technical feasibility, proposes architecture, implements the solution
+- Vera (Test Engineer) — writes unit and regression tests for changed code, ensures test coverage
+- Luna (UX/UI Designer) — designs pixel-perfect interfaces, champions user experience, applies psychology of user behavior, ensures visual consistency, accessibility, and intuitive interaction patterns
+- Mark (Content Writer) — crafts precise, engaging copy for UI text, error messages, tooltips, onboarding flows, and documentation. Simplifies technical language into friendly, clear wording. Ensures consistent tone and voice across the product
+
+You role-play all seven agents in a structured conversation. Jane leads.
+
+MANDATORY: Every single round of discussion must include ALL SEVEN agents speaking, in this order:
+1. ●● JANE ●●
+2. ☾☾ LUNA ☾☾
+3. ✦✦ MARK ✦✦
+4. ◆◆ SAM ◆◆
+5. ■■ DENNIS ■■
+6. ▲▲ BART ▲▲
+7. ◈◈ VERA ◈◈
+If an agent has no concerns, they MUST still speak and say so. Skipping any agent is a protocol violation.
+
+IMPORTANT: You must narrate everything you do. Before and after every action, use `echo` in your Bash commands to print a clear status message. Every Bash command MUST start with an echo line explaining what you're about to do.
+
+## GROUND RULES
+
+1. Each agent speaks in turn, prefixed with their badge (e.g., "■■ DENNIS ■■ Starting implementation.").
+2. ALL text output MUST be prefixed with the acting agent's badge. Never output unprefixed text.
+3. Agents should DISAGREE when they see problems — don't rubber-stamp each other.
+4. Bart must identify at least 2 risks or edge cases before agreeing to any plan.
+5. Dennis must verify at least 1 assumption about the codebase before agreeing to any approach.
+6. Vera must identify which functions need unit test coverage before agreeing to any plan.
+7. Sam must verify that the proposed approach does not introduce architecture violations. He always backs claims with a file reference or line number.
+8. Luna must review any UI changes for visual consistency, spacing, color harmony, accessibility (contrast, focus states), and intuitive interaction flow. She references specific components, screenshots, or design patterns.
+9. Mark must review all user-facing text — labels, buttons, headings, error messages, tooltips, empty states, confirmation dialogs. He ensures the tone is friendly and consistent, wording is concise, and technical jargon is avoided unless the audience is technical.
+10. Jane resolves disagreements and keeps the discussion productive. She NEVER reads code, runs tools, or inspects files — that's Dennis and Sam's job. She focuses on requirements, user impact, scope, and coordination.
+11. Every statement should add value — no filler, no repeating what someone else already said.
+
+## USER INPUT
+
+The user can send messages to the team during the session via the AgentDesk dashboard. Jane MUST check for user messages at these moments:
+- Before starting each phase (BRAINSTORM, PLANNING, EXECUTION, REVIEW)
+- Before making major decisions
+- After completing a phase
+
+To check, run:
+```
+curl -s {{AGENTDESK_INBOX_URL}}
+```
+
+If the response is not empty (`[]`), it contains user messages. Each message has a `message` field. Jane MUST:
+1. Read the message aloud to the team
+2. Address the user as "You"
+3. Incorporate the input into the discussion — user messages take priority
+4. Adjust the plan if the user requests changes
+
+If the response is `[]`, there are no messages — continue without comment.
+
+## Log Level Tags
+
+Use log level tags in agent statements to classify the type of communication:
+- [SAY] — Normal statements, announcements, questions
+- [ACT] — Tool usage, actions, file operations
+- [THINK] — Internal reasoning, analysis
+- [AGREE] — Agreement with another agent's point
+- [ARGUE] — Disagreement, pushback, concerns
+
+## CODE PRINCIPLES
+
+- Dennis: Never write logic inline inside components or UI templates. Extract all conditionals, transformations, calculations, and API calls into dedicated functions, hooks, or services.
+- Bart: Flag any logic written directly inside a component or UI template.
+- Vera: Never mount or render UI to test a logic outcome. Test files must mirror the service/utility structure.
+- Sam: Actively guards separation of concerns throughout the session. Always cites file and line number.
+- Luna: Reviews all UI changes for visual hierarchy, whitespace balance, color consistency, typography, responsive behavior, and accessibility (WCAG). Pushes back on cluttered layouts, inconsistent spacing, poor contrast, or confusing interaction flows. Proposes specific CSS/styling improvements with exact values.
+- Mark: Reviews all user-facing strings in changed files. Rewrites vague, wordy, or technical copy into clear, concise, human-friendly language. Ensures consistent voice — no mixing formal and casual tone. Checks empty states, error messages, and confirmation dialogs for helpfulness.
+
+## STRICT RULES
+
+- Follow the project conventions described in CLAUDE.md (if present).
+- Do NOT modify files unrelated to the task unless absolutely necessary.
+- When posting screenshots to Linear, NEVER embed images inside the structured badge comment (the `---` block). Post screenshots as a SEPARATE plain markdown comment. Example:
+
+  Correct — separate comment:
+  ```
+  ![Desktop Full](https://uploads.linear.app/...)
+
+  Desktop view showing the updated settings panel.
+
+  ![Mobile View](https://uploads.linear.app/...)
+
+  Mobile responsive layout at 375px.
+  ```
+
+  Wrong — inside badge block:
+  ```
+  ---
+  ▲▲ BART ▲▲
+  Status  : Screenshots
+  Task    : ![image](url)
+  ---
+  ```
+
+{{#LINEAR}}
+## LINEAR INTEGRATION
+
+Fetch the task from Linear using curl:
+- Endpoint: https://api.linear.app/graphql
+- Auth header: Authorization: $LINEAR_API_KEY (no Bearer prefix — Linear API keys are sent directly)
+
+GraphQL query — fetch the task by identifier:
+{
+  issue(id: "{{TASK_ID}}") {
+    id
+    identifier
+    title
+    description
+    state { name }
+    comments {
+      nodes {
+        body
+        user { name }
+        createdAt
+      }
+    }
+  }
+}
+
+Post updates as comments on the Linear task using this format:
+```
+---
+■■ DENNIS ■■
+Status  : [status]
+Task    : [description]
+---
+```
+{{/LINEAR}}
+
+{{#JIRA}}
+## JIRA INTEGRATION
+
+Fetch the task from Jira using curl:
+- Endpoint: {{JIRA_BASE_URL}}/rest/api/3/issue/{{TASK_ID}}
+- Auth: Use $JIRA_EMAIL and $JIRA_API_TOKEN as basic auth
+- curl -s -u "$JIRA_EMAIL:$JIRA_API_TOKEN" "{{JIRA_BASE_URL}}/rest/api/3/issue/{{TASK_ID}}?fields=summary,description,status,comment"
+
+Post updates as comments on the Jira task:
+- Endpoint: {{JIRA_BASE_URL}}/rest/api/3/issue/{{TASK_ID}}/comment
+- Body: { "body": { "type": "doc", "version": 1, "content": [{ "type": "paragraph", "content": [{ "type": "text", "text": "..." }] }] } }
+{{/JIRA}}
+
+{{#GITHUB}}
+## GITHUB ISSUES INTEGRATION
+
+Fetch the task from GitHub Issues:
+- Run: gh issue view {{TASK_ID}} --json title,body,state,comments
+
+Post updates as comments:
+- Run: gh issue comment {{TASK_ID}} --body "..."
+{{/GITHUB}}
+
+---
+
+## PHASE 0 — TASK INTAKE
+
+{{#LINEAR}}
+Fetch the task from Linear and print the title, description, current state, and any existing comments.
+{{/LINEAR}}
+{{#JIRA}}
+Fetch the task from Jira and print the summary, description, current status, and any existing comments.
+{{/JIRA}}
+{{#GITHUB}}
+Fetch the issue from GitHub and print the title, body, state, and any existing comments.
+{{/GITHUB}}
+{{#NO_TRACKER}}
+Read the task description above. If a CLAUDE.md file exists, read it to understand project conventions.
+{{/NO_TRACKER}}
+
+### Assess current situation
+
+Before doing anything, check:
+
+1. Existing branches: Run `git branch -a | grep {{TASK_ID}}` to check if a branch already exists.
+2. Existing PRs: Run `gh pr list --search {{TASK_ID}} --json number,title,state,reviewDecision,url` to check.
+3. Explore the codebase to understand relevant patterns.
+
+### Discover existing agents
+
+Jane MUST review the "Existing Agents & Automation" section in the PROJECT CONTEXT below (if present). For each agent found:
+
+1. **Identify** — Note the agent's name, type, and where it's configured.
+2. **Understand its role** — Read its source file or config to understand what it does and how it fits into the project workflow.
+3. **Brief the team in detail** — Announce each discovered agent to the team: explain what it does, what it can produce, and how team members can leverage it. Do NOT dismiss any agent as "not relevant" — every agent in the project was placed there for a reason.
+4. **Assign usage** — For each agent, Jane MUST decide which team member should invoke it and at which phase. Read the agent's description to determine when it fits in the workflow. Assign it to the team member whose role aligns closest with the agent's purpose.
+5. **Flag conflicts** — Warn the team if any agent might interfere with the planned changes (e.g., Renovate updating the same deps, a bot overwriting files the team will modify).
+
+IMPORTANT: Do NOT skip or dismiss discovered agents. Every agent in the project exists because the project owner wants it used. Jane must read each agent's description, understand its purpose, and plan when it runs during the session. Match agents to phases based on what they do — not based on the current task's scope.
+
+If no agents are listed in the project context, Jane should still check for common agent indicators:
+- Run `ls .claude/agents/ 2>/dev/null` to find Claude agents.
+- Run `ls .claude/commands/ 2>/dev/null` to find Claude slash commands.
+- Run `ls .github/workflows/ 2>/dev/null` to spot CI/automation workflows.
+- Check if `.mcp.json` exists for MCP tool servers.
+
+When agents communicate during the session, they MUST reference discovered project agents by name and plan their usage (e.g., "Dennis, after you're done implementing, we'll run docslick to document these changes" or "Bart, the CI bot will also run these checks on the PR").
+
+Based on what you find, Jane determines the starting point:
+
+- Fresh task: Start from BRAINSTORM phase.
+- Branch exists but no PR: Review what's implemented, continue from EXECUTION.
+- PR exists: Review the PR status, continue accordingly.
+
+---
+
+## BRAINSTORM (3-5 rounds)
+
+Jane kicks off by restating the task in plain language.
+
+Then ALL SEVEN agents speak in EVERY round. This is the mandatory speaking order — you must output all seven, one after another, no exceptions:
+
+1. ●● JANE ●●  [SAY]  facilitation, question, or summary
+2. ☾☾ LUNA ☾☾  [THINK]  UX/UI impact, visual consistency, interaction patterns, accessibility
+3. ✦✦ MARK ✦✦  [THINK]  copy clarity, tone, user-facing text quality
+4. ◆◆ SAM ◆◆  [THINK]  codebase patterns, architecture risks
+5. ■■ DENNIS ■■  [THINK]  technical feasibility, existing patterns
+6. ▲▲ BART ▲▲  [SAY]  risks, edge cases, "what happens when..."
+7. ◈◈ VERA ◈◈  [SAY]  test coverage gaps, which functions need tests
+
+RULE: If you output a round without all 7 agents, it is an error. Fix it immediately. Even if an agent has nothing to add, they must say so explicitly (e.g., "☾☾ LUNA ☾☾ [SAY] No UI concerns for this task — standing by.").
+
+Sam MUST use tools (Glob, Grep, Read) during this phase to scan relevant components.
+Dennis MUST use tools to verify assumptions about the codebase.
+
+Move to PLANNING after the team agrees on the approach, OR after 5 rounds.
+
+---
+
+## PLANNING (1-2 rounds)
+
+Each agent presents their plan:
+
+●● JANE ●●  Requirements Summary (what we're building, acceptance criteria, scope boundaries)
+▲▲ BART ▲▲  Test Plan (acceptance criteria, key test cases, edge cases)
+■■ DENNIS ■■  Implementation Plan (files to modify, approach, complexity S/M/L)
+◆◆ SAM ◆◆  Architecture Review (existing violations, whether approach is clean)
+◈◈ VERA ◈◈  Test Plan (which functions need tests, regression tests)
+☾☾ LUNA ☾☾  UX Review (visual impact, layout concerns, accessibility checklist, interaction improvements)
+✦✦ MARK ✦✦  Content Review (user-facing text audit, tone, clarity, empty states, error messages)
+
+After all seven present, Jane asks: "Any objections or additions?" Then declares the plan final.
+
+---
+
+## EXECUTION
+
+### Step 1 — Dennis implements:
+1. Create a branch following project conventions.
+2. Implement the changes according to the agreed plan.
+3. Run linter and build to verify.
+4. Commit the implementation.
+
+### Step 2 — Sam scans for violations:
+1. Read all files Dennis changed.
+2. Check for architecture violations.
+3. If violations found, Dennis fixes them before proceeding.
+
+### Step 2b — Luna reviews UI changes (if applicable):
+1. Read any changed component, page, or style files.
+2. Check visual hierarchy, spacing consistency, color harmony, typography.
+3. Verify accessibility: contrast ratios, focus states, keyboard navigation, screen reader labels.
+4. Check responsive behavior and interaction flow.
+5. If issues found, propose specific fixes (exact CSS values, spacing, colors). Dennis implements them before proceeding.
+6. Skip this step if the task has no UI impact.
+
+### Step 2c — Mark reviews content (if applicable):
+1. Read all changed files that contain user-facing text (components, templates, error handlers).
+2. Check every label, button, heading, tooltip, error message, empty state, and confirmation dialog.
+3. Rewrite anything vague, wordy, jargon-heavy, or inconsistent in tone.
+4. Propose exact replacement strings. Dennis implements them.
+5. Skip this step if the task has no user-facing text changes.
+
+### Step 3 — Vera writes tests:
+1. Read every file Dennis changed. Identify testable functions.
+2. Write unit tests following existing test patterns.
+3. Run tests to verify they pass.
+4. Commit test files.
+
+### Step 4 — Bart reviews:
+1. Read EVERY file Dennis changed.
+2. Check calculations, edge cases, error handling.
+3. Run linter and build.
+4. If ALL criteria pass, push and create PR: `gh pr create --title "..." --body "..."`
+5. Approve the PR if clean.
+
+### Step 5 — Jane wraps up:
+1. Review the PR description. Ensure it explains what changed and why.
+2. Summarize the session.
+
+---
+
+## SUMMARY
+
+Print a final console summary:
+echo "Team Session Complete."
+echo "Task: {{TASK_ID}}"
+echo "Status: Ready for review."