@kendoo.agentdesk/agentdesk 0.27.0 → 0.28.1

package/CHANGELOG.md

@@ -8,6 +8,39 @@ All user-facing changes to AgentDesk. Each entry is tagged:
 
 Internal refactors, infrastructure changes, and architectural notes are not listed here.
 
+## [0.28.1] — 2026-09-17
+
+### Fixed
+- `[CLI]` Jane's delegation to the team ran the delegate in the background by default, leaving its own tool calls with no live turn to get approved — every one was rejected, so a delegated agent could do nothing. Delegation now always runs synchronously.
+
+## [0.28.0] — 2026-09-17
+
+### Changed
+- `[CLI]` Team sessions now run on a new engine built on the Claude Agent SDK. Each phase (INTAKE → PLAN → EXECUTION → REVIEW → SUMMARY) is its own Claude run; Jane leads with a single tool — delegation — and the engineering roles are real subagents with role-scoped tools. Jane can no longer touch code because the tools do not exist in her session. The dashboard's per-agent feed is now driven by real attribution instead of name-matching prose.
+- `[CLI]` REVIEW fans out three independent reviewers (Sam, Bart, Vera) who read the diff themselves rather than the implementer's summary. The verdict is structured and validated; a review that ends without an explicit verdict is treated as *not approved*, never as approval.
+- `[CLI]` Publishing (pushing or opening a PR) is blocked during EXECUTION until Sam's audit has run in that phase. This was previously a prose rule that did not hold.
+- `[CLI]` Session memory (`.agentdesk/session-memory.md`) is now written by the engine from each phase's structured summary, so later phases never start with a missing or malformed handoff. Stale memory from an earlier run is archived instead of being fed into the next session.
+- `[CLI]` Per-phase model overrides continue to apply; REVIEW and SUMMARY still default to Haiku. New project settings: `phaseMaxTurns` (per-phase turn cap) and `maxBudgetUsd` (hard spend cap for a session).
+- `[CLI]` The CLI update check no longer blocks on minor releases, never blocks the daemon, and no longer runs for `--version`/`help`. `AGENTDESK_SKIP_UPDATE_CHECK=1` disables it.
+
+### Removed
+- `[CLI]` `--single-process` / `--no-phased`. Every session runs the phased engine; the flags are accepted and ignored with a note.
+
+### Fixed
+- `[CLI]` `agentdesk init` run from the directory that contains the clone (the parent of `./<repo>`) now uses that clone instead of stopping with "already exists and is not empty". When the directory holds something else, the message now says what it found: a checkout of another repo, or not a git checkout at all.
+- `[CLI]` `agentdesk init` no longer leaves the Jira project / Linear team empty. In existing mode it copied the server's value without asking, and in new mode it only asked when the credential check succeeded, so "Save anyway" skipped the question. With no project bound, create-from-description sessions filed issues in whatever project the token could reach, and the final hint printed the agentdesk project id as if it were the tracker prefix. Init now always resolves the team/project (listing the tracker's projects when credentials verify, asking by hand otherwise), fills the one missing field in on agentdesk.live for existing projects, and the tracker check — in init and before every `agentdesk team` — fails with "Missing Jira project key — run 'agentdesk init'" instead of passing.
+- `[CLI]` Settings pushes to agentdesk.live (init's registration push and the background heal-sync) were silently rejected with "Unknown fields: projectKey", so the server never learned the tracker binding the wizard had picked. The push payload is now reduced to the fields the settings API accepts.
+- `[CLI]` Cancelling a session from the dashboard now actually stops it. Previously the daemon reported "stopped" while Claude kept editing and pushing, and a new session could start on the same working tree.
+- `[CLI]` Sessions that crashed mid-way are no longer reported as complete; they end as a handoff with a resume file. Crash detection had been dead code since the first phase always wrote session memory.
+- `[CLI]` Team sessions no longer die instantly on macOS. The strict sandbox profile was missing read access to the root directory and to the project's ancestor directories, which killed every Claude child process at startup (sessions ended after 0.1s with a misleading rate-limit handoff). The profile now grants those directory nodes plus Claude's own state files, while keeping ~/.ssh, ~/.aws, ~/Documents, and other projects' files blocked.
+- `[CLI]` On macOS, sessions started by a user logged in through the browser reported "Not logged in" inside the sandbox: the strict profile blocked reads of the Keychain where Claude Code keeps its login. The profile now allows that, and also exposes an account profile directory when one is selected.
+- `[CLI]` Running `agentdesk team` from inside an interactive Claude Code session no longer makes the child believe it is nested in that session (which also surfaced as "Not logged in").
+- `[CLI]` `agentdesk init` no longer leaves the GitHub token in the clone's git remote URL, writes `.env` with owner-only permissions, adds `.env` to `.gitignore`, masks secret prompts, verifies a new token before saving it, and recognises repository names containing dots. Existing clones are repaired on the next `init`.
+- `[CLI]` `agentdesk init` now reports a failed project registration instead of printing success, defaults the final confirmation to "no" when an access check failed, and offers to re-enter tracker credentials in existing-project mode.
+- `[CLI]` Two projects mapped to the same tracker team no longer overwrite each other's settings on the server; the second gets a repo-qualified project id.
+- `[CLI]` `agentdesk login` opens the browser on Windows.
+- `[UI]` Saved tracker credentials could not be read back by sessions since late May; they now decrypt again and no data was lost.
+
 ## [0.27.0] — 2026-07-06
 
 ### Added

package/bin/agentdesk.mjs

@@ -5,6 +5,7 @@
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
+import { classifyUpdate, shouldSkipCheck, updateAction } from "../cli/update-check.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -13,37 +14,6 @@ const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8")
 const args = process.argv.slice(2);
 const command = args[0];
 
