@kendoo.agentdesk/agentdesk 0.9.5 → 0.9.7

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

@@ -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);
 
@@ -35,7 +34,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 +43,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 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;
@@ -31,7 +32,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);
@@ -84,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)}`;
@@ -125,26 +158,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 +186,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/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.5",
+  "version": "0.9.7",
   "description": "AI team orchestrator for Claude Code — run collaborative agent sessions from your terminal",
   "type": "module",
   "bin": {