crewswarm 0.9.5 → 1.0.0

package/lib/crew-lead/llm-caller.mjs

@@ -385,21 +385,78 @@ function _recordCrewLeadTokens(modelId, providerKey, usage) {
     fs.writeFileSync(TOKEN_USAGE_FILE, JSON.stringify(data, null, 2));
   } catch {}
   
-  // Calculate cost with cache discount - inline pricing table to avoid circular import
-  const PRICING = {
-    groq:       { input: 0.05,  output: 0.05,  cached: 0.025 },
-    anthropic:  { input: 3.00,  output: 15.00, cached: 0.30 },
-    openai:     { input: 5.00,  output: 15.00, cached: 2.50 },
-    perplexity: { input: 1.00,  output: 1.00,  cached: 1.00 },
-    mistral:    { input: 0.70,  output: 2.00,  cached: 0.70 },
-    google:     { input: 0.075, output: 0.30,  cached: 0.00 },  // FREE!
-    xai:        { input: 5.00,  output: 15.00, cached: 2.50 },
-    deepseek:   { input: 0.27,  output: 1.10,  cached: 0.135 },
-    nvidia:     { input: 1.00,  output: 1.00,  cached: 1.00 },
-    cerebras:   { input: 0.10,  output: 0.10,  cached: 0.10 },
+  // Calculate cost with cache discount — per-model pricing (matches dashboard usage-tab)
+  // Keys matched via model.includes(key); more specific keys must come first
+  const MODEL_PRICING = {
+    // xAI Grok
+    'grok-4-1-fast':    { input: 0.20,  output: 0.50 },
+    'grok-4-fast':      { input: 0.20,  output: 0.50 },
+    'grok-4':           { input: 3.00,  output: 15.00 },
+    'grok-3-mini':      { input: 0.30,  output: 0.50 },
+    'grok-3':           { input: 3.00,  output: 15.00 },
+    'grok-code-fast':   { input: 0.20,  output: 1.50 },
+    'grok-beta':        { input: 5.00,  output: 15.00 },
+    // OpenAI
+    'gpt-5.3-codex':    { input: 2.50,  output: 20.00 },
+    'gpt-5.2-codex':    { input: 1.75,  output: 14.00 },
+    'gpt-5.2':          { input: 1.75,  output: 14.00 },
+    'gpt-5.1-codex-max':{ input: 2.50,  output: 20.00 },
+    'gpt-5.1-codex-mini':{ input: 0.25, output: 2.00 },
+    'gpt-5.1-codex':    { input: 1.25,  output: 10.00 },
+    'gpt-5.1':          { input: 1.25,  output: 10.00 },
+    'gpt-5-codex':      { input: 1.25,  output: 10.00 },
+    'gpt-5-nano':       { input: 0.15,  output: 0.60 },
+    'gpt-5':            { input: 1.25,  output: 10.00 },
+    'codex-mini':       { input: 0.25,  output: 2.00 },
+    'gpt-4o-mini':      { input: 0.15,  output: 0.60 },
+    'gpt-4o':           { input: 2.50,  output: 10.00 },
+    'gpt-4':            { input: 30.0,  output: 60.00 },
+    // DeepSeek
+    'deepseek-reasoner':{ input: 0.70,  output: 2.50 },
+    'deepseek-chat':    { input: 0.27,  output: 1.10 },
+    // Mistral
+    'mistral-large':    { input: 0.50,  output: 1.50 },
+    'mistral-small':    { input: 0.10,  output: 0.30 },
+    // Google Gemini
+    'gemini-3.1-pro':   { input: 2.50,  output: 15.00 },
+    'gemini-3.1-flash': { input: 0.075, output: 0.30 },
+    'gemini-3-pro':     { input: 2.50,  output: 15.00 },
+    'gemini-3-flash':   { input: 0.075, output: 0.30 },
+    'gemini-2.5-pro':   { input: 1.25,  output: 10.00 },
+    'gemini-2.5-flash-lite': { input: 0.04, output: 0.15 },
+    'gemini-2.5-flash': { input: 0.075, output: 0.30 },
+    'gemini-2.0-flash': { input: 0.10,  output: 0.40 },
+    // Anthropic
+    'claude-opus-4':    { input: 15.0,  output: 75.00 },
+    'claude-sonnet-4':  { input: 3.00,  output: 15.00 },
+    'claude-haiku-4':   { input: 0.80,  output: 4.00 },
+    // Groq-hosted
+    'llama-3.3':        { input: 0.05,  output: 0.05 },
+    'llama-3.1':        { input: 0.05,  output: 0.05 },
+    'gemma':            { input: 0.05,  output: 0.05 },
+    // Cerebras
+    'cerebras':         { input: 0.10,  output: 0.10 },
+    // Perplexity
+    'perplexity':       { input: 1.00,  output: 1.00 },
   };
-  
-  const pricing = PRICING[providerKey] || { input: 1.0, output: 1.0, cached: 1.0 };
+  // Provider-level fallback for models not matched above
+  const PROVIDER_FALLBACK = {
+    groq:       { input: 0.05,  output: 0.05 },
+    google:     { input: 0.075, output: 0.30 },
+    xai:        { input: 0.20,  output: 0.50 },
+    deepseek:   { input: 0.27,  output: 1.10 },
+    anthropic:  { input: 3.00,  output: 15.00 },
+    openai:     { input: 1.25,  output: 10.00 },
+    mistral:    { input: 0.50,  output: 1.50 },
+    nvidia:     { input: 1.00,  output: 1.00 },
+    cerebras:   { input: 0.10,  output: 0.10 },
+    perplexity: { input: 1.00,  output: 1.00 },
+  };
+  const modelLower = modelId.toLowerCase();
+  const matchedKey = Object.keys(MODEL_PRICING).find(k => modelLower.includes(k));
+  const pricing = matchedKey
+    ? { ...MODEL_PRICING[matchedKey], cached: MODEL_PRICING[matchedKey].input * 0.5 }
+    : { ...(PROVIDER_FALLBACK[providerKey] || { input: 1.0, output: 1.0 }), cached: (PROVIDER_FALLBACK[providerKey]?.input || 1.0) * 0.5 };
   const uncachedInput = Math.max(0, p - cached);
   const inputCost  = (uncachedInput / 1_000_000) * pricing.input;
   const cachedCost = (cached / 1_000_000) * pricing.cached;

package/lib/crew-lead/prompts.mjs

@@ -244,6 +244,7 @@ export function buildSystemPrompt(cfg) {
     "",
     "ALL MARKERS: @@READ_FILE, @@WRITE_FILE...@@END_FILE, @@MKDIR, @@RUN_CMD, @@WEB_SEARCH, @@WEB_FETCH, @@SEARCH_HISTORY, @@TELEGRAM, @@WHATSAPP, @@DISPATCH, @@PIPELINE, @@PROJECT, @@PROMPT, @@TOOLS, @@GLOBALRULE, @@SERVICE, @@BRAIN, @@MEMORY, @@SKILL, @@CREATE_AGENT, @@REMOVE_AGENT, @@DEFINE_SKILL, @@DEFINE_WORKFLOW, @@STOP, @@KILL.",
     'Self-teaching: if you make a tool mistake, emit @@PROMPT {"agent":"crew-lead","append":"learned: ..."} to remember it.',
+    'CRITICAL: You CANNOT use "set" on your own prompt (crew-lead). Only "append" is allowed for yourself. "set" will be blocked to prevent accidental self-wipe.',
     "",
 
     // ═══════════════════════════════════════════════════════════════════════════
@@ -281,7 +282,7 @@ export function buildSystemPrompt(cfg) {
     "",
     "TEAM STATUS: You are the secretary. When asked about team status, answer immediately from health snapshot. Never say 'check the dashboard'.",
     "Only state status/model/runtime facts verified in this turn from snapshot or tool output.",
-    "FULL ROSTER REQUESTS: If user asks for 'all agents', 'full roster', 'whole crew' — list EVERY agent from the health snapshot. The 2000-char brevity rule does NOT apply.",
+    "FULL ROSTER REQUESTS: If user asks for 'all agents', 'full roster', 'whole crew' — list EVERY agent from the health snapshot.",
     "",
 
     // ═══════════════════════════════════════════════════════════════════════════
@@ -364,6 +365,7 @@ export function buildSystemPrompt(cfg) {
     "",
     "- Never fabricate file contents, tool results, or system health output. Emit the tag; report ACTUAL results.",
     "- Never describe what a command 'would' show. Run it.",
+    "- If the user asks you to run a command, you MUST emit @@RUN_CMD on its own line. Do NOT skip the tool and write fake output. If you think you already know the answer, run the command ANYWAY — your job is to verify, not guess.",
     "- Never fabricate dispatch history. Only quote exact @@DISPATCH lines visible in conversation. If you don't see it, say so.",
     "- Never invent URLs, gists, or 'prior search results'. Only cite what's in conversation history.",
     "- If the user says you lied or made something up, accept it. Don't double down.",
@@ -376,7 +378,7 @@ export function buildSystemPrompt(cfg) {
     // ═══════════════════════════════════════════════════════════════════════════
     "## § 9 — STYLE",
     "",
-    "- Under 2000 chars (except full roster requests). No filler.",
+    "- Be concise. No filler. Never cut yourself off mid-sentence — finish your thought.",
     "- When user throws shade, roast back. Match their energy. Sharp, sarcastic, no cap.",
     "- Every @@command you reference MUST appear as the actual @@ line in your reply. Prose descriptions execute nothing.",
   ].join("\n");

package/lib/engines/rt-envelope.mjs

@@ -1068,11 +1068,14 @@ export async function handleRealtimeEnvelope(envelope, client, bridge) {
       /and nothing else\b/i.test(prompt || "");
 
     // Append original task spec for self-verification (LangChain pattern)
-    // Skip strict-output prompts where any extra text would violate the task.
+    // Skip strict-output prompts and trivial/empty replies where the reminder adds noise.
+    const replyStripped = (reply || "").replace(/\s+/g, " ").trim();
+    const isTrivialReply = replyStripped.length < 50 || /^\(completed\)$/i.test(replyStripped);
     if (
       reply &&
       prompt &&
       !requestsExactReply &&
+      !isTrivialReply &&
       !reply.includes("[ORIGINAL TASK]")
     ) {
       const taskSpecReminder = `\n\n---\n**[ORIGINAL TASK]:**\n${prompt.slice(0, 500)}${prompt.length > 500 ? "..." : ""}\n\nDoes your implementation address ALL requirements above?`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crewswarm",
-  "version": "0.9.5",
+  "version": "1.0.0",
   "description": "Local-first multi-agent orchestration platform — coordinate AI coding agents, LLMs, and tools from a single dashboard",
   "type": "module",
   "license": "MIT",
@@ -133,10 +133,12 @@
     "release:check": "bash scripts/release-check.sh",
     "test:report": "node scripts/test-report-summary.mjs",
     "test:rerun": "node scripts/test-rerun.mjs",
-    "test:stale": "node scripts/test-rerun.mjs --stale"
+    "test:stale": "node scripts/test-rerun.mjs --stale",
+    "typecheck": "tsc -p tsconfig.json"
   },
   "devDependencies": {
     "@playwright/test": "^1.58.2",
-    "puppeteer-core": "^24.40.0"
+    "puppeteer-core": "^24.40.0",
+    "typescript": "^5.9.3"
   }
 }

package/scripts/dashboard.mjs

@@ -132,9 +132,21 @@ const OAUTH_TOKEN_TTL_MS = 25 * 60 * 1000; // 25 minutes (tokens typically expir
 // Capture execFileSync at module load for sync token refresh
 const { execFileSync: _oauthExecFileSync } = await import("node:child_process");
 
+function getKeychainAccountCandidates() {
+  const candidates = [
+    process.env.CLAUDE_CODE_ACCOUNT,
+    process.env.USER,
+    process.env.LOGNAME,
+  ];
+  try {
+    candidates.unshift(os.userInfo().username);
+  } catch { /* os user lookup can fail in restricted environments */ }
+  return [...new Set(candidates.filter(Boolean))];
+}
+
 function refreshAnthropicOAuthToken() {
   try {
-    for (const acct of [os.userInfo().username, "jeffhobbs", "unknown"]) {
+    for (const acct of getKeychainAccountCandidates()) {
       try {
         const raw = _oauthExecFileSync("security", [
           "find-generic-password", "-s", "Claude Code-credentials", "-a", acct, "-w"
@@ -152,7 +164,7 @@ function refreshAnthropicOAuthToken() {
 
 // Initial load at startup
 try {
-  for (const acct of [os.userInfo().username, "jeffhobbs", "unknown"]) {
+  for (const acct of getKeychainAccountCandidates()) {
     try {
       const raw = _oauthExecFileSync("security", [
         "find-generic-password", "-s", "Claude Code-credentials", "-a", acct, "-w"
@@ -1581,16 +1593,34 @@ const server = http.createServer(async (req, res) => {
         // by inspecting run.json test_command
         async function detectSuite(runDir) {
           try {
-            const r = JSON.parse(await fs.promises.readFile(path.join(runDir, "run.json"), "utf8"));
-            const cmd = r.test_command || "";
+            // Try run.json first
+            let cmd = "";
+            try {
+              const r = JSON.parse(await fs.promises.readFile(path.join(runDir, "run.json"), "utf8"));
+              cmd = r.test_command || "";
+            } catch {
+              // No run.json — try to infer from directory contents
+              try {
+                const ents = await fs.promises.readdir(runDir);
+                const testDirs = ents.filter(e => !e.endsWith(".json") && !e.startsWith("."));
+                // Check first test dir name for suite hint
+                const first = testDirs[0] || "";
+                if (first.includes("test-e2e-")) return "e2e";
+                if (first.includes("test-integration-")) return "integration";
+                if (first.includes("test-unit-")) return "unit";
+                if (first.includes("spec-")) return "playwright";
+              } catch {}
+              return "unknown";
+            }
+            if (cmd.includes("test:playwright") || cmd.includes("playwright test")) return "playwright";
             if (cmd.includes("test/e2e/") || cmd.includes("test:e2e")) return "e2e";
             if (cmd.includes("test/integration/")) return "integration";
             if (cmd.includes("test/unit/")) {
-              // If it has ONLY unit tests, it's a unit run; if mixed, it's "all"
               if (cmd.includes("test/integration/") || cmd.includes("test/e2e/")) return "all";
               return "unit";
             }
-            // Check file count heuristic: >100 files = probably "all"
+            if (cmd.includes("test:all")) return "all";
+            if (cmd.includes("crew-cli") || cmd.includes("--prefix crew-cli")) return "crew-cli";
             const fileCount = (cmd.match(/\.test\.mjs/g) || []).length;
             if (fileCount > 100) return "all";
             if (fileCount > 15) return "unit";
@@ -1699,7 +1729,7 @@ const server = http.createServer(async (req, res) => {
           let count = 0;
           try {
             for (const ent of await fs.promises.readdir(dir, { withFileTypes: true })) {
-              if (ent.isDirectory()) { count += countTestCallsRecursive(path.join(dir, ent.name)); continue; }
+              if (ent.isDirectory()) { count += await countTestCallsRecursive(path.join(dir, ent.name)); continue; }
               if (!ent.name.match(/\.test\./)) continue;
               const src = await fs.promises.readFile(path.join(dir, ent.name), "utf8");
               const matches = src.match(/^\s*(test|it)\s*\(/gm);
@@ -1708,13 +1738,22 @@ const server = http.createServer(async (req, res) => {
           } catch {}
           return count;
         }
+        const [unitTests, intTests, e2eTests, pwTests, cliTests1, cliTests2, rootTests] = await Promise.all([
+          countTestCalls(path.join(testFileDir, "unit"), /\.test\.mjs$/),
+          countTestCalls(path.join(testFileDir, "integration"), /\.test\.mjs$/),
+          countTestCalls(path.join(testFileDir, "e2e"), /\.test\.mjs$/),
+          countTestCalls(testsE2eDir, /\.spec\.js$/),
+          countTestCallsRecursive(crewCliTestDir),
+          countTestCallsRecursive(crewCliTestDir2),
+          countTestCalls(testFileDir, /\.test\./),
+        ]);
         const testCounts = {
-          unit: countTestCalls(path.join(testFileDir, "unit"), /\.test\.mjs$/),
-          integration: countTestCalls(path.join(testFileDir, "integration"), /\.test\.mjs$/),
-          e2e: countTestCalls(path.join(testFileDir, "e2e"), /\.test\.mjs$/),
-          playwright: countTestCalls(testsE2eDir, /\.spec\.js$/),
-          "crew-cli": countTestCallsRecursive(crewCliTestDir) + countTestCallsRecursive(crewCliTestDir2),
-          root: countTestCalls(testFileDir, /\.test\./),
+          unit: unitTests,
+          integration: intTests,
+          e2e: e2eTests,
+          playwright: pwTests,
+          "crew-cli": cliTests1 + cliTests2,
+          root: rootTests,
         };
         res.writeHead(200, { "content-type": "application/json" });
         res.end(JSON.stringify({
@@ -1745,22 +1784,38 @@ const server = http.createServer(async (req, res) => {
               const s = JSON.parse(await fs.promises.readFile(summaryFile, "utf8"));
               entry = { runId: d, timestamp: s.timestamp, status: s.status || (s.failed > 0 ? "failed" : "passed"), passed: s.passed || 0, failed: s.failed || 0, skipped: s.skipped || 0, total: s.total || 0, duration_ms: s.duration_ms || 0 };
             } else {
-              const runMeta = JSON.parse(await fs.promises.readFile(path.join(runDir, "run.json"), "utf8"));
+              let timestamp = null;
+              try { const runMeta = JSON.parse(await fs.promises.readFile(path.join(runDir, "run.json"), "utf8")); timestamp = runMeta.timestamp; } catch {}
+              if (!timestamp) { try { const stat = await fs.promises.stat(runDir); timestamp = stat.mtime.toISOString(); } catch {} }
               const ents = await fs.promises.readdir(runDir);
               const testDirs = ents.filter(e => !e.endsWith(".json") && !e.startsWith("."));
               let failed = 0;
               for (const td of testDirs) { if (await exists(path.join(runDir, td, "failure.json"))) failed++; }
-              entry = { runId: d, timestamp: runMeta.timestamp, status: failed > 0 ? "failed" : "passed", passed: testDirs.length - failed, failed, skipped: 0, total: testDirs.length, duration_ms: 0 };
+              entry = { runId: d, timestamp, status: failed > 0 ? "failed" : "passed", passed: testDirs.length - failed, failed, skipped: 0, total: testDirs.length, duration_ms: 0 };
             }
             // Detect suite from test_command
             try {
               const r = JSON.parse(await fs.promises.readFile(path.join(runDir, "run.json"), "utf8"));
               const cmd = r.test_command || "";
-              if (cmd.includes("test/e2e/")) entry.suite = "e2e";
+              if (cmd.includes("test:playwright") || cmd.includes("playwright test")) entry.suite = "playwright";
+              else if (cmd.includes("test/e2e/") || cmd.includes("test:e2e")) entry.suite = "e2e";
               else if (cmd.includes("test/integration/")) entry.suite = "integration";
+              else if (cmd.includes("test:all")) entry.suite = "all";
+              else if (cmd.includes("crew-cli") || cmd.includes("--prefix crew-cli")) entry.suite = "crew-cli";
               else if (cmd.includes("test/unit/") && !cmd.includes("test/integration/")) entry.suite = "unit";
               else { const fc = (cmd.match(/\.test\.mjs/g) || []).length; entry.suite = fc > 100 ? "all" : fc > 15 ? "unit" : "unknown"; }
-            } catch { entry.suite = "unknown"; }
+            } catch {
+              // No run.json — try to infer from directory contents
+              try {
+                const ents = await fs.promises.readdir(runDir);
+                const first = ents.find(e => !e.endsWith(".json") && !e.startsWith(".")) || "";
+                if (first.includes("test-e2e-")) entry.suite = "e2e";
+                else if (first.includes("test-integration-")) entry.suite = "integration";
+                else if (first.includes("test-unit-")) entry.suite = "unit";
+                else if (first.includes("spec-")) entry.suite = "playwright";
+                else entry.suite = "unknown";
+              } catch { entry.suite = "unknown"; }
+            }
             history.push(entry);
           } catch { /* skip */ }
         }
@@ -1846,8 +1901,42 @@ const server = http.createServer(async (req, res) => {
         const { spawn } = await import("node:child_process");
         const progressFile = path.join(CREWSWARM_DIR, "test-results", ".test-progress.json");
         const outputFile = path.join(CREWSWARM_DIR, "test-results", ".test-output.log");
+        // Count total files for this suite so progress can show X/Y
+        let files_total = 0;
+        try {
+          const testFileDir = path.join(CREWSWARM_DIR, "test");
+          const testsE2eDir = path.join(CREWSWARM_DIR, "tests", "e2e");
+          const crewCliTestDir = path.join(CREWSWARM_DIR, "crew-cli", "tests");
+          const crewCliTestDir2 = path.join(CREWSWARM_DIR, "crew-cli", "test");
+          const suiteKey = suite.replace("test:", "");
+          if (suiteKey === "unit") files_total = (await fs.promises.readdir(path.join(testFileDir, "unit"))).filter(f => f.endsWith(".test.mjs")).length;
+          else if (suiteKey === "integration") files_total = (await fs.promises.readdir(path.join(testFileDir, "integration"))).filter(f => f.endsWith(".test.mjs")).length;
+          else if (suiteKey === "e2e") files_total = (await fs.promises.readdir(path.join(testFileDir, "e2e"))).filter(f => f.endsWith(".test.mjs")).length;
+          else if (suiteKey === "playwright") files_total = (await fs.promises.readdir(testsE2eDir)).filter(f => f.endsWith(".spec.js")).length;
+          else if (suite === "test") { // crew-cli
+            const count = async (d) => { try { return (await fs.promises.readdir(d)).filter(f => f.match(/\.test\./)).length; } catch { return 0; } };
+            files_total = await count(path.join(crewCliTestDir, "unit")) + await count(crewCliTestDir) + await count(crewCliTestDir2);
+          } else if (suiteKey === "all") {
+            // Sum all suites
+            const count = async (d, p) => { try { return (await fs.promises.readdir(d)).filter(f => f.match(p)).length; } catch { return 0; } };
+            const countR = async (d) => { try { return (await fs.promises.readdir(d)).filter(f => f.match(/\.test\./)).length; } catch { return 0; } };
+            files_total = await count(path.join(testFileDir, "unit"), /\.test\.mjs$/)
+              + await count(path.join(testFileDir, "integration"), /\.test\.mjs$/)
+              + await count(path.join(testFileDir, "e2e"), /\.test\.mjs$/)
+              + await count(testsE2eDir, /\.spec\.js$/)
+              + await countR(path.join(crewCliTestDir, "unit")) + await countR(crewCliTestDir) + await countR(crewCliTestDir2);
+          }
+        } catch {}
         // Write initial progress
-        await fs.promises.writeFile(progressFile, JSON.stringify({ suite, running: true, pid: 0, started: Date.now(), passed: 0, failed: 0, skipped: 0, files_done: 0, current_file: singleFile || "" }));
+        await fs.promises.writeFile(progressFile, JSON.stringify({ suite, running: true, pid: 0, started: Date.now(), passed: 0, failed: 0, skipped: 0, files_done: 0, files_total, current_file: singleFile || "" }));
+        // Clean up any stale progress from a previous interrupted run
+        const staleProgress = path.join(CREWSWARM_DIR, "test-results", ".test-progress.json");
+        try {
+          const prev = JSON.parse(fs.readFileSync(staleProgress, "utf8"));
+          if (prev.running && prev.pid) {
+            try { process.kill(prev.pid, 0); process.kill(prev.pid, "SIGTERM"); } catch { /* already dead */ }
+          }
+        } catch { /* no stale progress */ }
         let child;
         const outFd = fs.openSync(outputFile, "w");
         if (singleFile) {
@@ -1874,7 +1963,8 @@ const server = http.createServer(async (req, res) => {
                 current_file = line.trim();
               }
             }
-            fs.writeFileSync(progressFile, JSON.stringify({ suite, running: true, pid: child.pid, started: JSON.parse(fs.readFileSync(progressFile, "utf8")).started, passed, failed, skipped, files_done, current_file }));
+            const prev = JSON.parse(fs.readFileSync(progressFile, "utf8"));
+            fs.writeFileSync(progressFile, JSON.stringify({ suite, running: true, pid: child.pid, started: prev.started, passed, failed, skipped, files_done, files_total: prev.files_total || 0, current_file }));
           } catch { /* file may not exist yet */ }
         }, 2000);
         child.on("exit", (code) => {
@@ -1897,6 +1987,30 @@ const server = http.createServer(async (req, res) => {
       });
       return;
     }
+    if (url.pathname === "/api/tests/stop" && req.method === "POST") {
+      const progressFile = path.join(CREWSWARM_DIR, "test-results", ".test-progress.json");
+      try {
+        const data = JSON.parse(await fs.promises.readFile(progressFile, "utf8"));
+        if (data.running && data.pid) {
+          try { process.kill(data.pid, "SIGTERM"); } catch { /* already dead */ }
+          // Also kill child processes (node --test spawns sub-processes)
+          try { process.kill(-data.pid, "SIGTERM"); } catch { /* no process group */ }
+          data.running = false;
+          data.stopped = true;
+          data.finished = Date.now();
+          await fs.promises.writeFile(progressFile, JSON.stringify(data));
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify({ stopped: true, pid: data.pid }));
+        } else {
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify({ stopped: false, reason: "no running test" }));
+        }
+      } catch {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ stopped: false, reason: "no progress file" }));
+      }
+      return;
+    }
     if (url.pathname === "/api/tests/progress" && req.method === "GET") {
       const progressFile = path.join(CREWSWARM_DIR, "test-results", ".test-progress.json");
       try {
@@ -4696,8 +4810,7 @@ const server = http.createServer(async (req, res) => {
       if (!providers["anthropic-oauth"]) {
         try {
           const { execFileSync } = await import("node:child_process");
-          const { userInfo } = await import("node:os");
-          for (const acct of [userInfo().username, "jeffhobbs", "unknown"]) {
+          for (const acct of getKeychainAccountCandidates()) {
             try {
               const raw = execFileSync("security", [
                 "find-generic-password", "-s", "Claude Code-credentials", "-a", acct, "-w"
@@ -4732,8 +4845,7 @@ const server = http.createServer(async (req, res) => {
         if (!token) {
           if (providerId === "anthropic-oauth") {
             const { execFileSync } = await import("node:child_process");
-            const { userInfo } = await import("node:os");
-            for (const acct of [userInfo().username, "jeffhobbs", "unknown"]) {
+            for (const acct of getKeychainAccountCandidates()) {
               try {
                 const raw = execFileSync("security", [
                   "find-generic-password", "-s", "Claude Code-credentials", "-a", acct, "-w"
@@ -4862,8 +4974,7 @@ const server = http.createServer(async (req, res) => {
         let token = getOAuthTokenCached(providerId);
         if (!token && providerId === "anthropic-oauth") {
           const { execFileSync } = await import("node:child_process");
-          const { userInfo } = await import("node:os");
-          for (const acct of [userInfo().username, "jeffhobbs", "unknown"]) {
+          for (const acct of getKeychainAccountCandidates()) {
             try {
               const raw = execFileSync("security", [
                 "find-generic-password", "-s", "Claude Code-credentials", "-a", acct, "-w"
@@ -7822,6 +7933,86 @@ ORDER BY day DESC, cost DESC;`;
       }
       return;
     }
+    // ── crew-cli cost stats ──────────────────────────────────────────────────
+    if (url.pathname === "/api/crew-cli-stats" && req.method === "GET") {
+      const days = Number(url.searchParams.get("days") || "14");
+      const cutoff = new Date(Date.now() - days * 86400000).toISOString().slice(0, 10);
+      try {
+        // Scan known project directories for .crew/cost.json files
+        const searchDirs = new Set();
+        // 1. opencodeProject from config
+        try {
+          const cfg = JSON.parse(fs.readFileSync(path.join(os.homedir(), ".crewswarm", "crewswarm.json"), "utf8"));
+          if (cfg.opencodeProject) searchDirs.add(cfg.opencodeProject.replace(/\/+$/, ""));
+        } catch {}
+        // 2. Registered projects
+        try {
+          const projFile = path.join(os.homedir(), ".crewswarm", "projects.json");
+          const projs = JSON.parse(fs.readFileSync(projFile, "utf8"));
+          for (const p of (projs.projects || projs || [])) {
+            if (p.outputDir) searchDirs.add(p.outputDir.replace(/\/+$/, ""));
+          }
+        } catch {}
+        // 3. Home .crew dir
+        searchDirs.add(os.homedir());
+
+        const allEntries = [];
+        for (const dir of searchDirs) {
+          const costFile = path.join(dir, ".crew", "cost.json");
+          try {
+            const raw = JSON.parse(fs.readFileSync(costFile, "utf8"));
+            for (const entry of (raw.entries || [])) {
+              if (!entry.timestamp) continue;
+              const day = entry.timestamp.slice(0, 10);
+              if (day >= cutoff) {
+                allEntries.push({ ...entry, day, project: dir });
+              }
+            }
+          } catch {}
+        }
+
+        // Roll up by day
+        const byDay = {};
+        let totalCost = 0;
+        let totalCalls = 0;
+        let totalPromptTokens = 0;
+        let totalCompletionTokens = 0;
+        for (const e of allEntries) {
+          if (!byDay[e.day]) byDay[e.day] = { cost: 0, calls: 0, prompt_tokens: 0, completion_tokens: 0, byModel: {} };
+          const d = byDay[e.day];
+          const usd = Number(e.usd || 0);
+          d.cost += usd;
+          d.calls += 1;
+          d.prompt_tokens += Number(e.promptTokens || 0);
+          d.completion_tokens += Number(e.completionTokens || 0);
+          const model = e.model || "unknown";
+          if (!d.byModel[model]) d.byModel[model] = { cost: 0, calls: 0, prompt_tokens: 0, completion_tokens: 0 };
+          d.byModel[model].cost += usd;
+          d.byModel[model].calls += 1;
+          d.byModel[model].prompt_tokens += Number(e.promptTokens || 0);
+          d.byModel[model].completion_tokens += Number(e.completionTokens || 0);
+          totalCost += usd;
+          totalCalls += 1;
+          totalPromptTokens += Number(e.promptTokens || 0);
+          totalCompletionTokens += Number(e.completionTokens || 0);
+        }
+
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({
+          ok: true,
+          totalCost,
+          totalCalls,
+          totalPromptTokens,
+          totalCompletionTokens,
+          projects: [...searchDirs],
+          byDay,
+        }));
+      } catch (e) {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: e.message, byDay: {} }));
+      }
+      return;
+    }
     // ── OpenCode models API ──────────────────────────────────────────────────
     if (url.pathname === "/api/opencode-models" && req.method === "GET") {
       let models = [];