-// Blocking update check — require update for major/minor bumps, warn for patches
-if (command !== "update") {
-  try {
-    const res = await fetch(`https://registry.npmjs.org/${pkg.name}/latest`, { signal: AbortSignal.timeout(3000) });
-    if (res.ok) {
-      const { version } = await res.json();
-      if (version !== pkg.version) {
-        const [curMajor, curMinor] = pkg.version.split(".").map(Number);
-        const [latMajor, latMinor] = version.split(".").map(Number);
-        const breaking = latMajor > curMajor || latMinor > curMinor;
-
-        const dim = "\x1b[2m";
-        const red = "\x1b[31m";
-        const yellow = "\x1b[33m";
-        const green = "\x1b[32m";
-        const cyan = "\x1b[36m";
-        const reset = "\x1b[0m";
-
-        if (breaking) {
-          console.log(`\n  ${red}Update required:${reset} ${dim}${pkg.version}${reset} → ${green}${version}${reset}`);
-          console.log(`  Run: ${cyan}agentdesk update${reset}\n`);
-          process.exit(1);
-        } else {
-          console.log(`\n  ${yellow}Update available:${reset} ${dim}${pkg.version}${reset} → ${green}${version}${reset}`);
-          console.log(`  Run: ${cyan}agentdesk update${reset}\n`);
-        }
-      }
-    }
-  } catch {}
-}
-
 if (command === "--version" || command === "-v" || command === "version") {
   console.log(pkg.version);
   process.exit(0);
@@ -80,11 +50,13 @@ if (!command || command === "help" || command === "--help") {
   Options:
     --description, -d    Task description or requirements
     --cwd                Working directory (defaults to current)
-    --single-process     Run the whole team session in one Claude process on the EXECUTION model.
-                         Default is phased mode (INTAKE → PLAN → EXECUTION → REVIEW → SUMMARY),
-                         which honors per-phase model overrides from project settings.
     --child-strategy     How to handle child tasks: "inline" (default) or "branch"
 
+  Sessions run five phases — INTAKE → PLAN → EXECUTION → REVIEW → SUMMARY — each as
+  its own Claude query. Jane leads with a single tool (Agent) and delegates to
+  role-scoped subagents; REVIEW fans out independent reviewers who read the diff cold.
+  Per-phase model overrides come from project settings (phaseModels).
+
 
   How it works:
     With a tracker (Linear, Jira, GitHub Issues):
@@ -96,7 +68,6 @@ if (!command || command === "help" || command === "--help") {
 
   Examples:
     agentdesk team KEN-517
-    agentdesk team KEN-517 --single-process
     agentdesk team -d "Fix the checkout total calculation"
     agentdesk team -d "Add Google OAuth to the login page"
 
@@ -109,6 +80,30 @@ if (!command || command === "help" || command === "--help") {
   process.exit(0);
 }
 
+// Update check. Runs after version/help so those never need the network, and
+// only a MAJOR release blocks — and never for `daemon`, which runs unattended
+// and must not refuse to start because a new version was published overnight.
+// Policy lives in cli/update-check.mjs; AGENTDESK_SKIP_UPDATE_CHECK=1 disables.
+if (!shouldSkipCheck(command)) {
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${pkg.name}/latest`, { signal: AbortSignal.timeout(3000) });
+    if (res.ok) {
+      const { version } = await res.json();
+      const { action } = updateAction(command, classifyUpdate(pkg.version, version));
+      if (action !== "none") {
+        const dim = "\x1b[2m", red = "\x1b[31m", yellow = "\x1b[33m", green = "\x1b[32m", cyan = "\x1b[36m", reset = "\x1b[0m";
+        if (action === "block") {
+          console.log(`\n  ${red}Update required:${reset} ${dim}${pkg.version}${reset} → ${green}${version}${reset} (major release)`);
+          console.log(`  Run: ${cyan}agentdesk update${reset}\n`);
+          process.exit(1);
+        }
+        console.log(`\n  ${yellow}Update available:${reset} ${dim}${pkg.version}${reset} → ${green}${version}${reset}`);
+        console.log(`  Run: ${cyan}agentdesk update${reset}\n`);
+      }
+    }
+  } catch {}
+}
+
 // Single-agent mode — agentdesk jane -d "...", agentdesk dennis TASK-123, etc.
 const AGENT_NAMES = ["jane", "dennis", "sam", "bart", "vera", "luna", "mark", "nora"];
 if (AGENT_NAMES.includes(command?.toLowerCase())) {
@@ -165,15 +160,12 @@ else if (command === "bootstrap") {
 
 else if (command === "team") {
   // Parse options first to find -d, --cwd, --child-strategy.
-  // `phased` is the default — each phase spawns its own Claude process so
-  // per-phase model overrides from .agentdesk.json are honored. Pass
-  // --single-process (alias --no-phased) to fall back to the legacy
-  // single-process mode that runs everything on the EXECUTION model.
+  // Every team session runs the phased engine (INTAKE → PLAN → EXECUTION →
+  // REVIEW → SUMMARY) with real subagents; the old single-process mode is gone.
   let description = "";
   let cwd = process.cwd();
   let taskId = null;
   let childStrategy = null;
-  let phased = true;
   const remaining = args.slice(1);
 
   for (let i = 0; i < remaining.length; i++) {
@@ -183,10 +175,8 @@ else if (command === "team") {
       cwd = remaining[++i];
     } else if (remaining[i] === "--child-strategy" && remaining[i + 1]) {
       childStrategy = remaining[++i];
-    } else if (remaining[i] === "--phased") {
-      phased = true;
-    } else if (remaining[i] === "--single-process" || remaining[i] === "--no-phased") {
-      phased = false;
+    } else if (remaining[i] === "--phased" || remaining[i] === "--single-process" || remaining[i] === "--no-phased") {
+      console.error(`  Note: ${remaining[i]} is no longer needed — sessions always run the phased engine.`);
     } else if (!taskId && !remaining[i].startsWith("-")) {
       taskId = remaining[i];
     }
@@ -199,7 +189,7 @@ else if (command === "team") {
   }
 
   const { runTeam } = await import("../cli/team.mjs");
-  const code = await runTeam(taskId, { description, cwd, childStrategy, phased });
+  const code = await runTeam(taskId, { description, cwd, childStrategy });
   process.exit(code);
 }
 

package/cli/agents.mjs

@@ -5,7 +5,7 @@ export const BUILT_IN_AGENTS = {
     badge: "●● JANE ●●",
     role: "Product Analyst / Team Lead",
     description: "leads the session, clarifies requirements, coordinates the team, dictates tracker comments (Dennis executes), decomposes large tasks into subtasks",
-    groundRules: "Jane is strictly non-technical and NEVER calls tools. She MUST NEVER: call Read, Write, Edit, Bash, Grep, Glob, or any other tool; read or reference code; mention file names, paths, function names, variable names, class names, imports, code snippets, terminal commands, error messages, or stack traces; write or modify code; execute tracker API calls herself. Her language is product-only: user stories, acceptance criteria, scope, priorities, stakeholder impact. When she needs technical information she asks Dennis or Sam (\"Dennis, can you check...\"). When tracker comments or status transitions are needed, Jane DICTATES the exact text and Dennis runs the command. If you are about to call a tool while the current speaker is Jane, STOP and switch to Dennis instead.",
+    groundRules: "Jane is strictly non-technical and NEVER calls tools. She MUST NEVER: call Read, Write, Edit, Bash, Grep, Glob, or any other tool; read or reference code; mention file names, paths, function names, variable names, class names, imports, code snippets, terminal commands, error messages, or stack traces; write or modify code; execute tracker API calls herself. Her language is product-only: user stories, acceptance criteria, scope, priorities, stakeholder impact. During INTAKE she evaluates task complexity and decomposes large features into subtasks (basic vs deferred). When she needs technical information she asks Dennis or Sam (\"Dennis, can you check...\"). When tracker comments or status transitions are needed, Jane DICTATES the exact text and Dennis runs the command. If you are about to call a tool while the current speaker is Jane, STOP and switch to Dennis instead.",
     planning: "Requirements: what we're building, acceptance criteria, scope. Flags UI tasks for Luna. (No code, no files, no tool calls.)",
     execution: {
       step: "Jane wraps up (dictates, Dennis executes)",
@@ -184,6 +184,7 @@ export function resolveTeam(config) {
             badge: `** ${custom.name.toUpperCase()} **`,
             role: custom.role || "Team Member",
             description: custom.role || "Custom team member",
+            tools: Array.isArray(custom.tools) ? custom.tools : undefined,
             groundRules: custom.when ? `${custom.name} is invoked: ${custom.when}. How to use: ${custom.how || "as needed"}.` : "",
             planning: `${custom.role || custom.name} Review`,
             execution: custom.when ? {
@@ -212,6 +213,8 @@ export function resolveTeam(config) {
           badge: entry.badge || `** ${entry.name.toUpperCase()} **`,
           role: entry.role || "Team Member",
           description: entry.description || entry.role || "Custom team member",
+          // Engine: explicit tool list for this agent's subagent definition.
+          tools: Array.isArray(entry.tools) ? entry.tools : undefined,
           groundRules: entry.groundRules || "",
           planning: entry.planning || `${entry.role || entry.name} Review`,
           execution: entry.execution || null,
@@ -235,258 +238,3 @@ export function resolveTeam(config) {
 
   return team;
 }
-
-/**
- * Return tracker-specific command snippets for execution steps.
- */
-function trackerCommands(tracker, config) {
-  if (!tracker) return null;
-
-  if (tracker === "linear") {
-    return {
-      postPrLink: [
-        'Post PR link on Linear using attachmentCreate:',
-        '```',
-        'curl -s -X POST https://api.linear.app/graphql \\',
-        '  -H "Authorization: $LINEAR_API_KEY" -H "Content-Type: application/json" \\',
-        '  -d \'{"query":"mutation { attachmentCreate(input: { issueId: \\"$ISSUE_ID\\", title: \\"Pull Request\\", url: \\"$PR_URL\\" }) { success } }"}\'',
-        '```',
-      ].join('\n'),
-      attachScreenshots: [
-        'Upload each screenshot via Linear fileUpload mutation, then post a comment with the image URLs:',
-        '```bash',
-        'for f in screenshots/*.png; do',
-        '  UPLOAD=$(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: \\"\'$(basename "$f")\'\\", size: \'$(stat -f%z "$f")\') { uploadFile { uploadUrl assetUrl headers { key value } } } }"}\')',
-        '  # Extract uploadUrl, assetUrl, headers from $UPLOAD — PUT the file to uploadUrl, then collect assetUrl',
-        'done',
-        '# Post a comment with all image URLs as markdown images',
-        '```',
-      ].join('\n'),
-      agentComment: [
-        'Post a comment on Linear with key findings:',
-        '```',
-        '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: \\"<COMMENT>\\" }) { success } }"}\'',
-        '```',
-      ].join('\n'),
-      transitionToReview: [
-        'Transition to "In Review" on Linear:',
-        '```',
-        'curl -s -X POST https://api.linear.app/graphql \\',
-        '  -H "Authorization: $LINEAR_API_KEY" -H "Content-Type: application/json" \\',
-        '  -d \'{"query":"mutation { issueUpdate(id: \\"$ISSUE_ID\\", input: { stateId: \\"$IN_REVIEW_STATE_ID\\" }) { success } }"}\'',
-        '```',
-        'Find the "In Review" state ID from workflowStates first.',
-      ].join('\n'),
-      postSummary: [
-        'Post final summary comment on Linear (use commentCreate mutation above).',
-      ].join('\n'),
-    };
-  }
-
-  const baseUrl = config?.jira?.baseUrl || '$JIRA_BASE_URL';
-  if (tracker === "jira") {
-    return {
-      postPrLink: [
-        'Post PR link on Jira as a remote link:',
-        '```bash',
-        `curl -s -X POST -u "$JIRA_EMAIL:$JIRA_API_TOKEN" -H "Content-Type: application/json" \\`,
-        `  "${baseUrl}/rest/api/3/issue/$TASK_ID/remotelink" \\`,
-        `  -d '{"object":{"url":"$PR_URL","title":"Pull Request"}}'`,
-        '```',
-      ].join('\n'),
-      attachScreenshots: [
-        'Upload each screenshot as a Jira attachment:',
-        '```bash',
-        `for f in screenshots/*.png; do`,
-        `  curl -s -X POST -u "$JIRA_EMAIL:$JIRA_API_TOKEN" \\`,
-        `    -H "X-Atlassian-Token: no-check" \\`,
-        `    -F "file=@$f" \\`,
-        `    "${baseUrl}/rest/api/3/issue/$TASK_ID/attachments"`,
-        `done`,
-        '```',
-      ].join('\n'),
-      agentComment: [
-        'Post a comment on Jira with key findings. IMPORTANT: Any URLs in the comment MUST use ADF inlineCard nodes so they render as clickable links:',
-        '```bash',
-        `curl -s -X POST -u "$JIRA_EMAIL:$JIRA_API_TOKEN" -H "Content-Type: application/json" \\`,
-        `  "${baseUrl}/rest/api/3/issue/$TASK_ID/comment" \\`,
-        `  -d '<ADF_BODY>'`,
-        '```',
-        'For plain text: `{"type":"text","text":"..."}`',
-        'For clickable URLs: `{"type":"inlineCard","attrs":{"url":"https://..."}}`',
-        'Example body with a link:',
-        '```json',
-        '{"body":{"type":"doc","version":1,"content":[{"type":"paragraph","content":[{"type":"text","text":"Session: "},{"type":"inlineCard","attrs":{"url":"https://agentdesk.live/sessions/..."}}]}]}}',
-        '```',
-      ].join('\n'),
-      transitionToReview: [
-        'Transition task to "In Review" on Jira:',
-        '```bash',
-        `# First get available transitions:`,
-        `curl -s -u "$JIRA_EMAIL:$JIRA_API_TOKEN" "${baseUrl}/rest/api/3/issue/$TASK_ID/transitions"`,
-        `# Then transition (find the "In Review" transition ID):`,
-        `curl -s -X POST -u "$JIRA_EMAIL:$JIRA_API_TOKEN" -H "Content-Type: application/json" \\`,
-        `  "${baseUrl}/rest/api/3/issue/$TASK_ID/transitions" \\`,
-        `  -d '{"transition":{"id":"<TRANSITION_ID>"}}'`,
-        '```',
-      ].join('\n'),
-      postSummary: [
-        `Post final summary comment on Jira (use comment endpoint above).`,
-      ].join('\n'),
-    };
-  }
-
-  if (tracker === "github") {
-    return {
-      postPrLink: [
-        'Reference the issue in the PR body ("Closes #$TASK_ID") and post a comment:',
-        '```bash',
-        'gh issue comment $TASK_ID --body "PR created: $PR_URL"',
-        '```',
-      ].join('\n'),
-      attachScreenshots: [
-        'Upload screenshots and post them in a GitHub issue comment:',
-        '```bash',
-        'BODY=""',
-        'for f in screenshots/*.png; do',
-        '  BASE64=$(base64 < "$f")',
-        '  BODY="$BODY![$(basename $f)](data:image/png;base64,$BASE64)\\n"',
-        'done',
-        'gh issue comment $TASK_ID --body "$BODY"',
-        '```',
-      ].join('\n'),
-      agentComment: [
-        'Post a comment on GitHub with key findings:',
-        '```bash',
-        'gh issue comment $TASK_ID --body "<COMMENT>"',
-        '```',
-      ].join('\n'),
-      transitionToReview: [
-        'Add "in review" label on GitHub:',
-        '```bash',
-        'gh issue edit $TASK_ID --remove-label "in progress" --add-label "in review" 2>/dev/null || true',
-        '```',
-      ].join('\n'),
-      postSummary: [
-        'Post final summary comment on GitHub:',
-        '```bash',
-        'gh issue comment $TASK_ID --body "<SUMMARY>"',
-        '```',
-      ].join('\n'),
-    };
-  }
-
-  return null;
-}
-
-/**
- * Generate the dynamic parts of the prompt from the team.
- * @param {Array} team - resolved team array
- * @param {Object} opts - optional { tracker, config } for tracker-specific execution steps
- */
-export function generateTeamPrompt(team, opts = {}) {
-  const count = team.length;
-  const agentWord = count === 1 ? "one AI agent" : `${count} AI agents`;
-
-  const sections = {};
-
-  // Agent list
-  sections.agentList = team.map(a =>
-    `- ${a.name} (${a.role}) — ${a.description}`
-  ).join("\n");
-
-  // Speaking order
-  sections.speakingOrder = team.map((a, i) =>
-    `${i + 1}. ${a.badge}`
-  ).join("\n");
-
-  // Ground rules
-  const rules = [];
-  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.`);
-  rules.push(`4. **No announcement without observation.** Before any agent claims "done", "deployed", "fixed", "passes", "works", "ready", "now shows X", or "should work" — run the check that would falsify it: execute the command and read the output, fetch the live endpoint and grep the response, load the page and inspect the DOM, verify the deployed artifact contains the new code. "The code looks right" / "the CI is green" / "the DB has the row" are intermediate signals, NOT proof of user-visible outcome. If the observation is out of reach (auth, browser state, external system), say so plainly and ask the user to confirm — don't paper over with confident language. If a fix didn't land on the first try, stop and re-diagnose from scratch: repeated near-misses mean the hypothesis is wrong, not that one more patch will do it.`);
-  let ruleNum = 5;
-  for (const a of team) {
-    if (a.groundRules) {
-      rules.push(`${ruleNum}. ${a.groundRules}`);
-      ruleNum++;
-    }
-  }
-  sections.groundRules = rules.join("\n");
-
-  // Code principles
-  const principles = team
-    .filter(a => a.codePrinciple)
-    .map(a => `- ${a.name}: ${a.codePrinciple}`);
-  sections.codePrinciples = principles.length > 0 ? principles.join("\n") : "";
-
-  // Planning presentations
-  sections.planningOrder = team.map(a =>
-    `${a.badge}  ${a.planning}`
-  ).join("\n");
-
-  // Execution steps — inject tracker-specific commands
-  const cmds = trackerCommands(opts.tracker, opts.config);
-  const execAgents = team
-    .filter(a => a.execution)
-    .sort((a, b) => a.execution.order - b.execution.order);
-  let stepNum = 1;
-  const execSteps = [];
-  for (const a of execAgents) {
-    let tasks = [...a.execution.tasks];
-
-    if (cmds) {
-      // Bart: expand PR link + tracker comment tasks with actual commands
-      if (a.name === "Bart") {
-        tasks = tasks.map(t => {
-          if (/PR link/i.test(t) || /Post PR.*tracker/i.test(t)) {
-            return `Push and create PR.\n   ${cmds.postPrLink}`;
-          }
-          if (/screenshot.*tracker/i.test(t)) {
-            return `Upload screenshots to tracker, then post a comment.\n   ${cmds.attachScreenshots}\n   ${cmds.agentComment.replace('<COMMENT>', 'Screenshots attached — see attachments above.')}`;
-          }
-          return t;
-        });
-      }
-
-      // Jane: expand transition + summary tasks
-      if (a.name === "Jane") {
-        tasks = tasks.map(t => {
-          if (/transition.*in review/i.test(t) || /move.*in review/i.test(t)) {
-            return `Transition task to "In Review".\n   ${cmds.transitionToReview}`;
-          }
-          if (/summary.*tracker/i.test(t) || /final summary/i.test(t)) {
-            return `Post final summary comment on tracker.\n   ${cmds.postSummary}`;
-          }
-          return t;
-        });
-      }
-
-      // Dennis & Sam: expand tracker comment
-      if (a.name === "Dennis" || a.name === "Sam") {
-        const hasTrackerTask = tasks.some(t => /tracker/i.test(t) || /comment/i.test(t));
-        if (!hasTrackerTask) {
-          const findingsLabel = a.name === "Dennis" ? "Files changed, technical decisions" : "Architecture concerns or clean audit";
-          tasks.push(`Post comment on tracker with key findings (${findingsLabel}).\n   ${cmds.agentComment}`);
-        }
-      }
-    }
-
-    const taskList = tasks.map((t, i) => `${i + 1}. ${t}`).join("\n");
-    execSteps.push(`### Step ${stepNum} — ${a.name} ${a.execution.step.replace(/^[A-Za-z]+ /, "")}:\n${taskList}`);
-    stepNum++;
-  }
-  sections.executionSteps = execSteps.join("\n\n");
-
-  // Count and phrasing
-  sections.count = count;
-  sections.agentWord = agentWord;
-  sections.names = team.map(a => a.name);
-
-  return sections;
-}

