panopticon-cli 0.4.33 → 0.5.0

package/dist/{chunk-ASY7T35E.js → chunk-AAFQANKW.js}

@@ -1,25 +1,29 @@
 import {
+  capturePaneAsync,
   checkHook,
+  confirmDelivery,
   getModelId,
   init_hooks,
   init_tmux,
   init_work_type_router,
   popFromHook,
   pushToHook,
-  sendKeysAsync
-} from "./chunk-KJ2TRXNK.js";
+  sendKeysAsync,
+  waitForClaudePrompt
+} from "./chunk-FTCPTHIJ.js";
 import {
   init_pipeline_notifier,
   notifyPipeline
 } from "./chunk-JQBV3Q2W.js";
 import {
+  clearCredentialFileAuth,
   getProviderEnv,
   getProviderForModel,
   init_providers,
   init_settings,
   loadSettings,
   setupCredentialFileAuth
-} from "./chunk-7XNJJBH6.js";
+} from "./chunk-HJSM6E6U.js";
 import {
   init_projects,
   projects_exports
@@ -393,6 +397,40 @@ import { homedir as homedir2 } from "os";
 import { exec } from "child_process";
 import { promisify } from "util";
 import { randomUUID } from "crypto";
+async function resolveWorkspaceGitInfo(workspace, taskBranch) {
+  const gitDirs = [];
+  let branch = taskBranch || "unknown";
+  if (!workspace || workspace === "unknown") {
+    return { gitDirs, branch, isPolyrepo: false };
+  }
+  if (existsSync3(join4(workspace, ".git"))) {
+    gitDirs.push(workspace);
+  } else {
+    try {
+      const entries = readdirSync2(workspace, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && existsSync3(join4(workspace, entry.name, ".git"))) {
+          gitDirs.push(join4(workspace, entry.name));
+        }
+      }
+    } catch {
+    }
+  }
+  if (branch === "unknown" && gitDirs.length > 0) {
+    try {
+      const { stdout } = await execAsync(
+        `cd "${gitDirs[0]}" && git branch --show-current`,
+        { encoding: "utf-8", timeout: 5e3 }
+      );
+      const detected = stdout.trim();
+      if (detected) {
+        branch = detected;
+      }
+    } catch {
+    }
+  }
+  return { gitDirs, branch, isPolyrepo: gitDirs.length > 1 };
+}
 function getProviderEnvForModel(model) {
   const provider = getProviderForModel(model);
   if (provider.name === "anthropic") return {};
@@ -584,9 +622,9 @@ function recordWake(name, sessionId) {
 }
 async function spawnEphemeralSpecialist(projectKey, specialistType, task) {
   ensureProjectSpecialistDir(projectKey, specialistType);
-  const { loadContextDigest } = await import("./specialist-context-T3NBMCIE.js");
+  const { loadContextDigest } = await import("./specialist-context-ZC6A4M3I.js");
   const contextDigest = loadContextDigest(projectKey, specialistType);
-  const { createRunLog: createRunLog2 } = await import("./specialist-logs-CVKD3YJ3.js");
+  const { createRunLog: createRunLog2 } = await import("./specialist-logs-KLGJCEUL.js");
   const { runId, filePath: logFilePath } = createRunLog2(
     projectKey,
     specialistType,
@@ -611,6 +649,8 @@ async function spawnEphemeralSpecialist(projectKey, specialistType, task) {
     const providerConfig = getProviderForModel(model);
     if (providerConfig.authType === "credential-file") {
       setupCredentialFileAuth(providerConfig, cwd);
+    } else {
+      clearCredentialFileAuth(cwd);
     }
     const permissionFlags = specialistType === "merge-agent" ? "--dangerously-skip-permissions --permission-mode bypassPermissions" : "--dangerously-skip-permissions";
     const agentDir = join4(homedir2(), ".panopticon", "agents", tmuxSession);
@@ -633,7 +673,7 @@ echo "## Specialist completed task"
       `tmux new-session -d -s "${tmuxSession}"${envFlags} "bash '${launcherScript}'"`,
       { encoding: "utf-8" }
     );
-    const { saveAgentRuntimeState } = await import("./agents-VLK4BMVA.js");
+    const { saveAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
     saveAgentRuntimeState(tmuxSession, {
       state: "active",
       lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
@@ -718,14 +758,23 @@ Update status via API:
 - If tests pass: POST to /api/workspaces/${task.issueId}/review-status with {"testStatus":"passed"}
 - If tests fail: POST with {"testStatus":"failed","testNotes":"..."}`;
       break;
-    case "merge-agent":
+    case "merge-agent": {
+      const bInfo = await resolveWorkspaceGitInfo(task.workspace, task.branch);
+      if (bInfo.isPolyrepo) {
+        prompt += `This is a POLYREPO project with ${bInfo.gitDirs.length} repos: ${bInfo.gitDirs.map((d) => basename2(d)).join(", ")}.
+You must merge each repo separately.
+
+`;
+      }
       prompt += `Your task:
 1. Fetch the latest main branch
-2. Attempt to merge ${task.branch} into main
+2. Attempt to merge ${bInfo.branch} into main
 3. Resolve conflicts intelligently if needed
 4. Run tests to verify merge is clean
-5. Complete merge if tests pass`;
+5. Complete merge if tests pass
+6. NEVER use git push --force`;
       break;
+    }
   }
   prompt += `
 
@@ -818,7 +867,7 @@ async function terminateSpecialist(projectKey, specialistType) {
     console.error(`[specialist] Failed to kill tmux session ${tmuxSession}:`, error);
   }
   if (metadata.currentRun) {
-    const { finalizeRunLog: finalizeRunLog2 } = await import("./specialist-logs-CVKD3YJ3.js");
+    const { finalizeRunLog: finalizeRunLog2 } = await import("./specialist-logs-KLGJCEUL.js");
     try {
       finalizeRunLog2(projectKey, specialistType, metadata.currentRun, {
         status: metadata.lastRunStatus || "incomplete",
@@ -831,19 +880,19 @@ async function terminateSpecialist(projectKey, specialistType) {
   }
   const key = `${projectKey}-${specialistType}`;
   gracePeriodStates.delete(key);
-  const { saveAgentRuntimeState } = await import("./agents-VLK4BMVA.js");
+  const { saveAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
   saveAgentRuntimeState(tmuxSession, {
     state: "suspended",
     lastActivity: (/* @__PURE__ */ new Date()).toISOString()
   });
-  const { scheduleDigestGeneration } = await import("./specialist-context-T3NBMCIE.js");
+  const { scheduleDigestGeneration } = await import("./specialist-context-ZC6A4M3I.js");
   scheduleDigestGeneration(projectKey, specialistType);
   scheduleLogCleanup(projectKey, specialistType);
 }
 function scheduleLogCleanup(projectKey, specialistType) {
   Promise.resolve().then(async () => {
     try {
-      const { cleanupOldLogs: cleanupOldLogs2 } = await import("./specialist-logs-CVKD3YJ3.js");
+      const { cleanupOldLogs: cleanupOldLogs2 } = await import("./specialist-logs-KLGJCEUL.js");
       const { getSpecialistRetention } = await import("./projects-JEIVIYC6.js");
       const retention = getSpecialistRetention(projectKey);
       const deleted = cleanupOldLogs2(projectKey, specialistType, { maxDays: retention.max_days, maxRuns: retention.max_runs });
@@ -1022,7 +1071,7 @@ async function getSpecialistStatus(name, projectKey) {
   const sessionId = getSessionId(name);
   const running = await isRunning(name, projectKey);
   const contextTokens = countContextTokens(name);
-  const { getAgentRuntimeState } = await import("./agents-VLK4BMVA.js");
+  const { getAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
   const tmuxSession = getTmuxSessionName(name, projectKey);
   const runtimeState = getAgentRuntimeState(tmuxSession);
   let state;
@@ -1100,6 +1149,8 @@ Say: "I am the ${name} specialist, ready and waiting for tasks."`;
     const providerCfg = getProviderForModel(model);
     if (providerCfg.authType === "credential-file") {
       setupCredentialFileAuth(providerCfg, cwd);
+    } else {
+      clearCredentialFileAuth(cwd);
     }
     const agentDir = join4(homedir2(), ".panopticon", "agents", tmuxSession);
     await execAsync(`mkdir -p "${agentDir}"`, { encoding: "utf-8" });
@@ -1162,9 +1213,7 @@ async function resetSpecialist(name) {
   const tmuxSession = getTmuxSessionName(name);
   try {
     await execAsync(`tmux send-keys -t "${tmuxSession}" C-c`, { encoding: "utf-8" });
-    await new Promise((resolve) => setTimeout(resolve, 200));
-    await sendKeysAsync(tmuxSession, "cd ~");
-    await new Promise((resolve) => setTimeout(resolve, 200));
+    await new Promise((resolve) => setTimeout(resolve, 500));
     await execAsync(`tmux send-keys -t "${tmuxSession}" C-u`, { encoding: "utf-8" });
     await new Promise((resolve) => setTimeout(resolve, 100));
   } catch (error) {
@@ -1200,6 +1249,8 @@ async function wakeSpecialist(name, taskPrompt, options = {}) {
       const provCfg = getProviderForModel(model);
       if (provCfg.authType === "credential-file") {
         setupCredentialFileAuth(provCfg, cwd);
+      } else {
+        clearCredentialFileAuth(cwd);
       }
       const permissionFlags = name === "merge-agent" ? "--dangerously-skip-permissions --permission-mode bypassPermissions" : "--dangerously-skip-permissions";
       let claudeCmd;
@@ -1215,7 +1266,10 @@ async function wakeSpecialist(name, taskPrompt, options = {}) {
         { encoding: "utf-8" }
       );
       if (waitForReady) {
-        await new Promise((resolve) => setTimeout(resolve, 3e3));
+        const ready = await waitForClaudePrompt(tmuxSession, 15e3);
+        if (!ready) {
+          console.warn(`[specialist] ${name}: prompt not detected within 15s, proceeding anyway`);
+        }
       }
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
@@ -1228,21 +1282,43 @@ async function wakeSpecialist(name, taskPrompt, options = {}) {
     }
   }
   await resetSpecialist(name);
+  const promptReady = await waitForClaudePrompt(tmuxSession, wasAlreadyRunning ? 5e3 : 15e3);
+  if (!promptReady) {
+    console.warn(`[specialist] ${name}: prompt not detected after reset, proceeding anyway`);
+  }
   try {
     const isLargePrompt = taskPrompt.length > 500 || taskPrompt.includes("\n");
+    let messageToSend;
     if (isLargePrompt) {
       if (!existsSync3(TASKS_DIR)) {
         mkdirSync2(TASKS_DIR, { recursive: true });
       }
       const taskFile = join4(TASKS_DIR, `${name}-${Date.now()}.md`);
       writeFileSync(taskFile, taskPrompt, "utf-8");
-      const shortMessage = `Read and execute the task in: ${taskFile}`;
-      await sendKeysAsync(tmuxSession, shortMessage);
+      messageToSend = `Read and execute the task in: ${taskFile}`;
     } else {
-      await sendKeysAsync(tmuxSession, taskPrompt);
+      messageToSend = taskPrompt;
+    }
+    const outputBefore = await capturePaneAsync(tmuxSession, 50);
+    await sendKeysAsync(tmuxSession, messageToSend);
+    const delivered = await confirmDelivery(tmuxSession, outputBefore, 1e4);
+    if (!delivered) {
+      console.warn(`[specialist] ${name}: no activity detected after task send, retrying...`);
+      const retryBefore = await capturePaneAsync(tmuxSession, 50);
+      await sendKeysAsync(tmuxSession, messageToSend);
+      const retryDelivered = await confirmDelivery(tmuxSession, retryBefore, 1e4);
+      if (!retryDelivered) {
+        return {
+          success: false,
+          message: `Task message not received by specialist ${name} after retry`,
+          tmuxSession,
+          wasAlreadyRunning,
+          error: "delivery_failed"
+        };
+      }
     }
     recordWake(name, sessionId || void 0);
-    const { saveAgentRuntimeState } = await import("./agents-VLK4BMVA.js");
+    const { saveAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
     saveAgentRuntimeState(tmuxSession, {
       state: "active",
       lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1270,46 +1346,65 @@ async function wakeSpecialistWithTask(name, task) {
   const apiUrl = process.env.DASHBOARD_URL || `http://localhost:${apiPort}`;
   let prompt;
   switch (name) {
-    case "merge-agent":
+    case "merge-agent": {
+      const mergeWorkspace = task.workspace || "unknown";
+      const mergeInfo = await resolveWorkspaceGitInfo(task.workspace, task.branch);
+      const mergeBranch = mergeInfo.branch;
+      const mergeRepoInstructions = mergeInfo.isPolyrepo ? `
+IMPORTANT: This is a POLYREPO project. There are ${mergeInfo.gitDirs.length} separate git repositories to merge:
+${mergeInfo.gitDirs.map((d, i) => `${i + 1}. ${basename2(d)}: ${d}`).join("\n")}
+
+The workspace root is NOT a git repo. You must cd into each subdirectory to run git commands.
+You MUST complete the merge for ALL repos.
+` : "";
       prompt = `New merge task for ${task.issueId}:
 
-Branch: ${task.branch || "unknown"}
-Workspace: ${task.workspace || "unknown"}
+Branch: ${mergeBranch}
+Workspace: ${mergeWorkspace}
+${mergeInfo.isPolyrepo ? `Polyrepo: git repos in subdirectories: ${mergeInfo.gitDirs.map((d) => basename2(d)).join(", ")}` : ""}
 ${task.prUrl ? `PR URL: ${task.prUrl}` : ""}
-
-Your task:
-1. Fetch the latest main branch
-2. Attempt to merge ${task.branch} into main
-3. If conflicts arise, resolve them intelligently based on context
-4. Run the test suite to verify the merge is clean
-5. If tests pass, complete the merge and push
-6. If tests fail, analyze the failures and either fix them or report back
-
-When done, provide feedback on:
-- Any conflicts encountered and how you resolved them
-- Test results
-- Any patterns you notice that future agents should be aware of
-
-Use the send-feedback-to-agent skill to report findings back to the issue agent.`;
+${mergeRepoInstructions}
+For ${mergeInfo.isPolyrepo ? "EACH repo" : "the repo"}, perform these steps:
+
+PHASE 1 \u2014 SYNC & BASELINE (before merge):
+1. ${mergeInfo.isPolyrepo ? "cd into the repo directory" : `cd ${mergeWorkspace}`}
+2. git checkout main
+3. git fetch origin main
+4. Sync local main with origin/main:
+   Run: git rev-list --left-right --count main...origin/main
+   If REMOTE_AHEAD > 0: git rebase origin/main
+   If rebase conflicts: abort and report failure.
+5. Run tests on main to establish a baseline. Record BASELINE_PASS and BASELINE_FAIL.
+
+PHASE 2 \u2014 MERGE:
+6. git merge ${mergeBranch} --no-edit
+7. If conflicts: resolve them intelligently, then git add and git commit
+8. If clean merge: the merge commit is auto-created (or fast-forward)
+
+PHASE 3 \u2014 VERIFY:
+9. Run tests again. Record MERGE_PASS and MERGE_FAIL.
+
+PHASE 4 \u2014 DECIDE:
+10. Compare results:
+    - If MERGE_FAIL > BASELINE_FAIL (NEW test failures): ROLLBACK with git reset --hard ORIG_HEAD
+    - If MERGE_FAIL <= BASELINE_FAIL (no new failures): PUSH with git push origin main
+    - Pre-existing failures on main are NOT a reason to rollback
+
+PHASE 5 \u2014 REPORT:
+11. Call the Panopticon API to report results:
+    curl -s -X POST ${apiUrl}/api/specialists/done \\
+      -H "Content-Type: application/json" \\
+      -d '{"specialist":"merge","issueId":"${task.issueId}","status":"passed|failed","notes":"<summary>"}'
+
+CRITICAL: You MUST call the /api/specialists/done endpoint whether you succeed or fail.
+CRITICAL: NEVER use git push --force.
+CRITICAL: Do NOT delete the feature branch.`;
       break;
+    }
     case "review-agent": {
       const workspace = task.workspace || "unknown";
-      let gitDirs = [];
-      if (workspace !== "unknown") {
-        if (existsSync3(join4(workspace, ".git"))) {
-          gitDirs = [workspace];
-        } else {
-          try {
-            const entries = readdirSync2(workspace, { withFileTypes: true });
-            for (const entry of entries) {
-              if (entry.isDirectory() && existsSync3(join4(workspace, entry.name, ".git"))) {
-                gitDirs.push(join4(workspace, entry.name));
-              }
-            }
-          } catch {
-          }
-        }
-      }
+      const reviewGitInfo = await resolveWorkspaceGitInfo(task.workspace, task.branch);
+      const gitDirs = reviewGitInfo.gitDirs;
       const gitDir = gitDirs[0] || workspace;
       let staleBranch = false;
       if (workspace !== "unknown" && gitDirs.length > 0) {
@@ -1332,7 +1427,7 @@ Use the send-feedback-to-agent skill to report findings back to the issue agent.
             });
             console.log(`[specialist] review-agent: auto-passed ${task.issueId} (stale branch)`);
             const tmuxSession = getTmuxSessionName("review-agent");
-            const { saveAgentRuntimeState } = await import("./agents-VLK4BMVA.js");
+            const { saveAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
             saveAgentRuntimeState(tmuxSession, {
               state: "idle",
               lastActivity: (/* @__PURE__ */ new Date()).toISOString()
@@ -1433,14 +1528,62 @@ curl -s -X POST ${apiUrl}/api/specialists/test-agent/queue -H "Content-Type: app
 \u26A0\uFE0F VERIFICATION: After running each curl, confirm you see valid JSON output. If you get an error, report it.`;
       break;
     }
-    case "test-agent":
+    case "test-agent": {
+      const testWorkspace = task.workspace || "unknown";
+      const testGitInfo = await resolveWorkspaceGitInfo(task.workspace, task.branch);
+      const testIsPolyrepo = testGitInfo.isPolyrepo;
+      const { extractTeamPrefix, findProjectByTeam } = await import("./projects-JEIVIYC6.js");
+      const testTeamPrefix = extractTeamPrefix(task.issueId);
+      const testProjectConfig = testTeamPrefix ? findProjectByTeam(testTeamPrefix) : null;
+      const testConfigs = testProjectConfig?.tests;
+      let testCommands = "";
+      let baselineCommands = "";
+      const featureName = task.issueId.toLowerCase();
+      const mainWorkspacePath = testWorkspace.replace(/workspaces\/feature-[^/]+/, "workspaces/main");
+      const projectRootPath = testProjectConfig?.path || testWorkspace.replace(/\/workspaces\/.*/, "");
+      if (testConfigs && Object.keys(testConfigs).length > 0) {
+        const testEntries = Object.entries(testConfigs);
+        const testSuites = [];
+        const baselineSuites = [];
+        for (const [name2, cfg] of testEntries) {
+          const testDir = testIsPolyrepo ? `${testWorkspace}/${cfg.path}` : cfg.path === "." ? testWorkspace : `${testWorkspace}/${cfg.path}`;
+          const baseDir = testIsPolyrepo ? `${mainWorkspacePath}/${cfg.path}` : cfg.path === "." ? mainWorkspacePath : `${mainWorkspacePath}/${cfg.path}`;
+          const fallbackDir = cfg.path === "." ? projectRootPath : `${projectRootPath}/${cfg.path}`;
+          testSuites.push(`echo "\\n=== Test suite: ${name2} (${cfg.type}) ===" && cd "${testDir}" && ${cfg.command} 2>&1; echo "EXIT_CODE_${name2}: $?"`);
+          baselineSuites.push(`echo "\\n=== Baseline: ${name2} (${cfg.type}) ===" && cd "${baseDir}" 2>/dev/null && ${cfg.command} 2>&1 || (cd "${fallbackDir}" 2>/dev/null && ${cfg.command} 2>&1) || echo "BASELINE_SKIP_${name2}: could not run baseline"; echo "EXIT_CODE_${name2}: $?"`);
+        }
+        testCommands = testSuites.map((cmd, i) => `# Suite ${i + 1}
+${cmd}`).join("\n");
+        baselineCommands = baselineSuites.map((cmd, i) => `# Suite ${i + 1}
+${cmd}`).join("\n");
+      } else if (testIsPolyrepo) {
+        const testSuites = [];
+        const baselineSuites = [];
+        for (const gitDir of testGitInfo.gitDirs) {
+          const repoName = basename2(gitDir);
+          testSuites.push(`echo "\\n=== ${repoName} ===" && cd "${gitDir}" && if [ -f pom.xml ]; then ./mvnw test 2>&1; elif [ -f package.json ]; then npm test 2>&1; else echo "No test runner found"; fi; echo "EXIT_CODE_${repoName}: $?"`);
+          const baseDir = `${mainWorkspacePath}/${repoName}`;
+          baselineSuites.push(`echo "\\n=== Baseline: ${repoName} ===" && cd "${baseDir}" 2>/dev/null && if [ -f pom.xml ]; then ./mvnw test 2>&1; elif [ -f package.json ]; then npm test 2>&1; else echo "No test runner found"; fi; echo "EXIT_CODE_${repoName}: $?"`);
+        }
+        testCommands = testSuites.join("\n");
+        baselineCommands = baselineSuites.join("\n");
+      } else {
+        testCommands = `cd "${testWorkspace}" && npm test 2>&1; echo "EXIT_CODE: $?"`;
+        baselineCommands = `cd "${mainWorkspacePath}" 2>/dev/null && npm test 2>&1 || (cd "${projectRootPath}" && npm test 2>&1); echo "EXIT_CODE: $?"`;
+      }
+      const testConfigSummary = testConfigs ? Object.entries(testConfigs).map(([name2, cfg]) => `- **${name2}** (${cfg.type}): \`${cfg.command}\` in \`${cfg.path}/\``).join("\n") : testIsPolyrepo ? testGitInfo.gitDirs.map((d) => `- **${basename2(d)}**: auto-detected`).join("\n") : "- Single test suite at workspace root";
       prompt = `New test task for ${task.issueId}:
 
 Branch: ${task.branch || "unknown"}
-Workspace: ${task.workspace || "unknown"}
+Workspace: ${testWorkspace}
+${testIsPolyrepo ? `Polyrepo: git repos in subdirectories: ${testGitInfo.gitDirs.map((d) => basename2(d)).join(", ")}` : ""}
+
+## Test Suites
+
+${testConfigSummary}
 
 Your task:
-1. Run the full test suite \u2014 redirect output to file, read only summaries
+1. Run ALL test suites \u2014 redirect output to file, read only summaries
 2. If ALL pass, skip baseline and report PASS
 3. If failures, run baseline on main and compare
 4. Only fail for NEW regressions (not pre-existing)
@@ -1454,32 +1597,43 @@ Raw test output from large suites (1000+ tests) WILL fill your context and cause
 ## CRITICAL: Bash Timeout for Test Commands
 
 **ALWAYS use timeout: 300000 (5 minutes) when running test commands.**
+For Maven/Spring Boot tests, use timeout: 600000 (10 minutes) \u2014 they take longer.
 
 ## Step 1: Run Feature Branch Tests
 
+${testIsPolyrepo || testConfigs && Object.keys(testConfigs).length > 1 ? `**Run ALL test suites** \u2014 each suite is a separate repo/runner. Redirect ALL output to one file.` : ""}
+
 \`\`\`bash
-cd ${task.workspace || "unknown"} && npm test 2>&1 > /tmp/test-feature.txt; echo "EXIT_CODE: $?"
-# Use timeout: 300000 for this command
-tail -20 /tmp/test-feature.txt
+(
+${testCommands}
+) > /tmp/test-feature.txt 2>&1
+# Use timeout: ${testConfigs && Object.values(testConfigs).some((c) => c.type === "maven") ? "600000" : "300000"} for this command
+echo "--- Feature test output tail ---"
+tail -40 /tmp/test-feature.txt
+grep "EXIT_CODE" /tmp/test-feature.txt
 \`\`\`
 
 ## Step 2: Check Results
 
-- If ALL tests pass (exit code 0) \u2192 skip baseline, go to "Update Status"
-- If failures exist \u2192 continue to Step 3
+- If ALL exit codes are 0 \u2192 skip baseline, go to "Update Status"
+- If any failures \u2192 continue to Step 3
 
 ## Step 3: Baseline Comparison (ONLY if failures found)
 
 \`\`\`bash
-cd ${task.context?.workspace ? task.context.workspace.replace(/workspaces\/feature-[^/]+/, "") : "unknown"} && npm test 2>&1 > /tmp/test-main.txt; echo "EXIT_CODE: $?"
-# Use timeout: 300000 for this command
-tail -20 /tmp/test-main.txt
+(
+${baselineCommands}
+) > /tmp/test-main.txt 2>&1
+# Use timeout: ${testConfigs && Object.values(testConfigs).some((c) => c.type === "maven") ? "600000" : "300000"} for this command
+echo "--- Baseline test output tail ---"
+tail -40 /tmp/test-main.txt
+grep "EXIT_CODE" /tmp/test-main.txt
 \`\`\`
 
 Then compare failures (targeted, NOT full output):
 \`\`\`bash
-grep -E "FAIL|\u2717|Error|failed" /tmp/test-feature.txt | head -30
-grep -E "FAIL|\u2717|Error|failed" /tmp/test-main.txt | head -30
+grep -E "FAIL|\u2717|Error|failed|BUILD FAILURE" /tmp/test-feature.txt | head -30
+grep -E "FAIL|\u2717|Error|failed|BUILD FAILURE" /tmp/test-main.txt | head -30
 \`\`\`
 
 Tests that fail on BOTH = pre-existing (don't block). Tests that fail ONLY on feature = NEW regression (block).
@@ -1493,12 +1647,12 @@ You MUST execute the appropriate curl command and verify it succeeds. Do NOT jus
 
 If NO new regressions (tests PASS):
 \`\`\`bash
-curl -s -X POST ${apiUrl}/api/workspaces/${task.issueId}/review-status -H "Content-Type: application/json" -d '{"testStatus":"passed","testNotes":"[summary including pre-existing failures if any]"}' | jq .
+curl -s -X POST ${apiUrl}/api/workspaces/${task.issueId}/review-status -H "Content-Type: application/json" -d '{"testStatus":"passed","testNotes":"[summary including pre-existing failures if any, and which suites were tested]"}' | jq .
 \`\`\`
 
 If NEW regressions found (tests FAIL):
 \`\`\`bash
-curl -s -X POST ${apiUrl}/api/workspaces/${task.issueId}/review-status -H "Content-Type: application/json" -d '{"testStatus":"failed","testNotes":"[describe NEW failures only]"}' | jq .
+curl -s -X POST ${apiUrl}/api/workspaces/${task.issueId}/review-status -H "Content-Type: application/json" -d '{"testStatus":"failed","testNotes":"[describe NEW failures only \u2014 specify which suite/repo]"}' | jq .
 \`\`\`
 Then use send-feedback-to-agent skill to notify issue agent of NEW failures only.
 
@@ -1508,6 +1662,7 @@ Then use send-feedback-to-agent skill to notify issue agent of NEW failures only
 
 IMPORTANT: Do NOT hand off to merge-agent. Human clicks Merge button when ready.`;
       break;
+    }
     default:
       prompt = `Task for ${task.issueId}: Please process this task and report findings.`;
   }
@@ -1516,7 +1671,7 @@ IMPORTANT: Do NOT hand off to merge-agent. Human clicks Merge button when ready.
 async function wakeSpecialistOrQueue(name, task, options = {}) {
   const { priority = "normal", source = "handoff" } = options;
   const running = await isRunning(name);
-  const { getAgentRuntimeState } = await import("./agents-VLK4BMVA.js");
+  const { getAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
   const tmuxSession = getTmuxSessionName(name);
   const runtimeState = getAgentRuntimeState(tmuxSession);
   const idle = runtimeState?.state === "idle" || runtimeState?.state === "suspended";
@@ -1547,7 +1702,7 @@ async function wakeSpecialistOrQueue(name, task, options = {}) {
       };
     }
   }
-  const { saveAgentRuntimeState } = await import("./agents-VLK4BMVA.js");
+  const { saveAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
   saveAgentRuntimeState(tmuxSession, {
     state: "active",
     lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1667,7 +1822,7 @@ async function sendFeedbackToAgent(feedback) {
     return false;
   }
   try {
-    const { messageAgent } = await import("./agents-VLK4BMVA.js");
+    const { messageAgent } = await import("./agents-E43Y3HNU.js");
     const msg = `SPECIALIST FEEDBACK: ${fromSpecialist} reported ${feedback.feedbackType.toUpperCase()} for ${toIssueId}.
 Read and address: ${fileResult.relativePath}`;
     await messageAgent(agentSession, msg);
@@ -2161,4 +2316,4 @@ export {
   getFeedbackStats,
   init_specialists
 };
-//# sourceMappingURL=chunk-ASY7T35E.js.map
+//# sourceMappingURL=chunk-AAFQANKW.js.map