@kendoo.agentdesk/agentdesk 0.9.4 → 0.9.6

package/README.md

@@ -79,7 +79,6 @@ agentdesk update                       Update to the latest version
 |------|-------------|
 | `--description`, `-d` | Task description or requirements |
 | `--cwd` | Working directory (defaults to current) |
-| `--lite` | Lite mode — all agents share one process (faster, cheaper) |
 
 ## Configuration
 
@@ -116,22 +115,14 @@ AgentDesk also auto-discovers agents from `.claude/agents/`, `.claude/commands/`
 
 ## How It Works
 
-Each agent runs in its own Claude process — not one model role-playing multiple personas. This produces genuine disagreements and better output because each agent reasons separately.
+All agents collaborate in a single Claude process — each with distinct roles, ground rules, and areas of expertise.
 
 1. You run `agentdesk team TASK-ID` in your project directory
 2. AgentDesk detects your project type, reads `CLAUDE.md`, and discovers existing agents
 3. The orchestrator manages 5 phases: **Intake** > **Brainstorm** > **Planning** > **Execution** > **Review**
-4. In brainstorm/planning/review, all agents run **in parallel** — each gets their own Claude session
-5. In execution, agents run sequentially: Dennis implements > Sam audits > Luna+Mark review > Vera tests > Bart QA
-6. The session streams live to [agentdesk.live](https://agentdesk.live) where you can watch and send messages to the team
-7. Token usage is tracked and displayed per session
-
-### Agent Modes
-
-| Mode | Command | Description |
-|------|---------|-------------|
-| Full (default) | `agentdesk team -d "..."` | Each agent runs in its own process. Better output. |
-| Lite | `agentdesk team -d "..." --lite` | All agents share one process. Faster and cheaper. |
+4. Agents discuss, disagree, and build on each other's ideas within a shared context
+5. The session streams live to [agentdesk.live](https://agentdesk.live) where you can watch and send messages to the team
+6. Token usage is tracked and displayed per session
 
 ## Daemon (Remote Sessions)
 

package/bin/agentdesk.mjs

@@ -44,6 +44,11 @@ if (command !== "update") {
   } catch {}
 }
 
+if (command === "--version" || command === "-v" || command === "version") {
+  console.log(pkg.version);
+  process.exit(0);
+}
+
 if (!command || command === "help" || command === "--help") {
   console.log(`
   AgentDesk — AI team orchestrator for Claude Code
@@ -65,7 +70,7 @@ if (!command || command === "help" || command === "--help") {
   Options:
     --description, -d    Task description or requirements
     --cwd                Working directory (defaults to current)
-    --lite               Lite mode — all agents share one process (faster, cheaper)
+
 
   How it works:
     With a tracker (Linear, Jira, GitHub Issues):
@@ -105,7 +110,6 @@ else if (command === "team") {
   let description = "";
   let cwd = process.cwd();
   let taskId = null;
-  let lite = false;
   const remaining = args.slice(1);
 
   for (let i = 0; i < remaining.length; i++) {
@@ -113,10 +117,6 @@ else if (command === "team") {
       description = remaining[++i];
     } else if (remaining[i] === "--cwd" && remaining[i + 1]) {
       cwd = remaining[++i];
-    } else if (remaining[i] === "--lite" || remaining[i] === "--legacy") {
-      lite = true;
-    } else if (remaining[i] === "--full") {
-      lite = false;
     } else if (!taskId && !remaining[i].startsWith("-")) {
       taskId = remaining[i];
     }
@@ -129,7 +129,7 @@ else if (command === "team") {
   }
 
   const { runTeam } = await import("../cli/team.mjs");
-  const code = await runTeam(taskId, { description, cwd, lite });
+  const code = await runTeam(taskId, { description, cwd });
   process.exit(code);
 }
 

package/cli/agents.mjs

@@ -5,13 +5,15 @@ export const BUILT_IN_AGENTS = {
     badge: "●● JANE ●●",
     role: "Product Analyst / Team Lead",
     description: "facilitates discussion, clarifies requirements, keeps the team focused, evaluates team performance at the end",
-    groundRules: "Jane resolves disagreements and keeps the discussion productive. She NEVER reads code, runs tools, or inspects files — that's the developer and auditor's job. She focuses on requirements, user impact, scope, and coordination.",
+    groundRules: "Jane resolves disagreements and keeps the discussion productive. She NEVER reads code or inspects files — that's the developer and auditor's job. She focuses on requirements, user impact, scope, and coordination. If no task ID was provided (only a description), Jane MUST create a new task in the tracker FIRST, announce the new task ID clearly, and then set its status. Jane is responsible for tracker status updates: posting the session start comment, changing task status to 'In Progress' at start and 'In Review' at end, and posting the final summary comment. Jane keeps the task status current throughout the session.",
     brainstorm: { tag: "SAY", focus: "facilitation, question, or summary" },
     planning: "Requirements Summary (what we're building, acceptance criteria, scope boundaries). If this task involves UI changes, Jane declares it a UI task and tells Luna to define screenshot requirements.",
     execution: {
       step: "Jane wraps up",
       tasks: [
+        "Transition the task status to 'In Review' (or equivalent) in the tracker.",
         "Review the PR description. Ensure it explains what changed and why.",
+        "Post a final summary comment on the tracker task.",
         "Summarize the session.",
       ],
       order: 99, // last
@@ -70,6 +72,7 @@ export const BUILT_IN_AGENTS = {
         "Run linter and build.",
         "If this is a UI task, capture screenshots following Luna's screenshot plan (see SCREENSHOTS section in prompt).",
         "If ALL criteria pass, push and create PR: `gh pr create --title \"...\" --body \"...\"`",
+        "Post the PR link as a comment on the tracker task and attach it to the issue (see tracker integration section for API calls).",
         "Post screenshots to the task tracker as a separate comment (not inside badge blocks).",
         "Approve the PR if clean.",
       ],

package/cli/daemon.mjs

@@ -313,7 +313,7 @@ export async function runDaemon() {
 
   // 4. Session handling
 
-  async function handleStartSession({ sessionId, projectId, taskId: remoteTaskId, prompt, mode }) {
+  async function handleStartSession({ sessionId, projectId, taskId: remoteTaskId, prompt }) {
     // Validate project against local allowlist
     const project = projects.find(p => p.id === projectId);
     if (!project) {
@@ -379,7 +379,6 @@ export async function runDaemon() {
         project: detected, team, teamSections,
         inboxUrl, sessionUrl,
         cwd: project.path,
-        mode: mode || "full",
         apiKey,
         serverUrl: agentdeskServer,
         onEvent(event) {

package/cli/init.mjs

@@ -62,6 +62,12 @@ export async function runInit(cwd) {
   if (project.lintCommand) console.log(`  Lint:         ${project.lintCommand}`);
   if (project.testCommand || project.buildCommand || project.lintCommand) console.log("");
 
+  // --- Project key ---
+  const defaultKey = existingConfig.projectKey || projectId;
+  const keyAnswer = await ask(rl, `  Project key (${defaultKey}): `);
+  const finalProjectKey = keyAnswer.trim() || defaultKey;
+  console.log("");
+
   // --- Tracker selection ---
   const trackerOptions = [
     { label: "Linear", value: "linear" },
@@ -75,22 +81,28 @@ export async function runInit(cwd) {
   console.log("");
 
   // Build config
-  const config = {};
+  const config = { projectKey: finalProjectKey };
   if (tracker) config.tracker = tracker;
 
   if (tracker === "linear") {
-    const current = existingConfig.linear?.workspace || "";
-    const answer = await ask(rl, `  Linear workspace slug${current ? ` (${current})` : ""}: `);
-    const ws = answer.trim() || current;
-    if (ws) config.linear = { workspace: ws };
+    const currentWs = existingConfig.linear?.workspace || "";
+    const wsAnswer = await ask(rl, `  Linear workspace slug${currentWs ? ` (${currentWs})` : ""}: `);
+    const ws = wsAnswer.trim() || currentWs;
+    const currentKey = existingConfig.linear?.teamKey || "";
+    const keyAnswer = await ask(rl, `  Linear team key${currentKey ? ` (${currentKey})` : ""} (e.g. KEN): `);
+    const teamKey = keyAnswer.trim() || currentKey;
+    if (ws || teamKey) config.linear = { ...(ws && { workspace: ws }), ...(teamKey && { teamKey }) };
     console.log("");
   }
 
   if (tracker === "jira") {
-    const current = existingConfig.jira?.baseUrl || "";
-    const answer = await ask(rl, `  Jira base URL${current ? ` (${current})` : ""}: `);
-    const url = answer.trim() || current;
-    if (url) config.jira = { baseUrl: url };
+    const currentUrl = existingConfig.jira?.baseUrl || "";
+    const urlAnswer = await ask(rl, `  Jira base URL${currentUrl ? ` (${currentUrl})` : ""}: `);
+    const url = urlAnswer.trim() || currentUrl;
+    const currentProj = existingConfig.jira?.project || "";
+    const projAnswer = await ask(rl, `  Jira project key${currentProj ? ` (${currentProj})` : ""} (e.g. PROJ): `);
+    const proj = projAnswer.trim() || currentProj;
+    if (url || proj) config.jira = { ...(url && { baseUrl: url }), ...(proj && { project: proj }) };
     console.log("");
   }
 
@@ -108,6 +120,8 @@ export async function runInit(cwd) {
     try { merged = JSON.parse(readFileSync(configPath, "utf-8")); } catch {}
   }
 
+  merged.projectKey = finalProjectKey;
+
   if (tracker) {
     merged.tracker = tracker;
     if (config.linear) merged.linear = config.linear;
@@ -124,7 +138,7 @@ export async function runInit(cwd) {
   console.log(`  Saved .agentdesk.json`);
 
   // Register in local project index (for daemon discovery)
-  registerLocalProject(projectId, project.name || projectId, project.dir);
+  registerLocalProject(finalProjectKey, project.name || finalProjectKey, project.dir);
 
   // --- Register with server ---
   try {
@@ -135,8 +149,8 @@ export async function runInit(cwd) {
         ...(loadApiKey(cwd) ? { "x-api-key": loadApiKey(cwd) } : {}),
       },
       body: JSON.stringify({
-        id: projectId,
-        name: project.name || projectId,
+        id: finalProjectKey,
+        name: project.name || finalProjectKey,
         path: project.dir,
         type: project.type,
         tracker,
@@ -148,7 +162,7 @@ export async function runInit(cwd) {
     // Push settings to server
     const key = loadApiKey(cwd);
     if (key) {
-      await fetch(`${SERVER}/api/projects/${projectId}/settings`, {
+      await fetch(`${SERVER}/api/projects/${finalProjectKey}/settings`, {
         method: "PUT",
         headers: { "Content-Type": "application/json", "x-api-key": key },
         body: JSON.stringify(merged),

package/cli/orchestrator.mjs

@@ -1,18 +1,15 @@
-// Orchestrator — manages agent sub-sessions across phases
+// Orchestrator — runs a single Claude process with all agents as personas
 
 import { spawn } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import { createInterface } from "readline";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-import { runAgent } from "./agent-runner.mjs";
 import { buildPrompt } from "./prompt.mjs";
 import { createStreamParser } from "./stream-parser.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CLI_VERSION = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8")).version;
-import { buildAgentPrompt, getAgentTools } from "./agent-prompts.mjs";
-import { detectProject, generateContext } from "./detect.mjs";
 
 // Fetch decrypted tracker credentials from server
 async function fetchTrackerCredentials(projectName, apiKey, serverUrl) {
@@ -50,274 +47,8 @@ function timestamp() {
 export async function runOrchestrator({
   taskId, taskLink, description, createTask, tracker, config,
   project, team, teamSections, inboxUrl, sessionUrl, cwd,
-  onEvent, mode = "full", apiKey, serverUrl,
+  onEvent, apiKey, serverUrl,
 }) {
-  // --- Lite mode: single process, legacy behavior ---
-  if (mode === "lite") {
-    return runLiteMode({ taskId, taskLink, description, createTask, tracker, config, project, teamSections, inboxUrl, sessionUrl, cwd, onEvent, apiKey, serverUrl });
-  }
-
-  // --- Full mode: independent sub-agents ---
-  const state = {
-    task: { id: taskId, link: taskLink, description: description || "" },
-    conversationLog: [],   // { type: "message"|"phase", agent?, tag?, message?, phase? }
-    phaseSummaries: {},
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-    totalSteps: 0,
-  };
-
-  const trackerCreds = await fetchTrackerCredentials(project?.name, apiKey, serverUrl);
-  const env = { ...process.env, ...loadDotEnv(cwd), ...trackerCreds };
-
-  // Emit event to WebSocket (same protocol as single-process mode)
-  function emit(event) {
-    onEvent?.({ ...event, timestamp: timestamp() });
-  }
-
-  // Add to conversation log
-  function logMessage(agent, tag, message) {
-    state.conversationLog.push({ type: "message", agent, tag, message });
-  }
-
-  function logPhase(phase) {
-    state.conversationLog.push({ type: "phase", phase });
-  }
-
-  // Run a single agent and collect results
-  async function spawnAgent(agentName, agent, phase, extraConversation) {
-    const conversation = extraConversation || state.conversationLog;
-
-    const prompt = buildAgentPrompt(agent, {
-      phase,
-      task: state.task,
-      project,
-      conversation,
-      inboxUrl,
-      sessionUrl,
-    });
-
-    const tools = getAgentTools(agentName);
-
-    const result = await runAgent(agentName, {
-      prompt,
-      allowedTools: tools,
-      cwd,
-      env,
-      onMessage(msg) {
-        emit({ type: "agent:message", agent: msg.agent, tag: msg.tag, message: msg.message });
-        logMessage(msg.agent, msg.tag, msg.message);
-      },
-      onToolUse(use) {
-        emit({ type: "tool:use", agent: use.agent, tool: use.tool, description: use.description });
-      },
-      onToolResult(res) {
-        emit({ type: "tool:result", success: res.success, summary: res.summary });
-      },
-    });
-
-    state.totalInputTokens += result.inputTokens;
-    state.totalOutputTokens += result.outputTokens;
-    state.totalSteps += result.steps;
-
-    return result;
-  }
-
-  // Run multiple agents in parallel
-  async function spawnAgentsParallel(agents, phase, extraConversation) {
-    const conversation = extraConversation || [...state.conversationLog];
-    return Promise.all(
-      agents.map(([name, agent]) => spawnAgent(name, agent, phase, conversation))
-    );
-  }
-
-  // Build summary from agent results
-  function summarizeResults(results) {
-    return results
-      .filter(r => r.messages.length > 0)
-      .map(r => r.messages.map(m => `${m.agent} [${m.tag}]: ${m.message}`).join("\n"))
-      .join("\n\n");
-  }
-
-  // Detect if any agent argued
-  function hasDisagreement(results) {
-    return results.some(r => r.hadArgue);
-  }
-
-  // --- Session start ---
-  const startTime = Date.now();
-  emit({
-    type: "session:start",
-    taskId, taskLink,
-    title: description || taskId,
-    project: project?.name || null,
-    sessionNumber: 1,
-    agents: teamSections.names,
-    cliVersion: CLI_VERSION,
-  });
-
-  // Build agent lookup
-  const agentMap = new Map();
-  for (const agent of team) {
-    agentMap.set(agent.name, agent);
-  }
-
-  // Find specific agents
-  const jane = agentMap.get("Jane");
-  const dennis = agentMap.get("Dennis");
-
-  // ===========================
-  // PHASE 1: INTAKE (Jane only)
-  // ===========================
-  emit({ type: "phase:change", phase: "INTAKE" });
-  logPhase("INTAKE");
-
-  const intakeResult = await spawnAgent("Jane", jane, "intake");
-  state.phaseSummaries.intake = summarizeResults([intakeResult]);
-
-  // Extract short title from Jane's intake (SESSION_TITLE: ...)
-  const titleMatch = intakeResult.rawOutput.match(/SESSION_TITLE:\s*(.+)/);
-  if (titleMatch) {
-    const shortTitle = titleMatch[1].trim().slice(0, 60);
-    emit({ type: "session:update", title: shortTitle });
-  }
-
-  // ===========================
-  // PHASE 2: BRAINSTORM (parallel, 3-5 rounds)
-  // ===========================
-  emit({ type: "phase:change", phase: "BRAINSTORM" });
-  logPhase("BRAINSTORM");
-
-  const allAgents = [...agentMap.entries()];
-  let brainstormRounds = 0;
-  const MAX_BRAINSTORM_ROUNDS = 5;
-
-  for (let round = 0; round < MAX_BRAINSTORM_ROUNDS; round++) {
-    brainstormRounds++;
-    const results = await spawnAgentsParallel(allAgents, "brainstorm");
-
-    // Check for consensus (no ARGUE tags = consensus)
-    if (!hasDisagreement(results) && round >= 2) {
-      break; // Minimum 3 rounds, then stop on consensus
-    }
-  }
-  state.phaseSummaries.brainstorm = `Brainstorm completed in ${brainstormRounds} rounds.`;
-
-  // ===========================
-  // PHASE 3: PLANNING (parallel + review)
-  // ===========================
-  emit({ type: "phase:change", phase: "PLANNING" });
-  logPhase("PLANNING");
-
-  // Round 1: each agent presents their plan
-  await spawnAgentsParallel(allAgents, "planning");
-
-  // Round 2: review all plans, raise objections
-  const planReviewResults = await spawnAgentsParallel(allAgents, "planning-review");
-  state.phaseSummaries.planning = "Plans finalized.";
-
-  // If there were objections, one more planning round
-  if (hasDisagreement(planReviewResults)) {
-    await spawnAgentsParallel(allAgents, "planning");
-  }
-
-  // ===========================
-  // PHASE 4: EXECUTION (sequential)
-  // ===========================
-  emit({ type: "phase:change", phase: "EXECUTION" });
-  logPhase("EXECUTION");
-
-  // Step 1: Dennis implements
-  if (dennis) {
-    const dennisResult = await spawnAgent("Dennis", dennis, "execution");
-
-    // Step 2: Sam audits (if on team)
-    const sam = agentMap.get("Sam");
-    if (sam) {
-      let fixAttempts = 0;
-      const MAX_FIX_ATTEMPTS = 3;
-
-      while (fixAttempts < MAX_FIX_ATTEMPTS) {
-        const samResult = await spawnAgent("Sam", sam, "execution-review");
-
-        if (!samResult.hadArgue) break; // No issues found
-
-        // Dennis fixes Sam's issues
-        fixAttempts++;
-        if (fixAttempts < MAX_FIX_ATTEMPTS) {
-          await spawnAgent("Dennis", dennis, "execution");
-        }
-      }
-    }
-
-    // Step 3: Luna + Mark review in parallel (if on team)
-    const reviewAgents = [];
-    const luna = agentMap.get("Luna");
-    const mark = agentMap.get("Mark");
-    if (luna) reviewAgents.push(["Luna", luna]);
-    if (mark) reviewAgents.push(["Mark", mark]);
-
-    if (reviewAgents.length > 0) {
-      const reviewResults = await spawnAgentsParallel(reviewAgents, "execution-review");
-
-      // If Luna or Mark found issues, Dennis fixes
-      if (hasDisagreement(reviewResults)) {
-        await spawnAgent("Dennis", dennis, "execution");
-      }
-    }
-
-    // Step 4: Vera writes tests (if on team)
-    const vera = agentMap.get("Vera");
-    if (vera) {
-      await spawnAgent("Vera", vera, "execution");
-    }
-
-    // Step 5: Bart does QA (if on team)
-    const bart = agentMap.get("Bart");
-    if (bart) {
-      await spawnAgent("Bart", bart, "execution");
-    }
-  }
-
-  state.phaseSummaries.execution = "Execution complete.";
-
-  // ===========================
-  // PHASE 5: REVIEW (Jane + parallel)
-  // ===========================
-  emit({ type: "phase:change", phase: "REVIEW" });
-  logPhase("REVIEW");
-
-  // All agents provide final notes in parallel
-  await spawnAgentsParallel(allAgents, "review");
-
-  // Jane wraps up
-  if (jane) {
-    await spawnAgent("Jane", jane, "review");
-  }
-
-  // ===========================
-  // SESSION END
-  // ===========================
-  const duration = `${((Date.now() - startTime) / 1000).toFixed(1)}s`;
-  emit({
-    type: "session:end",
-    duration,
-    steps: state.totalSteps,
-    inputTokens: state.totalInputTokens,
-    outputTokens: state.totalOutputTokens,
-  });
-
-  return {
-    duration,
-    steps: state.totalSteps,
-    inputTokens: state.totalInputTokens,
-    outputTokens: state.totalOutputTokens,
-  };
-}
-
-// --- Lite mode: single Claude process with all agents as personas ---
-
-async function runLiteMode({ taskId, taskLink, description, createTask, tracker, config, project, teamSections, inboxUrl, sessionUrl, cwd, onEvent, apiKey, serverUrl }) {
   const trackerCreds = await fetchTrackerCredentials(project?.name, apiKey, serverUrl);
   const env = { ...process.env, ...loadDotEnv(cwd), ...trackerCreds };
   const startTime = Date.now();

package/cli/prompt.mjs

@@ -35,7 +35,7 @@ export function buildPrompt({ taskId, taskLink, description, createTask, tracker
 
   // 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";
+    let createInstr = "\n\n## CREATE TASK (MANDATORY — FIRST ACTION IN INTAKE)\n\nNo task ID was provided — only a description. Jane MUST create a new task in the tracker as the VERY FIRST action before anything else.\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") {
@@ -44,7 +44,12 @@ export function buildPrompt({ taskId, taskLink, description, createTask, tracker
       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`;
+    createInstr += `\nAfter creating the task, Jane MUST:\n`;
+    createInstr += `1. ANNOUNCE the new task ID clearly to the team: "I've created task <ID> in ${tracker}. This is our task for this session."\n`;
+    createInstr += `2. Output the task ID on its own line in this exact format (required for dashboard linking):\n   TASK_ID: <identifier>\n   Example: TASK_ID: KEN-530\n`;
+    createInstr += `3. Immediately set the task status to "In Progress" and post the session start comment.\n`;
+    createInstr += `4. Use this new task ID for ALL subsequent tracker operations (comments, status updates, PR linking).\n`;
+    createInstr += `\nDo NOT proceed to BRAINSTORM until the task is created, announced, and set to "In Progress".\n`;
     prompt += createInstr;
   }
 

package/cli/team.mjs

@@ -31,7 +31,6 @@ function loadDotEnv(dir) {
 export async function runTeam(taskId, opts = {}) {
   const cwd = opts.cwd || process.cwd();
   const description = opts.description || "";
-  const lite = opts.lite || false;
 
   // Detect project and resolve API key early (needed for server config fetch)
   const project = detectProject(cwd);
@@ -125,26 +124,10 @@ export async function runTeam(taskId, opts = {}) {
           } else {
             console.log("AgentDesk: reconnected");
           }
-          if (!lite) {
-            // Orchestrator sends its own session:start — just flush queue
-            sessionStartSent = true;
-            while (vizQueue.length > 0 && vizWs.readyState === WebSocket.OPEN) {
-              vizWs.send(vizQueue.shift());
-            }
-          } else {
-            vizSend({
-              type: "session:start",
-              taskId, taskLink,
-              title: description || taskId,
-              project: project.name || null,
-              sessionNumber: 1,
-              agents: teamSections.names,
-              cliVersion: CLI_VERSION,
-            });
-            sessionStartSent = true;
-            while (vizQueue.length > 0 && vizWs.readyState === WebSocket.OPEN) {
-              vizWs.send(vizQueue.shift());
-            }
+          // Orchestrator sends its own session:start — just flush queue
+          sessionStartSent = true;
+          while (vizQueue.length > 0 && vizWs.readyState === WebSocket.OPEN) {
+            vizWs.send(vizQueue.shift());
           }
         } else if (msg.type === "auth:error") {
           console.log("AgentDesk: authentication failed — run 'agentdesk login'");
@@ -169,14 +152,10 @@ export async function runTeam(taskId, opts = {}) {
 
   connectWs();
 
-  const agentMode = lite ? "lite" : "full";
-  console.log(`Agents: ${agentMode === "lite" ? "lite (shared process)" : "full (independent process)"}\n`);
-
   const result = await runOrchestrator({
     taskId, taskLink, description, createTask, tracker, config,
     project, team, teamSections, inboxUrl, sessionUrl, cwd,
     onEvent: vizSend,
-    mode: agentMode,
     apiKey,
     serverUrl: agentdeskServer,
   });

package/package.json

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

package/prompts/team.md

@@ -258,6 +258,7 @@ GraphQL query — fetch the task by identifier:
     title
     description
     state { name }
+    labels { nodes { name } }
     comments {
       nodes {
         body
@@ -279,6 +280,36 @@ Session : {{SESSION_URL}}
 ```
 
 IMPORTANT: The first comment on any task MUST include the session link: {{SESSION_URL}}
+
+### Every agent must comment on the tracker
+
+When an agent completes meaningful work or has important findings, they MUST post a comment on the tracker task. Not just Jane and Bart — everyone relevant:
+- **Dennis**: After implementing — what was changed, which files, any technical decisions made
+- **Sam**: After audit — architecture concerns found (or "clean audit, no violations")
+- **Vera**: After writing tests — which tests were added, coverage notes
+- **Luna**: After UI review — any UX issues found and fixes applied
+- **Mark**: After content review — any copy changes made
+- **Bart**: After QA + PR — PR link, test results, screenshot links
+
+Each agent posts using their own badge format. Keep comments concise — bullet points, not essays. The tracker should tell the full story of what happened without needing to watch the dashboard.
+
+### Required tracker actions (Jane MUST do these — not optional)
+
+1. **On session start (INTAKE):** Post a comment: "Team session started. Session: {{SESSION_URL}}" and move the task to "In Progress" state:
+   ```
+   mutation { issueUpdate(id: "$ISSUE_ID", input: { stateId: "$IN_PROGRESS_STATE_ID" }) { success } }
+   ```
+   To find the state ID, query: `{ workflowStates(filter: { team: { issues: { id: { eq: "$ISSUE_ID" } } } }) { nodes { id name } } }`
+
+2. **After PR is created (EXECUTION — Bart does this, not Jane):** Bart MUST post a comment with the PR link and attach it to the issue:
+   ```
+   mutation { attachmentCreate(input: { issueId: "$ISSUE_ID", title: "Pull Request", url: "$PR_URL" }) { success } }
+   ```
+   Also post a comment: "PR created: $PR_URL"
+
+3. **On session end (SUMMARY):** Jane moves the task to "In Review" state and posts a final summary comment.
+
+Steps 1 and 3 are Jane's responsibility. Step 2 is Bart's responsibility (he creates the PR, so he links it). If any step fails, retry once. These are not suggestions — they are required protocol.
 {{/LINEAR}}
 
 {{#JIRA}}
@@ -287,31 +318,97 @@ IMPORTANT: The first comment on any task MUST include the session link: {{SESSIO
 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"
+- curl -s -u "$JIRA_EMAIL:$JIRA_API_TOKEN" "{{JIRA_BASE_URL}}/rest/api/3/issue/{{TASK_ID}}?fields=summary,description,status,comment,transition"
 
 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": "..." }] }] } }
 
 IMPORTANT: The first comment on any task MUST include the session link: {{SESSION_URL}}
+
+### Every agent must comment on the tracker
+
+When an agent completes meaningful work or has important findings, they MUST post a comment on the tracker task. Not just Jane and Bart — everyone relevant:
+- **Dennis**: After implementing — what was changed, which files, any technical decisions made
+- **Sam**: After audit — architecture concerns found (or "clean audit, no violations")
+- **Vera**: After writing tests — which tests were added, coverage notes
+- **Luna**: After UI review — any UX issues found and fixes applied
+- **Mark**: After content review — any copy changes made
+- **Bart**: After QA + PR — PR link, test results, screenshot links
+
+Each agent posts using their own badge format. Keep comments concise — bullet points, not essays. The tracker should tell the full story of what happened without needing to watch the dashboard.
+
+### Required tracker actions (Jane MUST do these — not optional)
+
+1. **On session start (INTAKE):** Post a comment: "Team session started. Session: {{SESSION_URL}}" and transition the task to "In Progress":
+   ```bash
+   # Get available transitions
+   curl -s -u "$JIRA_EMAIL:$JIRA_API_TOKEN" "{{JIRA_BASE_URL}}/rest/api/3/issue/{{TASK_ID}}/transitions"
+   # Find the transition ID for "In Progress", then:
+   curl -s -X POST -u "$JIRA_EMAIL:$JIRA_API_TOKEN" -H "Content-Type: application/json" \
+     "{{JIRA_BASE_URL}}/rest/api/3/issue/{{TASK_ID}}/transitions" \
+     -d '{"transition":{"id":"<TRANSITION_ID>"}}'
+   ```
+
+2. **After PR is created (EXECUTION — Bart does this, not Jane):** Bart MUST post a comment with the PR link and attach it as a remote link:
+   ```bash
+   curl -s -X POST -u "$JIRA_EMAIL:$JIRA_API_TOKEN" -H "Content-Type: application/json" \
+     "{{JIRA_BASE_URL}}/rest/api/3/issue/{{TASK_ID}}/remotelink" \
+     -d '{"object":{"url":"$PR_URL","title":"Pull Request"}}'
+   ```
+
+3. **On session end (SUMMARY):** Jane transitions the task to "In Review" (or equivalent) and posts a final summary comment.
+
+Steps 1 and 3 are Jane's responsibility. Step 2 is Bart's responsibility (he creates the PR, so he links it). If any step fails, retry once. These are not suggestions — they are required protocol.
 {{/JIRA}}
 
 {{#GITHUB}}
 ## GITHUB ISSUES INTEGRATION
 
 Fetch the task from GitHub Issues:
-- Run: gh issue view {{TASK_ID}} --json title,body,state,comments
+- Run: gh issue view {{TASK_ID}} --json title,body,state,comments,labels
 
 Post updates as comments:
 - Run: gh issue comment {{TASK_ID}} --body "..."
 
 IMPORTANT: The first comment on any task MUST include the session link: {{SESSION_URL}}
+
+### Every agent must comment on the tracker
+
+When an agent completes meaningful work or has important findings, they MUST post a comment on the issue. Not just Jane and Bart — everyone relevant:
+- **Dennis**: After implementing — what was changed, which files, any technical decisions made
+- **Sam**: After audit — architecture concerns found (or "clean audit, no violations")
+- **Vera**: After writing tests — which tests were added, coverage notes
+- **Luna**: After UI review — any UX issues found and fixes applied
+- **Mark**: After content review — any copy changes made
+- **Bart**: After QA + PR — PR link, test results, screenshot links
+
+Keep comments concise — bullet points, not essays. The tracker should tell the full story of what happened without needing to watch the dashboard.
+
+### Required tracker actions (Jane MUST do these — not optional)
+
+1. **On session start (INTAKE):** Post a comment: "Team session started. Session: {{SESSION_URL}}" and add an "in progress" label (if the project uses one):
+   ```bash
+   gh issue comment {{TASK_ID}} --body "Team session started. Session: {{SESSION_URL}}"
+   gh issue edit {{TASK_ID}} --add-label "in progress" 2>/dev/null || true
+   ```
+
+2. **After PR is created (EXECUTION — Bart does this, not Jane):** The PR should reference the issue (e.g., "Closes #{{TASK_ID}}" in the PR body). Bart MUST also post a comment linking the PR:
+   ```bash
+   gh issue comment {{TASK_ID}} --body "PR created: $PR_URL"
+   ```
+
+3. **On session end (SUMMARY):** Jane posts a final summary comment on the issue.
+
+Steps 1 and 3 are Jane's responsibility. Step 2 is Bart's responsibility (he creates the PR, so he links it). If any step fails, retry once. These are not suggestions — they are required protocol.
 {{/GITHUB}}
 
 ---
 
 ## INTAKE
 
+**If a CREATE TASK section exists above**, Jane MUST execute it NOW — before fetching, before assessing, before anything else. Create the task, announce the new ID to the team, output the TASK_ID line, and set the status to "In Progress". Only then continue with the steps below using the newly created task ID.
+
 {{#LINEAR}}
 Fetch the task from Linear and print the title, description, current state, and any existing comments.
 {{/LINEAR}}
@@ -359,6 +456,8 @@ Based on what you find, Jane determines the starting point:
 - Branch exists but no PR: Review what's implemented, continue from EXECUTION.
 - PR exists: Review the PR status, continue accordingly.
 
+MANDATORY: At the end of intake, Jane MUST post the first comment on the tracker task ("Team session started. Session: {{SESSION_URL}}") and move the task to "In Progress" status. See the tracker integration section above for exact API calls. Do this BEFORE moving to the next phase.
+
 IMPORTANT: At the end of the intake, Jane MUST provide a short title for this session on its own line in this exact format:
 SESSION_TITLE: <4-8 word title>
 Example: SESSION_TITLE: Fix checkout total calculation
@@ -401,6 +500,18 @@ After all agents present, Jane asks: "Any objections or additions?" Then declare
 
 ## SUMMARY
 
+Jane MUST verify the task status is up to date. Throughout the session, Jane is responsible for keeping the tracker status current:
+- **INTAKE**: "In Progress" (set when session starts or task is created)
+- **EXECUTION complete**: Still "In Progress" (work is happening)
+- **SUMMARY**: Transition to "In Review" (below)
+
+Jane MUST complete these tracker actions before ending the session:
+1. Verify Bart posted the PR link to the tracker. If he didn't, do it now.
+2. Transition the task to "In Review" (or equivalent status) in the tracker.
+3. Post a final summary comment on the tracker task with what was accomplished.
+
+If any of these were already done during execution, skip that step. But verify — don't assume.
+
 Print a final console summary:
 echo "Team Session Complete."
 echo "Task: {{TASK_ID}}"

package/cli/agent-prompts.mjs

@@ -1,166 +0,0 @@
-// Per-agent prompt generator for sub-agent architecture
-
-import { generateContext } from "./detect.mjs";
-
-const PHASE_INSTRUCTIONS = {
-  intake: {
-    Jane: `You are leading the intake for this task. Your job:
-1. Understand the task requirements from the description and/or tracker.
-2. Check for existing branches: \`git branch -a | grep <task-id>\`
-3. Check for existing PRs: \`gh pr list --search <task-id> --json number,title,state\`
-4. Explore the codebase briefly to understand what we're working with.
-5. Summarize: what needs to be done, what already exists, and what the starting point is.
-6. Recommend which phase to start from (BRAINSTORM for new work, EXECUTION if branch exists).
-
-IMPORTANT: At the end of your intake summary, you MUST provide a short title for this session on its own line in this exact format:
-SESSION_TITLE: <4-8 word title>
-Example: SESSION_TITLE: Fix checkout total calculation
-This title will be displayed in the dashboard navbar, so keep it short and descriptive.`,
-  },
-
-  brainstorm: {
-    _default: (agent) => `Share your perspective on this task from your role as ${agent.role}.
-Focus on: ${agent.brainstorm?.focus || "your area of expertise"}.
-Use [${agent.brainstorm?.tag || "SAY"}] tag.
-Be specific. If you disagree with anything in the conversation so far, use [ARGUE] and explain why.
-If you agree, still add value — don't just say "I agree."`,
-  },
-
-  planning: {
-    _default: (agent) => `Present your plan for this task from your role as ${agent.role}.
-Your expected output: ${agent.planning || "Your role-specific plan."}
-Be concrete — name files, approaches, specific concerns.`,
-  },
-
-  "planning-review": {
-    _default: () => `Review all the plans presented by the team.
-If you see problems, conflicts, or missing considerations, use [ARGUE] and explain.
-If everything looks good, acknowledge with [AGREE] and note why.`,
-  },
-
-  execution: {
-    _default: (agent) => {
-      if (!agent.execution) return "This task has no execution step for your role. Skip this phase.";
-      return `Complete your execution tasks:
-${agent.execution.tasks.map((t, i) => `${i + 1}. ${t}`).join("\n")}
-
-Work carefully. Use tools as needed. Narrate what you're doing.`;
-    },
-  },
-
-  "execution-review": {
-    _default: (agent) => `Review the changes made so far.
-From your perspective as ${agent.role}:
-${agent.groundRules || "Review for issues in your area of expertise."}
-If you find issues, describe them specifically with file paths and line numbers.
-If everything looks good, confirm with [AGREE].`,
-  },
-
-  review: {
-    _default: (agent) => `The session is wrapping up. Provide your final notes:
-- Any remaining concerns?
-- Anything the team should watch out for?
-- Overall assessment from your perspective as ${agent.role}.
-Keep it brief.`,
-    Jane: `The session is wrapping up. Provide the final summary:
-1. What was accomplished
-2. Any remaining concerns from the team
-3. What the next steps should be
-Keep it concise.`,
-  },
-};
-
-export function buildAgentPrompt(agent, { phase, task, project, conversation, inboxUrl, sessionUrl }) {
-  const parts = [];
-
-  // Identity
-  parts.push(`You are ${agent.name}, ${agent.role} on a software development team.`);
-  parts.push("");
-
-  // Role
-  parts.push("## Your Role");
-  parts.push(agent.description);
-  if (agent.groundRules) parts.push(`\nGround rules: ${agent.groundRules}`);
-  if (agent.codePrinciple) parts.push(`\nCode principle: ${agent.codePrinciple}`);
-  parts.push("");
-
-  // Communication
-  parts.push("## Communication");
-  parts.push(`Prefix your output with your badge: ${agent.badge}`);
-  parts.push("Use these tags in your messages:");
-  parts.push("- [SAY] — Normal statements, announcements, questions");
-  parts.push("- [THINK] — Internal reasoning, analysis");
-  parts.push("- [ACT] — When using tools or taking actions");
-  parts.push("- [ARGUE] — When you disagree or see problems");
-  parts.push("- [AGREE] — When you agree (but still add value)");
-  parts.push("");
-
-  // Task
-  parts.push("## Task");
-  parts.push(`Task ID: ${task.id}`);
-  if (task.link) parts.push(`Task link: ${task.link}`);
-  if (task.description) parts.push(`\nDescription: ${task.description}`);
-  parts.push("");
-
-  // Project context
-  if (project) {
-    const context = generateContext(project);
-    parts.push("## Project Context");
-    parts.push(context);
-    parts.push("");
-  }
-
-  // Conversation so far
-  if (conversation && conversation.length > 0) {
-    parts.push("## Conversation So Far");
-    for (const msg of conversation) {
-      if (msg.type === "phase") {
-        parts.push(`\n--- ${msg.phase} ---\n`);
-      } else if (msg.agent && msg.message) {
-        parts.push(`${msg.agent} [${msg.tag || "SAY"}]: ${msg.message}`);
-      }
-    }
-    parts.push("");
-  }
-
-  // Phase instructions
-  parts.push(`## Current Phase: ${phase.toUpperCase()}`);
-  const phaseConfig = PHASE_INSTRUCTIONS[phase] || {};
-  const agentInstr = phaseConfig[agent.name] || (phaseConfig._default ? phaseConfig._default(agent) : "Contribute from your area of expertise.");
-  parts.push(agentInstr);
-  parts.push("");
-
-  // Inbox (Jane only)
-  if (agent.name === "Jane" && inboxUrl) {
-    parts.push("## User Messages");
-    parts.push(`Before starting, check for user messages: \`curl -s ${inboxUrl}\``);
-    parts.push("If the response is not empty ([]), read the messages and incorporate the user's input.");
-    parts.push("");
-  }
-
-  // Session URL
-  if (sessionUrl) {
-    parts.push(`Session: ${sessionUrl}`);
-  }
-
-  // Time
-  const now = new Date();
-  parts.push(`\nCurrent 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 parts.join("\n");
-}
-
-// Get tool list for an agent
-const AGENT_TOOLS = {
-  Jane:   ["Bash", "Read"],
-  Dennis: ["Bash", "Read", "Edit", "Write", "Glob", "Grep"],
-  Sam:    ["Read", "Glob", "Grep"],
-  Bart:   ["Bash", "Read", "Glob", "Grep"],
-  Vera:   ["Bash", "Read", "Edit", "Write", "Glob", "Grep"],
-  Luna:   ["Read", "Glob"],
-  Mark:   ["Read", "Glob"],
-};
-
-export function getAgentTools(agentName) {
-  return AGENT_TOOLS[agentName] || ["Bash", "Read", "Edit", "Write", "Glob", "Grep"];
-}

package/cli/agent-runner.mjs

@@ -1,148 +0,0 @@
-// Spawns a single Claude process for one agent and parses its output
-
-import { spawn } from "child_process";
-import { createInterface } from "readline";
-
-export async function runAgent(agentName, {
-  prompt,
-  allowedTools = ["Bash", "Read", "Edit", "Write", "Glob", "Grep"],
-  cwd,
-  env,
-  onMessage,
-  onToolUse,
-  onToolResult,
-}) {
-  const messages = [];
-  const toolUses = [];
-  let rawOutput = "";
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let steps = 0;
-  let hadArgue = false;
-
-  const child = spawn(
-    "claude",
-    [
-      "-p", prompt,
-      "--allowedTools", allowedTools.join(","),
-      "--verbose",
-      "--output-format", "stream-json",
-    ],
-    {
-      stdio: ["pipe", "pipe", "inherit"],
-      shell: false,
-      env: env || process.env,
-      cwd,
-    }
-  );
-
-  child.stdin.end();
-
-  const rl = createInterface({ input: child.stdout });
-
-  for await (const line of rl) {
-    try {
-      const event = JSON.parse(line);
-
-      // Track tokens
-      if (event.usage) {
-        if (event.usage.input_tokens) inputTokens = Math.max(inputTokens, event.usage.input_tokens);
-        if (event.usage.output_tokens) outputTokens += (event.usage.output_tokens_delta || 0);
-      }
-      if (event.message?.usage) {
-        if (event.message.usage.input_tokens) inputTokens = Math.max(inputTokens, event.message.usage.input_tokens);
-        if (event.message.usage.output_tokens) outputTokens = Math.max(outputTokens, event.message.usage.output_tokens);
-      }
-
-      // Text output
-      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();
-            rawOutput += text + "\n";
-
-            // Detect tags
-            let tag = "SAY";
-            if (/\[ARGUE\]/i.test(text)) { tag = "ARGUE"; hadArgue = true; }
-            else if (/\[AGREE\]/i.test(text)) tag = "AGREE";
-            else if (/\[THINK\]/i.test(text)) tag = "THINK";
-            else if (/\[ACT\]/i.test(text)) tag = "ACT";
-
-            const cleanMsg = text.replace(/\[(SAY|ACT|THINK|AGREE|ARGUE)\]\s*/gi, "").replace(/\*+/g, "");
-            const msg = { agent: agentName, tag, message: cleanMsg };
-            messages.push(msg);
-            onMessage?.(msg);
-          }
-        }
-      }
-
-      // Tool use
-      if (event.type === "tool_use") {
-        const name = event.name || event.tool_name;
-        steps++;
-
-        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 || ""}`;
-        }
-
-        const use = { agent: agentName, tool: name, description };
-        toolUses.push(use);
-        onToolUse?.(use);
-      }
-
-      // Tool result
-      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";
-        onToolResult?.({ success: !hasError, summary });
-      }
-
-      // Final result
-      if (event.type === "result") {
-        if (event.usage) {
-          if (event.usage.input_tokens) inputTokens = Math.max(inputTokens, event.usage.input_tokens);
-          if (event.usage.output_tokens) outputTokens = Math.max(outputTokens, event.usage.output_tokens);
-        }
-      }
-    } catch {
-      // skip non-JSON
-    }
-  }
-
-  const exitCode = await new Promise(resolve => {
-    child.on("close", (code) => resolve(code || 0));
-  });
-
-  return {
-    agent: agentName,
-    messages,
-    toolUses,
-    rawOutput,
-    inputTokens,
-    outputTokens,
-    steps,
-    hadArgue,
-    exitCode,
-  };
-}