package/cli/bootstrap.mjs

@@ -10,24 +10,30 @@
 // This module also exports reusable building blocks so `agentdesk init` can
 // short-circuit to the bootstrap flow when it detects a fresh clone.
 
-import { existsSync, readFileSync, writeFileSync } from "fs";
+import { writeFileSync } from "fs";
 import { join } from "path";
-import { execSync } from "child_process";
 import { loadConfig } from "./config.mjs";
 import { getStoredApiKey } from "./login.mjs";
 import { checkTrackerPermissions, resolveCredentialsFromEnv } from "./tracker-check.mjs";
-import { assertPushable, PreflightError } from "./session-preflight.mjs";
-import { select, promptRequired } from "./prompts.mjs";
+import { assertPushable, PreflightError, getGitRemoteUrl } from "./session-preflight.mjs";
+import { select, promptRequired, promptSecret } from "./prompts.mjs";
+import { loadDotEnv, saveEnvVar } from "./dotenv.mjs";
+import {
+  fetchGitHubLogin,
+  parseGitHubRef,
+  printAccessChecks,
+  readLocalConfig,
+  runAccessChecks,
+} from "./setup-helpers.mjs";
 
 const SERVER = process.env.AGENTDESK_SERVER || "https://agentdesk.live";
 
+// Shares parseGitHubRef with init so both entry points agree on what counts
+// as a GitHub remote (the private regex here rejected repo names with dots).
 function detectGitRemote(dir) {
-  try {
-    const url = execSync("git remote get-url origin", { cwd: dir, stdio: ["ignore", "pipe", "ignore"], encoding: "utf-8" }).trim();
-    const m = url.match(/github\.com[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/);
-    if (m) return `${m[1]}/${m[2]}`;
-  } catch {}
-  return null;
+  const url = getGitRemoteUrl(dir);
+  const parsed = url ? parseGitHubRef(url) : null;
+  return parsed ? `${parsed.owner}/${parsed.repo}` : null;
 }
 
 async function fetchProjects(apiKey) {
@@ -162,37 +168,6 @@ export function writeProjectConfig(cwd, projectKey) {
   writeFileSync(join(cwd, ".agentdesk.json"), JSON.stringify({ projectKey }, null, 2) + "\n");
 }
 
-function saveEnvVar(dir, key, value) {
-  const envPath = join(dir, ".env");
-  let content = existsSync(envPath) ? readFileSync(envPath, "utf-8") : "";
-  const re = new RegExp(`^${key}=.*$`, "m");
-  if (re.test(content)) {
-    content = content.replace(re, `${key}=${value}`);
-  } else {
-    content += `${content && !content.endsWith("\n") ? "\n" : ""}${key}=${value}\n`;
-  }
-  writeFileSync(envPath, content);
-}
-
-function loadDotEnvLocal(dir) {
-  const envPath = join(dir, ".env");
-  const out = {};
-  if (!existsSync(envPath)) return out;
-  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) out[trimmed.slice(0, eq)] = trimmed.slice(eq + 1);
-  }
-  return out;
-}
-
-function readLocalConfig(cwd) {
-  const path = join(cwd, ".agentdesk.json");
-  if (!existsSync(path)) return null;
-  try { return JSON.parse(readFileSync(path, "utf-8")); } catch { return null; }
-}
-
 // Compact step list — the init wizard carries the full narrative; bootstrap
 // assumes the user has already seen it on their first machine.
 function printTrackerHint(tracker) {
@@ -211,7 +186,7 @@ async function promptTrackerCreds(cwd, tracker, existing) {
     if (!creds.LINEAR_API_KEY) {
       console.log("");
       printTrackerHint("linear");
-      const v = await promptRequired("Linear API key");
+      const v = await promptSecret("Linear API key");
       saveEnvVar(cwd, "LINEAR_API_KEY", v);
       creds.LINEAR_API_KEY = v;
       console.log("  ✓ Saved LINEAR_API_KEY to .env");
@@ -227,7 +202,7 @@ async function promptTrackerCreds(cwd, tracker, existing) {
     }
     if (!creds.JIRA_API_TOKEN) {
       if (creds.JIRA_EMAIL) console.log("");
-      const v = await promptRequired("Jira API token");
+      const v = await promptSecret("Jira API token");
       saveEnvVar(cwd, "JIRA_API_TOKEN", v);
       creds.JIRA_API_TOKEN = v;
       console.log("  ✓ Saved JIRA_API_TOKEN to .env");
@@ -239,7 +214,7 @@ async function promptTrackerCreds(cwd, tracker, existing) {
 async function promptGitHubToken(cwd) {
   console.log("");
   printTrackerHint("github");
-  const v = await promptRequired("GitHub token");
+  const v = await promptSecret("GitHub token");
   saveEnvVar(cwd, "GITHUB_TOKEN", v);
   console.log("  ✓ Saved GITHUB_TOKEN to .env");
   return v;
@@ -250,7 +225,9 @@ async function promptGitHubToken(cwd) {
 // are missing or broken, prompt for them, validate. Writes to `.env` only.
 // Returns { trackerOk, githubOk } for the caller to surface.
 export async function gapScan({ cwd, apiKey, projectKey }) {
-  const config = await loadConfig(cwd, { apiKey, serverUrl: SERVER, projectName: projectKey, silent: true });
+  // readOnly: bootstrap's contract is "writes to .env only". loadConfig's
+  // default behaviour rewrote .agentdesk.json and pushed to the server.
+  const config = await loadConfig(cwd, { apiKey, serverUrl: SERVER, projectName: projectKey, silent: true, readOnly: true });
   const tracker = config.tracker || null;
   const repo = config.github?.repo || null;
   const login = config.github?.login || null;
@@ -262,7 +239,7 @@ export async function gapScan({ cwd, apiKey, projectKey }) {
   if (repo) console.log(`  Repo:      ${repo}${login ? ` (@${login})` : ""}`);
   console.log("");
 
-  let creds = resolveCredentialsFromEnv(loadDotEnvLocal(cwd));
+  let creds = resolveCredentialsFromEnv(loadDotEnv(cwd));
   let trackerOk = !tracker;
   let githubOk = false;
   let attempts = 0;
@@ -309,16 +286,22 @@ export async function gapScan({ cwd, apiKey, projectKey }) {
       if (!creds.GITHUB_TOKEN) creds.GITHUB_TOKEN = await promptGitHubToken(cwd);
       try {
         assertPushable({ cwd, creds: { GITHUB_TOKEN: creds.GITHUB_TOKEN }, projectName: projectKey });
-        try {
-          const env = { ...process.env, GH_TOKEN: creds.GITHUB_TOKEN };
-          const who = execSync("gh api user --jq .login", { env, stdio: ["ignore", "pipe", "ignore"], encoding: "utf-8" }).trim();
-          if (who && login && who.toLowerCase() !== login.toLowerCase()) {
-            console.log(`  ⚠  GitHub token authenticates as @${who}, not @${login} (from .agentdesk.json). Agents will post as @${who}.`);
-          } else if (who) {
-            console.log(`  ✓ GitHub verified as @${who}`);
-          }
-        } catch {
-          console.log("  ✓ GITHUB_TOKEN present (couldn't verify via gh — install gh CLI for identity check)");
+        // REST call, same as init. This used to shell out to `gh`, so a
+        // machine without the gh CLI got no identity check at all, and an
+        // invalid token was printed as "✓ present" and accepted. An
+        // unverifiable token now goes through the same retry/skip prompt as a
+        // missing one.
+        const who = await fetchGitHubLogin(creds.GITHUB_TOKEN);
+        if (!who) {
+          throw new PreflightError(
+            "GITHUB_TOKEN did not authenticate with GitHub (invalid token, or offline)",
+            { code: "INVALID_GITHUB_TOKEN" }
+          );
+        }
+        if (login && who.toLowerCase() !== login.toLowerCase()) {
+          console.log(`  ⚠  GitHub token authenticates as @${who}, not @${login} (from .agentdesk.json). Agents will post as @${who}.`);
+        } else {
+          console.log(`  ✓ GitHub verified as @${who}`);
         }
         githubOk = true;
       } catch (err) {
@@ -363,7 +346,7 @@ export async function runBootstrap(cwd = process.cwd()) {
     process.exit(1);
   }
 
-  let localConfig = readLocalConfig(cwd);
+  const localConfig = readLocalConfig(cwd);
   let projectKey = localConfig?.projectKey || null;
 
   if (!projectKey) {
@@ -383,8 +366,6 @@ export async function runBootstrap(cwd = process.cwd()) {
   // Final access-checks summary — same checklist the new-project wizard
   // prints at the end of its own flow, so both entry points finish
   // consistently.
-  const { loadDotEnv } = await import("./setup-helpers.mjs");
-  const { runAccessChecks, printAccessChecks } = await import("./setup-helpers.mjs");
   const creds = loadDotEnv(cwd);
   const results = await runAccessChecks({ apiKey, serverUrl: SERVER, cwd, config, creds });
   printAccessChecks(results, { tracker: config?.tracker });