panopticon-cli 0.4.32 → 0.5.0

package/dist/{chunk-2NIAOCIC.js → chunk-AAFQANKW.js}

@@ -1,23 +1,39 @@
 import {
+  capturePaneAsync,
   checkHook,
+  confirmDelivery,
   getModelId,
   init_hooks,
   init_tmux,
   init_work_type_router,
   popFromHook,
   pushToHook,
-  sendKeysAsync
-} from "./chunk-VIWUCJ4V.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-HJSM6E6U.js";
 import {
   init_projects,
   projects_exports
-} from "./chunk-JY7R7V4G.js";
+} from "./chunk-OMNXYPXC.js";
 import {
   COSTS_DIR,
   PANOPTICON_HOME,
   getPanopticonHome,
   init_paths
-} from "./chunk-6HXKTOD7.js";
+} from "./chunk-ZTFNYOC7.js";
 import {
   __esm,
   __export,
@@ -380,6 +396,59 @@ import { join as join4, basename as basename2 } from "path";
 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 {};
+  const settings = loadSettings();
+  const apiKey = settings.api_keys?.[provider.name];
+  if (apiKey) {
+    return getProviderEnv(provider, apiKey);
+  }
+  console.warn(`[specialist] No API key for ${provider.displayName}, falling back to Anthropic`);
+  return {};
+}
+function buildTmuxEnvFlags(env) {
+  let flags = "";
+  for (const [key, value] of Object.entries(env)) {
+    flags += ` -e ${key}="${value.replace(/"/g, '\\"')}"`;
+  }
+  return flags;
+}
 function initSpecialistsDirectory() {
   if (!existsSync3(SPECIALISTS_DIR)) {
     mkdirSync2(SPECIALISTS_DIR, { recursive: true });
@@ -553,9 +622,9 @@ function recordWake(name, sessionId) {
 }
 async function spawnEphemeralSpecialist(projectKey, specialistType, task) {
   ensureProjectSpecialistDir(projectKey, specialistType);
-  const { loadContextDigest } = await import("./specialist-context-N32QBNNQ.js");
+  const { loadContextDigest } = await import("./specialist-context-ZC6A4M3I.js");
   const contextDigest = loadContextDigest(projectKey, specialistType);
-  const { createRunLog: createRunLog2 } = await import("./specialist-logs-GF3YV4KL.js");
+  const { createRunLog: createRunLog2 } = await import("./specialist-logs-KLGJCEUL.js");
   const { runId, filePath: logFilePath } = createRunLog2(
     projectKey,
     specialistType,
@@ -568,13 +637,21 @@ async function spawnEphemeralSpecialist(projectKey, specialistType, task) {
   const tmuxSession = getTmuxSessionName(specialistType, projectKey);
   const cwd = process.env.HOME || "/home/exedev";
   try {
-    let model = "claude-sonnet-4-5";
+    let model = "claude-sonnet-4-6";
     try {
       const workTypeId = `specialist-${specialistType}`;
       model = getModelId(workTypeId);
     } catch (error) {
       console.warn(`Warning: Could not resolve model for ${specialistType}, using default`);
     }
+    const providerEnv = getProviderEnvForModel(model);
+    const envFlags = buildTmuxEnvFlags(providerEnv);
+    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);
     await execAsync(`mkdir -p "${agentDir}"`, { encoding: "utf-8" });
@@ -593,10 +670,10 @@ echo ""
 echo "## Specialist completed task"
 `, { mode: 493 });
     await execAsync(
-      `tmux new-session -d -s "${tmuxSession}" "bash '${launcherScript}'"`,
+      `tmux new-session -d -s "${tmuxSession}"${envFlags} "bash '${launcherScript}'"`,
       { encoding: "utf-8" }
     );
-    const { saveAgentRuntimeState } = await import("./agents-BDFHF4T3.js");
+    const { saveAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
     saveAgentRuntimeState(tmuxSession, {
       state: "active",
       lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
@@ -620,7 +697,7 @@ echo "## Specialist completed task"
   }
 }
 async function buildTaskPrompt(projectKey, specialistType, task, contextDigest) {
-  const { getSpecialistPromptOverride } = await import("./projects-VXRUCMLM.js");
+  const { getSpecialistPromptOverride } = await import("./projects-JEIVIYC6.js");
   const customPrompt = getSpecialistPromptOverride(projectKey, specialistType);
   let prompt = `# ${specialistType} Task - ${task.issueId}
 
@@ -681,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 += `
 
@@ -781,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-GF3YV4KL.js");
+    const { finalizeRunLog: finalizeRunLog2 } = await import("./specialist-logs-KLGJCEUL.js");
     try {
       finalizeRunLog2(projectKey, specialistType, metadata.currentRun, {
         status: metadata.lastRunStatus || "incomplete",
@@ -794,20 +880,20 @@ async function terminateSpecialist(projectKey, specialistType) {
   }
   const key = `${projectKey}-${specialistType}`;
   gracePeriodStates.delete(key);
-  const { saveAgentRuntimeState } = await import("./agents-BDFHF4T3.js");
+  const { saveAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
   saveAgentRuntimeState(tmuxSession, {
     state: "suspended",
     lastActivity: (/* @__PURE__ */ new Date()).toISOString()
   });
-  const { scheduleDigestGeneration } = await import("./specialist-context-N32QBNNQ.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-GF3YV4KL.js");
-      const { getSpecialistRetention } = await import("./projects-VXRUCMLM.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 });
       if (deleted > 0) {
@@ -985,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-BDFHF4T3.js");
+  const { getAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
   const tmuxSession = getTmuxSessionName(name, projectKey);
   const runtimeState = getAgentRuntimeState(tmuxSession);
   let state;
@@ -1045,7 +1131,7 @@ async function initializeSpecialist(name) {
   }
   const tmuxSession = getTmuxSessionName(name);
   const cwd = process.env.HOME || "/home/eltmon";
-  let model = "claude-sonnet-4-5";
+  let model = "claude-sonnet-4-6";
   try {
     const workTypeId = `specialist-${name}`;
     model = getModelId(workTypeId);
@@ -1058,18 +1144,28 @@ Your role: ${name === "merge-agent" ? "Resolve merge conflicts and ensure clean
 You will be woken up when your services are needed. For now, acknowledge your initialization and wait.
 Say: "I am the ${name} specialist, ready and waiting for tasks."`;
   try {
+    const providerEnv = getProviderEnvForModel(model);
+    const envFlags = buildTmuxEnvFlags(providerEnv);
+    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" });
     const promptFile = join4(agentDir, "identity-prompt.md");
     const launcherScript = join4(agentDir, "launcher.sh");
     writeFileSync(promptFile, identityPrompt);
+    const newSessionId = randomUUID();
     writeFileSync(launcherScript, `#!/bin/bash
 cd "${cwd}"
 prompt=$(cat "${promptFile}")
-exec claude --dangerously-skip-permissions --model ${model} "$prompt"
+exec claude --dangerously-skip-permissions --session-id "${newSessionId}" --model ${model} "$prompt"
 `, { mode: 493 });
+    setSessionId(name, newSessionId);
     await execAsync(
-      `tmux new-session -d -s "${tmuxSession}" "bash '${launcherScript}'"`,
+      `tmux new-session -d -s "${tmuxSession}"${envFlags} "bash '${launcherScript}'"`,
       { encoding: "utf-8" }
     );
     recordWake(name);
@@ -1117,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) {
@@ -1142,15 +1236,40 @@ async function wakeSpecialist(name, taskPrompt, options = {}) {
     }
     const cwd = process.env.HOME || "/home/eltmon";
     try {
-      const modelFlag = name === "merge-agent" ? "--model opus" : "";
+      let model = "claude-sonnet-4-6";
+      try {
+        const workTypeId = `specialist-${name}`;
+        model = getModelId(workTypeId);
+      } catch (error) {
+        console.warn(`[specialist] Could not resolve model for ${name}, using default`);
+      }
+      const modelFlag = `--model ${model}`;
+      const providerEnv = getProviderEnvForModel(model);
+      const envFlags = buildTmuxEnvFlags(providerEnv);
+      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";
-      const claudeCmd = sessionId ? `claude --resume "${sessionId}" ${modelFlag} ${permissionFlags}` : `claude ${modelFlag} ${permissionFlags}`;
+      let claudeCmd;
+      if (sessionId) {
+        claudeCmd = `claude --resume "${sessionId}" ${modelFlag} ${permissionFlags}`;
+      } else {
+        const newSessionId = randomUUID();
+        claudeCmd = `claude --session-id "${newSessionId}" ${modelFlag} ${permissionFlags}`;
+        setSessionId(name, newSessionId);
+      }
       await execAsync(
-        `tmux new-session -d -s "${tmuxSession}" -c "${cwd}" "${claudeCmd}"`,
+        `tmux new-session -d -s "${tmuxSession}" -c "${cwd}"${envFlags} "${claudeCmd}"`,
         { 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);
@@ -1163,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-BDFHF4T3.js");
+    const { saveAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
     saveAgentRuntimeState(tmuxSession, {
       state: "active",
       lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1205,49 +1346,88 @@ 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}` : ""}
+${mergeRepoInstructions}
+For ${mergeInfo.isPolyrepo ? "EACH repo" : "the repo"}, perform these steps:
 
-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.`;
+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";
+      const reviewGitInfo = await resolveWorkspaceGitInfo(task.workspace, task.branch);
+      const gitDirs = reviewGitInfo.gitDirs;
+      const gitDir = gitDirs[0] || workspace;
       let staleBranch = false;
-      if (workspace !== "unknown") {
+      if (workspace !== "unknown" && gitDirs.length > 0) {
         try {
-          const { stdout: diffOutput } = await execAsync(
-            `cd "${workspace}" && git fetch origin main 2>/dev/null; git diff --name-only main...HEAD 2>/dev/null`,
-            { encoding: "utf-8", timeout: 15e3 }
-          );
-          const changedFiles = diffOutput.trim().split("\n").filter((f) => f.length > 0);
-          if (changedFiles.length === 0) {
+          let totalChangedFiles = 0;
+          for (const dir of gitDirs) {
+            const { stdout: dirDiff } = await execAsync(
+              `cd "${dir}" && git fetch origin main 2>/dev/null; git diff --name-only main...HEAD 2>/dev/null`,
+              { encoding: "utf-8", timeout: 15e3 }
+            );
+            totalChangedFiles += dirDiff.trim().split("\n").filter((f) => f.length > 0).length;
+          }
+          if (totalChangedFiles === 0) {
             staleBranch = true;
             console.log(`[specialist] review-agent: stale branch detected for ${task.issueId} \u2014 0 files changed vs main`);
-            const { setReviewStatus } = await import("./review-status-GWQYY77L.js");
+            const { setReviewStatus } = await import("./review-status-EPFG4XM7.js");
             setReviewStatus(task.issueId.toUpperCase(), {
               reviewStatus: "passed",
               reviewNotes: "No changes to review \u2014 branch identical to main (already merged or stale)"
             });
             console.log(`[specialist] review-agent: auto-passed ${task.issueId} (stale branch)`);
             const tmuxSession = getTmuxSessionName("review-agent");
-            const { saveAgentRuntimeState } = await import("./agents-BDFHF4T3.js");
+            const { saveAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
             saveAgentRuntimeState(tmuxSession, {
               state: "idle",
               lastActivity: (/* @__PURE__ */ new Date()).toISOString()
@@ -1258,10 +1438,14 @@ Use the send-feedback-to-agent skill to report findings back to the issue agent.
           console.warn(`[specialist] review-agent: stale branch pre-check failed for ${task.issueId}:`, err);
         }
       }
+      const isPolyrepo = gitDirs.length > 1;
+      const gitDiffCommands = gitDirs.length > 0 ? gitDirs.map((d) => `cd "${d}" && git diff --name-only main...HEAD`).join("\n") : `cd "${workspace}" && git diff --name-only main...HEAD`;
+      const gitDiffFileCmd = gitDirs.length > 0 ? `cd "${gitDir}" && git diff main...HEAD -- <file>` : `cd "${workspace}" && git diff main...HEAD -- <file>`;
       prompt = `New review task for ${task.issueId}:
 
 Branch: ${task.branch || "unknown"}
 Workspace: ${workspace}
+${isPolyrepo ? `Polyrepo: git repos in subdirectories: ${gitDirs.map((d) => basename2(d)).join(", ")}` : ""}
 ${task.prUrl ? `PR URL: ${task.prUrl}` : ""}
 
 Your task:
@@ -1276,11 +1460,12 @@ The TEST agent will run tests in the next step.
 ## How to Review Changes
 
 **Step 0 (CRITICAL):** First check if there are ANY changes to review:
+${isPolyrepo ? `This is a polyrepo \u2014 run git diff in each repo subdirectory:` : ""}
 \`\`\`bash
-cd ${workspace} && git diff --name-only main...HEAD
+${gitDiffCommands}
 \`\`\`
 
-**If the diff is EMPTY (0 files changed):** The branch is stale or already merged into main. In this case:
+**If the diff is EMPTY (0 files changed across all repos):** The branch is stale or already merged into main. In this case:
 1. Do NOT attempt a full review
 2. Update status as passed immediately:
 \`\`\`bash
@@ -1294,7 +1479,7 @@ pan work tell ${task.issueId} "Review complete: branch has 0 diff from main \u20
 
 **Step 1:** Get the list of changed files:
 \`\`\`bash
-cd ${workspace} && git diff --name-only main...HEAD
+${gitDiffCommands}
 \`\`\`
 
 **Step 2:** Read the CURRENT version of each changed file using the Read tool.
@@ -1302,7 +1487,7 @@ Review the actual file contents \u2014 do NOT rely solely on diff output.
 
 **Step 3:** If you need to see what specifically changed, use:
 \`\`\`bash
-cd ${workspace} && git diff main...HEAD -- <file>
+${gitDiffFileCmd}
 \`\`\`
 
 ## Avoiding False Positives
@@ -1343,47 +1528,118 @@ 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 on the feature branch
-2. Run the same test suite on the main branch (baseline)
-3. Compare results: identify which failures are NEW vs pre-existing
-4. Only fail the feature branch for NEW regressions
+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)
 5. Update status via API when done
 
+## CRITICAL: Context Management \u2014 Output Redirection
+
+**NEVER let full test output flow into your context.** Always redirect to file and read only summaries.
+Raw test output from large suites (1000+ tests) WILL fill your context and cause compaction, losing your task.
+
 ## CRITICAL: Bash Timeout for Test Commands
 
 **ALWAYS use timeout: 300000 (5 minutes) when running test commands.**
-Test suites commonly take 2-5 minutes. The default bash timeout is only 2 minutes and WILL cause premature failures.
-Do NOT run test commands in background mode \u2014 run them directly with a 5-minute timeout.
+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.` : ""}
 
-Example:
 \`\`\`bash
-cd ${task.workspace || "unknown"} && npm test 2>&1 | tail -30
-# Use timeout: 300000 for this command
+(
+${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
 \`\`\`
 
-## CRITICAL: Baseline Comparison
+## Step 2: Check Results
+
+- If ALL exit codes are 0 \u2192 skip baseline, go to "Update Status"
+- If any failures \u2192 continue to Step 3
 
-**You MUST compare test results against the main branch baseline.**
+## Step 3: Baseline Comparison (ONLY if failures found)
 
-Pre-existing failures that also occur on main branch should NOT block the feature branch.
+\`\`\`bash
+(
+${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
+\`\`\`
 
-Steps:
-1. Run \`npm test\` (or detected command) on the feature branch - record results (timeout: 300000)
-2. Run tests on main branch baseline (timeout: 300000): \`cd ${task.context?.workspace ? task.context.workspace.replace(/workspaces\/feature-[^/]+/, "") : "unknown"} && npm test 2>&1 | tail -30\`
-3. Compare: any test that fails on BOTH branches is pre-existing
-4. Only NEW failures (pass on main, fail on feature) should block
+Then compare failures (targeted, NOT full output):
+\`\`\`bash
+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
+\`\`\`
 
-**Pass criteria:** The feature branch introduces ZERO new test failures compared to main.
-**Fail criteria:** The feature branch introduces one or more NEW test failures not present on main.
+Tests that fail on BOTH = pre-existing (don't block). Tests that fail ONLY on feature = NEW regression (block).
 
-Report pre-existing failures as informational notes, but do NOT block the feature for them.
+**Pass criteria:** Feature branch introduces ZERO new test failures vs main.
+**Fail criteria:** Feature branch introduces NEW failures not present on main.
 
 ## REQUIRED: Update Status via API
 
@@ -1391,21 +1647,22 @@ You MUST execute the appropriate curl command and verify it succeeds. Do NOT jus
 
 If NO new regressions (tests PASS):
 \`\`\`bash
-# EXECUTE THIS - verify you see JSON response with testStatus:"passed"
-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
-# EXECUTE THIS - verify you see JSON response with testStatus:"failed"
-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.
 
 \u26A0\uFE0F VERIFICATION: After running curl, confirm you see valid JSON output with the updated status. If you get an error or empty response, the update FAILED - report this.
 
+**NEVER run test commands without redirecting to a file.** This is not optional.
+
 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.`;
   }
@@ -1414,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-BDFHF4T3.js");
+  const { getAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
   const tmuxSession = getTmuxSessionName(name);
   const runtimeState = getAgentRuntimeState(tmuxSession);
   const idle = runtimeState?.state === "idle" || runtimeState?.state === "suspended";
@@ -1445,7 +1702,7 @@ async function wakeSpecialistOrQueue(name, task, options = {}) {
       };
     }
   }
-  const { saveAgentRuntimeState } = await import("./agents-BDFHF4T3.js");
+  const { saveAgentRuntimeState } = await import("./agents-E43Y3HNU.js");
   saveAgentRuntimeState(tmuxSession, {
     state: "active",
     lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1499,6 +1756,7 @@ function submitToSpecialistQueue(specialistName, task) {
     }
   };
   const queueItem = pushToHook(specialistName, item);
+  notifyPipeline({ type: "task_queued", specialist: specialistName, issueId: task.issueId });
   const handoffEvent = createSpecialistHandoff(
     task.source,
     // From (e.g., 'review-agent' or 'issue-agent')
@@ -1544,7 +1802,7 @@ async function sendFeedbackToAgent(feedback) {
   }
   const agentSession = `agent-${toIssueId.toLowerCase()}`;
   const feedbackMessage = formatFeedbackForAgent(fullFeedback);
-  const { writeFeedbackFile } = await import("./feedback-writer-AAKF5BTK.js");
+  const { writeFeedbackFile } = await import("./feedback-writer-LVZ5TFYZ.js");
   const specialistMap = {
     "review-agent": "review-agent",
     "test-agent": "test-agent",
@@ -1564,7 +1822,7 @@ async function sendFeedbackToAgent(feedback) {
     return false;
   }
   try {
-    const { messageAgent } = await import("./agents-BDFHF4T3.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);
@@ -1670,8 +1928,11 @@ var init_specialists = __esm({
     init_paths();
     init_jsonl_parser();
     init_specialist_handoff_logger();
+    init_settings();
     init_work_type_router();
+    init_providers();
     init_tmux();
+    init_pipeline_notifier();
     init_hooks();
     execAsync = promisify(exec);
     SPECIALISTS_DIR = join4(PANOPTICON_HOME, "specialists");
@@ -1887,18 +2148,18 @@ function getRecentRunLogs(projectKey, specialistType, count) {
 }
 function cleanupOldLogs(projectKey, specialistType, retention) {
   const { maxDays, maxRuns } = retention;
+  const now = /* @__PURE__ */ new Date();
+  const cutoffDate = new Date(now.getTime() - maxDays * 24 * 60 * 60 * 1e3);
   const allLogs = listRunLogs(projectKey, specialistType);
   if (allLogs.length === 0) {
     return 0;
   }
-  const now = /* @__PURE__ */ new Date();
-  const cutoffDate = new Date(now.getTime() - maxDays * 24 * 60 * 60 * 1e3);
   let deletedCount = 0;
   allLogs.forEach((log, index) => {
     if (index < maxRuns) {
       return;
     }
-    if (log.createdAt >= cutoffDate) {
+    if (maxDays > 0 && log.createdAt >= cutoffDate) {
       return;
     }
     try {
@@ -2055,4 +2316,4 @@ export {
   getFeedbackStats,
   init_specialists
 };
-//# sourceMappingURL=chunk-2NIAOCIC.js.map
+//# sourceMappingURL=chunk-AAFQANKW.js.map