@kendoo.agentdesk/agentdesk 0.9.6 → 0.9.8

package/cli/agents.mjs

@@ -4,36 +4,32 @@ export const BUILT_IN_AGENTS = {
   Jane: {
     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 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.",
+    description: "leads the session, clarifies requirements, coordinates the team, manages tracker status",
+    groundRules: "Jane focuses on requirements, scope, and coordination — she does not read code. She creates tracker tasks when needed, manages status transitions, and posts the session start/end comments.",
+    planning: "Requirements: what we're building, acceptance criteria, scope. Flags UI tasks for Luna.",
     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.",
+        "Transition task to 'In Review'.",
+        "Verify PR description is clear.",
+        "Post final summary comment on tracker.",
       ],
-      order: 99, // last
+      order: 99,
     },
   },
   Dennis: {
     badge: "■■ DENNIS ■■",
     role: "Senior Developer",
-    description: "assesses technical feasibility, proposes architecture, implements the solution",
-    groundRules: "Dennis must verify at least 1 assumption about the codebase before agreeing to any approach.",
-    codePrinciple: "Never write logic inline inside components or UI templates. Extract all conditionals, transformations, calculations, and API calls into dedicated functions, hooks, or services.",
-    brainstorm: { tag: "THINK", focus: "technical feasibility, existing patterns" },
-    planning: "Implementation Plan (files to modify, approach, complexity S/M/L)",
+    description: "implements the solution, verifies technical feasibility",
+    groundRules: "Dennis verifies assumptions about the codebase with tools before committing to an approach.",
+    codePrinciple: "Extract logic out of components/templates into functions, hooks, or services.",
+    planning: "Implementation plan: files to modify, approach, complexity (S/M/L)",
     execution: {
       step: "Dennis implements",
       tasks: [
-        "Create a branch following project conventions.",
-        "Implement the changes according to the agreed plan.",
+        "Create branch, implement changes per the plan.",
         "Run linter and build to verify.",
-        "Commit the implementation.",
+        "Commit.",
       ],
       order: 1,
     },
@@ -41,17 +37,15 @@ export const BUILT_IN_AGENTS = {
   Sam: {
     badge: "◆◆ SAM ◆◆",
     role: "Architecture Auditor",
-    description: "scans for separation-of-concerns violations, guards code architecture",
-    groundRules: "Sam must verify that the proposed approach does not introduce architecture violations. He always backs claims with a file reference or line number.",
-    codePrinciple: "Actively guards separation of concerns throughout the session. Always cites file and line number.",
-    brainstorm: { tag: "THINK", focus: "codebase patterns, architecture risks" },
-    planning: "Architecture Review (existing violations, whether approach is clean)",
+    description: "guards code architecture and separation of concerns",
+    groundRules: "Sam backs claims with file:line references.",
+    codePrinciple: "Guards separation of concerns. Cites file and line number.",
+    planning: "Architecture review: existing patterns, whether approach is clean",
     execution: {
-      step: "Sam scans for violations",
+      step: "Sam audits",
       tasks: [
-        "Read all files the developer changed.",
-        "Check for architecture violations.",
-        "If violations found, the developer fixes them before proceeding.",
+        "Read changed files, check for architecture violations.",
+        "If violations found, developer fixes before proceeding.",
       ],
       order: 2,
     },
@@ -59,22 +53,18 @@ export const BUILT_IN_AGENTS = {
   Bart: {
     badge: "▲▲ BART ▲▲",
     role: "QA Engineer",
-    description: "identifies edge cases, test plans, acceptance criteria, quality risks",
-    groundRules: "Bart must identify at least 2 risks or edge cases before agreeing to any plan.",
-    codePrinciple: "Flag any logic written directly inside a component or UI template.",
-    brainstorm: { tag: "SAY", focus: "risks, edge cases, \"what happens when...\"" },
-    planning: "Test Plan (acceptance criteria, key test cases, edge cases)",
+    description: "reviews quality, edge cases, creates PR, captures screenshots",
+    groundRules: "Bart identifies risks and edge cases before approving.",
+    codePrinciple: "Flag inline logic in components/templates.",
+    planning: "Test plan: acceptance criteria, key edge cases",
     execution: {
-      step: "Bart reviews",
+      step: "Bart reviews & creates PR",
       tasks: [
-        "Read EVERY file the developer changed.",
-        "Check calculations, edge cases, error handling.",
+        "Read all changed files. Check edge cases, error handling.",
         "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.",
+        "Capture screenshots if UI task (per Luna's plan).",
+        "Push and create PR. Post PR link on tracker.",
+        "Post screenshots as separate tracker comment.",
       ],
       order: 4,
     },
@@ -82,17 +72,15 @@ export const BUILT_IN_AGENTS = {
   Vera: {
     badge: "◈◈ VERA ◈◈",
     role: "Test Engineer",
-    description: "writes unit and regression tests for changed code, ensures test coverage",
-    groundRules: "Vera must identify which functions need unit test coverage before agreeing to any plan.",
-    codePrinciple: "Never mount or render UI to test a logic outcome. Test files must mirror the service/utility structure.",
-    brainstorm: { tag: "SAY", focus: "test coverage gaps, which functions need tests" },
-    planning: "Test Plan (which functions need tests, regression tests)",
+    description: "writes unit and regression tests for changed code",
+    groundRules: "Vera identifies which functions need test coverage.",
+    codePrinciple: "Test logic directly — don't mount UI to test outcomes. Mirror service/utility structure.",
+    planning: "Test coverage: which functions need tests, regression cases",
     execution: {
       step: "Vera writes tests",
       tasks: [
-        "Read every file the developer changed. Identify testable functions.",
-        "Write unit tests following existing test patterns.",
-        "Run tests to verify they pass.",
+        "Identify testable functions in changed files.",
+        "Write unit tests following existing patterns. Run and verify.",
         "Commit test files.",
       ],
       order: 3,
@@ -101,21 +89,16 @@ export const BUILT_IN_AGENTS = {
   Luna: {
     badge: "☾☾ LUNA ☾☾",
     role: "UX/UI Designer",
-    description: "designs pixel-perfect interfaces, champions user experience, applies psychology of user behavior, ensures visual consistency, accessibility, and intuitive interaction patterns",
-    groundRules: "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.",
-    codePrinciple: "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.",
-    brainstorm: { tag: "THINK", focus: "UX/UI impact, visual consistency, interaction patterns, accessibility" },
-    planning: "UX Review (visual impact, layout concerns, accessibility checklist, interaction improvements). For UI tasks: define which pages/views need screenshots and whether desktop, mobile, or both are relevant.",
+    description: "reviews UI changes for visual consistency, accessibility, and UX",
+    groundRules: "Luna references specific components and proposes exact CSS fixes.",
+    codePrinciple: "Reviews visual hierarchy, spacing, color, typography, responsive behavior, accessibility (WCAG).",
+    planning: "UX review: visual impact, accessibility. For UI tasks: define screenshot plan (pages, viewports).",
     execution: {
-      step: "Luna reviews UI changes (if applicable)",
+      step: "Luna reviews UI (if applicable)",
       tasks: [
-        "Read any changed component, page, or style files.",
-        "Check visual hierarchy, spacing consistency, color harmony, typography.",
-        "Verify accessibility: contrast ratios, focus states, keyboard navigation, screen reader labels.",
-        "Check responsive behavior and interaction flow.",
-        "If issues found, propose specific fixes (exact CSS values, spacing, colors). The developer implements them before proceeding.",
-        "Define the screenshot plan: which pages/routes to capture and which viewports (desktop, mobile, or both). Hand this plan to Bart.",
-        "Skip this step if the task has no UI impact.",
+        "Read changed UI files. Check visual consistency and accessibility.",
+        "Propose specific fixes if needed. Developer implements.",
+        "Hand screenshot plan to Bart. Skip if no UI impact.",
       ],
       order: 2.1,
     },
@@ -123,19 +106,16 @@ export const BUILT_IN_AGENTS = {
   Mark: {
     badge: "✦✦ MARK ✦✦",
     role: "Content Writer",
-    description: "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",
-    groundRules: "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.",
-    codePrinciple: "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.",
-    brainstorm: { tag: "THINK", focus: "copy clarity, tone, user-facing text quality" },
-    planning: "Content Review (user-facing text audit, tone, clarity, empty states, error messages)",
+    description: "reviews user-facing text for clarity, tone, and consistency",
+    groundRules: "Mark reviews all labels, buttons, error messages, tooltips, and empty states.",
+    codePrinciple: "Rewrites vague or jargon-heavy copy into clear, concise language. Ensures consistent tone.",
+    planning: "Content review: user-facing text audit, tone consistency",
     execution: {
       step: "Mark reviews content (if applicable)",
       tasks: [
-        "Read all changed files that contain user-facing text (components, templates, error handlers).",
-        "Check every label, button, heading, tooltip, error message, empty state, and confirmation dialog.",
-        "Rewrite anything vague, wordy, jargon-heavy, or inconsistent in tone.",
-        "Propose exact replacement strings. The developer implements them.",
-        "Skip this step if the task has no user-facing text changes.",
+        "Read changed files with user-facing text.",
+        "Propose exact replacement strings if needed. Developer implements.",
+        "Skip if no user-facing text changes.",
       ],
       order: 2.2,
     },
@@ -175,7 +155,6 @@ export function resolveTeam(config) {
             role: custom.role || "Team Member",
             description: custom.role || "Custom team member",
             groundRules: custom.when ? `${custom.name} is invoked: ${custom.when}. How to use: ${custom.how || "as needed"}.` : "",
-            brainstorm: { tag: "SAY", focus: custom.role || "general input" },
             planning: `${custom.role || custom.name} Review`,
             execution: custom.when ? {
               step: `${custom.name} reviews`,
@@ -204,7 +183,6 @@ export function resolveTeam(config) {
           role: entry.role || "Team Member",
           description: entry.description || entry.role || "Custom team member",
           groundRules: entry.groundRules || "",
-          brainstorm: entry.brainstorm || { tag: "SAY", focus: entry.role || "general input" },
           planning: entry.planning || `${entry.role || entry.name} Review`,
           execution: entry.execution || null,
         });
@@ -245,9 +223,9 @@ export function generateTeamPrompt(team) {
 
   // Ground rules
   const rules = [];
-  rules.push(`1. Each agent speaks in turn, prefixed with their badge (e.g., "${team[0].badge} Starting.").`);
-  rules.push(`2. ALL text output MUST be prefixed with the acting agent's badge. Never output unprefixed text.`);
-  rules.push(`3. Agents should DISAGREE when they see problems — don't rubber-stamp each other.`);
+  rules.push(`1. Each agent speaks prefixed with their badge (e.g., "${team[0].badge} ...").`);
+  rules.push(`2. ALL text output MUST be prefixed with the acting agent's badge.`);
+  rules.push(`3. Raise concerns when you see problems — don't rubber-stamp.`);
   let ruleNum = 4;
   for (const a of team) {
     if (a.groundRules) {
@@ -255,7 +233,6 @@ export function generateTeamPrompt(team) {
       ruleNum++;
     }
   }
-  rules.push(`${ruleNum}. Every statement should add value — no filler, no repeating what someone else already said.`);
   sections.groundRules = rules.join("\n");
 
   // Code principles
@@ -264,11 +241,6 @@ export function generateTeamPrompt(team) {
     .map(a => `- ${a.name}: ${a.codePrinciple}`);
   sections.codePrinciples = principles.length > 0 ? principles.join("\n") : "";
 
-  // Brainstorm order
-  sections.brainstormOrder = team.map((a, i) =>
-    `${i + 1}. ${a.badge}  [${a.brainstorm.tag}]  ${a.brainstorm.focus}`
-  ).join("\n");
-
   // Planning presentations
   sections.planningOrder = team.map(a =>
     `${a.badge}  ${a.planning}`

package/cli/init.mjs

@@ -7,6 +7,7 @@ import { detectProject } from "./detect.mjs";
 import { loadConfig } from "./config.mjs";
 import { getStoredApiKey } from "./login.mjs";
 import { registerLocalProject } from "./projects.mjs";
+import { checkTrackerPermissions, resolveCredentialsFromEnv } from "./tracker-check.mjs";
 
 const SERVER = process.env.AGENTDESK_SERVER || "https://agentdesk.live";
 
@@ -114,6 +115,56 @@ export async function runInit(cwd) {
     console.log("");
   }
 
+  // --- Verify tracker permissions ---
+  if (tracker) {
+    console.log("  Checking tracker permissions...");
+    const envPath = join(cwd, ".env");
+    let dotEnv = {};
+    if (existsSync(envPath)) {
+      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) dotEnv[trimmed.slice(0, eq)] = trimmed.slice(eq + 1);
+      }
+    }
+
+    // Also try fetching credentials from server
+    const apiKey = loadApiKey(cwd);
+    let serverCreds = {};
+    if (apiKey) {
+      try {
+        const res = await fetch(`${SERVER}/api/projects/${finalProjectKey}/settings/credentials`, {
+          headers: { "x-api-key": apiKey },
+          signal: AbortSignal.timeout(5000),
+        });
+        if (res.ok) serverCreds = await res.json();
+      } catch {}
+    }
+
+    const credentials = resolveCredentialsFromEnv({ ...dotEnv, ...serverCreds });
+    const check = await checkTrackerPermissions({ tracker, config, credentials });
+
+    if (!check.ok) {
+      console.log("");
+      console.log("  ⚠  Tracker permission issues:");
+      for (const err of check.errors) {
+        console.log(`     • ${err}`);
+      }
+      console.log("");
+      const proceed = await ask(rl, "  Continue anyway? (y/N): ");
+      if (proceed.trim().toLowerCase() !== "y") {
+        console.log("  Setup cancelled. Fix the issues above and run 'agentdesk init' again.");
+        rl.close();
+        return;
+      }
+      console.log("");
+    } else {
+      console.log("  ✓ Tracker permissions verified (read, create, update)");
+      console.log("");
+    }
+  }
+
   // --- Save .agentdesk.json ---
   let merged = {};
   if (hasConfig) {

package/cli/prompt.mjs

@@ -17,7 +17,6 @@ export function buildPrompt({ taskId, taskLink, description, createTask, tracker
   prompt = prompt.replace(/\{\{SPEAKING_ORDER\}\}/g, teamSections.speakingOrder);
   prompt = prompt.replace(/\{\{GROUND_RULES\}\}/g, teamSections.groundRules);
   prompt = prompt.replace(/\{\{CODE_PRINCIPLES\}\}/g, teamSections.codePrinciples);
-  prompt = prompt.replace(/\{\{BRAINSTORM_ORDER\}\}/g, teamSections.brainstormOrder);
   prompt = prompt.replace(/\{\{PLANNING_ORDER\}\}/g, teamSections.planningOrder);
   prompt = prompt.replace(/\{\{EXECUTION_STEPS\}\}/g, teamSections.executionSteps);
 
@@ -49,7 +48,7 @@ export function buildPrompt({ taskId, taskLink, description, createTask, tracker
     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`;
+    createInstr += `\nDo NOT proceed to PLAN until the task is created, announced, and set to "In Progress".\n`;
     prompt += createInstr;
   }
 

package/cli/stream-parser.mjs

@@ -1,6 +1,6 @@
 // Shared Claude stream-json parser — used by both `agentdesk team` and `agentdesk daemon`
 
-const PHASE_NAMES = ["INTAKE", "BRAINSTORM", "PLANNING", "EXECUTION", "REVIEW"];
+const PHASE_NAMES = ["INTAKE", "PLAN", "EXECUTION", "REVIEW", "SUMMARY"];
 
 function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/cli/team.mjs

@@ -10,6 +10,7 @@ import { loadConfig } from "./config.mjs";
 import { getStoredApiKey } from "./login.mjs";
 import { resolveTeam, generateTeamPrompt } from "./agents.mjs";
 import { runOrchestrator } from "./orchestrator.mjs";
+import { checkTrackerPermissions, resolveCredentialsFromEnv } from "./tracker-check.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CLI_VERSION = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8")).version;
@@ -83,6 +84,39 @@ export async function runTeam(taskId, opts = {}) {
   const team = resolveTeam(config);
   const teamSections = generateTeamPrompt(team);
 
+  // --- Verify tracker permissions before starting session ---
+  if (tracker) {
+    const projectEnvVars = loadDotEnv(cwd);
+    let serverCreds = {};
+    if (apiKey) {
+      try {
+        const res = await fetch(`${agentdeskServer}/api/projects/${config.projectKey || project.name}/settings/credentials`, {
+          headers: { "x-api-key": apiKey },
+          signal: AbortSignal.timeout(5000),
+        });
+        if (res.ok) serverCreds = await res.json();
+      } catch {}
+    }
+
+    const credentials = resolveCredentialsFromEnv({ ...projectEnvVars, ...serverCreds });
+    const check = await checkTrackerPermissions({ tracker, config, credentials });
+
+    if (!check.ok) {
+      console.log("");
+      console.log("Tracker permission issues:");
+      for (const err of check.errors) {
+        console.log(`  • ${err}`);
+      }
+      console.log("");
+      console.log("Fix the issues above or run 'agentdesk init' to reconfigure.");
+      console.log("To skip this check, set AGENTDESK_SKIP_TRACKER_CHECK=1");
+      if (!process.env.AGENTDESK_SKIP_TRACKER_CHECK) {
+        return 1;
+      }
+      console.log("Skipping check (AGENTDESK_SKIP_TRACKER_CHECK=1)...\n");
+    }
+  }
+
   // --- AgentDesk WebSocket config ---
   const AGENTDESK_URL = process.env.AGENTDESK_URL || "wss://agentdesk.live/ws/agent";
   const sessionId = `${taskId}-${randomUUID().slice(0, 8)}`;

package/cli/tracker-check.mjs

@@ -0,0 +1,211 @@
+// Verify tracker API permissions before starting a session
+// Checks: read tasks, create tasks, update tasks
+
+import { execSync } from "child_process";
+
+const LINEAR_API = "https://api.linear.app/graphql";
+
+/**
+ * Check tracker permissions. Returns { ok, errors[] }.
+ * Each error is a string describing what permission is missing.
+ */
+export async function checkTrackerPermissions({ tracker, config, credentials }) {
+  if (!tracker) return { ok: true, errors: [] };
+
+  switch (tracker) {
+    case "linear":
+      return checkLinear(config.linear || {}, credentials);
+    case "jira":
+      return checkJira(config.jira || {}, credentials);
+    case "github":
+      return checkGitHub(config.github || {}, credentials);
+    default:
+      return { ok: true, errors: [] };
+  }
+}
+
+async function checkLinear({ teamKey, workspace }, creds) {
+  const apiKey = creds.LINEAR_API_KEY;
+  if (!apiKey) return { ok: false, errors: ["Missing LINEAR_API_KEY — configure it in the AgentDesk dashboard or .env"] };
+
+  const errors = [];
+
+  // Check read: fetch viewer and team info
+  try {
+    const viewerRes = await gql(apiKey, `{ viewer { id name } }`);
+    if (viewerRes.errors) {
+      return { ok: false, errors: ["LINEAR_API_KEY is invalid or expired"] };
+    }
+  } catch (e) {
+    return { ok: false, errors: [`Cannot reach Linear API: ${e.message}`] };
+  }
+
+  // Check read issues: list 1 issue from the team
+  if (teamKey) {
+    try {
+      const issuesRes = await gql(apiKey, `{ issues(filter: { team: { key: { eq: "${teamKey}" } } }, first: 1) { nodes { id identifier } } }`);
+      if (issuesRes.errors) {
+        errors.push(`Cannot read issues for team ${teamKey}: ${issuesRes.errors[0]?.message}`);
+      }
+    } catch {
+      errors.push(`Cannot read issues for team ${teamKey}`);
+    }
+  }
+
+  // Check create: attempt issueCreate dry-run — Linear doesn't have a dry-run mode,
+  // so we verify the team exists (which is required for creating issues)
+  if (teamKey) {
+    try {
+      const teamRes = await gql(apiKey, `{ teams(filter: { key: { eq: "${teamKey}" } }) { nodes { id name } } }`);
+      if (teamRes.errors || !teamRes.data?.teams?.nodes?.length) {
+        errors.push(`Team "${teamKey}" not found — cannot create issues`);
+      }
+    } catch {
+      errors.push(`Cannot verify team "${teamKey}" for issue creation`);
+    }
+  }
+
+  // Check update: verify we can read workflow states (needed for status transitions)
+  if (teamKey) {
+    try {
+      const statesRes = await gql(apiKey, `{ workflowStates(filter: { team: { key: { eq: "${teamKey}" } } }, first: 1) { nodes { id name } } }`);
+      if (statesRes.errors) {
+        errors.push(`Cannot read workflow states for team ${teamKey} — status updates will fail`);
+      }
+    } catch {
+      errors.push(`Cannot verify workflow states for team ${teamKey}`);
+    }
+  }
+
+  return { ok: errors.length === 0, errors };
+}
+
+async function checkJira({ baseUrl, project }, creds) {
+  const email = creds.JIRA_EMAIL;
+  const token = creds.JIRA_API_TOKEN;
+
+  if (!email || !token) return { ok: false, errors: ["Missing JIRA_EMAIL or JIRA_API_TOKEN — configure them in the AgentDesk dashboard or .env"] };
+  if (!baseUrl) return { ok: false, errors: ["Missing Jira base URL — run 'agentdesk init' to configure"] };
+
+  const errors = [];
+  const auth = "Basic " + Buffer.from(`${email}:${token}`).toString("base64");
+
+  // Use Jira's mypermissions endpoint to check all permissions at once
+  const permissionsToCheck = "BROWSE_PROJECTS,CREATE_ISSUES,EDIT_ISSUES,ADD_COMMENTS,TRANSITION_ISSUES";
+  try {
+    const url = `${baseUrl}/rest/api/3/mypermissions?permissions=${permissionsToCheck}` +
+      (project ? `&projectKey=${project}` : "");
+    const res = await fetch(url, {
+      headers: { Authorization: auth, Accept: "application/json" },
+      signal: AbortSignal.timeout(10000),
+    });
+
+    if (res.status === 401) {
+      return { ok: false, errors: ["Jira authentication failed — check JIRA_EMAIL and JIRA_API_TOKEN"] };
+    }
+    if (res.status === 403) {
+      return { ok: false, errors: ["Jira access forbidden — your account may lack access to this project"] };
+    }
+    if (!res.ok) {
+      return { ok: false, errors: [`Jira API error (${res.status}) — check your base URL: ${baseUrl}`] };
+    }
+
+    const data = await res.json();
+    const perms = data.permissions || {};
+
+    const permMap = {
+      BROWSE_PROJECTS: "read tasks",
+      CREATE_ISSUES: "create tasks",
+      EDIT_ISSUES: "update tasks",
+      ADD_COMMENTS: "add comments",
+      TRANSITION_ISSUES: "change task status",
+    };
+
+    for (const [key, label] of Object.entries(permMap)) {
+      if (perms[key] && !perms[key].havePermission) {
+        errors.push(`Missing permission: ${label} (${key})`);
+      }
+    }
+  } catch (e) {
+    if (e.name === "AbortError" || e.name === "TimeoutError") {
+      return { ok: false, errors: [`Cannot reach Jira at ${baseUrl} — request timed out`] };
+    }
+    return { ok: false, errors: [`Cannot reach Jira at ${baseUrl}: ${e.message}`] };
+  }
+
+  return { ok: errors.length === 0, errors };
+}
+
+async function checkGitHub({ repo }, creds) {
+  if (!repo) return { ok: false, errors: ["Missing GitHub repo — run 'agentdesk init' to configure"] };
+
+  const errors = [];
+
+  // Check if gh CLI is available
+  try {
+    execSync("gh --version", { stdio: "pipe" });
+  } catch {
+    return { ok: false, errors: ["GitHub CLI (gh) is not installed — install it from https://cli.github.com"] };
+  }
+
+  // Check auth status
+  try {
+    execSync("gh auth status", { stdio: "pipe" });
+  } catch {
+    return { ok: false, errors: ["GitHub CLI is not authenticated — run 'gh auth login'"] };
+  }
+
+  // Check repo access and permissions
+  try {
+    const result = execSync(`gh api repos/${repo} --jq ".permissions"`, { stdio: "pipe", encoding: "utf-8" });
+    const perms = JSON.parse(result.trim());
+
+    if (!perms.pull) {
+      errors.push("Missing permission: read issues (no pull access to repo)");
+    }
+    if (!perms.push) {
+      errors.push("Missing permission: create/update issues (no push access to repo)");
+    }
+  } catch (e) {
+    const msg = e.stderr?.toString() || e.message;
+    if (msg.includes("404") || msg.includes("Not Found")) {
+      errors.push(`Repository "${repo}" not found or not accessible`);
+    } else {
+      errors.push(`Cannot verify GitHub repo access: ${msg.trim()}`);
+    }
+  }
+
+  return { ok: errors.length === 0, errors };
+}
+
+// Helper: execute a Linear GraphQL query
+async function gql(apiKey, query) {
+  const res = await fetch(LINEAR_API, {
+    method: "POST",
+    headers: {
+      Authorization: apiKey,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ query }),
+    signal: AbortSignal.timeout(10000),
+  });
+
+  if (!res.ok) {
+    throw new Error(`Linear API returned ${res.status}`);
+  }
+
+  return res.json();
+}
+
+/**
+ * Resolve tracker credentials from available sources.
+ * Checks: env vars, .env file, server credentials.
+ */
+export function resolveCredentialsFromEnv(env = {}) {
+  return {
+    LINEAR_API_KEY: env.LINEAR_API_KEY || process.env.LINEAR_API_KEY || undefined,
+    JIRA_EMAIL: env.JIRA_EMAIL || process.env.JIRA_EMAIL || undefined,
+    JIRA_API_TOKEN: env.JIRA_API_TOKEN || process.env.JIRA_API_TOKEN || undefined,
+    GITHUB_TOKEN: env.GITHUB_TOKEN || process.env.GITHUB_TOKEN || undefined,
+  };
+}

package/package.json

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

package/prompts/team.md

@@ -12,13 +12,12 @@ The agents are:
 
 {{AGENT_LIST}}
 
-You role-play all {{AGENT_COUNT}} agents in a structured conversation. Jane leads.
+You role-play all {{AGENT_COUNT}} agents. Jane leads. Be concise — every message must add value.
 
-MANDATORY: Every single round of discussion must include ALL {{AGENT_COUNT}} agents speaking, in this order:
+Speaking order:
 {{SPEAKING_ORDER}}
-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.
+Agents only speak when they have something substantive to contribute. No filler, no "I agree" without adding new information.
 
 ## GROUND RULES
 
@@ -26,469 +25,223 @@ IMPORTANT: You must narrate everything you do. Before and after every action, us
 
 ## 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:
+Check for user messages at phase transitions:
 ```
 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
+If not empty (`[]`), Jane reads the messages and incorporates them — user input takes priority.
 
 ## CODE PRINCIPLES
 
 {{CODE_PRINCIPLES}}
 
-## 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:
+## RULES
 
-  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)
-  ---
-  ```
+- Follow CLAUDE.md conventions (if present).
+- Do NOT modify files unrelated to the task.
+- When posting screenshots to Linear, post them as a SEPARATE comment — never inside badge blocks.
 
 ## SCREENSHOTS
 
-When a task involves UI changes, the team MUST capture screenshots of the affected views. This is not optional for UI tasks.
-
-**Roles:**
-- **Jane** identifies during PLANNING whether this is a UI task (any visual changes to components, pages, layouts, or styles).
-- **Luna** defines the screenshot plan during her review step: which pages/routes to capture and which viewports (desktop, mobile, or both — based on what's relevant to the change).
-- **Bart** executes the screenshot plan during his review step, after all code changes are finalized.
+When a task involves UI changes, capture screenshots of affected views.
 
-**How to capture screenshots:**
+- **Jane** flags UI tasks during planning.
+- **Luna** defines what to capture (pages, viewports).
+- **Bart** captures screenshots after code changes are finalized, before creating the PR.
 
-Bart writes and executes a project-specific puppeteer script for each screenshot session. This handles auth, navigation, and viewport sizing in one shot.
+Bart writes a puppeteer script adapted to the project's auth flow. Read the project's login mechanism, dev server port, and test credentials before writing the script.
 
-**Step 1 — Prepare:** Before writing the script, Bart MUST:
-- Read the project's login/auth flow (check auth pages, middleware, `.env` for test credentials)
-- Identify the dev server port (from `package.json` scripts, `.env`, or framework defaults)
-- Get the list of routes and viewports from Luna's screenshot plan
-
-**Step 2 — Start the dev server:**
 ```bash
-echo "Starting dev server for screenshots..."
 npm run dev &
 DEV_PID=$!
-sleep 8  # Wait for server to start
-```
-
-**Step 3 — Write and run a puppeteer script** that handles the project's auth and captures all required views:
-```bash
-npx --yes puppeteer@latest node -e "
-const puppeteer = require('puppeteer');
-(async () => {
-  const browser = await puppeteer.launch({ headless: 'new' });
-  const page = await browser.newPage();
-
-  // --- AUTH: Adapt this to the project's login flow ---
-  // Read .env or config for test credentials
-  // Navigate to login page, fill form, submit
-  // Example:
-  // await page.goto('http://localhost:3000/login');
-  // await page.type('input[name=email]', process.env.TEST_EMAIL || 'test@example.com');
-  // await page.type('input[name=password]', process.env.TEST_PASSWORD || 'password');
-  // await page.click('button[type=submit]');
-  // await page.waitForNavigation();
-
-  // --- CAPTURE: Take screenshots per Luna's plan ---
-  const routes = ['/affected-route'];  // From Luna's plan
-  const viewports = [
-    { name: 'desktop', width: 1280, height: 800 },
-    { name: 'mobile', width: 375, height: 812 },
-  ];
-
-  for (const route of routes) {
-    for (const vp of viewports) {
-      await page.setViewport({ width: vp.width, height: vp.height });
-      await page.goto('http://localhost:3000' + route, { waitUntil: 'networkidle0' });
-      await new Promise(r => setTimeout(r, 1000));
-      const filename = 'screenshots/' + route.replace(/\\//g, '-').slice(1) + '-' + vp.name + '.png';
-      await page.screenshot({ path: filename, fullPage: true });
-      console.log('Captured: ' + filename);
-    }
-  }
-
-  await browser.close();
-})();
-"
-```
-
-IMPORTANT: Bart MUST adapt the auth section to the specific project. Do NOT use a generic/placeholder login — read the actual auth code, find real dev/test credentials from `.env`, seed files, or test fixtures, and write the login flow to match the project's actual login page (selectors, fields, OAuth flow, etc.). If the project uses OAuth only and has no test credentials, Bart should note this and skip screenshots with an explanation.
-
-**Step 4 — Stop the dev server:**
-```bash
+sleep 8
+# Run puppeteer script for screenshots
 kill $DEV_PID 2>/dev/null
 ```
 
-**Step 5 — Upload** screenshots to the task tracker (see upload instructions below).
+Adapt auth to the actual project — no placeholders. If the project uses OAuth with no test credentials, skip screenshots with an explanation.
 
-**When to capture:**
-- After ALL code changes, reviews, and fixes are complete (during Bart's review step)
-- Before creating the PR
-- Only capture the pages/views that were actually affected by the changes
-
-### Uploading screenshots to the task tracker
+### Uploading screenshots
 
 {{#LINEAR}}
-**Linear — Upload & attach screenshots:**
-
-Step 1: Get an upload URL from Linear:
+Upload via Linear's fileUpload mutation, then post image URLs as a separate comment:
 ```bash
 UPLOAD_RESPONSE=$(curl -s -X POST https://api.linear.app/graphql \
   -H "Authorization: $LINEAR_API_KEY" \
   -H "Content-Type: application/json" \
   -d '{"query":"mutation { fileUpload(contentType: \"image/png\", filename: \"screenshot.png\", size: '$(stat -f%z screenshot.png)') { uploadFile { uploadUrl assetUrl headers { key value } } } }"}')
-
-UPLOAD_URL=$(echo "$UPLOAD_RESPONSE" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['data']['fileUpload']['uploadFile']['uploadUrl'])")
-ASSET_URL=$(echo "$UPLOAD_RESPONSE" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['data']['fileUpload']['uploadFile']['assetUrl'])")
-HEADERS=$(echo "$UPLOAD_RESPONSE" | python3 -c "import sys,json; d=json.load(sys.stdin); h=d['data']['fileUpload']['uploadFile']['headers']; print(' '.join([f'-H \"{x[\"key\"]}: {x[\"value\"]}\"' for x in h]))")
-```
-
-Step 2: Upload the file to the signed URL:
-```bash
-eval curl -s -X PUT "$UPLOAD_URL" \
-  -H "Content-Type: image/png" \
-  $HEADERS \
-  --data-binary @screenshot.png
-```
-
-Step 3: Post a comment with the uploaded image URLs (as a SEPARATE comment, not inside badge blocks):
-```bash
-curl -s -X POST https://api.linear.app/graphql \
-  -H "Authorization: $LINEAR_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"query":"mutation { commentCreate(input: { issueId: \"'$ISSUE_ID'\", body: \"![Desktop]('$DESKTOP_ASSET_URL')\n\nDesktop view.\n\n![Mobile]('$MOBILE_ASSET_URL')\n\nMobile view.\" }) { success } }"}'
+# Extract uploadUrl, assetUrl, headers — upload file, then post comment with image markdown
 ```
-
-Repeat steps 1-2 for each screenshot file (desktop, mobile). Use the ASSET_URL values in the comment body.
 {{/LINEAR}}
 
 {{#JIRA}}
-**Jira — Upload & attach screenshots:**
-
-Upload each screenshot as an attachment:
+Upload as attachments, then post a comment referencing them:
 ```bash
 curl -s -X POST "$JIRA_BASE_URL/rest/api/3/issue/{{TASK_ID}}/attachments" \
   -u "$JIRA_EMAIL:$JIRA_API_TOKEN" \
   -H "X-Atlassian-Token: no-check" \
-  -F "file=@screenshots/desktop.png" \
-  -F "file=@screenshots/mobile.png"
-```
-
-Then post a comment referencing the attachments:
-```bash
-curl -s -X POST "$JIRA_BASE_URL/rest/api/3/issue/{{TASK_ID}}/comment" \
-  -u "$JIRA_EMAIL:$JIRA_API_TOKEN" \
-  -H "Content-Type: application/json" \
-  -d '{"body":{"type":"doc","version":1,"content":[{"type":"paragraph","content":[{"type":"text","text":"Screenshots of affected views:"}]},{"type":"mediaGroup","content":[{"type":"media","attrs":{"type":"file","collection":"","id":"desktop.png"}},{"type":"media","attrs":{"type":"file","collection":"","id":"mobile.png"}}]}]}}'
+  -F "file=@screenshots/desktop.png"
 ```
 {{/JIRA}}
 
 {{#GITHUB}}
-**GitHub — Upload & attach screenshots:**
-
-GitHub supports drag-and-drop image uploads in comments. To upload via CLI, use the GitHub API:
+Post screenshots as base64 in a comment, or upload to a gist for large images:
 ```bash
-# Upload image to GitHub's user content (via issue comment with image)
-# The simplest approach: create a comment with base64-embedded images or use gh CLI
-gh issue comment {{TASK_ID}} --body "$(cat <<SCREENSHOT_EOF
-**Screenshots of affected views:**
-
-Desktop (1280x800):
-![Desktop]($(python3 -c "import base64; print('data:image/png;base64,' + base64.b64encode(open('screenshots/desktop.png','rb').read()).decode())"))
-
-Mobile (375x812):
-![Mobile]($(python3 -c "import base64; print('data:image/png;base64,' + base64.b64encode(open('screenshots/mobile.png','rb').read()).decode())"))
-SCREENSHOT_EOF
-)"
+gh issue comment {{TASK_ID}} --body "![Desktop](data:image/png;base64,...)"
 ```
-
-Note: If base64 images are too large, upload them as release assets or to a gist and reference the raw URLs instead.
 {{/GITHUB}}
 
 {{#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 }
-    labels { nodes { name } }
-    comments {
-      nodes {
-        body
-        user { name }
-        createdAt
-      }
-    }
-  }
-}
-
-Post updates as comments on the Linear task using this format:
-```
----
-■■ DENNIS ■■
-Status  : [status]
-Task    : [description]
-Session : {{SESSION_URL}}
----
-```
-
-IMPORTANT: The first comment on any task MUST include the session link: {{SESSION_URL}}
+- Auth header: Authorization: $LINEAR_API_KEY (no Bearer prefix)
 
-### Every agent must comment on the tracker
+Fetch task: `{ issue(id: "{{TASK_ID}}") { id identifier title description state { name } labels { nodes { name } } comments { nodes { body user { name } createdAt } } } }`
 
-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
+Post comments using badge format with session link: {{SESSION_URL}}
 
-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
 
-### 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:
+1. **Session start (Jane):** Post "Team session started. Session: {{SESSION_URL}}" and move to "In Progress":
    ```
    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 } } }`
+   Find state ID: `{ 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:
+2. **PR created (Bart):** Post PR link and attach:
    ```
    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.
+3. **Session end (Jane):** Move to "In Review" and post summary.
+
+### Agent tracker comments
 
-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.
+After completing work, agents post a brief comment on the tracker with key findings:
+- **Dennis**: Files changed, technical decisions
+- **Sam**: Architecture concerns or clean audit
+- **Bart**: PR link, test results, screenshots
+
+Keep comments to bullet points. The tracker should tell the story without the dashboard.
 {{/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,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
+- Auth: Basic auth with $JIRA_EMAIL:$JIRA_API_TOKEN
+- Fetch: `curl -s -u "$JIRA_EMAIL:$JIRA_API_TOKEN" "{{JIRA_BASE_URL}}/rest/api/3/issue/{{TASK_ID}}?fields=summary,description,status,comment,transition"`
+- Comment: POST to {{JIRA_BASE_URL}}/rest/api/3/issue/{{TASK_ID}}/comment
 
-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.
+Post comments using badge format with session link: {{SESSION_URL}}
 
-### Required tracker actions (Jane MUST do these — not optional)
+### Required tracker actions
 
-1. **On session start (INTAKE):** Post a comment: "Team session started. Session: {{SESSION_URL}}" and transition the task to "In Progress":
+1. **Session start (Jane):** Post "Team session started. Session: {{SESSION_URL}}" and transition 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:
+   # Find "In Progress" transition ID, 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:
+2. **PR created (Bart):** Post PR link and attach as 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.
+3. **Session end (Jane):** Transition to "In Review" and post summary.
 
-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.
+### Agent tracker comments
+
+After completing work, agents post a brief comment on the tracker with key findings:
+- **Dennis**: Files changed, technical decisions
+- **Sam**: Architecture concerns or clean audit
+- **Bart**: PR link, test results, screenshots
+
+Keep comments to bullet points. The tracker should tell the story without the dashboard.
 {{/JIRA}}
 
 {{#GITHUB}}
 ## GITHUB ISSUES INTEGRATION
 
-Fetch the task from GitHub Issues:
-- 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
+- Fetch: `gh issue view {{TASK_ID}} --json title,body,state,comments,labels`
+- Comment: `gh issue comment {{TASK_ID}} --body "..."`
 
-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
+Post comments with session link: {{SESSION_URL}}
 
-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
 
-### 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):
+1. **Session start (Jane):** Post "Team session started. Session: {{SESSION_URL}}" and add "in progress" label:
    ```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"
-   ```
+2. **PR created (Bart):** Reference issue in PR body ("Closes #{{TASK_ID}}") and post comment with PR link.
+
+3. **Session end (Jane):** Post summary comment.
+
+### Agent tracker comments
 
-3. **On session end (SUMMARY):** Jane posts a final summary comment on the issue.
+After completing work, agents post a brief comment on the issue with key findings:
+- **Dennis**: Files changed, technical decisions
+- **Sam**: Architecture concerns or clean audit
+- **Bart**: PR link, test results, screenshots
 
-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.
+Keep comments to bullet points.
 {{/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.
+**If a CREATE TASK section exists above**, Jane executes it NOW — create the task, announce the ID, output `TASK_ID: <identifier>`, set status to "In Progress". Only then continue.
 
 {{#LINEAR}}
-Fetch the task from Linear and print the title, description, current state, and any existing comments.
+Fetch the task from Linear — print title, description, state, existing comments.
 {{/LINEAR}}
 {{#JIRA}}
-Fetch the task from Jira and print the summary, description, current status, and any existing comments.
+Fetch the task from Jira — print summary, description, status, existing comments.
 {{/JIRA}}
 {{#GITHUB}}
-Fetch the issue from GitHub and print the title, body, state, and any existing comments.
+Fetch the issue from GitHub — print title, body, state, existing comments.
 {{/GITHUB}}
 {{#NO_TRACKER}}
-Read the task description above. If a CLAUDE.md file exists, read it to understand project conventions.
+Read the task description. If CLAUDE.md exists, read it.
 {{/NO_TRACKER}}
 
-### Assess current situation
+### Assess
 
-Before doing anything, check:
+1. Check for existing branches: `git branch -a | grep {{TASK_ID}}`
+2. Check for existing PRs: `gh pr list --search {{TASK_ID}} --json number,title,state,reviewDecision,url`
+3. Explore relevant code to understand patterns.
+4. Check for project agents: `ls .claude/agents/ .claude/commands/ .github/workflows/ 2>/dev/null`; check if `.mcp.json` exists. If agents are found, Jane briefs the team and assigns usage.
 
-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.
+Based on findings:
+- Fresh task → PLAN phase
+- Branch exists, no PR → review what's done, continue from EXECUTION
+- PR exists → review PR status, continue accordingly
 
-### Discover existing agents
+Jane MUST post the session start comment and set "In Progress" before moving on.
 
-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.
-
-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
-This title is displayed in the dashboard navbar, so keep it short and descriptive.
-
----
-
-## BRAINSTORM (3-5 rounds)
-
-Jane kicks off by restating the task in plain language.
-
-Then ALL {{AGENT_COUNT}} agents speak in EVERY round. This is the mandatory speaking order — you must output all of them, one after another, no exceptions:
-
-{{BRAINSTORM_ORDER}}
-
-RULE: If you output a round without all {{AGENT_COUNT}} agents, it is an error. Fix it immediately. Even if an agent has nothing to add, they must say so explicitly.
-
-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.
+Output on its own line: `SESSION_TITLE: <4-8 word title>`
 
 ---
 
-## PLANNING (1-2 rounds)
+## PLAN (1-2 rounds max)
 
-Each agent presents their plan:
+Jane restates the task concisely. Then each agent contributes their perspective in one pass:
 
 {{PLANNING_ORDER}}
 
-After all agents present, Jane asks: "Any objections or additions?" Then declares the plan final.
+Dennis and Sam MUST use tools (Glob, Grep, Read) to verify assumptions about the codebase.
+
+After the first round, Jane asks for objections. If none, declare the plan final and move to EXECUTION. Do not brainstorm beyond 2 rounds — decide and execute.
 
 ---
 
@@ -500,19 +253,12 @@ 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.
+Jane verifies tracker status is current:
+1. Verify Bart posted the PR link. If not, do it now.
+2. Transition task to "In Review".
+3. Post a final summary comment on the tracker.
 
-Print a final console summary:
+Print:
 echo "Team Session Complete."
 echo "Task: {{TASK_ID}}"
 echo "Status: Ready for review."