@elizaos/plugin-agent-orchestrator 0.6.1 → 0.6.2-alpha.0

package/dist/index.js

@@ -23,6 +23,9 @@ function applyAnsiStrip(input) {
 function stripAnsi(raw) {
   return applyAnsiStrip(raw);
 }
+function isSessionBootstrapNoiseLine(line) {
+  return SESSION_BOOTSTRAP_NOISE_PATTERNS.some((pattern) => pattern.test(line));
+}
 function cleanForChat(raw) {
   const stripped = applyAnsiStrip(raw);
   return stripped.replace(TUI_DECORATIVE, " ").replace(/\xa0/g, " ").split(`
@@ -38,6 +41,8 @@ function cleanForChat(raw) {
       return false;
     if (GIT_NOISE_LINE.test(trimmed))
       return false;
+    if (isSessionBootstrapNoiseLine(trimmed))
+      return false;
     if (!/[a-zA-Z0-9]/.test(trimmed))
       return false;
     if (trimmed.length <= 3)
@@ -46,6 +51,23 @@ function cleanForChat(raw) {
   }).map((line) => line.replace(/ {2,}/g, " ").trim()).filter((line) => line.length > 0).join(`
 `).replace(/\n{3,}/g, `
 
+`).trim();
+}
+function isWorkdirEchoLine(line, workdir) {
+  if (!workdir)
+    return false;
+  const normalizedWorkdir = workdir.trim();
+  if (!normalizedWorkdir)
+    return false;
+  if (line === normalizedWorkdir || line === `/private${normalizedWorkdir}`) {
+    return true;
+  }
+  const basename = normalizedWorkdir.split("/").filter(Boolean).at(-1);
+  return Boolean(basename && line.includes(basename) && (/^\/(?:private\/)?/.test(line) || /^\/…\//.test(line)));
+}
+function cleanForFailoverContext(raw, workdir) {
+  return cleanForChat(raw).split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => !FAILOVER_CONTEXT_NOISE_PATTERNS.some((pattern) => pattern.test(line))).filter((line) => !isWorkdirEchoLine(line, workdir)).join(`
 `).trim();
 }
 function extractCompletionSummary(raw) {
@@ -89,7 +111,15 @@ function captureTaskResponse(sessionId, buffers, markers) {
   return cleanForChat(responseLines.join(`
 `));
 }
-var CURSOR_MOVEMENT, CURSOR_POSITION, ERASE, OSC, ALL_ANSI, CONTROL_CHARS, ORPHAN_SGR, LONG_SPACES, TUI_DECORATIVE, LOADING_LINE, STATUS_LINE, TOOL_MARKER_LINE, GIT_NOISE_LINE;
+function peekTaskResponse(sessionId, buffers, markers) {
+  const buffer = buffers.get(sessionId);
+  const marker = markers.get(sessionId);
+  if (!buffer || marker === undefined)
+    return "";
+  return cleanForChat(buffer.slice(marker).join(`
+`));
+}
+var CURSOR_MOVEMENT, CURSOR_POSITION, ERASE, OSC, ALL_ANSI, CONTROL_CHARS, ORPHAN_SGR, LONG_SPACES, TUI_DECORATIVE, LOADING_LINE, STATUS_LINE, TOOL_MARKER_LINE, GIT_NOISE_LINE, SESSION_BOOTSTRAP_NOISE_PATTERNS, FAILOVER_CONTEXT_NOISE_PATTERNS;
 var init_ansi_utils = __esm(() => {
   CURSOR_MOVEMENT = /\x1b\[\d*[CDABGdEF]/g;
   CURSOR_POSITION = /\x1b\[\d*(?:;\d+)?[Hf]/g;
@@ -99,11 +129,44 @@ var init_ansi_utils = __esm(() => {
   CONTROL_CHARS = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
   ORPHAN_SGR = /\[[\d;]*m/g;
   LONG_SPACES = / {3,}/g;
-  TUI_DECORATIVE = /[│╭╰╮╯─═╌║╔╗╚╝╠╣╦╩╬┌┐└┘├┤┬┴┼●○❮❯▶◀⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⣾⣽⣻⢿⡿⣟⣯⣷✽✻✶✳✢⏺←→↑↓⬆⬇◆▪▫■□▲△▼▽◈⟨⟩⌘⏎⏏⌫⌦⇧⇪⌥·⎿✔◼]/g;
+  TUI_DECORATIVE = /[│╭╰╮╯─═╌║╔╗╚╝╠╣╦╩╬┌┐└┘├┤┬┴┼●○❮❯▶◀⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⣾⣽⣻⢿⡿⣟⣯⣷✽✻✶✳✢⏺←→↑↓⬆⬇◆▪▫■□▲△▼▽◈⟨⟩⌘⏎⏏⌫⌦⇧⇪⌥·⎿✔◼█▌▐▖▗▘▝▛▜▟▙◐◑◒◓⏵]/g;
   LOADING_LINE = /^\s*(?:[A-Z][a-z]+(?:-[a-z]+)?(?:ing|ed)\w*|thinking|Loading|processing)(?:…|\.{3})(?:\s*\(.*\)|\s+for\s+\d+[smh](?:\s+\d+[smh])*)?\s*$|^\s*(?:[A-Z][a-z]+(?:-[a-z]+)?(?:ing|ed)\w*|thinking|Loading|processing)\s+for\s+\d+[smh](?:\s+\d+[smh])*\s*$/;
   STATUS_LINE = /^\s*(?:\d+[smh]\s+\d+s?\s*·|↓\s*[\d.]+k?\s*tokens|·\s*↓|esc\s+to\s+interrupt|[Uu]pdate available|ate available|Run:\s+brew|brew\s+upgrade|\d+\s+files?\s+\+\d+\s+-\d+|ctrl\+\w|\+\d+\s+lines|Wrote\s+\d+\s+lines\s+to|\?\s+for\s+shortcuts|Cooked for|Baked for|Cogitated for)/i;
   TOOL_MARKER_LINE = /^\s*(?:Bash|Write|Read|Edit|Glob|Grep|Search|TodoWrite|Agent)\s*\(.*\)\s*$/;
   GIT_NOISE_LINE = /^\s*(?:On branch\s+\w|Your branch is|modified:|new file:|deleted:|renamed:|Untracked files:|Changes (?:not staged|to be committed)|\d+\s+files?\s+changed.*(?:insertion|deletion))/i;
+  SESSION_BOOTSTRAP_NOISE_PATTERNS = [
+    /^OpenAI Codex\b/i,
+    /^model:\s/i,
+    /^directory:\s/i,
+    /^Tip:\s+New Try the Codex App\b/i,
+    /^until .*Run ['"]codex app['"]/i,
+    /Do you trust the contents of this directory/i,
+    /higher risk of prompt injection/i,
+    /Yes,\s*continue.*No,\s*quit/i,
+    /^Press enter to continue$/i,
+    /^Quick safety check:/i,
+    /^Claude Code can make mistakes\./i,
+    /^Claude Code(?:'ll| will)\s+be able to read, edit, and execute files here\.?$/i,
+    /^\d+\.\s+Yes,\s*I trust this folder$/i,
+    /^\d+\.\s+No,\s*exit$/i,
+    /^Enter to confirm(?:\s+Esc to cancel)?$/i,
+    /^Welcome back .*Run \/init to create a CLAUDE\.md file with instructions for Claude\./i,
+    /^Your bash commands will be sandboxed\. Disable with \/sandbox\./i
+  ];
+  FAILOVER_CONTEXT_NOISE_PATTERNS = [
+    /^Accessing workspace:?$/i,
+    /work from your team\)\. If not, take a moment to review what's in this folder first\.$/i,
+    /(?:se)?curity guide$/i,
+    /^Yes,\s*I trust this folder$/i,
+    /^Claude Code v[\d.]+$/i,
+    /^Tips for getting started$/i,
+    /^Welcome back .*Run \/init to create a CLAUDE\.md file with instructions for Claude\.?$/i,
+    /^Recent activity$/i,
+    /^No recent activity$/i,
+    /^.*\(\d+[MK]? context\)\s+Claude\b.*$/i,
+    /^don'?t ask on \(shift\+tab to cycle\)$/i,
+    /^\w+\s+\/effort$/i
+  ];
 });
 
 // src/services/trajectory-context.ts
@@ -533,7 +596,7 @@ import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { mkdir, readdir, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path2 from "node:path";
+import path4 from "node:path";
 import { promisify } from "node:util";
 import { ModelType as ModelType3 } from "@elizaos/core";
 function extractJsonBlock(raw) {
@@ -562,8 +625,8 @@ function parseValidationResponse(raw) {
   }
 }
 function getValidationRootDir() {
-  const stateDir = process.env.MILADY_STATE_DIR?.trim() || process.env.ELIZA_STATE_DIR?.trim() || path2.join(homedir2(), ".milady");
-  return path2.join(stateDir, "task-validation");
+  const stateDir = process.env.MILADY_STATE_DIR?.trim() || process.env.ELIZA_STATE_DIR?.trim() || path4.join(homedir2(), ".milady");
+  return path4.join(stateDir, "task-validation");
 }
 function truncate(text, limit = 1200) {
   const compact = text.replace(/\s+/g, " ").trim();
@@ -600,9 +663,9 @@ async function captureValidationScreenshot(runtime, task, thread, sessionId) {
         reason: "Screenshot endpoint returned an empty PNG payload"
       };
     }
-    const dir = path2.join(getValidationRootDir(), task.threadId);
+    const dir = path4.join(getValidationRootDir(), task.threadId);
     await mkdir(dir, { recursive: true });
-    const screenshotPath = path2.join(dir, `screenshot-${sessionId}-${Date.now()}.png`);
+    const screenshotPath = path4.join(dir, `screenshot-${sessionId}-${Date.now()}.png`);
     await writeFile2(screenshotPath, bytes);
     const screenshotDescription = await describeScreenshotContent(runtime, task, thread, bytes);
     return {
@@ -626,7 +689,7 @@ async function captureValidationScreenshot(runtime, task, thread, sessionId) {
   }
 }
 async function listRelevantTrajectories(runtime, task, thread) {
-  const logger2 = runtime.getService("trajectory_logger");
+  const logger2 = runtime.getService("trajectories");
   if (!logger2?.listTrajectories) {
     return [];
   }
@@ -731,7 +794,7 @@ async function collectWorkspaceEvidence(workdir) {
     evidence.notes.push("no workdir supplied");
     return evidence;
   }
-  const resolved = workdir.startsWith("~") ? path2.join(homedir2(), workdir.slice(1)) : path2.resolve(workdir);
+  const resolved = workdir.startsWith("~") ? path4.join(homedir2(), workdir.slice(1)) : path4.resolve(workdir);
   evidence.workdir = resolved;
   try {
     const rootStat = await stat(resolved);
@@ -766,13 +829,13 @@ async function collectWorkspaceEvidence(workdir) {
         walkCeilingHit = true;
         break;
       }
-      const full = path2.join(dir, entry.name);
+      const full = path4.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(full, depth + 1);
       } else if (entry.isFile()) {
         totalCount++;
         if (collected.length < WORKSPACE_EVIDENCE_FILE_LIMIT) {
-          collected.push(path2.relative(resolved, full));
+          collected.push(path4.relative(resolved, full));
         }
       }
     }
@@ -913,9 +976,9 @@ function buildValidationPrompt(task, thread, completionReasoning, completionSumm
 `);
 }
 async function persistValidationReport(threadId, sessionId, report) {
-  const dir = path2.join(getValidationRootDir(), threadId);
+  const dir = path4.join(getValidationRootDir(), threadId);
   await mkdir(dir, { recursive: true });
-  const reportPath = path2.join(dir, `validation-${sessionId}-${Date.now()}.json`);
+  const reportPath = path4.join(dir, `validation-${sessionId}-${Date.now()}.json`);
   await writeFile2(reportPath, JSON.stringify(report, null, 2), "utf8");
   return reportPath;
 }
@@ -1047,6 +1110,338 @@ var init_task_validation = __esm(() => {
   ]);
 });
 
+// src/services/task-verifier-runner.ts
+import { mkdir as mkdir2, writeFile as writeFile3 } from "node:fs/promises";
+import { createHash as createHash2 } from "node:crypto";
+import { homedir as homedir3 } from "node:os";
+import path5 from "node:path";
+import { ModelType as ModelType4 } from "@elizaos/core";
+function extractJsonBlock2(raw) {
+  const trimmed = raw.trim();
+  const fenceMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  return (fenceMatch?.[1] ?? trimmed).trim();
+}
+function parseAcceptanceEvaluation(raw) {
+  try {
+    const parsed = JSON.parse(extractJsonBlock2(raw));
+    if (parsed.verdict !== "pass" && parsed.verdict !== "fail" || typeof parsed.summary !== "string" || parsed.summary.trim().length === 0) {
+      return null;
+    }
+    const checklist = Array.isArray(parsed.checklist) ? parsed.checklist.filter((entry) => Boolean(entry && typeof entry === "object" && typeof entry.criterion === "string" && typeof entry.status === "string" && typeof entry.evidence === "string")).map((entry) => ({
+      criterion: entry.criterion.trim(),
+      status: entry.status === "pass" || entry.status === "fail" || entry.status === "partial" ? entry.status : "partial",
+      evidence: entry.evidence.trim()
+    })).filter((entry) => entry.criterion.length > 0 && entry.evidence.length > 0) : [];
+    return {
+      verdict: parsed.verdict,
+      summary: parsed.summary.trim(),
+      checklist
+    };
+  } catch {
+    return null;
+  }
+}
+function getVerifierRootDir() {
+  const stateDir = process.env.MILADY_STATE_DIR?.trim() || process.env.ELIZA_STATE_DIR?.trim() || path5.join(homedir3(), ".milady");
+  return path5.join(stateDir, "task-verifiers");
+}
+function truncate2(text, limit = 1200) {
+  const compact = text.replace(/\s+/g, " ").trim();
+  return compact.length <= limit ? compact : `${compact.slice(0, limit)}...`;
+}
+function isVerifierReady(thread, job) {
+  if (job.status !== "pending")
+    return false;
+  if (job.verifierType !== "acceptance_criteria")
+    return false;
+  const executionNodes = thread.nodes.filter((node2) => node2.kind !== "goal");
+  if (executionNodes.some((node2) => !terminalNodeStates.has(node2.status))) {
+    return false;
+  }
+  if (!job.nodeId)
+    return true;
+  const node = thread.nodes.find((entry) => entry.id === job.nodeId);
+  return node ? terminalNodeStates.has(node.status) : false;
+}
+function collectAcceptancePrerequisiteFailures(thread) {
+  const executionNodes = thread.nodes.filter((node) => node.kind === "execution");
+  const passedCompletionVerifierNodeIds = new Set(thread.verifierJobs.filter((job) => job.verifierType === "task_completion" && job.status === "passed" && typeof job.nodeId === "string").map((job) => job.nodeId));
+  const evidenceBackedNodeIds = new Set(thread.evidence.filter((entry) => typeof entry.nodeId === "string" && (entry.evidenceType === "validation_summary" || entry.evidenceType === "acceptance_report")).map((entry) => entry.nodeId));
+  return {
+    failedExecutionNodes: executionNodes.filter((node) => node.status === "failed" || node.status === "canceled" || node.status === "interrupted"),
+    completedWithoutEvidence: executionNodes.filter((node) => node.status === "completed" && !passedCompletionVerifierNodeIds.has(node.id) && !evidenceBackedNodeIds.has(node.id))
+  };
+}
+function buildDeterministicFailureEvaluation(thread, failures) {
+  if (failures.failedExecutionNodes.length > 0) {
+    return {
+      verdict: "fail",
+      summary: `Acceptance cannot pass because execution nodes failed: ${failures.failedExecutionNodes.map((node) => node.title).join(", ")}.`,
+      checklist: thread.acceptanceCriteria.map((criterion) => ({
+        criterion,
+        status: "fail",
+        evidence: `Execution nodes failed before acceptance verification completed: ${failures.failedExecutionNodes.map((node) => `${node.title}=${node.status}`).join(", ")}.`
+      }))
+    };
+  }
+  if (failures.completedWithoutEvidence.length > 0) {
+    return {
+      verdict: "fail",
+      summary: `Acceptance cannot pass because completed execution nodes lack verification evidence: ${failures.completedWithoutEvidence.map((node) => node.title).join(", ")}.`,
+      checklist: thread.acceptanceCriteria.map((criterion) => ({
+        criterion,
+        status: "partial",
+        evidence: `Missing task-completion evidence for: ${failures.completedWithoutEvidence.map((node) => node.title).join(", ")}.`
+      }))
+    };
+  }
+  return null;
+}
+function summarizeThreadEvidence(thread) {
+  const sessionSummaries = thread.sessions.map((session) => [
+    `${session.label} [${session.framework}] status=${session.status}`,
+    session.completionSummary ? `summary=${truncate2(session.completionSummary, 400)}` : ""
+  ].filter(Boolean).join(" | ")).filter(Boolean).join(`
+`);
+  const decisions = thread.decisions.slice(-8).map((decision) => `${decision.decision}: ${truncate2(decision.reasoning, 240)}`).join(`
+`);
+  const artifacts = thread.artifacts.slice(-12).map((artifact) => `${artifact.artifactType}: ${artifact.title}${artifact.path ? ` (${artifact.path})` : ""}`).join(`
+`);
+  const evidence = thread.evidence.slice(-16).map((entry) => `${entry.evidenceType}: ${entry.title}${entry.summary ? ` - ${truncate2(entry.summary, 220)}` : ""}`).join(`
+`);
+  const transcripts = thread.transcripts.slice(-8).map((entry) => `${entry.direction}: ${truncate2(entry.content, 240)}`).join(`
+`);
+  return [
+    sessionSummaries ? `Sessions
+${sessionSummaries}` : "",
+    decisions ? `Decisions
+${decisions}` : "",
+    artifacts ? `Artifacts
+${artifacts}` : "",
+    evidence ? `Evidence
+${evidence}` : "",
+    transcripts ? `Recent transcripts
+${transcripts}` : ""
+  ].filter(Boolean).join(`
+
+`);
+}
+async function evaluateAcceptanceCriteria(runtime, thread, job) {
+  const prompt = [
+    "You are a strict task verifier for an agent coordinator.",
+    "Decide whether the thread satisfies its acceptance criteria based only on the provided evidence.",
+    "Return JSON only with keys: verdict, summary, checklist.",
+    'Set verdict to "pass" only if every criterion is satisfied by concrete evidence.',
+    'Set verdict to "fail" if any criterion is missing, contradicted, or unsupported.',
+    "Each checklist entry must contain criterion, status (pass|fail|partial), and evidence.",
+    "",
+    `Thread title: ${thread.title}`,
+    `Original request: ${thread.originalRequest}`,
+    `Verifier job: ${job.title}`,
+    `Acceptance criteria:
+${thread.acceptanceCriteria.map((criterion, index) => `${index + 1}. ${criterion}`).join(`
+`)}`,
+    "",
+    `Thread evidence:
+${summarizeThreadEvidence(thread) || "No evidence recorded."}`
+  ].join(`
+`);
+  const raw = await withTrajectoryContext(runtime, {
+    source: "orchestrator",
+    decisionType: "acceptance-verifier",
+    threadId: thread.id,
+    verifierJobId: job.id
+  }, () => runtime.useModel(ModelType4.TEXT_SMALL, {
+    prompt,
+    temperature: 0,
+    stream: false
+  }));
+  const parsed = parseAcceptanceEvaluation(raw);
+  if (parsed) {
+    return parsed;
+  }
+  return {
+    verdict: "fail",
+    summary: "Acceptance verifier returned an invalid response, so the thread could not be proven complete.",
+    checklist: thread.acceptanceCriteria.map((criterion) => ({
+      criterion,
+      status: "partial",
+      evidence: "Verifier response was invalid JSON."
+    }))
+  };
+}
+async function writeAcceptanceReport(thread, job, evaluation) {
+  const dir = path5.join(getVerifierRootDir(), thread.id);
+  await mkdir2(dir, { recursive: true });
+  const reportPath = path5.join(dir, `${job.id}.json`);
+  const report = {
+    threadId: thread.id,
+    verifierJobId: job.id,
+    title: job.title,
+    originalRequest: thread.originalRequest,
+    acceptanceCriteria: thread.acceptanceCriteria,
+    evaluation,
+    generatedAt: new Date().toISOString()
+  };
+  const serialized = JSON.stringify(report, null, 2);
+  await writeFile3(reportPath, serialized, "utf8");
+  return {
+    reportPath,
+    sha256: createHash2("sha256").update(serialized).digest("hex")
+  };
+}
+async function finalizeAcceptanceJob(taskRegistry, thread, job, evaluation, reportPath, sha256) {
+  await taskRegistry.updateTaskVerifierJob(job.id, {
+    status: evaluation.verdict === "pass" ? "passed" : "failed",
+    completedAt: new Date().toISOString(),
+    metadata: {
+      verdict: evaluation.verdict,
+      summary: evaluation.summary,
+      reportPath,
+      sha256,
+      checklist: evaluation.checklist
+    }
+  });
+  await taskRegistry.recordArtifact({
+    threadId: thread.id,
+    sessionId: thread.latestSessionId ?? null,
+    artifactType: "acceptance_report",
+    title: `${job.title} report`,
+    path: reportPath,
+    mimeType: "application/json",
+    metadata: {
+      verifierJobId: job.id,
+      verdict: evaluation.verdict,
+      sha256
+    }
+  });
+  await taskRegistry.recordTaskEvidence({
+    threadId: thread.id,
+    nodeId: job.nodeId,
+    sessionId: thread.latestSessionId ?? null,
+    verifierJobId: job.id,
+    evidenceType: "acceptance_report",
+    title: job.title,
+    summary: evaluation.summary,
+    path: reportPath,
+    content: {
+      checklist: evaluation.checklist,
+      verdict: evaluation.verdict
+    },
+    metadata: {
+      sha256
+    }
+  });
+  await taskRegistry.appendEvent({
+    threadId: thread.id,
+    sessionId: thread.latestSessionId ?? null,
+    eventType: "verifier_job_completed",
+    summary: `${job.title} ${evaluation.verdict}`,
+    data: {
+      verifierJobId: job.id,
+      verdict: evaluation.verdict,
+      reportPath
+    }
+  });
+  if (job.nodeId) {
+    const node = thread.nodes.find((entry) => entry.id === job.nodeId);
+    const patch = evaluation.verdict === "pass" ? {
+      metadata: {
+        acceptanceVerifierJobId: job.id,
+        acceptanceSummary: evaluation.summary
+      }
+    } : {
+      status: "failed",
+      metadata: {
+        acceptanceVerifierJobId: job.id,
+        acceptanceSummary: evaluation.summary
+      }
+    };
+    if (node) {
+      await taskRegistry.updateTaskNode(node.id, patch);
+    }
+  }
+}
+async function runReadyTaskVerifiers(runtime, taskRegistry, threadId) {
+  let thread = await taskRegistry.getThread(threadId);
+  if (!thread) {
+    return;
+  }
+  const readyJobs = thread.verifierJobs.filter((job) => isVerifierReady(thread, job));
+  for (const job of readyJobs) {
+    if (activeVerifierRuns.has(job.id)) {
+      continue;
+    }
+    activeVerifierRuns.add(job.id);
+    try {
+      await taskRegistry.updateTaskVerifierJob(job.id, {
+        status: "running",
+        startedAt: new Date().toISOString(),
+        metadata: {
+          source: "acceptance-runner"
+        }
+      });
+      await taskRegistry.appendEvent({
+        threadId,
+        sessionId: thread.latestSessionId ?? null,
+        eventType: "verifier_job_started",
+        summary: `Running ${job.title}`,
+        data: {
+          verifierJobId: job.id,
+          verifierType: job.verifierType
+        }
+      });
+      thread = await taskRegistry.getThread(threadId) ?? thread;
+      const deterministicFailure = buildDeterministicFailureEvaluation(thread, collectAcceptancePrerequisiteFailures(thread));
+      const evaluation = deterministicFailure ?? await evaluateAcceptanceCriteria(runtime, thread, job);
+      const report = await writeAcceptanceReport(thread, job, evaluation);
+      await finalizeAcceptanceJob(taskRegistry, thread, job, evaluation, report.reportPath, report.sha256);
+      thread = await taskRegistry.getThread(threadId) ?? thread;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      await taskRegistry.updateTaskVerifierJob(job.id, {
+        status: "failed",
+        completedAt: new Date().toISOString(),
+        metadata: {
+          source: "acceptance-runner",
+          error: message
+        }
+      });
+      await taskRegistry.appendEvent({
+        threadId,
+        sessionId: thread.latestSessionId ?? null,
+        eventType: "verifier_job_failed",
+        summary: `${job.title} failed`,
+        data: {
+          verifierJobId: job.id,
+          error: message
+        }
+      });
+      if (job.nodeId) {
+        await taskRegistry.updateTaskNode(job.nodeId, {
+          status: "failed",
+          metadata: {
+            acceptanceVerifierJobId: job.id,
+            acceptanceSummary: message
+          }
+        });
+      }
+    } finally {
+      activeVerifierRuns.delete(job.id);
+    }
+  }
+}
+var terminalNodeStates, activeVerifierRuns;
+var init_task_verifier_runner = __esm(() => {
+  terminalNodeStates = new Set([
+    "completed",
+    "failed",
+    "canceled",
+    "interrupted"
+  ]);
+  activeVerifierRuns = new Set;
+});
+
 // src/services/swarm-decision-loop.ts
 var exports_swarm_decision_loop = {};
 __export(exports_swarm_decision_loop, {
@@ -1061,8 +1456,8 @@ __export(exports_swarm_decision_loop, {
   checkAllTasksComplete: () => checkAllTasksComplete,
   POST_SEND_COOLDOWN_MS: () => POST_SEND_COOLDOWN_MS
 });
-import * as path3 from "node:path";
-import { ModelType as ModelType4 } from "@elizaos/core";
+import * as path6 from "node:path";
+import { ModelType as ModelType5 } from "@elizaos/core";
 function withTimeout(promise, ms, label) {
   return new Promise((resolve2, reject) => {
     const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
@@ -1195,6 +1590,27 @@ function formatDecisionResponse(decision) {
     return;
   return decision.useKeys ? `keys:${decision.keys?.join(",")}` : decision.response;
 }
+function truncateForUser(text, max = 140) {
+  const trimmed = text.trim();
+  if (trimmed.length <= max) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, max)}...`;
+}
+function formatSuggestedAction(decision) {
+  if (!decision) {
+    return "Needs human review with no automatic suggestion.";
+  }
+  if (decision.action === "respond") {
+    if (decision.useKeys && decision.keys?.length) {
+      return `Suggested action: send keys ${decision.keys.join(", ")}.`;
+    }
+    if (decision.response?.trim()) {
+      return `Suggested action: reply "${truncateForUser(decision.response, 80)}".`;
+    }
+  }
+  return `Suggested action: ${decision.action}.`;
+}
 function decisionFromSuggestedResponse(suggestedResponse, reasoning = "Used adapter-provided auto-response for a routine blocking prompt.") {
   if (suggestedResponse.startsWith("keys:")) {
     return {
@@ -1219,8 +1635,8 @@ function inferRoutinePromptResponse(promptText, promptType) {
   }
   if (promptType === "config" && /claude (?:dialog awaiting navigation|menu navigation required)/i.test(promptText)) {
     return {
-      suggestedResponse: "keys:esc",
-      reasoning: "Dismissed Claude's routine navigation dialog so the replacement session can reach a normal prompt."
+      suggestedResponse: "keys:enter",
+      reasoning: "Accepted Claude's default dialog action so the replacement session can continue without exiting the CLI."
     };
   }
   if (promptType && promptType !== "unknown") {
@@ -1252,10 +1668,10 @@ function isOutOfScopeAccess(promptText, workdir) {
   ];
   if (matches.length === 0)
     return false;
-  const resolvedWorkdir = path3.resolve(workdir);
+  const resolvedWorkdir = path6.resolve(workdir);
   return matches.some((p) => {
-    const resolved = path3.resolve(p);
-    return !resolved.startsWith(resolvedWorkdir + path3.sep) && resolved !== resolvedWorkdir;
+    const resolved = path6.resolve(p);
+    return !resolved.startsWith(resolvedWorkdir + path6.sep) && resolved !== resolvedWorkdir;
   });
 }
 function checkAllTasksComplete(ctx) {
@@ -1273,20 +1689,18 @@ async function checkAllTasksCompleteAsync(ctx) {
     return;
   }
   const threadIds = [...new Set(tasks.map((task) => task.threadId))];
+  const failingThreads = [];
   for (const threadId of threadIds) {
+    await runReadyTaskVerifiers(ctx.runtime, ctx.taskRegistry, threadId);
     const thread = await ctx.taskRegistry.getThread(threadId);
     if (!thread || thread.nodes.length === 0) {
       continue;
     }
-    const terminalNodeStates = new Set([
-      "completed",
-      "failed",
-      "canceled",
-      "interrupted"
-    ]);
     const goalNodes = thread.nodes.filter((node) => node.kind === "goal");
-    if (goalNodes.some((node) => !terminalNodeStates.has(node.status))) {
-      const pendingGoals = goalNodes.filter((node) => !terminalNodeStates.has(node.status)).map((node) => `${node.title}=${node.status}`).join(", ");
+    const failedGoals = goalNodes.filter((node) => node.status === "failed" || node.status === "canceled" || node.status === "interrupted").map((node) => `${node.title}=${node.status}`);
+    const incompleteGoals = goalNodes.filter((node) => node.status !== "completed" && node.status !== "failed" && node.status !== "canceled" && node.status !== "interrupted").map((node) => `${node.title}=${node.status}`);
+    if (incompleteGoals.length > 0) {
+      const pendingGoals = goalNodes.filter((node) => node.status !== "completed").map((node) => `${node.title}=${node.status}`).join(", ");
       ctx.log(`checkAllTasksComplete: thread ${threadId} still has non-terminal goal nodes — ${pendingGoals}`);
       return;
     }
@@ -1295,6 +1709,43 @@ async function checkAllTasksCompleteAsync(ctx) {
       ctx.log(`checkAllTasksComplete: thread ${threadId} still has running verifier jobs`);
       return;
     }
+    const pendingVerifiers = thread.verifierJobs.filter((job) => job.status === "pending");
+    if (pendingVerifiers.length > 0) {
+      ctx.log(`checkAllTasksComplete: thread ${threadId} still has pending verifier jobs`);
+      return;
+    }
+    const failedVerifiers = thread.verifierJobs.filter((job) => job.status === "failed").map((job) => `${job.title}=failed`);
+    if (failedGoals.length > 0 || failedVerifiers.length > 0) {
+      failingThreads.push({
+        threadId,
+        failedGoals,
+        failedVerifiers
+      });
+    }
+  }
+  if (failingThreads.length > 0) {
+    if (ctx.swarmCompleteNotified) {
+      ctx.log("checkAllTasksComplete: failure notification already sent — skipping");
+      return;
+    }
+    ctx.swarmCompleteNotified = true;
+    const summary = failingThreads.map((thread) => [
+      `thread ${thread.threadId}`,
+      thread.failedGoals.length > 0 ? `failed goals: ${thread.failedGoals.join(", ")}` : "",
+      thread.failedVerifiers.length > 0 ? `failed verifiers: ${thread.failedVerifiers.join(", ")}` : ""
+    ].filter(Boolean).join(" | ")).join("; ");
+    ctx.log(`checkAllTasksComplete: sessions are terminal but acceptance failed — ${summary}`);
+    ctx.broadcast({
+      type: "swarm_attention_required",
+      sessionId: "",
+      timestamp: Date.now(),
+      data: {
+        summary,
+        threads: failingThreads
+      }
+    });
+    ctx.sendChatMessage(`Task agents finished running, but the coordinator could not prove completion. ${summary}`, "task-agent");
+    return;
   }
   if (ctx.swarmCompleteNotified) {
     ctx.log("checkAllTasksComplete: already notified — skipping");
@@ -1384,7 +1835,7 @@ async function makeCoordinationDecision(ctx, taskCtx, promptText, recentOutput)
       repo: taskCtx.repo,
       workdir: taskCtx.workdir,
       originalTask: taskCtx.originalTask
-    }, () => ctx.runtime.useModel(ModelType4.TEXT_SMALL, { prompt }));
+    }, () => ctx.runtime.useModel(ModelType5.TEXT_SMALL, { prompt }));
     return parseCoordinationResponse(result);
   } catch (err) {
     ctx.log(`LLM coordination call failed: ${err}`);
@@ -1803,6 +2254,7 @@ async function handleBlocked(ctx, sessionId, taskCtx, data) {
         reason: "max_auto_responses_exceeded"
       }
     });
+    ctx.sendChatMessage(`[${taskCtx.label}] Paused for your attention after ${MAX_AUTO_RESPONSES} consecutive automatic approvals. Prompt: ${truncateForUser(promptText, 180)}`, "coding-agent");
     return;
   }
   switch (ctx.getSupervisionLevel()) {
@@ -1820,6 +2272,7 @@ async function handleBlocked(ctx, sessionId, taskCtx, data) {
         decision: "escalate",
         reasoning: "Supervision level is notify — broadcasting only"
       });
+      ctx.sendChatMessage(`[${taskCtx.label}] Waiting on a blocked prompt: ${truncateForUser(promptText, 180)}`, "coding-agent");
       break;
   }
 }
@@ -1909,7 +2362,7 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
         repo: taskCtx.repo,
         workdir: taskCtx.workdir,
         originalTask: taskCtx.originalTask
-      }, () => ctx.runtime.useModel(ModelType4.TEXT_SMALL, { prompt }));
+      }, () => ctx.runtime.useModel(ModelType5.TEXT_SMALL, { prompt }));
       decision = parseCoordinationResponse(result);
     } catch (err) {
       ctx.log(`Turn-complete LLM call failed: ${err}`);
@@ -1950,6 +2403,7 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
         const instruction = decision.response ?? "";
         const preview = instruction.length > 120 ? `${instruction.slice(0, 120)}...` : instruction;
         ctx.log(`[${taskCtx.label}] Turn done, continuing: ${preview}`);
+        ctx.sendChatMessage(`[${taskCtx.label}] Continuing work: ${preview || "sent follow-up instructions."}`, "coding-agent");
       } else if (decision.action === "escalate") {
         ctx.sendChatMessage(`[${taskCtx.label}] Turn finished — needs your attention: ${decision.reasoning}`, "coding-agent");
       }
@@ -2017,6 +2471,7 @@ async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, rec
           reason: "invalid_llm_response"
         }
       });
+      ctx.sendChatMessage(`[${taskCtx.label}] Needs your attention: the coordinator could not decide how to handle "${truncateForUser(promptText, 160)}".`, "coding-agent");
       return;
     }
     if (decision.action === "respond" && isOutOfScopeAccess(promptText, taskCtx.workdir)) {
@@ -2170,6 +2625,11 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
         fromPipeline: decisionFromPipeline
       }
     });
+    ctx.sendChatMessage([
+      `[${taskCtx.label}] Waiting for your approval: ${truncateForUser(promptText, 180)}`,
+      formatSuggestedAction(decision),
+      decision?.reasoning ? `Reason: ${truncateForUser(decision.reasoning, 180)}` : ""
+    ].filter(Boolean).join(" "), "coding-agent");
   } finally {
     ctx.inFlightDecisions.delete(sessionId);
     await drainPendingTurnComplete(ctx, sessionId);
@@ -2181,6 +2641,7 @@ var init_swarm_decision_loop = __esm(() => {
   init_ansi_utils();
   init_swarm_event_triage();
   init_task_validation();
+  init_task_verifier_runner();
   deferredTurnCompleteTimers = new Map;
 });
 
@@ -3145,7 +3606,7 @@ var init_query_promise = __esm(() => {
 // node_modules/drizzle-orm/utils.js
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
-  const result = columns.reduce((result2, { path: path6, field }, columnIndex) => {
+  const result = columns.reduce((result2, { path: path9, field }, columnIndex) => {
     let decoder;
     if (is(field, Column)) {
       decoder = field;
@@ -3157,8 +3618,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
       decoder = field.sql.decoder;
     }
     let node = result2;
-    for (const [pathChunkIndex, pathChunk] of path6.entries()) {
-      if (pathChunkIndex < path6.length - 1) {
+    for (const [pathChunkIndex, pathChunk] of path9.entries()) {
+      if (pathChunkIndex < path9.length - 1) {
         if (!(pathChunk in node)) {
           node[pathChunk] = {};
         }
@@ -3166,8 +3627,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
       } else {
         const rawValue = row[columnIndex];
         const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-        if (joinsNotNullableMap && is(field, Column) && path6.length === 2) {
-          const objectName = path6[0];
+        if (joinsNotNullableMap && is(field, Column) && path9.length === 2) {
+          const objectName = path9[0];
           if (!(objectName in nullifyMap)) {
             nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
           } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -3971,6 +4432,194 @@ var init_drizzle_orm = __esm(() => {
   init_view_common();
 });
 
+// src/services/task-policy.ts
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+var ROLE_RANK = {
+  GUEST: 0,
+  USER: 1,
+  ADMIN: 2,
+  OWNER: 3
+};
+var DEFAULT_POLICY = {
+  default: "GUEST",
+  connectors: {
+    discord: {
+      create: "ADMIN",
+      interact: "ADMIN"
+    }
+  }
+};
+var LOCAL_ROLES_MODULE_CANDIDATES = [
+  path.resolve(process.cwd(), "packages/plugin-roles/src/index.ts"),
+  path.resolve(process.cwd(), "packages/plugin-roles/dist/index.js")
+];
+function normalizeRole(value) {
+  const upper = typeof value === "string" ? value.trim().toUpperCase() : "";
+  switch (upper) {
+    case "OWNER":
+    case "ADMIN":
+    case "USER":
+      return upper;
+    default:
+      return "GUEST";
+  }
+}
+function normalizeConnectorPolicy(value) {
+  if (!value)
+    return {};
+  if (typeof value === "string") {
+    const role = normalizeRole(value);
+    return {
+      create: role,
+      interact: role
+    };
+  }
+  return {
+    ...value.create ? { create: normalizeRole(value.create) } : {},
+    ...value.interact ? { interact: normalizeRole(value.interact) } : {}
+  };
+}
+function parseTaskAgentPolicy(runtime) {
+  if (typeof runtime.getSetting !== "function") {
+    return DEFAULT_POLICY;
+  }
+  const configured = runtime.getSetting("TASK_AGENT_ROLE_POLICY") ?? runtime.getSetting("TASK_AGENT_CONNECTOR_ROLE_POLICY");
+  if (!configured) {
+    return DEFAULT_POLICY;
+  }
+  let parsed = configured;
+  if (typeof configured === "string") {
+    try {
+      parsed = JSON.parse(configured);
+    } catch {
+      return DEFAULT_POLICY;
+    }
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return DEFAULT_POLICY;
+  }
+  const record = parsed;
+  const connectors = record.connectors && typeof record.connectors === "object" && !Array.isArray(record.connectors) ? Object.fromEntries(Object.entries(record.connectors).map(([connector, value]) => [
+    connector,
+    normalizeConnectorPolicy(value)
+  ])) : DEFAULT_POLICY.connectors;
+  return {
+    default: normalizeConnectorPolicy(record.default ?? DEFAULT_POLICY.default),
+    connectors
+  };
+}
+function getConnectorFromBridgeMetadata(message) {
+  const metadata = message.content?.metadata;
+  if (!metadata || typeof metadata !== "object")
+    return null;
+  const bridgeSender = metadata.bridgeSender;
+  if (!bridgeSender || typeof bridgeSender !== "object")
+    return null;
+  const liveMetadata = bridgeSender.metadata;
+  if (!liveMetadata || typeof liveMetadata !== "object")
+    return null;
+  for (const [connector, value] of Object.entries(liveMetadata)) {
+    if (value && typeof value === "object") {
+      return connector;
+    }
+  }
+  return null;
+}
+async function resolveConnectorSource(runtime, message) {
+  const content = message.content;
+  const directSource = typeof content?.source === "string" && content.source !== "client_chat" ? content.source : null;
+  if (directSource)
+    return directSource;
+  const bridgeSource = getConnectorFromBridgeMetadata(message);
+  if (bridgeSource)
+    return bridgeSource;
+  try {
+    const room = await runtime.getRoom(message.roomId);
+    if (typeof room?.source === "string" && room.source.trim().length > 0) {
+      return room.source;
+    }
+  } catch {}
+  return null;
+}
+async function resolveSenderRole(runtime, message) {
+  if (process.env.MILADY_SKIP_LOCAL_PLUGIN_ROLES !== "1") {
+    for (const candidate of LOCAL_ROLES_MODULE_CANDIDATES) {
+      if (!fs.existsSync(candidate)) {
+        continue;
+      }
+      try {
+        const localRolesModule = await import(pathToFileURL(candidate).href);
+        if (typeof localRolesModule.checkSenderRole === "function") {
+          return await localRolesModule.checkSenderRole(runtime, message);
+        }
+      } catch {}
+    }
+  }
+  try {
+    const rolesModuleSpecifier = "@miladyai/plugin-roles";
+    const rolesModule = await import(rolesModuleSpecifier);
+    if (typeof rolesModule.checkSenderRole !== "function") {
+      return null;
+    }
+    return await rolesModule.checkSenderRole(runtime, message);
+  } catch {
+    return null;
+  }
+}
+async function requireTaskAgentAccess(runtime, message, ability) {
+  const messageEntityId = typeof message.entityId === "string" && message.entityId.length > 0 ? message.entityId : null;
+  const runtimeAgentId = typeof runtime.agentId === "string" && runtime.agentId.length > 0 ? runtime.agentId : null;
+  if (messageEntityId && runtimeAgentId && messageEntityId === runtimeAgentId) {
+    return {
+      allowed: true,
+      connector: null,
+      requiredRole: "GUEST",
+      actualRole: "OWNER"
+    };
+  }
+  const connector = await resolveConnectorSource(runtime, message);
+  const policy = parseTaskAgentPolicy(runtime);
+  const connectorPolicy = connector ? normalizeConnectorPolicy(policy.connectors?.[connector]) : {};
+  const defaultPolicy = normalizeConnectorPolicy(policy.default);
+  const requiredRole = connectorPolicy[ability] ?? defaultPolicy[ability] ?? "GUEST";
+  if (requiredRole === "GUEST") {
+    return {
+      allowed: true,
+      connector,
+      requiredRole,
+      actualRole: "GUEST"
+    };
+  }
+  const roleCheck = await resolveSenderRole(runtime, message);
+  if (!roleCheck) {
+    return {
+      allowed: false,
+      connector,
+      requiredRole,
+      actualRole: "GUEST",
+      reason: connector === "discord" ? "Task-agent access in Discord requires a verified OWNER or ADMIN role." : "Task-agent access requires a verified role, but role context is unavailable."
+    };
+  }
+  const actualRole = normalizeRole(roleCheck.role);
+  if (ROLE_RANK[actualRole] < ROLE_RANK[requiredRole]) {
+    return {
+      allowed: false,
+      connector,
+      requiredRole,
+      actualRole,
+      reason: connector === "discord" ? `Task-agent access in Discord requires ${requiredRole} or higher. Current role: ${actualRole}.` : `Task-agent access requires ${requiredRole} or higher. Current role: ${actualRole}.`
+    };
+  }
+  return {
+    allowed: true,
+    connector,
+    requiredRole,
+    actualRole
+  };
+}
+
 // src/actions/finalize-workspace.ts
 var finalizeWorkspaceAction = {
   name: "FINALIZE_WORKSPACE",
@@ -4009,6 +4658,15 @@ var finalizeWorkspaceAction = {
     return workspaceService != null;
   },
   handler: async (runtime, message, state, _options, callback) => {
+    const access = await requireTaskAgentAccess(runtime, message, "interact");
+    if (!access.allowed) {
+      if (callback) {
+        await callback({
+          text: access.reason
+        });
+      }
+      return { success: false, error: "FORBIDDEN", text: access.reason };
+    }
     const workspaceService = runtime.getService("CODING_WORKSPACE_SERVICE");
     if (!workspaceService) {
       if (callback) {
@@ -4165,7 +4823,7 @@ Automated changes generated by Milady task agent.
 };
 
 // src/services/pty-service.ts
-import { appendFile as appendFile2, mkdir as mkdir3, readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir4, readFile as readFile3, writeFile as writeFile5 } from "node:fs/promises";
 import { dirname as dirname2, join as join4 } from "node:path";
 import { logger as logger4 } from "@elizaos/core";
 import {
@@ -4186,6 +4844,7 @@ class AgentMetricsTracker {
         completed: 0,
         completedViaFastPath: 0,
         completedViaClassifier: 0,
+        completedViaOutputReconcile: 0,
         stallCount: 0,
         avgCompletionMs: 0,
         totalCompletionMs: 0
@@ -4199,8 +4858,10 @@ class AgentMetricsTracker {
     m.completed++;
     if (method === "fast-path")
       m.completedViaFastPath++;
-    else
+    else if (method === "classifier")
       m.completedViaClassifier++;
+    else
+      m.completedViaOutputReconcile++;
     m.totalCompletionMs += durationMs;
     m.avgCompletionMs = Math.round(m.totalCompletionMs / m.completed);
   }
@@ -4220,10 +4881,10 @@ class AgentMetricsTracker {
 // src/services/config-env.ts
 import { readFileSync } from "node:fs";
 import * as os from "node:os";
-import * as path from "node:path";
+import * as path2 from "node:path";
 function readConfig() {
   try {
-    const configPath = path.join(process.env.MILADY_STATE_DIR ?? process.env.ELIZA_STATE_DIR ?? path.join(os.homedir(), ".milady"), process.env.ELIZA_NAMESPACE === "milady" || !process.env.ELIZA_NAMESPACE ? "milady.json" : `${process.env.ELIZA_NAMESPACE}.json`);
+    const configPath = path2.join(process.env.MILADY_STATE_DIR ?? process.env.ELIZA_STATE_DIR ?? path2.join(os.homedir(), ".milady"), process.env.ELIZA_NAMESPACE === "milady" || !process.env.ELIZA_NAMESPACE ? "milady.json" : `${process.env.ELIZA_NAMESPACE}.json`);
     const raw = readFileSync(configPath, "utf-8");
     return JSON.parse(raw);
   } catch {
@@ -4402,7 +5063,10 @@ async function handleGeminiAuth(ctx, sessionId, sendKeysToSession) {
 
 // src/services/pty-init.ts
 init_ansi_utils();
+import { existsSync, readdirSync } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
+import os2 from "node:os";
+import path3 from "node:path";
 import { createAllAdapters } from "coding-agent-adapters";
 import {
   BunCompatiblePTYManager,
@@ -4415,13 +5079,44 @@ var resolvedAdapterModule = "coding-agent-adapters";
 try {
   resolvedAdapterModule = _require.resolve("coding-agent-adapters");
 } catch {}
+function resolveNodeWorkerPath() {
+  const explicitCandidates = [
+    process.env.NODE,
+    process.env.NODE_BINARY,
+    "/opt/homebrew/bin/node",
+    "/usr/local/bin/node"
+  ].filter((value) => Boolean(value?.trim()));
+  for (const candidate of explicitCandidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  const nvmVersionsDir = path3.join(os2.homedir(), ".nvm", "versions", "node");
+  if (existsSync(nvmVersionsDir)) {
+    const versions = readdirSync(nvmVersionsDir).filter((entry) => entry.startsWith("v")).sort((a, b) => b.localeCompare(a, undefined, {
+      numeric: true,
+      sensitivity: "base"
+    }));
+    for (const version of versions) {
+      const candidate = path3.join(nvmVersionsDir, version, "bin", "node");
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return "node";
+}
 function forwardReadyAsTaskComplete(ctx, session) {
   if (!ctx.hasActiveTask?.(session.id) || !ctx.hasTaskActivity?.(session.id)) {
     return;
   }
   const response = ctx.taskResponseMarkers.has(session.id) ? captureTaskResponse(session.id, ctx.sessionOutputBuffers, ctx.taskResponseMarkers) : "";
   ctx.log(`session_ready for active task ${session.id} — forwarding as task_complete (stall classifier path, response: ${response.length} chars)`);
-  ctx.emitEvent(session.id, "task_complete", { session, response });
+  ctx.emitEvent(session.id, "task_complete", {
+    session,
+    response,
+    source: "session_ready_forward"
+  });
 }
 async function initializePTYManager(ctx) {
   const usingBunWorker = isBun();
@@ -4430,6 +5125,7 @@ async function initializePTYManager(ctx) {
     ctx.log(`Resolved adapter module: ${resolvedAdapterModule}`);
     const bunManager = new BunCompatiblePTYManager({
       adapterModules: [resolvedAdapterModule],
+      nodePath: resolveNodeWorkerPath(),
       stallDetectionEnabled: true,
       stallTimeoutMs: 4000,
       onStallClassify: async (sessionId, recentOutput, _stallDurationMs) => {
@@ -4438,40 +5134,62 @@ async function initializePTYManager(ctx) {
     });
     bunManager.on("session_ready", (session) => {
       ctx.log(`session_ready event received for ${session.id} (type: ${session.type}, status: ${session.status})`);
-      ctx.emitEvent(session.id, "ready", { session });
+      ctx.emitEvent(session.id, "ready", { session, source: "pty_manager" });
       forwardReadyAsTaskComplete(ctx, session);
       ctx.markTaskDelivered?.(session.id);
     });
     bunManager.on("session_exit", (id, code) => {
-      ctx.emitEvent(id, "stopped", { reason: `exit code ${code}` });
+      ctx.emitEvent(id, "stopped", {
+        reason: `exit code ${code}`,
+        source: "pty_manager"
+      });
     });
     bunManager.on("session_error", (id, error) => {
-      ctx.emitEvent(id, "error", { message: error });
+      ctx.emitEvent(id, "error", { message: error, source: "pty_manager" });
     });
     bunManager.on("blocking_prompt", (session, promptInfo, autoResponded) => {
       const info = promptInfo;
       ctx.log(`blocking_prompt for ${session.id}: type=${info?.type}, autoResponded=${autoResponded}, prompt="${(info?.prompt ?? "").slice(0, 80)}"`);
-      ctx.emitEvent(session.id, "blocked", { promptInfo, autoResponded });
+      ctx.emitEvent(session.id, "blocked", {
+        promptInfo,
+        autoResponded,
+        source: "pty_manager"
+      });
     });
     bunManager.on("login_required", (session, instructions, url) => {
       if (session.type === "gemini") {
         ctx.handleGeminiAuth(session.id);
       }
-      ctx.emitEvent(session.id, "login_required", { instructions, url });
+      ctx.emitEvent(session.id, "login_required", {
+        instructions,
+        url,
+        source: "pty_manager"
+      });
     });
     bunManager.on("task_complete", (session) => {
       const response = captureTaskResponse(session.id, ctx.sessionOutputBuffers, ctx.taskResponseMarkers);
       const durationMs = session.startedAt ? Date.now() - new Date(session.startedAt).getTime() : 0;
       ctx.metricsTracker.recordCompletion(session.type, "fast-path", durationMs);
       ctx.log(`Task complete for ${session.id} (adapter fast-path), response: ${response.length} chars`);
-      ctx.emitEvent(session.id, "task_complete", { session, response });
+      ctx.emitEvent(session.id, "task_complete", {
+        session,
+        response,
+        source: "adapter_fast_path"
+      });
     });
     bunManager.on("tool_running", (session, info) => {
       ctx.log(`tool_running for ${session.id}: ${info.toolName}${info.description ? ` — ${info.description}` : ""}`);
-      ctx.emitEvent(session.id, "tool_running", { session, ...info });
+      ctx.emitEvent(session.id, "tool_running", {
+        session,
+        ...info,
+        source: "pty_manager"
+      });
     });
     bunManager.on("message", (message) => {
-      ctx.emitEvent(message.sessionId, "message", message);
+      ctx.emitEvent(message.sessionId, "message", {
+        ...message,
+        source: "pty_manager"
+      });
     });
     bunManager.on("worker_error", (err) => {
       const raw = typeof err === "string" ? err : String(err);
@@ -4519,38 +5237,60 @@ async function initializePTYManager(ctx) {
     }
   }
   nodeManager.on("session_ready", (session) => {
-    ctx.emitEvent(session.id, "ready", { session });
+    ctx.emitEvent(session.id, "ready", { session, source: "pty_manager" });
     forwardReadyAsTaskComplete(ctx, session);
     ctx.markTaskDelivered?.(session.id);
   });
   nodeManager.on("blocking_prompt", (session, promptInfo, autoResponded) => {
-    ctx.emitEvent(session.id, "blocked", { promptInfo, autoResponded });
+    ctx.emitEvent(session.id, "blocked", {
+      promptInfo,
+      autoResponded,
+      source: "pty_manager"
+    });
   });
   nodeManager.on("login_required", (session, instructions, url) => {
     if (session.type === "gemini") {
       ctx.handleGeminiAuth(session.id);
     }
-    ctx.emitEvent(session.id, "login_required", { instructions, url });
+    ctx.emitEvent(session.id, "login_required", {
+      instructions,
+      url,
+      source: "pty_manager"
+    });
   });
   nodeManager.on("task_complete", (session) => {
     const response = captureTaskResponse(session.id, ctx.sessionOutputBuffers, ctx.taskResponseMarkers);
     const durationMs = session.startedAt ? Date.now() - new Date(session.startedAt).getTime() : 0;
     ctx.metricsTracker.recordCompletion(session.type, "fast-path", durationMs);
     ctx.log(`Task complete for ${session.id} (adapter fast-path), response: ${response.length} chars`);
-    ctx.emitEvent(session.id, "task_complete", { session, response });
+    ctx.emitEvent(session.id, "task_complete", {
+      session,
+      response,
+      source: "adapter_fast_path"
+    });
   });
   nodeManager.on("tool_running", (session, info) => {
     ctx.log(`tool_running for ${session.id}: ${info.toolName}${info.description ? ` — ${info.description}` : ""}`);
-    ctx.emitEvent(session.id, "tool_running", { session, ...info });
+    ctx.emitEvent(session.id, "tool_running", {
+      session,
+      ...info,
+      source: "pty_manager"
+    });
   });
   nodeManager.on("session_stopped", (session, reason) => {
-    ctx.emitEvent(session.id, "stopped", { reason });
+    ctx.emitEvent(session.id, "stopped", { reason, source: "pty_manager" });
   });
   nodeManager.on("session_error", (session, error) => {
-    ctx.emitEvent(session.id, "error", { message: error });
+    ctx.emitEvent(session.id, "error", {
+      message: error,
+      source: "pty_manager"
+    });
   });
   nodeManager.on("message", (message) => {
-    ctx.emitEvent(message.sessionId, "message", message);
+    ctx.emitEvent(message.sessionId, "message", {
+      ...message,
+      source: "pty_manager"
+    });
   });
   return { manager: nodeManager, usingBunWorker: false };
 }
@@ -4681,7 +5421,11 @@ async function getSessionOutput(ctx, sessionId, lines) {
 `);
 }
 
+// src/services/pty-service.ts
+init_ansi_utils();
+
 // src/services/pty-spawn.ts
+init_ansi_utils();
 var ENV_ALLOWLIST = [
   "PATH",
   "HOME",
@@ -4696,7 +5440,9 @@ var ENV_ALLOWLIST = [
   "TMPDIR",
   "XDG_RUNTIME_DIR",
   "NODE_OPTIONS",
-  "BUN_INSTALL"
+  "BUN_INSTALL",
+  "ANTHROPIC_MODEL",
+  "ANTHROPIC_SMALL_FAST_MODEL"
 ];
 function buildSanitizedBaseEnv() {
   const env = {};
@@ -4758,6 +5504,9 @@ function setupDeferredTaskDelivery(ctx, session, task, agentType) {
   const VERIFY_DELAY_MS = 5000;
   const MAX_RETRIES = 2;
   const minNewLines = MIN_NEW_LINES_BY_AGENT[agentType] ?? 15;
+  const READY_PROBE_INTERVAL_MS = 500;
+  const isAdapterBackedAgent = agentType === "claude" || agentType === "gemini" || agentType === "codex" || agentType === "aider";
+  const adapter = isAdapterBackedAgent ? ctx.getAdapter(agentType) : null;
   const sendTaskWithRetry = (attempt) => {
     const buffer = ctx.sessionOutputBuffers.get(sid);
     const baselineLength = buffer?.length ?? 0;
@@ -4767,7 +5516,10 @@ function setupDeferredTaskDelivery(ctx, session, task, agentType) {
       setTimeout(() => {
         const currentLength = buffer?.length ?? 0;
         const newLines = currentLength - baselineLength;
-        if (newLines < minNewLines) {
+        const newOutput = buffer?.slice(baselineLength).join(`
+`) ?? "";
+        const accepted = newLines > 0 || newLines >= minNewLines || (adapter?.detectLoading?.(newOutput) ?? false) || cleanForChat(newOutput).length >= 32;
+        if (!accepted) {
           ctx.log(`Session ${sid} — task may not have been accepted (only ${newLines} new lines after ${VERIFY_DELAY_MS}ms). Retrying (attempt ${attempt + 2}/${MAX_RETRIES + 1})`);
           sendTaskWithRetry(attempt + 1);
         } else {
@@ -4778,15 +5530,31 @@ function setupDeferredTaskDelivery(ctx, session, task, agentType) {
   };
   const READY_TIMEOUT_MS = 30000;
   let taskSent = false;
+  let taskDeliveredMarked = false;
   let readyTimeout;
+  let readyProbe;
+  const clearPendingReadyWait = () => {
+    if (readyTimeout) {
+      clearTimeout(readyTimeout);
+      readyTimeout = undefined;
+    }
+    if (readyProbe) {
+      clearInterval(readyProbe);
+      readyProbe = undefined;
+    }
+  };
   const sendTask = () => {
     if (taskSent)
       return;
     taskSent = true;
-    if (readyTimeout)
-      clearTimeout(readyTimeout);
-    ctx.markTaskDelivered(sid);
-    setTimeout(() => sendTaskWithRetry(0), settleMs);
+    clearPendingReadyWait();
+    setTimeout(() => {
+      if (!taskDeliveredMarked) {
+        ctx.markTaskDelivered(sid);
+        taskDeliveredMarked = true;
+      }
+      sendTaskWithRetry(0);
+    }, settleMs);
     if (ctx.usingBunWorker) {
       ctx.manager.removeListener("session_ready", onReady);
     } else {
@@ -4812,6 +5580,29 @@ function setupDeferredTaskDelivery(ctx, session, task, agentType) {
         sendTask();
       }
     }, READY_TIMEOUT_MS);
+    if (ctx.usingBunWorker && isAdapterBackedAgent && adapter) {
+      readyProbe = setInterval(() => {
+        if (taskSent)
+          return;
+        const buffer = ctx.sessionOutputBuffers.get(sid);
+        if (!buffer || buffer.length === 0)
+          return;
+        const output = buffer.join(`
+`);
+        const cleanedOutput = cleanForChat(output);
+        if (adapter.detectLoading?.(output))
+          return;
+        if (adapter.detectLogin(output).required)
+          return;
+        if (adapter.detectBlockingPrompt(output).detected)
+          return;
+        const promptVisible = adapter.detectReady(output) || agentType === "codex" && /›\s+(?:Ask Codex to do anything|\S.*)/.test(cleanedOutput);
+        if (!promptVisible)
+          return;
+        ctx.log(`Session ${sid} — detected ready prompt from buffered output, delivering task before timeout`);
+        sendTask();
+      }, READY_PROBE_INTERVAL_MS);
+    }
   }
 }
 function buildSpawnConfig(sessionId, options, workdir) {
@@ -4900,6 +5691,71 @@ import {
   buildTaskCompletionTimeline,
   extractTaskCompletionTraceRecords
 } from "pty-manager";
+var STATUS_NOISE_LINE = /messages to be submitted after next tool call|working \(\d+s .*esc to interrupt\)|\b\d+% left\b|context left|use \/skills to list available skills/i;
+var STATUS_PATH_LINE = /(\/private\/|\/var\/folders\/|\/Users\/|\/tmp\/)/;
+var SPINNER_FRAGMENT_TOKEN = /^(?:w|wo|wor|work|worki|workin|working|orking|rking|king|ing|ng|g|\d+|[•·])$/i;
+function normalizeForComparison(value) {
+  return stripAnsi(value).replace(/\s+/g, " ").trim().toLowerCase();
+}
+function looksLikeSpinnerFragments(line) {
+  const tokens = line.replace(/[^\w/%@.:\-/ ]+/g, " ").split(/\s+/).filter(Boolean);
+  if (tokens.length === 0)
+    return false;
+  const fragmentTokens = tokens.filter((token) => SPINNER_FRAGMENT_TOKEN.test(token));
+  return fragmentTokens.length >= 4 && fragmentTokens.length >= Math.ceil(tokens.length * 0.6);
+}
+function isStatusNoiseLine(line) {
+  const compact = line.replace(/\s+/g, " ").trim();
+  if (!compact)
+    return true;
+  if (compact.startsWith("› "))
+    return true;
+  if (STATUS_NOISE_LINE.test(compact))
+    return true;
+  if (looksLikeSpinnerFragments(compact))
+    return true;
+  if (STATUS_PATH_LINE.test(compact) && /\b\d+% left\b/i.test(compact))
+    return true;
+  if (STATUS_PATH_LINE.test(compact) && looksLikeSpinnerFragments(compact))
+    return true;
+  return false;
+}
+function sanitizeOutputForClassification(output, lastSentInput) {
+  const normalizedInput = lastSentInput ? normalizeForComparison(lastSentInput) : "";
+  let removedEchoLines = 0;
+  let removedStatusLines = 0;
+  const sanitized = stripAnsi(output).split(`
+`).map((line) => line.replace(/\s+/g, " ").trim()).filter((line) => {
+    if (!line)
+      return false;
+    const normalizedLine = line.toLowerCase();
+    if (normalizedInput && normalizedLine.length >= 12 && normalizedInput.includes(normalizedLine)) {
+      removedEchoLines += 1;
+      return false;
+    }
+    if (isStatusNoiseLine(line)) {
+      removedStatusLines += 1;
+      return false;
+    }
+    return true;
+  }).join(`
+`).trim();
+  return { sanitized, removedEchoLines, removedStatusLines };
+}
+function promptLooksLikeFalseBlockedNoise(prompt, lastSentInput) {
+  if (!prompt)
+    return false;
+  const normalizedPrompt = normalizeForComparison(prompt);
+  if (!normalizedPrompt)
+    return false;
+  if (lastSentInput) {
+    const normalizedInput = normalizeForComparison(lastSentInput);
+    if (normalizedPrompt.length >= 12 && normalizedInput.includes(normalizedPrompt)) {
+      return true;
+    }
+  }
+  return isStatusNoiseLine(prompt) || looksLikeSpinnerFragments(prompt);
+}
 function buildStallClassificationPrompt(agentType, sessionId, output) {
   return `You are Milady, an AI orchestrator managing task-agent sessions. ` + `A ${agentType} task agent (session: ${sessionId}) appears to have stalled — ` + `it has stopped producing output while in a busy state.
 
@@ -4920,7 +5776,7 @@ ${output.slice(-1500)}
 
 ` + `5. "tool_running" — The agent is using an external tool (browser automation, ` + `MCP tool, etc.). Indicators: "Claude in Chrome", "javascript_tool", ` + `"computer_tool", "screenshot", "navigate", tool execution output. ` + `The agent is actively working but the terminal may be quiet.
 
-` + `IMPORTANT: If you see BOTH completed work output AND an idle prompt (❯), choose "task_complete". ` + `Only choose "waiting_for_input" if the agent is clearly asking a question mid-task.
+` + `IMPORTANT: If you see BOTH completed work output AND an idle prompt (❯), choose "task_complete". ` + `Only choose "waiting_for_input" if the agent is clearly asking a question mid-task. ` + `Ignore echoed user input, copied prior transcripts, spinner fragments, and status rows like ` + `"Working (12s • esc to interrupt)" or "97% left" — those mean the agent is still working, not blocked.
 
 ` + `If "waiting_for_input", also provide:
 ` + `- "prompt": the text of what it's asking
@@ -4931,11 +5787,11 @@ ${output.slice(-1500)}
 }
 async function writeStallSnapshot(sessionId, agentType, recentOutput, effectiveOutput, buffers, traceEntries, log) {
   try {
-    const fs = await import("node:fs");
-    const os2 = await import("node:os");
-    const path2 = await import("node:path");
-    const snapshotDir = path2.join(os2.homedir(), ".milady", "debug");
-    fs.mkdirSync(snapshotDir, { recursive: true });
+    const fs2 = await import("node:fs");
+    const os3 = await import("node:os");
+    const path4 = await import("node:path");
+    const snapshotDir = path4.join(os3.homedir(), ".milady", "debug");
+    fs2.mkdirSync(snapshotDir, { recursive: true });
     const ourBuffer = buffers.get(sessionId);
     const ourTail = ourBuffer ? ourBuffer.slice(-100).join(`
 `) : "(no buffer)";
@@ -4966,8 +5822,8 @@ async function writeStallSnapshot(sessionId, agentType, recentOutput, effectiveO
       ``
     ].join(`
 `);
-    const snapshotPath = path2.join(snapshotDir, `stall-snapshot-${sessionId}.txt`);
-    fs.writeFileSync(snapshotPath, snapshot);
+    const snapshotPath = path4.join(snapshotDir, `stall-snapshot-${sessionId}.txt`);
+    fs2.writeFileSync(snapshotPath, snapshot);
     log(`Stall snapshot → ${snapshotPath}`);
   } catch (_) {}
 }
@@ -4997,7 +5853,19 @@ async function classifyStallOutput(ctx) {
       }
     }
   }
-  const systemPrompt = buildStallClassificationPrompt(agentType, sessionId, effectiveOutput);
+  const {
+    sanitized: sanitizedOutput,
+    removedEchoLines,
+    removedStatusLines
+  } = sanitizeOutputForClassification(effectiveOutput, ctx.lastSentInput);
+  if (removedEchoLines > 0 || removedStatusLines > 0) {
+    log(`Sanitized stall output for ${sessionId}: removed ${removedEchoLines} echoed lines and ${removedStatusLines} status lines`);
+  }
+  if (!sanitizedOutput && removedEchoLines + removedStatusLines > 0) {
+    log(`Stall classification short-circuit for ${sessionId}: only echoed input / status noise remained`);
+    return { state: "still_working" };
+  }
+  const systemPrompt = buildStallClassificationPrompt(agentType, sessionId, sanitizedOutput || effectiveOutput);
   if (ctx.debugSnapshots) {
     await writeStallSnapshot(sessionId, agentType, recentOutput, effectiveOutput, buffers, traceEntries, log);
   }
@@ -5031,6 +5899,10 @@ async function classifyStallOutput(ctx) {
       prompt: parsed.prompt,
       suggestedResponse: parsed.suggestedResponse
     };
+    if (classification.state === "waiting_for_input" && promptLooksLikeFalseBlockedNoise(classification.prompt, ctx.lastSentInput)) {
+      log(`Stall classification override for ${sessionId}: prompt looked like echoed input / status noise`);
+      return { state: "still_working" };
+    }
     log(`Stall classification for ${sessionId}: ${classification.state}${classification.suggestedResponse ? ` → "${classification.suggestedResponse}"` : ""}`);
     if (classification.state === "task_complete") {
       const session = manager?.get(sessionId);
@@ -5074,6 +5946,8 @@ Classification states:
 
 ` + `5. "tool_running" — The agent is using an external tool (browser automation, MCP tool, etc.).
 
+` + `Ignore echoed user input, copied prior transcripts, spinner fragments, and status rows like ` + `"Working (12s • esc to interrupt)" or "97% left" — those indicate active work, not a live prompt.
+
 ` + `If "waiting_for_input", you must also decide how to respond. Guidelines:
 - IMPORTANT: If the prompt asks to approve access to files or directories OUTSIDE the working directory (${taskContext.workdir}), DECLINE the request. Respond with "n" and tell the agent: "That path is outside your workspace. Use ${taskContext.workdir} instead."
 - For tool approval prompts (file writes, shell commands), respond "y" or use "keys:enter".
@@ -5113,7 +5987,19 @@ async function classifyAndDecideForCoordinator(ctx) {
       }
     }
   }
-  const systemPrompt = buildCombinedClassifyDecidePrompt(agentType, sessionId, effectiveOutput, taskContext, decisionHistory);
+  const {
+    sanitized: sanitizedOutput,
+    removedEchoLines,
+    removedStatusLines
+  } = sanitizeOutputForClassification(effectiveOutput, ctx.lastSentInput);
+  if (removedEchoLines > 0 || removedStatusLines > 0) {
+    log(`Sanitized combined stall output for ${sessionId}: removed ${removedEchoLines} echoed lines and ${removedStatusLines} status lines`);
+  }
+  if (!sanitizedOutput && removedEchoLines + removedStatusLines > 0) {
+    log(`Combined classify+decide short-circuit for ${sessionId}: only echoed input / status noise remained`);
+    return { state: "still_working" };
+  }
+  const systemPrompt = buildCombinedClassifyDecidePrompt(agentType, sessionId, sanitizedOutput || effectiveOutput, taskContext, decisionHistory);
   if (ctx.debugSnapshots) {
     await writeStallSnapshot(sessionId, agentType, recentOutput, effectiveOutput, buffers, traceEntries, log);
   }
@@ -5161,6 +6047,10 @@ async function classifyAndDecideForCoordinator(ctx) {
       prompt: parsed.prompt,
       suggestedResponse: parsed.suggestedResponse
     };
+    if (classification.state === "waiting_for_input" && promptLooksLikeFalseBlockedNoise(classification.prompt, ctx.lastSentInput)) {
+      log(`Combined classify+decide override for ${sessionId}: prompt looked like echoed input / status noise`);
+      return { state: "still_working" };
+    }
     log(`Combined classify+decide for ${sessionId}: ${classification.state}${classification.suggestedResponse ? ` → "${classification.suggestedResponse}"` : ""}`);
     if (classification.state === "task_complete") {
       const session = manager?.get(sessionId);
@@ -5191,6 +6081,20 @@ function buildCodexCloudProviderToml(baseUrl) {
 ` + `supports_websockets = false
 `;
 }
+function compactCredentials(credentials) {
+  return Object.fromEntries(Object.entries(credentials).filter(([, value]) => value !== undefined));
+}
+function isAnthropicOAuthToken(value) {
+  return typeof value === "string" && value.startsWith("sk-ant-oat");
+}
+function sanitizeCustomCredentials(customCredentials, blockedValues = []) {
+  if (!customCredentials) {
+    return;
+  }
+  const blocked = new Set(blockedValues.filter(Boolean));
+  const filtered = Object.entries(customCredentials).filter(([, value]) => !blocked.has(value));
+  return filtered.length > 0 ? Object.fromEntries(filtered) : undefined;
+}
 function buildAgentCredentials(runtime) {
   const llmProvider = readConfigEnvKey("PARALLAX_LLM_PROVIDER") || "subscription";
   if (llmProvider === "cloud") {
@@ -5198,7 +6102,7 @@ function buildAgentCredentials(runtime) {
     if (!cloudKey) {
       throw new Error("Eliza Cloud is selected as the LLM provider but no cloud.apiKey is paired. Pair your account in the Cloud settings section first.");
     }
-    const cloudCredentials = {
+    const cloudCredentials = compactCredentials({
       anthropicKey: cloudKey,
       openaiKey: cloudKey,
       googleKey: undefined,
@@ -5206,28 +6110,163 @@ function buildAgentCredentials(runtime) {
       openaiBaseUrl: ELIZA_CLOUD_OPENAI_BASE,
       githubToken: runtime.getSetting("GITHUB_TOKEN"),
       extraConfigToml: buildCodexCloudProviderToml(ELIZA_CLOUD_OPENAI_BASE)
-    };
+    });
     return cloudCredentials;
   }
-  const directCredentials = {
-    anthropicKey: runtime.getSetting("ANTHROPIC_API_KEY"),
+  const subscriptionMode = llmProvider === "subscription";
+  const rawAnthropicKey = runtime.getSetting("ANTHROPIC_API_KEY");
+  const anthropicKey = isAnthropicOAuthToken(rawAnthropicKey) ? undefined : rawAnthropicKey;
+  const directCredentials = compactCredentials({
+    anthropicKey: subscriptionMode ? undefined : anthropicKey,
     openaiKey: runtime.getSetting("OPENAI_API_KEY"),
     googleKey: runtime.getSetting("GOOGLE_GENERATIVE_AI_API_KEY"),
     githubToken: runtime.getSetting("GITHUB_TOKEN"),
-    anthropicBaseUrl: runtime.getSetting("ANTHROPIC_BASE_URL"),
+    anthropicBaseUrl: subscriptionMode ? undefined : anthropicKey ? runtime.getSetting("ANTHROPIC_BASE_URL") : undefined,
     openaiBaseUrl: runtime.getSetting("OPENAI_BASE_URL")
-  };
+  });
   return directCredentials;
 }
 
 // src/services/swarm-coordinator.ts
 init_ansi_utils();
+
+// src/services/coordinator-event-normalizer.ts
+function normalizeSource(data) {
+  const source = typeof data?.source === "string" ? data.source : "";
+  switch (source) {
+    case "pty_manager":
+    case "adapter_fast_path":
+    case "session_ready_forward":
+    case "hook":
+      return source;
+    default:
+      return "unknown";
+  }
+}
+function normalizeSessionSnapshot(data) {
+  const session = data?.session;
+  if (!session || typeof session !== "object" || Array.isArray(session)) {
+    return;
+  }
+  const record = session;
+  const id = typeof record.id === "string" ? record.id : undefined;
+  if (!id)
+    return;
+  return {
+    id,
+    ...typeof record.type === "string" ? { type: record.type } : {},
+    ...typeof record.status === "string" ? { status: record.status } : {}
+  };
+}
+function normalizeCoordinatorEvent(sessionId, event, data) {
+  const timestamp = typeof data?.timestamp === "number" ? data.timestamp : Date.now();
+  const source = normalizeSource(data);
+  const session = normalizeSessionSnapshot(data);
+  switch (event) {
+    case "ready":
+      return {
+        sessionId,
+        name: "ready",
+        source,
+        timestamp,
+        rawData: data,
+        ...session ? { session } : {}
+      };
+    case "blocked": {
+      const promptInfo = data?.promptInfo;
+      const promptRecord = promptInfo && typeof promptInfo === "object" && !Array.isArray(promptInfo) ? promptInfo : undefined;
+      const promptText = typeof promptRecord?.prompt === "string" && promptRecord.prompt || typeof promptRecord?.instructions === "string" && promptRecord.instructions || "";
+      return {
+        sessionId,
+        name: "blocked",
+        source,
+        timestamp,
+        rawData: data,
+        ...session ? { session } : {},
+        promptText,
+        ...typeof promptRecord?.type === "string" ? { promptType: promptRecord.type } : {},
+        ...promptRecord ? { promptInfo: promptRecord } : {},
+        autoResponded: data?.autoResponded === true
+      };
+    }
+    case "login_required":
+      return {
+        sessionId,
+        name: "login_required",
+        source,
+        timestamp,
+        rawData: data,
+        ...session ? { session } : {},
+        ...typeof data?.instructions === "string" ? {
+          instructions: data.instructions
+        } : {},
+        ...typeof data?.url === "string" ? {
+          url: data.url
+        } : {}
+      };
+    case "task_complete":
+      return {
+        sessionId,
+        name: "task_complete",
+        source,
+        timestamp,
+        rawData: data,
+        ...session ? { session } : {},
+        response: typeof data?.response === "string" ? data.response : ""
+      };
+    case "tool_running":
+      return {
+        sessionId,
+        name: "tool_running",
+        source,
+        timestamp,
+        rawData: data,
+        ...session ? { session } : {},
+        ...typeof data?.toolName === "string" ? { toolName: data.toolName } : {},
+        ...typeof data?.description === "string" ? { description: data.description } : {}
+      };
+    case "stopped":
+      return {
+        sessionId,
+        name: "stopped",
+        source,
+        timestamp,
+        rawData: data,
+        ...session ? { session } : {},
+        ...typeof data?.reason === "string" ? { reason: data.reason } : {}
+      };
+    case "error":
+      return {
+        sessionId,
+        name: "error",
+        source,
+        timestamp,
+        rawData: data,
+        ...session ? { session } : {},
+        message: typeof data?.message === "string" ? data.message : "unknown error"
+      };
+    case "message":
+      return {
+        sessionId,
+        name: "message",
+        source,
+        timestamp,
+        rawData: data,
+        ...session ? { session } : {},
+        ...typeof data?.content === "string" ? { content: data.content } : {}
+      };
+    default:
+      return null;
+  }
+}
+
+// src/services/swarm-coordinator.ts
 init_swarm_decision_loop();
 
 // src/services/swarm-history.ts
-import * as fs from "fs/promises";
-import * as os2 from "os";
-import * as path4 from "path";
+import * as fs2 from "fs/promises";
+import * as os3 from "os";
+import * as path7 from "path";
 var MAX_ENTRIES = 150;
 var TRUNCATE_TO = 100;
 var MAX_FILE_SIZE_BYTES = 1048576;
@@ -5259,26 +6298,26 @@ class SwarmHistory {
   appendCount = 0;
   mutex = new WriteMutex;
   constructor(stateDir) {
-    const dir = stateDir || process.env.MILADY_STATE_DIR || process.env.ELIZA_STATE_DIR || path4.join(os2.homedir(), ".milady");
-    this.filePath = path4.join(dir, "swarm-history.jsonl");
+    const dir = stateDir || process.env.MILADY_STATE_DIR || process.env.ELIZA_STATE_DIR || path7.join(os3.homedir(), ".milady");
+    this.filePath = path7.join(dir, "swarm-history.jsonl");
   }
   async append(entry) {
     await this.mutex.acquire();
     try {
-      const dir = path4.dirname(this.filePath);
-      await fs.mkdir(dir, { recursive: true });
-      await fs.appendFile(this.filePath, `${JSON.stringify(entry)}
+      const dir = path7.dirname(this.filePath);
+      await fs2.mkdir(dir, { recursive: true });
+      await fs2.appendFile(this.filePath, `${JSON.stringify(entry)}
 `, "utf-8");
       this.appendCount++;
       try {
-        const stat3 = await fs.stat(this.filePath);
+        const stat3 = await fs2.stat(this.filePath);
         if (stat3.size > MAX_FILE_SIZE_BYTES) {
           await this.truncateInner(TRUNCATE_TO);
           return;
         }
       } catch {}
       if (this.appendCount >= MAX_ENTRIES - TRUNCATE_TO) {
-        const content = await fs.readFile(this.filePath, "utf-8");
+        const content = await fs2.readFile(this.filePath, "utf-8");
         const lineCount = content.split(`
 `).filter((l) => l.trim() !== "").length;
         if (lineCount > MAX_ENTRIES) {
@@ -5294,7 +6333,7 @@ class SwarmHistory {
   }
   async readAll() {
     try {
-      const content = await fs.readFile(this.filePath, "utf-8");
+      const content = await fs2.readFile(this.filePath, "utf-8");
       const entries = [];
       const lines = content.split(`
 `);
@@ -5329,7 +6368,7 @@ class SwarmHistory {
     const entries = await this.readAll();
     if (entries.length === 0) {
       try {
-        await fs.stat(this.filePath);
+        await fs2.stat(this.filePath);
         console.error("[swarm-history] truncate aborted: file exists but readAll returned empty");
         return;
       } catch {
@@ -5346,7 +6385,7 @@ class SwarmHistory {
 `) + `
 `;
     }
-    await fs.writeFile(this.filePath, content, "utf-8");
+    await fs2.writeFile(this.filePath, content, "utf-8");
     this.appendCount = 0;
   }
 }
@@ -5354,7 +6393,7 @@ class SwarmHistory {
 // src/services/swarm-idle-watchdog.ts
 init_ansi_utils();
 init_swarm_decision_loop();
-import { ModelType as ModelType5 } from "@elizaos/core";
+import { ModelType as ModelType6 } from "@elizaos/core";
 var IDLE_THRESHOLD_MS = 5 * 60 * 1000;
 var MAX_IDLE_CHECKS = 4;
 async function scanIdleSessions(ctx) {
@@ -5510,7 +6549,7 @@ async function handleIdleCheck(ctx, taskCtx, idleMinutes) {
         repo: taskCtx.repo,
         workdir: taskCtx.workdir,
         originalTask: taskCtx.originalTask
-      }, () => ctx.runtime.useModel(ModelType5.TEXT_SMALL, { prompt }));
+      }, () => ctx.runtime.useModel(ModelType6.TEXT_SMALL, { prompt }));
       decision = parseCoordinationResponse(result);
     } catch (err) {
       ctx.log(`Idle check LLM call failed: ${err}`);
@@ -5554,7 +6593,7 @@ async function handleIdleCheck(ctx, taskCtx, idleMinutes) {
 }
 
 // src/services/task-acceptance.ts
-import { ModelType as ModelType6 } from "@elizaos/core";
+import { ModelType as ModelType7 } from "@elizaos/core";
 var MAX_CRITERIA = 7;
 function trimCriterion(value) {
   return value.replace(/^[\s*-]+/, "").replace(/\s+/g, " ").trim();
@@ -5641,7 +6680,7 @@ async function deriveTaskAcceptanceCriteria(runtime, input) {
     };
   }
   try {
-    const raw = await runtime.useModel(ModelType6.TEXT_SMALL, {
+    const raw = await runtime.useModel(ModelType7.TEXT_SMALL, {
       prompt: buildAcceptancePrompt(input),
       temperature: 0.1,
       stream: false
@@ -5664,9 +6703,69 @@ async function deriveTaskAcceptanceCriteria(runtime, input) {
 
 // src/services/task-agent-frameworks.ts
 import { execFileSync } from "node:child_process";
-import fs2 from "node:fs";
-import os3 from "node:os";
-import path5 from "node:path";
+import fs3 from "node:fs";
+import os4 from "node:os";
+import path8 from "node:path";
+var RESEARCH_SIGNAL_RE = /\b(research|investigate|analy[sz]e|analysis|compare|evaluate|review|study|summari[sz]e|deep research|look into|explore)\b/i;
+var PLANNING_SIGNAL_RE = /\b(plan|planning|roadmap|strategy|spec|architecture|design|scope|milestone|sequence|timeline)\b/i;
+var OPS_SIGNAL_RE = /\b(deploy|release|ship|rollback|monitor|incident|infra|infrastructure|configure|setup|docker|kubernetes|ci|cd|runbook)\b/i;
+var IMPLEMENTATION_SIGNAL_RE = /\b(code|coding|implement|fix|debug|refactor|write|build|patch|feature|server|api|component|function|typescrip?t|javascript|react)\b/i;
+var VERIFICATION_SIGNAL_RE = /\b(test|tests|verify|validation|prove|acceptance|check|regression|benchmark|lint|typecheck|qa)\b/i;
+var COORDINATION_SIGNAL_RE = /\b(parallel|delegate|subagent|sub-agent|swarm|coordinate|coordination|handoff|mailbox|scheduler|orchestrate)\b/i;
+var REPO_SIGNAL_RE = /\b(repo|repository|branch|commit|pull request|pr|diff|workspace|file|directory|codebase)\b/i;
+var FAST_ITERATION_SIGNAL_RE = /\b(fix|debug|patch|flaky|quick|fast|iterate|loop|unblock|repair)\b/i;
+var FRAMEWORK_CAPABILITY_PROFILES = {
+  claude: {
+    implementation: 0.95,
+    research: 0.95,
+    planning: 1,
+    ops: 0.8,
+    verification: 0.85,
+    coordination: 1,
+    repoWork: 0.9,
+    fastIteration: 0.75
+  },
+  codex: {
+    implementation: 1,
+    research: 0.8,
+    planning: 0.75,
+    ops: 0.85,
+    verification: 1,
+    coordination: 0.9,
+    repoWork: 1,
+    fastIteration: 0.95
+  },
+  gemini: {
+    implementation: 0.7,
+    research: 1,
+    planning: 0.95,
+    ops: 0.7,
+    verification: 0.6,
+    coordination: 0.7,
+    repoWork: 0.65,
+    fastIteration: 0.7
+  },
+  aider: {
+    implementation: 0.9,
+    research: 0.45,
+    planning: 0.45,
+    ops: 0.75,
+    verification: 0.85,
+    coordination: 0.35,
+    repoWork: 0.95,
+    fastIteration: 1
+  },
+  pi: {
+    implementation: 0.55,
+    research: 0.5,
+    planning: 0.55,
+    ops: 0.5,
+    verification: 0.5,
+    coordination: 0.35,
+    repoWork: 0.5,
+    fastIteration: 0.5
+  }
+};
 var FRAMEWORK_LABELS = {
   claude: "Claude Code",
   codex: "Codex",
@@ -5718,11 +6817,11 @@ function safeGetSetting(runtime, key) {
   }
 }
 function getUserHomeDir() {
-  return process.env.HOME?.trim() || process.env.USERPROFILE?.trim() || os3.homedir();
+  return process.env.HOME?.trim() || process.env.USERPROFILE?.trim() || os4.homedir();
 }
 function readJsonFile(filePath) {
   try {
-    return JSON.parse(fs2.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs3.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
@@ -5746,10 +6845,10 @@ function resolveMiladyConfigPath() {
   const explicit = process.env.MILADY_CONFIG_PATH?.trim() || process.env.ELIZA_CONFIG_PATH?.trim();
   if (explicit)
     return explicit;
-  const stateDir = process.env.MILADY_STATE_DIR?.trim() || process.env.ELIZA_STATE_DIR?.trim() || path5.join(getUserHomeDir(), ".milady");
+  const stateDir = process.env.MILADY_STATE_DIR?.trim() || process.env.ELIZA_STATE_DIR?.trim() || path8.join(getUserHomeDir(), ".milady");
   const namespace = process.env.ELIZA_NAMESPACE?.trim();
   const filename = !namespace || namespace === "milady" ? "milady.json" : `${namespace}.json`;
-  return path5.join(stateDir, filename);
+  return path8.join(stateDir, filename);
 }
 function readConfiguredSubscriptionProvider() {
   const config = readJsonFile(resolveMiladyConfigPath());
@@ -5765,7 +6864,7 @@ function readConfiguredSubscriptionProvider() {
   return typeof provider === "string" && provider.trim() ? provider.trim() : undefined;
 }
 function hasClaudeSubscriptionAuth() {
-  const credentialsPath = path5.join(getUserHomeDir(), ".claude", ".credentials.json");
+  const credentialsPath = path8.join(getUserHomeDir(), ".claude", ".credentials.json");
   const fileToken = extractOauthAccessToken(readJsonFile(credentialsPath));
   if (fileToken)
     return true;
@@ -5784,7 +6883,7 @@ function hasClaudeApiKey(runtime) {
   return Boolean(process.env.ANTHROPIC_API_KEY?.trim() || safeGetSetting(runtime, "ANTHROPIC_API_KEY"));
 }
 function hasCodexSubscriptionAuth() {
-  const authPath = path5.join(getUserHomeDir(), ".codex", "auth.json");
+  const authPath = path8.join(getUserHomeDir(), ".codex", "auth.json");
   const auth = readJsonFile(authPath);
   if (!auth || typeof auth !== "object" || Array.isArray(auth))
     return false;
@@ -5801,8 +6900,11 @@ function hasElizaCloudApiKey() {
   return Boolean(readConfigCloudKey("apiKey"));
 }
 function hasPiBinary() {
+  return hasBinaryOnPath("pi");
+}
+function hasBinaryOnPath(binaryName) {
   const command = process.platform === "win32" ? "where" : "which";
-  const args = process.platform === "win32" ? ["pi.exe"] : ["pi"];
+  const args = [binaryName];
   try {
     execFileSync(command, args, {
       encoding: "utf8",
@@ -5814,6 +6916,18 @@ function hasPiBinary() {
     return false;
   }
 }
+function hasFrameworkBinary(id) {
+  switch (id) {
+    case "claude":
+      return hasBinaryOnPath("claude");
+    case "codex":
+      return hasBinaryOnPath("codex");
+    case "gemini":
+      return hasBinaryOnPath("gemini");
+    case "aider":
+      return hasBinaryOnPath("aider");
+  }
+}
 function getFrameworkCooldown(id) {
   const cooldown = frameworkCooldowns.get(id);
   if (!cooldown)
@@ -5824,7 +6938,7 @@ function getFrameworkCooldown(id) {
   }
   return cooldown;
 }
-async function computeTaskAgentFrameworkState(runtime, probe) {
+async function computeTaskAgentFrameworkState(runtime, probe, profileInput) {
   const configuredSubscriptionProvider = readConfiguredSubscriptionProvider();
   const preflightByAdapter = new Map;
   if (probe?.checkAvailableAgents) {
@@ -5848,10 +6962,10 @@ async function computeTaskAgentFrameworkState(runtime, probe) {
   const piReady = hasPiBinary();
   const providerPrefersClaude = configuredSubscriptionProvider === "anthropic-subscription";
   const providerPrefersCodex = configuredSubscriptionProvider === "openai-codex" || configuredSubscriptionProvider === "openai-subscription";
-  const frameworks = STANDARD_FRAMEWORKS.map((id) => {
+  const inventory = STANDARD_FRAMEWORKS.map((id) => {
     const preflight = preflightByAdapter.get(id);
     const cooldown = getFrameworkCooldown(id);
-    const installed = preflight?.installed === true;
+    const installed = preflight?.installed === true || hasFrameworkBinary(id);
     const subscriptionReady = id === "claude" ? claudeSubscriptionReady : id === "codex" ? codexSubscriptionReady : false;
     const authReady = id === "claude" ? claudeAuthReady : id === "codex" ? codexAuthReady : id === "gemini" ? geminiAuthReady : claudeAuthReady || codexAuthReady || geminiAuthReady;
     const reason = id === "claude" && subscriptionReady ? "ready to use the user's Claude subscription" : id === "codex" && subscriptionReady ? "ready to use the user's OpenAI subscription" : installed ? authReady ? "installed with credentials available" : "installed but credentials were not detected" : "CLI not detected";
@@ -5870,7 +6984,7 @@ async function computeTaskAgentFrameworkState(runtime, probe) {
       docsUrl: preflight?.docsUrl
     };
   });
-  frameworks.push({
+  inventory.push({
     id: "pi",
     label: FRAMEWORK_LABELS.pi,
     installed: piReady,
@@ -5880,59 +6994,53 @@ async function computeTaskAgentFrameworkState(runtime, probe) {
     recommended: false,
     reason: piReady ? "CLI detected" : "CLI not detected"
   });
-  const byId = new Map(frameworks.map((framework) => [framework.id, framework]));
-  const isSelectable = (id) => !byId.get(id)?.temporarilyDisabled;
+  const frameworks = inventory.map((framework) => ({
+    ...framework,
+    recommended: false
+  }));
+  const metrics = probe?.getAgentMetrics?.() ?? {};
+  const profile = buildTaskAgentTaskProfile(profileInput);
   const explicitDefault = safeGetSetting(runtime, "PARALLAX_DEFAULT_AGENT_TYPE")?.toLowerCase().trim();
-  let preferred;
-  if (explicitDefault && (explicitDefault === "claude" || explicitDefault === "codex" || explicitDefault === "gemini" || explicitDefault === "aider" || explicitDefault === "pi") && byId.get(explicitDefault)?.installed && isSelectable(explicitDefault)) {
-    preferred = {
-      id: explicitDefault,
-      reason: "explicit PARALLAX_DEFAULT_AGENT_TYPE override"
-    };
-  } else if (providerPrefersClaude && byId.get("claude")?.installed && claudeSubscriptionReady && isSelectable("claude")) {
-    preferred = {
-      id: "claude",
-      reason: "configured Claude subscription should drive Claude Code first"
-    };
-  } else if (providerPrefersCodex && byId.get("codex")?.installed && codexSubscriptionReady && isSelectable("codex")) {
-    preferred = {
-      id: "codex",
-      reason: "configured OpenAI subscription should drive Codex first"
-    };
-  } else if (byId.get("claude")?.installed && claudeSubscriptionReady && isSelectable("claude")) {
-    preferred = {
-      id: "claude",
-      reason: "Claude Code is installed and the user is logged in"
-    };
-  } else if (byId.get("codex")?.installed && codexSubscriptionReady && isSelectable("codex")) {
-    preferred = {
-      id: "codex",
-      reason: "Codex is installed and the user is logged in"
-    };
-  } else if (byId.get("claude")?.installed && claudeAuthReady && isSelectable("claude")) {
-    preferred = {
-      id: "claude",
-      reason: "Claude Code is installed and credentials are available"
+  const selectable = frameworks.filter((framework) => framework.installed && !framework.temporarilyDisabled);
+  const candidates = selectable.length > 0 ? selectable : frameworks.filter((framework) => framework.installed);
+  const scoredCandidates = candidates.map((framework) => {
+    const explicitOverride = explicitDefault === framework.id ? framework.installed && !framework.temporarilyDisabled ? 40 : 0 : 0;
+    const providerPreference = providerPrefersClaude && framework.id === "claude" ? framework.subscriptionReady ? 18 : 6 : providerPrefersCodex && framework.id === "codex" ? framework.subscriptionReady ? 18 : 6 : 0;
+    const availabilityScore = (framework.installed ? 40 : -100) + (framework.authReady ? 18 : -25) + (framework.subscriptionReady ? 8 : 0) + (framework.temporarilyDisabled ? -80 : 0);
+    const profileScore = computeProfileFitScore(framework.id, profile);
+    const metricsScore = computeMetricsScore(metrics[framework.id], profile.signals.fastIteration);
+    const selectionSignals = {
+      availability: availabilityScore,
+      profile: profileScore,
+      provider: providerPreference,
+      metrics: metricsScore,
+      explicitOverride
     };
-  } else if (byId.get("codex")?.installed && codexAuthReady && isSelectable("codex")) {
-    preferred = {
-      id: "codex",
-      reason: "Codex is installed and credentials are available"
-    };
-  } else if (byId.get("gemini")?.installed && geminiAuthReady && isSelectable("gemini")) {
-    preferred = {
-      id: "gemini",
-      reason: "Gemini CLI is installed and credentials are available"
-    };
-  } else {
-    const fallback = frameworks.find((framework) => framework.installed && !framework.temporarilyDisabled) ?? frameworks.find((framework) => framework.installed) ?? frameworks[0];
-    preferred = {
-      id: fallback.id,
-      reason: fallback.installed ? "best available installed task-agent framework" : "default fallback while no task-agent CLI is installed"
+    return {
+      framework,
+      score: Object.values(selectionSignals).reduce((sum, value) => sum + value, 0),
+      selectionSignals
     };
-  }
+  });
+  const fallback = candidates[0] ?? frameworks.find((framework) => framework.installed) ?? frameworks[0];
+  const preferredCandidate = scoredCandidates.sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.framework.id.localeCompare(right.framework.id);
+  })[0]?.framework ?? fallback;
+  const preferredSignals = scoredCandidates.find((entry) => entry.framework.id === preferredCandidate.id)?.selectionSignals ?? {};
+  const preferred = {
+    id: preferredCandidate.id,
+    reason: buildPreferredReason(preferredCandidate, profile, preferredSignals, explicitDefault, configuredSubscriptionProvider)
+  };
   for (const framework of frameworks) {
     framework.recommended = framework.id === preferred.id;
+    const scored = scoredCandidates.find((entry) => entry.framework.id === framework.id);
+    if (scored) {
+      framework.selectionScore = scored.score;
+      framework.selectionSignals = scored.selectionSignals;
+    }
   }
   return {
     configuredSubscriptionProvider,
@@ -5940,16 +7048,169 @@ async function computeTaskAgentFrameworkState(runtime, probe) {
     preferred
   };
 }
-async function getTaskAgentFrameworkState(runtime, probe) {
+async function getTaskAgentFrameworkState(runtime, probe, profileInput) {
   if (frameworkStateCache && frameworkStateCache.expiresAt > Date.now()) {
-    return frameworkStateCache.value;
+    return computeTaskAgentFrameworkStateFromInventory(runtime, frameworkStateCache.value, probe, profileInput);
+  }
+  const value = await computeTaskAgentFrameworkState(runtime, probe, profileInput);
+  if (!profileInput) {
+    frameworkStateCache = {
+      expiresAt: Date.now() + 15000,
+      value: {
+        configuredSubscriptionProvider: value.configuredSubscriptionProvider,
+        frameworks: value.frameworks.map((framework) => ({
+          ...framework,
+          recommended: false,
+          selectionScore: undefined,
+          selectionSignals: undefined
+        }))
+      }
+    };
   }
-  const value = await computeTaskAgentFrameworkState(runtime, probe);
+  return value;
+}
+function computeTaskAgentFrameworkStateFromInventory(runtime, inventory, probe, profileInput) {
+  const clonedProbe = {
+    ...probe,
+    checkAvailableAgents: undefined
+  };
   frameworkStateCache = {
     expiresAt: Date.now() + 15000,
-    value
+    value: inventory
   };
-  return value;
+  return {
+    ...computeTaskAgentFrameworkStateFromCachedInventory(runtime, inventory, clonedProbe, profileInput)
+  };
+}
+function computeTaskAgentFrameworkStateFromCachedInventory(runtime, inventory, probe, profileInput) {
+  const metrics = probe?.getAgentMetrics?.() ?? {};
+  const frameworks = inventory.frameworks.map((framework) => ({
+    ...framework,
+    recommended: false
+  }));
+  const profile = buildTaskAgentTaskProfile(profileInput);
+  const configuredSubscriptionProvider = inventory.configuredSubscriptionProvider;
+  const providerPrefersClaude = configuredSubscriptionProvider === "anthropic-subscription";
+  const providerPrefersCodex = configuredSubscriptionProvider === "openai-codex" || configuredSubscriptionProvider === "openai-subscription";
+  const explicitDefault = safeGetSetting(runtime, "PARALLAX_DEFAULT_AGENT_TYPE")?.toLowerCase().trim();
+  const candidates = frameworks.filter((framework) => framework.installed && !framework.temporarilyDisabled).length > 0 ? frameworks.filter((framework) => framework.installed && !framework.temporarilyDisabled) : frameworks.filter((framework) => framework.installed);
+  const scoredCandidates = candidates.map((framework) => {
+    const explicitOverride = explicitDefault === framework.id ? framework.installed && !framework.temporarilyDisabled ? 40 : 0 : 0;
+    const providerPreference = providerPrefersClaude && framework.id === "claude" ? framework.subscriptionReady ? 18 : 6 : providerPrefersCodex && framework.id === "codex" ? framework.subscriptionReady ? 18 : 6 : 0;
+    const availabilityScore = (framework.installed ? 40 : -100) + (framework.authReady ? 18 : -25) + (framework.subscriptionReady ? 8 : 0) + (framework.temporarilyDisabled ? -80 : 0);
+    const profileScore = computeProfileFitScore(framework.id, profile);
+    const metricsScore = computeMetricsScore(metrics[framework.id], profile.signals.fastIteration);
+    const selectionSignals = {
+      availability: availabilityScore,
+      profile: profileScore,
+      provider: providerPreference,
+      metrics: metricsScore,
+      explicitOverride
+    };
+    return {
+      framework,
+      score: Object.values(selectionSignals).reduce((sum, value) => sum + value, 0),
+      selectionSignals
+    };
+  });
+  const fallback = candidates[0] ?? frameworks.find((framework) => framework.installed) ?? frameworks[0];
+  const preferredCandidate = scoredCandidates.sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.framework.id.localeCompare(right.framework.id);
+  })[0]?.framework ?? fallback;
+  const preferredSignals = scoredCandidates.find((entry) => entry.framework.id === preferredCandidate.id)?.selectionSignals ?? {};
+  const preferred = {
+    id: preferredCandidate.id,
+    reason: buildPreferredReason(preferredCandidate, profile, preferredSignals, explicitDefault, configuredSubscriptionProvider)
+  };
+  for (const framework of frameworks) {
+    framework.recommended = framework.id === preferred.id;
+    const scored = scoredCandidates.find((entry) => entry.framework.id === framework.id);
+    if (scored) {
+      framework.selectionScore = scored.score;
+      framework.selectionSignals = scored.selectionSignals;
+    }
+  }
+  frameworkStateCache = {
+    expiresAt: Date.now() + 15000,
+    value: inventory
+  };
+  return {
+    configuredSubscriptionProvider,
+    frameworks,
+    preferred
+  };
+}
+function clampSignal(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function kindBoost(kind, target) {
+  if (kind === "mixed")
+    return 0.25;
+  return kind === target ? 0.4 : 0;
+}
+function buildTaskAgentTaskProfile(input) {
+  const text = [
+    input?.task?.trim(),
+    input?.repo?.trim(),
+    ...(input?.acceptanceCriteria ?? []).map((value) => value.trim())
+  ].filter((value) => Boolean(value)).join(`
+`);
+  const inferredKind = input?.threadKind ?? (OPS_SIGNAL_RE.test(text) ? "ops" : PLANNING_SIGNAL_RE.test(text) ? "planning" : RESEARCH_SIGNAL_RE.test(text) && !IMPLEMENTATION_SIGNAL_RE.test(text) ? "research" : IMPLEMENTATION_SIGNAL_RE.test(text) ? "coding" : RESEARCH_SIGNAL_RE.test(text) ? "mixed" : "coding");
+  const repoPresent = Boolean(input?.repo?.trim() || input?.workdir?.trim());
+  const subtaskCount = Math.max(1, input?.subtaskCount ?? 1);
+  const signals = {
+    implementation: clampSignal((IMPLEMENTATION_SIGNAL_RE.test(text) ? 0.7 : 0.2) + (repoPresent ? 0.15 : 0) + kindBoost(inferredKind, "coding")),
+    research: clampSignal((RESEARCH_SIGNAL_RE.test(text) ? 0.7 : 0.1) + kindBoost(inferredKind, "research")),
+    planning: clampSignal((PLANNING_SIGNAL_RE.test(text) ? 0.75 : 0.1) + kindBoost(inferredKind, "planning")),
+    ops: clampSignal((OPS_SIGNAL_RE.test(text) ? 0.75 : 0.05) + kindBoost(inferredKind, "ops")),
+    verification: clampSignal((VERIFICATION_SIGNAL_RE.test(text) ? 0.8 : 0.15) + ((input?.acceptanceCriteria?.length ?? 0) > 0 ? 0.15 : 0)),
+    coordination: clampSignal((COORDINATION_SIGNAL_RE.test(text) ? 0.7 : 0.05) + (subtaskCount > 1 ? 0.25 : 0)),
+    repoWork: clampSignal((REPO_SIGNAL_RE.test(text) ? 0.7 : 0.1) + (repoPresent ? 0.25 : 0)),
+    fastIteration: clampSignal((FAST_ITERATION_SIGNAL_RE.test(text) ? 0.75 : 0.15) + (inferredKind === "coding" ? 0.1 : 0))
+  };
+  return {
+    text,
+    kind: inferredKind,
+    subtaskCount,
+    repoPresent,
+    signals
+  };
+}
+function computeProfileFitScore(frameworkId, profile) {
+  const capability = FRAMEWORK_CAPABILITY_PROFILES[frameworkId];
+  const weightedSum = profile.signals.implementation * capability.implementation * 18 + profile.signals.research * capability.research * 16 + profile.signals.planning * capability.planning * 14 + profile.signals.ops * capability.ops * 12 + profile.signals.verification * capability.verification * 14 + profile.signals.coordination * capability.coordination * 14 + profile.signals.repoWork * capability.repoWork * 10 + profile.signals.fastIteration * capability.fastIteration * 10;
+  return Math.round(weightedSum);
+}
+function computeMetricsScore(metrics, fastIterationSignal) {
+  if (!metrics || metrics.spawned === 0) {
+    return 0;
+  }
+  const successRate = metrics.spawned > 0 ? metrics.completed / metrics.spawned : 0;
+  const stallRate = metrics.spawned > 0 ? metrics.stallCount / metrics.spawned : 0;
+  const durationBonus = metrics.completed > 0 ? Math.max(-8, Math.min(8, (120000 - metrics.avgCompletionMs) / 120000 * (4 + fastIterationSignal * 4))) : 0;
+  return Math.round(successRate * 14 - stallRate * 12 + durationBonus);
+}
+function buildPreferredReason(framework, profile, selectionSignals, explicitDefault, configuredSubscriptionProvider) {
+  const dominantSignals = Object.entries(profile.signals).sort((left, right) => right[1] - left[1]).slice(0, 2).map(([key]) => key);
+  if (explicitDefault === framework.id && selectionSignals.explicitOverride > 0) {
+    return `explicit PARALLAX_DEFAULT_AGENT_TYPE override, with ${FRAMEWORK_LABELS[framework.id]} still scoring well for ${dominantSignals.join(" + ")} work`;
+  }
+  if (configuredSubscriptionProvider === "anthropic-subscription" && framework.id === "claude" && framework.subscriptionReady) {
+    return `best fit for ${dominantSignals.join(" + ")} work while honoring the configured Claude subscription`;
+  }
+  if ((configuredSubscriptionProvider === "openai-codex" || configuredSubscriptionProvider === "openai-subscription") && framework.id === "codex" && framework.subscriptionReady) {
+    return `best fit for ${dominantSignals.join(" + ")} work while honoring the configured OpenAI subscription`;
+  }
+  if (framework.subscriptionReady) {
+    return `best overall score for ${dominantSignals.join(" + ")} work with subscription-backed auth already available`;
+  }
+  if (framework.authReady) {
+    return `best overall score for ${dominantSignals.join(" + ")} work with credentials already available`;
+  }
+  return `selected as the highest-scoring installed framework for ${dominantSignals.join(" + ")} work`;
 }
 function clearTaskAgentFrameworkStateCache() {
   frameworkStateCache = undefined;
@@ -8147,6 +9408,8 @@ var PAUSE_TIMEOUT_MS = 30000;
 var MAX_PRE_BRIDGE_BUFFER = 100;
 var STOPPED_RECOVERY_WINDOW_MS = 90000;
 var FAILOVER_OUTPUT_MAX_CHARS = 4000;
+var MAX_AUTOMATIC_ERROR_RECOVERIES = 2;
+var ALTERNATE_FRAMEWORK_ERROR_RE = /\b(auth|login|credential|401|403|unauthorized|forbidden|token|api key|not found|enoent|missing executable|command not found)\b/i;
 function inferProviderSource(framework) {
   if (framework.subscriptionReady) {
     return "subscription";
@@ -8264,8 +9527,8 @@ class SwarmCoordinator {
     await this.taskRegistry.recoverInterruptedTasks();
     await this.rehydratePendingDecisions();
     this.ptyService = ptyService;
-    this.unsubscribeEvents = ptyService.onSessionEvent((sessionId, event, data) => {
-      this.handleSessionEvent(sessionId, event, data).catch((err) => {
+    this.unsubscribeEvents = ptyService.onNormalizedSessionEvent((normalized) => {
+      this.handleNormalizedSessionEvent(normalized).catch((err) => {
         this.log(`Error handling event: ${err}`);
       });
     });
@@ -8450,7 +9713,7 @@ class SwarmCoordinator {
     const buffered = [...this.pauseBuffer];
     this.pauseBuffer = [];
     for (const entry of buffered) {
-      this.handleSessionEvent(entry.sessionId, entry.event, entry.data).catch((err) => {
+      this.handleNormalizedSessionEvent(entry).catch((err) => {
         this.log(`Error replaying buffered event: ${err}`);
       });
     }
@@ -8498,7 +9761,9 @@ class SwarmCoordinator {
       repo: context.repo,
       workdir: context.workdir,
       originalTask: context.originalTask
-    }).catch(() => {});
+    }).catch((err) => {
+      this.log(`Failed to append task registration history for ${sessionId}: ${err}`);
+    });
     const taskCtx = this.tasks.get(sessionId);
     const persistPromise = taskCtx ? (async () => {
       const existingThread = await this.taskRegistry.getThreadRecord(threadId);
@@ -8619,7 +9884,7 @@ class SwarmCoordinator {
     if (buffered) {
       this.unregisteredBuffer.delete(sessionId);
       for (const entry of buffered) {
-        this.handleSessionEvent(sessionId, entry.event, entry.data).catch((err) => {
+        this.handleNormalizedSessionEvent(entry.normalized).catch((err) => {
           this.log(`Error replaying buffered event: ${err}`);
         });
       }
@@ -9206,8 +10471,40 @@ ${transcriptExcerpt}` : "",
     const remainder = frameworks.filter((framework) => framework.id !== preferredFrameworkId);
     return [preferred, ...remainder].filter((framework) => Boolean(framework && framework.id !== failedFramework && framework.installed && framework.authReady && !framework.temporarilyDisabled));
   }
+  getRecoveryCandidates(frameworks, currentFramework, preferredFrameworkId, preferAlternative) {
+    const healthy = frameworks.filter((framework) => framework.installed && framework.authReady && !framework.temporarilyDisabled);
+    const byId = new Map(healthy.map((framework) => [framework.id, framework]));
+    const orderedIds = [];
+    if (!preferAlternative) {
+      orderedIds.push(currentFramework);
+    }
+    orderedIds.push(preferredFrameworkId);
+    for (const framework of healthy) {
+      orderedIds.push(framework.id);
+    }
+    const seen = new Set;
+    const candidates = [];
+    for (const id of orderedIds) {
+      if (seen.has(id)) {
+        continue;
+      }
+      seen.add(id);
+      if (preferAlternative && id === currentFramework) {
+        continue;
+      }
+      const framework = byId.get(id);
+      if (framework) {
+        candidates.push(framework);
+      }
+    }
+    return candidates;
+  }
+  shouldPreferAlternativeFrameworkForError(reason) {
+    return ALTERNATE_FRAMEWORK_ERROR_RE.test(reason);
+  }
   formatFailoverPrompt(taskCtx, failedFramework, reason, recentOutput) {
-    const trimmedOutput = recentOutput.trim();
+    const cleanedOutput = cleanForFailoverContext(recentOutput, taskCtx.workdir);
+    const trimmedOutput = cleanedOutput.trim();
     const clippedOutput = trimmedOutput.length > FAILOVER_OUTPUT_MAX_CHARS ? trimmedOutput.slice(-FAILOVER_OUTPUT_MAX_CHARS) : trimmedOutput;
     const recentDecisions = taskCtx.decisions.slice(-5).map((decision, index) => `${index + 1}. ${decision.event}: ${decision.reasoning}${decision.response ? ` (response: ${decision.response})` : ""}`).join(`
 `);
@@ -9228,6 +10525,32 @@ ${clippedOutput}
 ` : "",
       "Use the existing workspace state instead of starting from scratch. Inspect the files, continue the task, run the needed validation, and then report what changed and how you verified it."
     ].filter(Boolean).join(`
+`);
+  }
+  formatErrorRecoveryPrompt(taskCtx, recoveryFramework, reason, recentOutput) {
+    const cleanedOutput = cleanForFailoverContext(recentOutput, taskCtx.workdir);
+    const trimmedOutput = cleanedOutput.trim();
+    const clippedOutput = trimmedOutput.length > FAILOVER_OUTPUT_MAX_CHARS ? trimmedOutput.slice(-FAILOVER_OUTPUT_MAX_CHARS) : trimmedOutput;
+    const recentDecisions = taskCtx.decisions.slice(-5).map((decision, index) => `${index + 1}. ${decision.event}: ${decision.reasoning}${decision.response ? ` (response: ${decision.response})` : ""}`).join(`
+`);
+    const recoveryMode = recoveryFramework === taskCtx.agentType ? `a fresh ${recoveryFramework} session` : `a ${recoveryFramework} recovery session`;
+    return [
+      `Continue an in-progress task after the previous session terminated unexpectedly. Milady started ${recoveryMode} for recovery.`,
+      "",
+      "Original task:",
+      taskCtx.originalTask,
+      "",
+      `Failure reason: ${reason}`,
+      `Workspace: ${taskCtx.workdir}`,
+      "",
+      recentDecisions ? `Recent coordinator decisions:
+${recentDecisions}
+` : "",
+      clippedOutput ? `Recent terminal output from the failed session:
+${clippedOutput}
+` : "",
+      "Use the existing workspace state instead of starting over. Inspect the current files, recover from the failure, continue the task, run the needed validation, and then report exactly what changed and how you verified it."
+    ].filter(Boolean).join(`
 `);
   }
   async handleFrameworkDepletion(taskCtx, sessionId, reason) {
@@ -9325,6 +10648,95 @@ ${clippedOutput}
       replacementLabel
     };
   }
+  async attemptTaskRecovery(taskCtx, errorMsg) {
+    if (!this.ptyService) {
+      return null;
+    }
+    const failedSession = this.ptyService.getSession(taskCtx.sessionId);
+    const priorMetadata = failedSession?.metadata && typeof failedSession.metadata === "object" && !Array.isArray(failedSession.metadata) ? failedSession.metadata : {};
+    const recoveryOrdinal = typeof priorMetadata.recoveryOrdinal === "number" ? priorMetadata.recoveryOrdinal + 1 : 1;
+    if (recoveryOrdinal > MAX_AUTOMATIC_ERROR_RECOVERIES) {
+      return null;
+    }
+    let recoveryFramework = taskCtx.agentType;
+    let recoveryAvailability = null;
+    if (this.isAutomaticFailoverFramework(taskCtx.agentType)) {
+      const frameworkState = await this.ptyService.getFrameworkState();
+      const candidates = this.getRecoveryCandidates(frameworkState.frameworks, taskCtx.agentType, frameworkState.preferred.id, this.shouldPreferAlternativeFrameworkForError(errorMsg));
+      const selected = candidates[0];
+      if (!selected) {
+        return null;
+      }
+      recoveryFramework = selected.id;
+      recoveryAvailability = selected;
+    }
+    const priorOutput = await Promise.race([
+      this.ptyService.getSessionOutput(taskCtx.sessionId, 200),
+      new Promise((resolve2) => setTimeout(() => resolve2(""), 5000))
+    ]);
+    const replacementLabel = `${taskCtx.label} (${recoveryFramework} recovery ${recoveryOrdinal})`;
+    const replacementSession = await this.ptyService.spawnSession({
+      name: failedSession?.name ?? `task-recovery-${Date.now()}-${recoveryFramework}`,
+      agentType: recoveryFramework,
+      workdir: taskCtx.workdir,
+      initialTask: this.formatErrorRecoveryPrompt(taskCtx, recoveryFramework, errorMsg, priorOutput),
+      credentials: buildAgentCredentials(this.runtime),
+      approvalPreset: this.ptyService.defaultApprovalPreset,
+      skipAdapterAutoResponse: true,
+      metadata: {
+        ...priorMetadata,
+        threadId: taskCtx.threadId,
+        requestedType: recoveryFramework,
+        label: replacementLabel,
+        recoveryOrdinal,
+        recoveredFromFramework: taskCtx.agentType,
+        recoveredFromSessionId: taskCtx.sessionId,
+        recoveryReason: errorMsg,
+        recoveryAt: Date.now()
+      }
+    });
+    await this.registerTask(replacementSession.id, {
+      threadId: taskCtx.threadId,
+      taskNodeId: taskCtx.taskNodeId,
+      agentType: recoveryFramework,
+      label: replacementLabel,
+      originalTask: taskCtx.originalTask,
+      workdir: taskCtx.workdir,
+      repo: taskCtx.repo,
+      providerSource: recoveryAvailability ? inferProviderSource(recoveryAvailability) : null,
+      metadata: replacementSession.metadata && typeof replacementSession.metadata === "object" && !Array.isArray(replacementSession.metadata) ? replacementSession.metadata : undefined
+    });
+    await this.taskRegistry.appendEvent({
+      threadId: taskCtx.threadId,
+      sessionId: replacementSession.id,
+      eventType: "task_error_recovery_started",
+      summary: `Continuing "${taskCtx.label}" after an agent error`,
+      data: {
+        fromFramework: taskCtx.agentType,
+        fromSessionId: taskCtx.sessionId,
+        toFramework: recoveryFramework,
+        toSessionId: replacementSession.id,
+        reason: errorMsg,
+        recoveryOrdinal
+      }
+    });
+    this.broadcast({
+      type: "task_recovery_started",
+      sessionId: replacementSession.id,
+      timestamp: Date.now(),
+      data: {
+        fromSessionId: taskCtx.sessionId,
+        fromFramework: taskCtx.agentType,
+        toFramework: recoveryFramework,
+        reason: errorMsg
+      }
+    });
+    return {
+      replacementSessionId: replacementSession.id,
+      replacementFramework: recoveryFramework,
+      replacementLabel
+    };
+  }
   async recordDecision(taskCtx, decision) {
     taskCtx.decisions.push(decision);
     await this.taskRegistry.recordDecision({
@@ -9357,7 +10769,9 @@ ${clippedOutput}
       if (ctx) {
         this.unregisteredBuffer.delete(sessionId);
         for (const entry of stillBuffered) {
-          this.handleSessionEvent(sessionId, entry.event, entry.data).catch(() => {});
+          this.handleNormalizedSessionEvent(entry.normalized).catch((err) => {
+            this.log(`Failed to replay buffered event for ${sessionId}: ${err}`);
+          });
         }
         return;
       }
@@ -9418,6 +10832,22 @@ ${clippedOutput}
     } catch {}
   }
   async handleSessionEvent(sessionId, event, data) {
+    const normalized = normalizeCoordinatorEvent(sessionId, event, data);
+    if (!normalized) {
+      this.broadcast({
+        type: event,
+        sessionId,
+        timestamp: Date.now(),
+        data
+      });
+      return;
+    }
+    await this.handleNormalizedSessionEvent(normalized);
+  }
+  async handleNormalizedSessionEvent(normalized) {
+    const sessionId = normalized.sessionId;
+    const event = normalized.name;
+    const data = normalized.rawData;
     if (!this.scratchDecisionWired) {
       this.wireScratchDecisionCallback();
     }
@@ -9436,7 +10866,7 @@ ${clippedOutput}
           buffer = [];
           this.unregisteredBuffer.set(sessionId, buffer);
         }
-        buffer.push({ event, data, receivedAt: Date.now() });
+        buffer.push({ normalized, receivedAt: Date.now() });
         if (!this.unregisteredRetryTimers.has(sessionId)) {
           this.scheduleUnregisteredRetry(sessionId, 0);
         }
@@ -9466,22 +10896,23 @@ ${clippedOutput}
     taskCtx.lastActivityAt = Date.now();
     taskCtx.idleCheckCount = 0;
     if (this._paused && (event === "blocked" || event === "task_complete")) {
-      const eventData = data;
-      if (!(event === "blocked" && eventData.autoResponded)) {
+      const blockedAutoResponded = event === "blocked" && normalized.autoResponded === true;
+      if (!blockedAutoResponded) {
         this.broadcast({
           type: event === "blocked" ? "blocked_buffered" : "turn_complete_buffered",
           sessionId,
           timestamp: Date.now(),
           data
         });
-        this.pauseBuffer.push({ sessionId, event, data });
+        this.pauseBuffer.push(normalized);
         this.log(`Buffered "${event}" for ${taskCtx.label} (coordinator paused)`);
         return;
       }
     }
     switch (event) {
       case "blocked": {
-        const blockedPrompt = data.promptInfo?.prompt ?? data.promptInfo?.instructions ?? "";
+        const blockedEvent = normalized;
+        const blockedPrompt = blockedEvent.promptText;
         if (this.isAutomaticFailoverFramework(taskCtx.agentType) && isUsageExhaustedTaskAgentError(blockedPrompt)) {
           const failoverResult = await this.handleFrameworkDepletion(taskCtx, sessionId, blockedPrompt);
           taskCtx.status = "error";
@@ -9549,8 +10980,18 @@ ${clippedOutput}
         });
         const errorMsg = data.message ?? "unknown error";
         const failoverResult = await this.handleFrameworkDepletion(taskCtx, sessionId, errorMsg);
+        let recoveryResult = null;
         if (!failoverResult) {
-          this.sendChatMessage(`"${taskCtx.label}" hit an error: ${errorMsg}`, "coding-agent");
+          try {
+            recoveryResult = await this.attemptTaskRecovery(taskCtx, errorMsg);
+          } catch (recoveryError) {
+            this.log(`Automatic error recovery failed for "${taskCtx.label}": ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`);
+          }
+        }
+        if (recoveryResult) {
+          this.sendChatMessage(`"${taskCtx.label}" hit an error: ${errorMsg}. Milady is continuing the same task on ${recoveryResult.replacementFramework}.`, "coding-agent");
+        } else if (!failoverResult) {
+          this.sendChatMessage(`"${taskCtx.label}" hit an error and needs your attention: ${errorMsg}`, "coding-agent");
         }
         taskCtx.status = "error";
         await this.taskRegistry.appendEvent({
@@ -9560,10 +11001,13 @@ ${clippedOutput}
           summary: `Task "${taskCtx.label}" errored`,
           data: { status: "error", message: errorMsg }
         });
-        checkAllTasksComplete(this);
+        if (!failoverResult && !recoveryResult) {
+          checkAllTasksComplete(this);
+        }
         break;
       }
-      case "stopped":
+      case "stopped": {
+        const alreadyTerminal = taskCtx.status === "completed" || taskCtx.status === "error";
         if (taskCtx.status !== "completed" && taskCtx.status !== "error") {
           taskCtx.status = "stopped";
           taskCtx.stoppedAt = Date.now();
@@ -9582,8 +11026,12 @@ ${clippedOutput}
           summary: `Task "${taskCtx.label}" stopped`,
           data: { status: taskCtx.status }
         });
+        if (!alreadyTerminal) {
+          this.sendChatMessage(`"${taskCtx.label}" stopped before completion.`, "coding-agent");
+        }
         checkAllTasksComplete(this);
         break;
+      }
       case "ready":
         taskCtx.status = "active";
         if (taskCtx.agentType === "claude" || taskCtx.agentType === "codex" || taskCtx.agentType === "gemini" || taskCtx.agentType === "aider") {
@@ -9603,6 +11051,35 @@ ${clippedOutput}
           data: { status: "ready" }
         });
         break;
+      case "login_required": {
+        const loginEvent = normalized;
+        taskCtx.status = "blocked";
+        this.broadcast({
+          type: "login_required",
+          sessionId,
+          timestamp: Date.now(),
+          data
+        });
+        await this.taskRegistry.appendEvent({
+          threadId: taskCtx.threadId,
+          sessionId,
+          eventType: "task_status_changed",
+          summary: `Task "${taskCtx.label}" is waiting for login`,
+          data: {
+            status: "blocked",
+            reason: "login_required",
+            instructions: loginEvent.instructions ?? null,
+            url: loginEvent.url ?? null
+          }
+        });
+        const loginParts = [
+          `"${taskCtx.label}" needs a provider login before it can continue.`,
+          loginEvent.instructions?.trim() || "",
+          loginEvent.url ? `Login link: ${loginEvent.url}` : ""
+        ].filter(Boolean);
+        this.sendChatMessage(loginParts.join(" "), "coding-agent");
+        break;
+      }
       case "tool_running": {
         taskCtx.status = "tool_running";
         taskCtx.lastActivityAt = Date.now();
@@ -9636,7 +11113,9 @@ ${clippedOutput}
               }
             } catch {}
           }
-          this.log(`[${taskCtx.label}] Running ${toolDesc}.${urlSuffix} The agent is working outside the terminal.`);
+          const message = `[${taskCtx.label}] Running ${toolDesc}.${urlSuffix} The agent is working outside the terminal.`;
+          this.log(message);
+          this.sendChatMessage(message, "coding-agent");
         }
         break;
       }
@@ -9701,6 +11180,7 @@ ${clippedOutput}
           response: decision.action === "respond" ? decision.useKeys ? `keys:${decision.keys?.join(",")}` : decision.response : undefined,
           reasoning: `Human-approved: ${decision.reasoning}`
         });
+        await this.syncTaskContext(taskCtx);
       }
       await this.executeDecision(sessionId, decision);
       this.pendingDecisions.delete(sessionId);
@@ -9728,6 +11208,9 @@ ${clippedOutput}
           keys: decision.keys
         }
       });
+      if (taskCtx) {
+        this.sendChatMessage(`"${taskCtx.label}" was approved. Milady is continuing the task now.`, "coding-agent");
+      }
     } else {
       if (taskCtx) {
         taskCtx.status = "blocked";
@@ -9738,6 +11221,7 @@ ${clippedOutput}
           decision: "escalate",
           reasoning: "Human rejected the suggested action"
         });
+        await this.syncTaskContext(taskCtx);
       }
       this.pendingDecisions.delete(sessionId);
       await this.taskRegistry.deletePendingDecision(sessionId);
@@ -9756,6 +11240,7 @@ ${clippedOutput}
         timestamp: Date.now(),
         data: { prompt: pending.promptText }
       });
+      this.sendChatMessage(`"${pending.taskContext.label}" remains blocked after the suggested action was rejected. Prompt: ${pending.promptText}`, "coding-agent");
     }
   }
   log(message) {
@@ -9765,6 +11250,21 @@ ${clippedOutput}
 
 // src/services/pty-service.ts
 init_swarm_decision_loop();
+function buildWorkspaceLockMemory(workdir) {
+  return `# Workspace
+
+Your working directory is \`${workdir}\`. Stay inside it: do not \`cd\` to \`/tmp\`, \`/\`, \`$HOME\`, or any other path outside the workspace. Create all files, run all builds, and start all servers from this directory. If you need scratch space, make a subdirectory here.`;
+}
+function prependWorkspaceLockToTask(task, workspaceLock) {
+  if (!task?.trim()) {
+    return;
+  }
+  return `${workspaceLock}
+
+---
+
+${task}`;
+}
 function getCoordinator(runtime) {
   const ptyService = runtime.getService("PTY_SERVICE");
   return ptyService?.coordinator ?? undefined;
@@ -9781,9 +11281,12 @@ class PTYService {
   sessionMetadata = new Map;
   sessionWorkdirs = new Map;
   eventCallbacks = [];
+  normalizedEventCallbacks = [];
   outputUnsubscribers = new Map;
   transcriptUnsubscribers = new Map;
   sessionOutputBuffers = new Map;
+  completionReconcileTimers = new Map;
+  completionSignalSince = new Map;
   terminalSessionStates = new Map;
   adapterCache = new Map;
   taskResponseMarkers = new Map;
@@ -9898,6 +11401,11 @@ class PTYService {
       unsubscribe();
     }
     this.transcriptUnsubscribers.clear();
+    for (const timer of this.completionReconcileTimers.values()) {
+      clearInterval(timer);
+    }
+    this.completionReconcileTimers.clear();
+    this.completionSignalSince.clear();
     if (this.manager) {
       await this.manager.shutdown();
       this.manager = null;
@@ -9926,7 +11434,6 @@ class PTYService {
     }
     const piRequested = isPiAgentType(options.agentType);
     const resolvedAgentType = piRequested ? "shell" : options.agentType;
-    const resolvedInitialTask = piRequested ? toPiCommand(options.initialTask) : options.initialTask;
     const effectiveApprovalPreset = options.approvalPreset ?? (resolvedAgentType !== "shell" ? this.defaultApprovalPreset : undefined);
     const maxSessions = this.serviceConfig.maxConcurrentSessions ?? 8;
     const activeSessions = (await this.listSessions()).length;
@@ -9935,10 +11442,19 @@ class PTYService {
     }
     const sessionId = this.generateSessionId();
     const workdir = options.workdir ?? process.cwd();
+    const workspaceLock = buildWorkspaceLockMemory(workdir);
+    const shouldWriteMemoryFile = resolvedAgentType !== "shell" && Boolean(options.memoryContent?.trim());
+    const effectiveInitialTask = shouldWriteMemoryFile ? options.initialTask : prependWorkspaceLockToTask(options.initialTask, workspaceLock);
+    const resolvedInitialTask = piRequested ? toPiCommand(effectiveInitialTask) : effectiveInitialTask;
     this.sessionWorkdirs.set(sessionId, workdir);
-    if (options.memoryContent && resolvedAgentType !== "shell") {
+    if (shouldWriteMemoryFile) {
+      const fullMemory = options.memoryContent ? `${workspaceLock}
+
+---
+
+${options.memoryContent}` : workspaceLock;
       try {
-        const writtenPath = await this.writeMemoryFile(resolvedAgentType, workdir, options.memoryContent);
+        const writtenPath = await this.writeMemoryFile(resolvedAgentType, workdir, fullMemory);
         this.log(`Wrote memory file for ${resolvedAgentType}: ${writtenPath}`);
       } catch (err) {
         this.log(`Failed to write memory file for ${resolvedAgentType}: ${err}`);
@@ -9978,8 +11494,8 @@ class PTYService {
           settings.hooks = { ...existingHooks, ...hookProtocol.settingsHooks };
           this.log(`Injecting HTTP hooks for session ${sessionId}`);
         }
-        await mkdir3(dirname2(settingsPath), { recursive: true });
-        await writeFile4(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+        await mkdir4(dirname2(settingsPath), { recursive: true });
+        await writeFile5(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
         this.log(`Wrote allowedDirectories [${workdir}] to ${settingsPath}`);
       } catch (err) {
         this.log(`Failed to write Claude settings: ${err}`);
@@ -10002,8 +11518,8 @@ class PTYService {
           settings.hooks = { ...existingHooks, ...hookProtocol.settingsHooks };
           this.log(`Injecting Gemini CLI hooks for session ${sessionId}`);
         }
-        await mkdir3(dirname2(settingsPath), { recursive: true });
-        await writeFile4(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+        await mkdir4(dirname2(settingsPath), { recursive: true });
+        await writeFile5(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
       } catch (err) {
         this.log(`Failed to write Gemini settings: ${err}`);
       }
@@ -10017,20 +11533,6 @@ class PTYService {
       initialTask: resolvedInitialTask,
       approvalPreset: effectiveApprovalPreset
     }, workdir);
-    {
-      const ac = spawnConfig.adapterConfig;
-      const mask = (v) => typeof v === "string" && v.length > 12 ? `${v.slice(0, 8)}...${v.slice(-4)}` : String(v);
-      const parts = [];
-      if (ac?.anthropicKey)
-        parts.push(`anthropicKey=${mask(ac.anthropicKey)}`);
-      if (ac?.anthropicBaseUrl)
-        parts.push(`anthropicBaseUrl=${ac.anthropicBaseUrl}`);
-      if (ac?.openaiKey)
-        parts.push(`openaiKey=${mask(ac.openaiKey)}`);
-      if (ac?.openaiBaseUrl)
-        parts.push(`openaiBaseUrl=${ac.openaiBaseUrl}`);
-      this.log(`[DEBUG] PTY spawn ${resolvedAgentType} adapterConfig credentials: ${parts.join(", ") || "(none)"}`);
-    }
     const session = await this.manager.spawn(spawnConfig);
     this.terminalSessionStates.delete(session.id);
     this.sessionNames.set(session.id, options.name);
@@ -10120,7 +11622,13 @@ class PTYService {
       throw new Error("PTYService not initialized");
     captureFeed(sessionId, input, "stdin");
     this.persistTranscript(sessionId, "stdin", input);
-    return sendToSession(this.ioContext(), sessionId, input);
+    const metadata = this.sessionMetadata.get(sessionId);
+    if (metadata) {
+      metadata.lastSentInput = input;
+    }
+    const message = await sendToSession(this.ioContext(), sessionId, input);
+    this.scheduleCompletionReconcile(sessionId);
+    return message;
   }
   async sendKeysToSession(sessionId, keys) {
     if (!this.manager)
@@ -10136,6 +11644,7 @@ class PTYService {
     try {
       return await stopSession(this.ioContext(), sessionId, this.sessionMetadata, this.sessionWorkdirs, (msg) => this.log(msg), force);
     } finally {
+      this.clearCompletionReconcile(sessionId);
       this.clearTranscriptCapture(sessionId);
     }
   }
@@ -10154,19 +11663,36 @@ class PTYService {
     return "fixed";
   }
   get defaultAgentType() {
+    return this.explicitDefaultAgentType ?? "claude";
+  }
+  get explicitDefaultAgentType() {
     const fromConfig = readConfigEnvKey("PARALLAX_DEFAULT_AGENT_TYPE");
     const fromRuntimeOrEnv = fromConfig || this.runtime.getSetting("PARALLAX_DEFAULT_AGENT_TYPE");
     if (fromRuntimeOrEnv && ["claude", "gemini", "codex", "aider"].includes(fromRuntimeOrEnv.toLowerCase())) {
       return fromRuntimeOrEnv.toLowerCase();
     }
-    return "claude";
+    return null;
   }
-  async resolveAgentType() {
-    const frameworkState = await this.getFrameworkState();
+  async resolveAgentType(selection) {
+    if (this.agentSelectionStrategy === "fixed" && this.explicitDefaultAgentType) {
+      return this.explicitDefaultAgentType;
+    }
+    const frameworkState = await this.getFrameworkState(selection);
     return frameworkState.preferred.id;
   }
-  async getFrameworkState() {
-    return getTaskAgentFrameworkState(this.runtime, this);
+  async getFrameworkState(selection) {
+    const profile = selection ? buildTaskAgentTaskProfile(selection) : undefined;
+    return getTaskAgentFrameworkState(this.runtime, {
+      checkAvailableAgents: (types) => this.checkAvailableAgents(types),
+      getAgentMetrics: () => this.metricsTracker.getAll()
+    }, profile ? {
+      task: selection?.task,
+      repo: selection?.repo,
+      workdir: selection?.workdir,
+      threadKind: profile.kind,
+      subtaskCount: profile.subtaskCount,
+      acceptanceCriteria: selection?.acceptanceCriteria
+    } : selection);
   }
   getSession(sessionId) {
     if (!this.manager)
@@ -10180,7 +11706,10 @@ class PTYService {
     if (!this.manager)
       return [];
     const sessions = this.usingBunWorker ? await this.manager.list() : this.manager.list(filter);
-    const liveSessions = sessions.map((s) => this.toSessionInfo(s, this.sessionWorkdirs.get(s.id)));
+    const liveSessions = sessions.map((session) => {
+      const cached = this.manager?.get(session.id);
+      return this.toSessionInfo(cached ?? session, this.sessionWorkdirs.get(session.id));
+    });
     const terminalSessions = Array.from(this.terminalSessionStates.keys()).filter((sessionId) => !sessions.some((session) => session.id === sessionId)).map((sessionId) => this.toTerminalSessionInfo(sessionId)).filter((session) => session !== undefined);
     return [...liveSessions, ...terminalSessions];
   }
@@ -10198,9 +11727,9 @@ class PTYService {
     if (!this.manager)
       return false;
     if (this.usingBunWorker) {
-      return this.manager.isSessionLoading(sessionId);
+      return this.manager.isSessionLoading?.(sessionId) ?? false;
     }
-    return this.manager.isSessionLoading(sessionId);
+    return this.manager.isSessionLoading?.(sessionId) ?? false;
   }
   clearTranscriptCapture(sessionId) {
     const unsubscribe = this.transcriptUnsubscribers.get(sessionId);
@@ -10280,20 +11809,21 @@ class PTYService {
     }
     switch (event) {
       case "tool_running":
-        this.emitEvent(sessionId, "tool_running", data);
+        this.emitEvent(sessionId, "tool_running", { ...data, source: "hook" });
         break;
       case "task_complete":
-        this.emitEvent(sessionId, "task_complete", data);
+        this.emitEvent(sessionId, "task_complete", { ...data, source: "hook" });
         break;
       case "permission_approved":
         break;
       case "notification":
-        this.emitEvent(sessionId, "message", data);
+        this.emitEvent(sessionId, "message", { ...data, source: "hook" });
         break;
       case "session_end":
         this.emitEvent(sessionId, "stopped", {
           ...data,
-          reason: "session_end"
+          reason: "session_end",
+          source: "hook"
         });
         break;
       default:
@@ -10330,6 +11860,7 @@ class PTYService {
           manager: this.manager,
           metricsTracker: this.metricsTracker,
           debugSnapshots: this.serviceConfig.debug === true,
+          lastSentInput: typeof meta?.lastSentInput === "string" ? meta.lastSentInput : undefined,
           log: (msg) => this.log(msg),
           taskContext: {
             sessionId: taskCtx.sessionId,
@@ -10359,6 +11890,7 @@ class PTYService {
       manager: this.manager,
       metricsTracker: this.metricsTracker,
       debugSnapshots: this.serviceConfig.debug === true,
+      lastSentInput: typeof meta?.lastSentInput === "string" ? meta.lastSentInput : undefined,
       log: (msg) => this.log(msg)
     });
     if (classification && meta?.coordinatorManaged && classification.suggestedResponse) {
@@ -10422,7 +11954,7 @@ class PTYService {
     ];
     try {
       if (existing.length === 0) {
-        await writeFile4(gitignorePath, `${entries.join(`
+        await writeFile5(gitignorePath, `${entries.join(`
 `)}
 `, "utf-8");
       } else {
@@ -10445,6 +11977,14 @@ class PTYService {
         this.eventCallbacks.splice(idx, 1);
     };
   }
+  onNormalizedSessionEvent(callback) {
+    this.normalizedEventCallbacks.push(callback);
+    return () => {
+      const idx = this.normalizedEventCallbacks.indexOf(callback);
+      if (idx !== -1)
+        this.normalizedEventCallbacks.splice(idx, 1);
+    };
+  }
   registerAdapter(adapter) {
     if (!this.manager) {
       throw new Error("PTYService not initialized");
@@ -10491,6 +12031,12 @@ class PTYService {
     };
   }
   emitEvent(sessionId, event, data) {
+    if (event === "blocked" && this.shouldSuppressBlockedEvent(sessionId, data)) {
+      return;
+    }
+    if (event === "ready" || event === "task_complete" || event === "stopped" || event === "error") {
+      this.clearCompletionReconcile(sessionId);
+    }
     if (event === "stopped" || event === "error") {
       const liveSession = this.manager?.get(sessionId);
       const createdAt = liveSession?.startedAt instanceof Date ? liveSession.startedAt : liveSession?.startedAt ? new Date(liveSession.startedAt) : new Date;
@@ -10510,6 +12056,16 @@ class PTYService {
         this.log(`Event callback error: ${err}`);
       }
     }
+    const normalized = normalizeCoordinatorEvent(sessionId, event, data);
+    if (!normalized)
+      return;
+    for (const callback of this.normalizedEventCallbacks) {
+      try {
+        callback(normalized);
+      } catch (err) {
+        this.log(`Normalized event callback error: ${err}`);
+      }
+    }
   }
   getAgentMetrics() {
     return this.metricsTracker.getAll();
@@ -10525,17 +12081,146 @@ class PTYService {
     if (trackedSessionIds.size === 0) {
       return;
     }
-    const reason = info.signal ? `PTY worker exited unexpectedly (signal ${info.signal})` : `PTY worker exited unexpectedly (code ${info.code ?? "unknown"})`;
-    for (const sessionId of trackedSessionIds) {
-      const terminalState = this.terminalSessionStates.get(sessionId);
-      if (terminalState?.status === "stopped" || terminalState?.status === "error") {
-        continue;
-      }
-      this.emitEvent(sessionId, "error", {
-        message: reason,
-        workerExit: info
-      });
+    const reason = info.signal ? `PTY worker exited unexpectedly (signal ${info.signal})` : `PTY worker exited unexpectedly (code ${info.code ?? "unknown"})`;
+    for (const sessionId of trackedSessionIds) {
+      const terminalState = this.terminalSessionStates.get(sessionId);
+      if (terminalState?.status === "stopped" || terminalState?.status === "error") {
+        continue;
+      }
+      this.emitEvent(sessionId, "error", {
+        message: reason,
+        workerExit: info,
+        source: "pty_manager"
+      });
+    }
+  }
+  clearCompletionReconcile(sessionId) {
+    const timer = this.completionReconcileTimers.get(sessionId);
+    if (timer) {
+      clearInterval(timer);
+      this.completionReconcileTimers.delete(sessionId);
+    }
+    this.completionSignalSince.delete(sessionId);
+  }
+  scheduleCompletionReconcile(sessionId) {
+    this.clearCompletionReconcile(sessionId);
+    const timer = setInterval(() => {
+      this.reconcileBusySessionFromOutput(sessionId);
+    }, 1000);
+    this.completionReconcileTimers.set(sessionId, timer);
+    this.reconcileBusySessionFromOutput(sessionId);
+  }
+  isAdapterBackedAgentType(value) {
+    return value === "claude" || value === "gemini" || value === "codex" || value === "aider" || value === "hermes";
+  }
+  shouldSuppressBlockedEvent(sessionId, data) {
+    const payload = data;
+    if (payload?.source !== "pty_manager") {
+      return false;
+    }
+    const promptInfo = payload.promptInfo && typeof payload.promptInfo === "object" && !Array.isArray(payload.promptInfo) ? payload.promptInfo : undefined;
+    if (!promptInfo) {
+      return false;
+    }
+    const promptType = typeof promptInfo.type === "string" ? promptInfo.type.toLowerCase() : "";
+    if (promptType && promptType !== "unknown") {
+      return false;
+    }
+    const promptText = typeof promptInfo.prompt === "string" ? cleanForChat(promptInfo.prompt) : "";
+    if (!promptText) {
+      return false;
+    }
+    const compactPrompt = promptText.replace(/\s+/g, " ").trim();
+    const hasWorkspacePath = /(\/private\/|\/var\/folders\/)/.test(compactPrompt);
+    const looksLikeWorkingStatus = /working \(\d+s .*esc to interrupt\)/i.test(compactPrompt) || /messages to be submitted after next tool call/i.test(compactPrompt) || /find and fix a bug in @filename/i.test(compactPrompt) || /use \/skills to list available skills/i.test(compactPrompt);
+    const looksLikeSpinnerTail = /\b\d+% left\b/i.test(compactPrompt) && hasWorkspacePath;
+    const looksLikeSpinnerFragments2 = hasWorkspacePath && /(?:\bW Wo\b|• Wor|• Work|Worki|Workin|Working)/i.test(compactPrompt);
+    if (!looksLikeWorkingStatus && !looksLikeSpinnerTail && !looksLikeSpinnerFragments2) {
+      return false;
+    }
+    this.log(`Suppressing false blocked prompt noise for ${sessionId}: ${compactPrompt.slice(0, 160)}`);
+    return true;
+  }
+  responseLooksMeaningful(response, rawOutput) {
+    if (extractCompletionSummary(rawOutput).trim().length > 0) {
+      return true;
+    }
+    const cleaned = response.trim();
+    if (!cleaned)
+      return false;
+    const substantiveLines = cleaned.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => !line.startsWith("› ") && !/^Work(?:i|in|ing)?(?:\s+\d+)?$/i.test(line) && !/^\d+% left\b/i.test(line) && !/context left/i.test(line) && !/esc to interrupt/i.test(line) && !/Use \/skills/i.test(line) && !/Messages to be submitted after next tool call/i.test(line));
+    if (substantiveLines.some((line) => /\b(Added|Created|Creating|Updated|Wrote|Deleted|Renamed|Verified|Completed|Finished|Saved|Ran|LIVE_)\b/i.test(line))) {
+      return true;
+    }
+    return false;
+  }
+  async reconcileBusySessionFromOutput(sessionId) {
+    if (!this.manager) {
+      this.clearCompletionReconcile(sessionId);
+      return;
+    }
+    const liveSession = this.manager.get(sessionId);
+    if (!liveSession) {
+      this.clearCompletionReconcile(sessionId);
+      return;
+    }
+    if (liveSession.status !== "busy") {
+      this.clearCompletionReconcile(sessionId);
+      return;
+    }
+    const agentType = this.sessionMetadata.get(sessionId)?.agentType;
+    if (!this.isAdapterBackedAgentType(agentType)) {
+      this.clearCompletionReconcile(sessionId);
+      return;
+    }
+    const adapter = this.getAdapter(agentType);
+    const rawOutput = await this.getSessionOutput(sessionId);
+    if (!rawOutput.trim()) {
+      this.completionSignalSince.delete(sessionId);
+      return;
+    }
+    if (adapter.detectLoading?.(rawOutput)) {
+      this.completionSignalSince.delete(sessionId);
+      return;
+    }
+    if (adapter.detectLogin(rawOutput).required) {
+      this.completionSignalSince.delete(sessionId);
+      return;
+    }
+    if (adapter.detectBlockingPrompt(rawOutput).detected) {
+      this.completionSignalSince.delete(sessionId);
+      return;
+    }
+    const completionSignal = adapter.detectTaskComplete ? adapter.detectTaskComplete(rawOutput) : adapter.detectReady(rawOutput);
+    if (!completionSignal) {
+      this.completionSignalSince.delete(sessionId);
+      return;
+    }
+    const previewResponse = this.taskResponseMarkers.has(sessionId) ? peekTaskResponse(sessionId, this.sessionOutputBuffers, this.taskResponseMarkers) : cleanForChat(rawOutput);
+    if (!this.responseLooksMeaningful(previewResponse, rawOutput)) {
+      this.completionSignalSince.delete(sessionId);
+      return;
+    }
+    const firstSeenAt = this.completionSignalSince.get(sessionId);
+    if (firstSeenAt === undefined) {
+      this.completionSignalSince.set(sessionId, Date.now());
+      return;
     }
+    if (Date.now() - firstSeenAt < 2500) {
+      return;
+    }
+    const response = this.taskResponseMarkers.has(sessionId) ? captureTaskResponse(sessionId, this.sessionOutputBuffers, this.taskResponseMarkers) : previewResponse;
+    const durationMs = liveSession.startedAt ? Date.now() - new Date(liveSession.startedAt).getTime() : 0;
+    liveSession.status = "ready";
+    liveSession.lastActivityAt = new Date;
+    this.metricsTracker.recordCompletion(agentType, "output-reconcile", durationMs);
+    this.log(`Reconciled ${sessionId} from busy to task_complete using stable adapter output`);
+    this.emitEvent(sessionId, "task_complete", {
+      session: liveSession,
+      response,
+      source: "output_reconcile"
+    });
   }
 }
 
@@ -10583,7 +12268,16 @@ var listAgentsAction = {
     const ptyService = runtime.getService("PTY_SERVICE");
     return ptyService != null;
   },
-  handler: async (runtime, _message, _state, _options, callback) => {
+  handler: async (runtime, message, _state, _options, callback) => {
+    const access = await requireTaskAgentAccess(runtime, message, "interact");
+    if (!access.allowed) {
+      if (callback) {
+        await callback({
+          text: access.reason
+        });
+      }
+      return { success: false, error: "FORBIDDEN", text: access.reason };
+    }
     const ptyService = runtime.getService("PTY_SERVICE");
     if (!ptyService) {
       if (callback) {
@@ -10682,169 +12376,6 @@ var listAgentsAction = {
 };
 var listTaskAgentsAction = listAgentsAction;
 
-// src/services/task-policy.ts
-var ROLE_RANK = {
-  GUEST: 0,
-  USER: 1,
-  ADMIN: 2,
-  OWNER: 3
-};
-var DEFAULT_POLICY = {
-  default: "GUEST",
-  connectors: {
-    discord: {
-      create: "ADMIN",
-      interact: "ADMIN"
-    }
-  }
-};
-function normalizeRole(value) {
-  const upper = typeof value === "string" ? value.trim().toUpperCase() : "";
-  switch (upper) {
-    case "OWNER":
-    case "ADMIN":
-    case "USER":
-      return upper;
-    default:
-      return "GUEST";
-  }
-}
-function normalizeConnectorPolicy(value) {
-  if (!value)
-    return {};
-  if (typeof value === "string") {
-    const role = normalizeRole(value);
-    return {
-      create: role,
-      interact: role
-    };
-  }
-  return {
-    ...value.create ? { create: normalizeRole(value.create) } : {},
-    ...value.interact ? { interact: normalizeRole(value.interact) } : {}
-  };
-}
-function parseTaskAgentPolicy(runtime) {
-  const configured = runtime.getSetting("TASK_AGENT_ROLE_POLICY") ?? runtime.getSetting("TASK_AGENT_CONNECTOR_ROLE_POLICY");
-  if (!configured) {
-    return DEFAULT_POLICY;
-  }
-  let parsed = configured;
-  if (typeof configured === "string") {
-    try {
-      parsed = JSON.parse(configured);
-    } catch {
-      return DEFAULT_POLICY;
-    }
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return DEFAULT_POLICY;
-  }
-  const record = parsed;
-  const connectors = record.connectors && typeof record.connectors === "object" && !Array.isArray(record.connectors) ? Object.fromEntries(Object.entries(record.connectors).map(([connector, value]) => [
-    connector,
-    normalizeConnectorPolicy(value)
-  ])) : DEFAULT_POLICY.connectors;
-  return {
-    default: normalizeConnectorPolicy(record.default ?? DEFAULT_POLICY.default),
-    connectors
-  };
-}
-function getConnectorFromBridgeMetadata(message) {
-  const metadata = message.content?.metadata;
-  if (!metadata || typeof metadata !== "object")
-    return null;
-  const bridgeSender = metadata.bridgeSender;
-  if (!bridgeSender || typeof bridgeSender !== "object")
-    return null;
-  const liveMetadata = bridgeSender.metadata;
-  if (!liveMetadata || typeof liveMetadata !== "object")
-    return null;
-  for (const [connector, value] of Object.entries(liveMetadata)) {
-    if (value && typeof value === "object") {
-      return connector;
-    }
-  }
-  return null;
-}
-async function resolveConnectorSource(runtime, message) {
-  const content = message.content;
-  const directSource = typeof content?.source === "string" && content.source !== "client_chat" ? content.source : null;
-  if (directSource)
-    return directSource;
-  const bridgeSource = getConnectorFromBridgeMetadata(message);
-  if (bridgeSource)
-    return bridgeSource;
-  try {
-    const room = await runtime.getRoom(message.roomId);
-    if (typeof room?.source === "string" && room.source.trim().length > 0) {
-      return room.source;
-    }
-  } catch {}
-  return null;
-}
-async function resolveSenderRole(runtime, message) {
-  try {
-    const rolesModuleSpecifier = "@miladyai/plugin-roles";
-    const rolesModule = await import(rolesModuleSpecifier);
-    if (typeof rolesModule.checkSenderRole !== "function") {
-      return null;
-    }
-    return await rolesModule.checkSenderRole(runtime, message);
-  } catch {
-    return null;
-  }
-}
-async function requireTaskAgentAccess(runtime, message, ability) {
-  if (message.entityId === runtime.agentId) {
-    return {
-      allowed: true,
-      connector: null,
-      requiredRole: "GUEST",
-      actualRole: "OWNER"
-    };
-  }
-  const connector = await resolveConnectorSource(runtime, message);
-  const policy = parseTaskAgentPolicy(runtime);
-  const connectorPolicy = connector ? normalizeConnectorPolicy(policy.connectors?.[connector]) : {};
-  const defaultPolicy = normalizeConnectorPolicy(policy.default);
-  const requiredRole = connectorPolicy[ability] ?? defaultPolicy[ability] ?? "GUEST";
-  if (requiredRole === "GUEST") {
-    return {
-      allowed: true,
-      connector,
-      requiredRole,
-      actualRole: "GUEST"
-    };
-  }
-  const roleCheck = await resolveSenderRole(runtime, message);
-  if (!roleCheck) {
-    return {
-      allowed: false,
-      connector,
-      requiredRole,
-      actualRole: "GUEST",
-      reason: connector === "discord" ? "Task-agent access in Discord requires a verified OWNER or ADMIN role." : "Task-agent access requires a verified role, but role context is unavailable."
-    };
-  }
-  const actualRole = normalizeRole(roleCheck.role);
-  if (ROLE_RANK[actualRole] < ROLE_RANK[requiredRole]) {
-    return {
-      allowed: false,
-      connector,
-      requiredRole,
-      actualRole,
-      reason: connector === "discord" ? `Task-agent access in Discord requires ${requiredRole} or higher. Current role: ${actualRole}.` : `Task-agent access requires ${requiredRole} or higher. Current role: ${actualRole}.`
-    };
-  }
-  return {
-    allowed: true,
-    connector,
-    requiredRole,
-    actualRole
-  };
-}
-
 // src/actions/task-thread-target.ts
 function stringValue(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
@@ -11400,17 +12931,17 @@ var taskHistoryAction = {
 // src/services/task-share.ts
 init_ansi_utils();
 import { readFileSync as readFileSync2 } from "node:fs";
-import os4 from "node:os";
-import path6 from "node:path";
+import os5 from "node:os";
+import path9 from "node:path";
 var URL_RE = /\bhttps?:\/\/[^\s<>"'`]+/gi;
 function resolveConfigPath() {
   const explicit = process.env.MILADY_CONFIG_PATH?.trim() || process.env.ELIZA_CONFIG_PATH?.trim();
   if (explicit)
     return explicit;
-  const stateDir = process.env.MILADY_STATE_DIR?.trim() || process.env.ELIZA_STATE_DIR?.trim() || path6.join(os4.homedir(), ".milady");
+  const stateDir = process.env.MILADY_STATE_DIR?.trim() || process.env.ELIZA_STATE_DIR?.trim() || path9.join(os5.homedir(), ".milady");
   const namespace = process.env.ELIZA_NAMESPACE?.trim();
   const filename = !namespace || namespace === "milady" ? "milady.json" : `${namespace}.json`;
-  return path6.join(stateDir, filename);
+  return path9.join(stateDir, filename);
 }
 function readMiladyConfig() {
   try {
@@ -11758,6 +13289,13 @@ var manageIssuesAction = {
     return workspaceService != null;
   },
   handler: async (runtime, message, _state, options, callback) => {
+    const access = await requireTaskAgentAccess(runtime, message, "interact");
+    if (!access.allowed) {
+      if (callback) {
+        await callback({ text: access.reason });
+      }
+      return { success: false, error: "FORBIDDEN", text: access.reason };
+    }
     const workspaceService = runtime.getService("CODING_WORKSPACE_SERVICE");
     if (!workspaceService) {
       if (callback) {
@@ -12140,6 +13678,15 @@ var provisionWorkspaceAction = {
     return workspaceService != null;
   },
   handler: async (runtime, message, state, _options, callback) => {
+    const access = await requireTaskAgentAccess(runtime, message, "create");
+    if (!access.allowed) {
+      if (callback) {
+        await callback({
+          text: access.reason
+        });
+      }
+      return { success: false, error: "FORBIDDEN", text: access.reason };
+    }
     const workspaceService = runtime.getService("CODING_WORKSPACE_SERVICE");
     if (!workspaceService) {
       if (callback) {
@@ -12452,6 +13999,7 @@ var sendToAgentAction = {
               ...existingTask?.repo ? { repo: existingTask.repo } : {},
               metadata: session.metadata && typeof session.metadata === "object" && !Array.isArray(session.metadata) ? session.metadata : undefined
             });
+            await coordinator.setTaskDelivered(sessionId);
           }
         }
         if (callback) {
@@ -12518,8 +14066,8 @@ var sendToAgentAction = {
 var sendToTaskAgentAction = sendToAgentAction;
 
 // src/actions/spawn-agent.ts
-import * as os5 from "node:os";
-import * as path7 from "node:path";
+import * as os6 from "node:os";
+import * as path10 from "node:path";
 import {
   logger as logger5
 } from "@elizaos/core";
@@ -12576,6 +14124,15 @@ var spawnAgentAction = {
     return true;
   },
   handler: async (runtime, message, state, options, callback) => {
+    const access = await requireTaskAgentAccess(runtime, message, "create");
+    if (!access.allowed) {
+      if (callback) {
+        await callback({
+          text: access.reason
+        });
+      }
+      return { success: false, error: "FORBIDDEN", text: access.reason };
+    }
     const ptyService = runtime.getService("PTY_SERVICE");
     if (!ptyService) {
       if (callback) {
@@ -12588,9 +14145,12 @@ var spawnAgentAction = {
     const params = options?.parameters;
     const content = message.content;
     const explicitRawType = params?.agentType ?? content.agentType;
-    const rawAgentType = explicitRawType ?? await ptyService.resolveAgentType();
-    const agentType = normalizeAgentType(rawAgentType);
     const task = params?.task ?? content.task;
+    const rawAgentType = explicitRawType ?? await ptyService.resolveAgentType({
+      task,
+      workdir: (params?.workdir ?? content.workdir) || undefined
+    });
+    const agentType = normalizeAgentType(rawAgentType);
     const piRequested = isPiAgentType(rawAgentType);
     const initialTask = piRequested ? toPiCommand(task) : task;
     let workdir = params?.workdir ?? content.workdir;
@@ -12614,13 +14174,13 @@ var spawnAgentAction = {
       }
       return { success: false, error: "NO_WORKSPACE" };
     }
-    const resolvedWorkdir = path7.resolve(workdir);
-    const workspaceBaseDir = path7.join(os5.homedir(), ".milady", "workspaces");
+    const resolvedWorkdir = path10.resolve(workdir);
+    const workspaceBaseDir = path10.join(os6.homedir(), ".milady", "workspaces");
     const allowedPrefixes = [
-      path7.resolve(workspaceBaseDir),
-      path7.resolve(process.cwd())
+      path10.resolve(workspaceBaseDir),
+      path10.resolve(process.cwd())
     ];
-    const isAllowed = allowedPrefixes.some((prefix) => resolvedWorkdir.startsWith(prefix + path7.sep) || resolvedWorkdir === prefix);
+    const isAllowed = allowedPrefixes.some((prefix) => resolvedWorkdir.startsWith(prefix + path10.sep) || resolvedWorkdir === prefix);
     if (!isAllowed) {
       if (callback) {
         await callback({
@@ -12642,6 +14202,8 @@ var spawnAgentAction = {
           customCredentials[key] = val;
       }
     }
+    const rawAnthropicKey = runtime.getSetting("ANTHROPIC_API_KEY");
+    customCredentials = sanitizeCustomCredentials(customCredentials, isAnthropicOAuthToken(rawAnthropicKey) ? [rawAnthropicKey] : []);
     const llmProvider = readConfigEnvKey("PARALLAX_LLM_PROVIDER") || "subscription";
     let credentials;
     try {
@@ -12813,7 +14375,7 @@ import {
 // src/actions/coding-task-handlers.ts
 import {
   logger as logger7,
-  ModelType as ModelType7
+  ModelType as ModelType8
 } from "@elizaos/core";
 // src/services/trajectory-feedback.ts
 import { logger as elizaLogger } from "@elizaos/core";
@@ -12828,13 +14390,13 @@ function withTimeout2(promise, ms) {
 function getTrajectoryLogger(runtime) {
   const runtimeAny = runtime;
   if (typeof runtimeAny.getService === "function") {
-    const svc = runtimeAny.getService("trajectory_logger");
+    const svc = runtimeAny.getService("trajectories");
     if (svc && typeof svc === "object" && hasListMethod(svc)) {
       return svc;
     }
   }
   if (typeof runtimeAny.getServicesByType === "function") {
-    const services = runtimeAny.getServicesByType("trajectory_logger");
+    const services = runtimeAny.getServicesByType("trajectories");
     if (Array.isArray(services)) {
       for (const svc of services) {
         if (svc && typeof svc === "object" && hasListMethod(svc)) {
@@ -13000,9 +14562,9 @@ function formatAge(timestamp) {
 
 // src/actions/coding-task-helpers.ts
 import { randomUUID } from "node:crypto";
-import * as fs3 from "node:fs";
-import * as os6 from "node:os";
-import * as path8 from "node:path";
+import * as fs4 from "node:fs";
+import * as os7 from "node:os";
+import * as path11 from "node:path";
 import {
   logger as logger6
 } from "@elizaos/core";
@@ -13010,29 +14572,29 @@ function sanitizeDirName(label) {
   return label.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "").slice(0, 60) || "scratch";
 }
 function resolveNonColliding(baseDir, name2) {
-  let candidate = path8.join(baseDir, name2);
-  if (!fs3.existsSync(candidate))
+  let candidate = path11.join(baseDir, name2);
+  if (!fs4.existsSync(candidate))
     return candidate;
   for (let i = 2;i < 100; i++) {
-    candidate = path8.join(baseDir, `${name2}-${i}`);
-    if (!fs3.existsSync(candidate))
+    candidate = path11.join(baseDir, `${name2}-${i}`);
+    if (!fs4.existsSync(candidate))
       return candidate;
   }
-  return path8.join(baseDir, `${name2}-${randomUUID().slice(0, 8)}`);
+  return path11.join(baseDir, `${name2}-${randomUUID().slice(0, 8)}`);
 }
 function createScratchDir(runtime, label) {
   const codingDir = runtime?.getSetting("PARALLAX_CODING_DIRECTORY") ?? readConfigEnvKey("PARALLAX_CODING_DIRECTORY") ?? process.env.PARALLAX_CODING_DIRECTORY;
   if (codingDir?.trim()) {
-    const resolved = codingDir.startsWith("~") ? path8.join(os6.homedir(), codingDir.slice(1)) : path8.resolve(codingDir);
+    const resolved = codingDir.startsWith("~") ? path11.join(os7.homedir(), codingDir.slice(1)) : path11.resolve(codingDir);
     const dirName = label ? sanitizeDirName(label) : `scratch-${randomUUID().slice(0, 8)}`;
     const scratchDir2 = resolveNonColliding(resolved, dirName);
-    fs3.mkdirSync(scratchDir2, { recursive: true });
+    fs4.mkdirSync(scratchDir2, { recursive: true });
     return scratchDir2;
   }
-  const baseDir = path8.join(os6.homedir(), ".milady", "workspaces");
+  const baseDir = path11.join(os7.homedir(), ".milady", "workspaces");
   const scratchId = randomUUID();
-  const scratchDir = path8.join(baseDir, scratchId);
-  fs3.mkdirSync(scratchDir, { recursive: true });
+  const scratchDir = path11.join(baseDir, scratchId);
+  fs4.mkdirSync(scratchDir, { recursive: true });
   return scratchDir;
 }
 function generateLabel(repo, task) {
@@ -13071,9 +14633,6 @@ function registerSessionEvents(ptyService, runtime, sessionId, label, scratchDir
 ${preview}` : `Agent "${label}" completed the task.`
           });
         }
-        ptyService.stopSession(sessionId, true).catch((err) => {
-          logger6.warn(`[START_CODING_TASK] Failed to stop session for "${label}" after task complete: ${err}`);
-        });
       }
       if (event === "error" && callback) {
         callback({
@@ -13171,7 +14730,7 @@ ${taskList}
 
 ` + `Output ONLY the bullet points, no preamble.`;
   try {
-    const result = await withTrajectoryContext(runtime, { source: "orchestrator", decisionType: "swarm-context-generation" }, () => runtime.useModel(ModelType7.TEXT_SMALL, {
+    const result = await withTrajectoryContext(runtime, { source: "orchestrator", decisionType: "swarm-context-generation" }, () => runtime.useModel(ModelType8.TEXT_SMALL, {
       prompt,
       temperature: 0.3,
       stream: false
@@ -13195,6 +14754,7 @@ async function handleMultiAgent(ctx, agentsParam) {
     repo,
     defaultAgentType,
     rawAgentType,
+    agentTypeExplicit,
     memoryContent,
     approvalPreset,
     explicitLabel
@@ -13261,15 +14821,17 @@ async function handleMultiAgent(ctx, agentsParam) {
     } : { subtasks: cleanSubtasks },
     metadata: evalMetadata.metadata
   }) : null;
-  const plannedAgents = agentSpecs.map((spec, i) => {
+  const plannedAgents = await Promise.all(agentSpecs.map(async (spec, i) => {
     let specAgentType = defaultAgentType;
     let specPiRequested = isPiAgentType(rawAgentType);
     let specRequestedType = rawAgentType;
     let specTask = spec;
+    let hasExplicitPrefix = false;
     const colonIdx = spec.indexOf(":");
     if (ctx.agentSelectionStrategy !== "fixed" && colonIdx > 0 && colonIdx < 20) {
       const prefix = spec.slice(0, colonIdx).trim().toLowerCase();
       if (KNOWN_AGENT_PREFIXES.includes(prefix)) {
+        hasExplicitPrefix = true;
         specRequestedType = prefix;
         specPiRequested = isPiAgentType(prefix);
         specAgentType = normalizeAgentType(prefix);
@@ -13279,6 +14841,15 @@ async function handleMultiAgent(ctx, agentsParam) {
       specTask = stripAgentPrefix(spec);
     }
     const specLabel = explicitLabel ? `${explicitLabel}-${i + 1}` : generateLabel(repo, specTask);
+    if (!agentTypeExplicit && !hasExplicitPrefix) {
+      specRequestedType = await ptyService.resolveAgentType({
+        task: specTask,
+        repo,
+        subtaskCount: agentSpecs.length
+      });
+      specPiRequested = isPiAgentType(specRequestedType);
+      specAgentType = normalizeAgentType(specRequestedType);
+    }
     return {
       specAgentType,
       specPiRequested,
@@ -13286,7 +14857,7 @@ async function handleMultiAgent(ctx, agentsParam) {
       specTask,
       specLabel
     };
-  });
+  }));
   const graphPlan = coordinator && taskThread ? await coordinator.planTaskThreadGraph({
     threadId: taskThread.id,
     title: threadTitle,
@@ -13348,6 +14919,8 @@ ${swarmContext}
       const agentMemory = [memoryContent, swarmMemory, pastExperienceBlock].filter(Boolean).join(`
 
 `) || undefined;
+      const coordinatorManagedSession = !!coordinator && llmProvider === "subscription";
+      const useDirectCallbackResponses = Boolean(callback);
       const session = await ptyService.spawnSession({
         name: `coding-${Date.now()}-${i}`,
         agentType: specAgentType,
@@ -13357,7 +14930,7 @@ ${swarmContext}
         credentials,
         approvalPreset: approvalPreset ?? ptyService.defaultApprovalPreset,
         customCredentials,
-        ...coordinator && llmProvider === "subscription" ? { skipAdapterAutoResponse: true } : {},
+        ...coordinatorManagedSession ? { skipAdapterAutoResponse: true } : {},
         metadata: {
           threadId: taskThread?.id,
           taskNodeId,
@@ -13366,12 +14939,15 @@ ${swarmContext}
           userId: message.userId,
           workspaceId,
           label: specLabel,
-          multiAgentIndex: i
+          multiAgentIndex: i,
+          roomId: message.roomId,
+          worldId: message.worldId,
+          source: message.content?.source
         }
       });
       const isScratch = !repo;
       const scratchDir = isScratch ? workdir : null;
-      registerSessionEvents(ptyService, runtime, session.id, specLabel, scratchDir, callback, !!coordinator);
+      registerSessionEvents(ptyService, runtime, session.id, specLabel, scratchDir, callback, coordinatorManagedSession && !useDirectCallbackResponses);
       if (coordinator && specTask) {
         await coordinator.registerTask(session.id, {
           threadId: taskThread?.id ?? session.id,
@@ -13506,8 +15082,6 @@ var startCodingTaskAction = {
     const params = options?.parameters;
     const content = message.content;
     const explicitRawType = params?.agentType ?? content.agentType;
-    const rawAgentType = explicitRawType ?? await ptyService.resolveAgentType();
-    const defaultAgentType = normalizeAgentType(rawAgentType);
     const memoryContent = params?.memoryContent ?? content.memoryContent;
     const approvalPreset = params?.approvalPreset ?? content.approvalPreset;
     let repo = params?.repo ?? content.repo;
@@ -13534,6 +15108,13 @@ var startCodingTaskAction = {
         }
       }
     }
+    const selectionTask = params?.task ?? content.task ?? content.text;
+    const rawAgentType = explicitRawType ?? await ptyService.resolveAgentType({
+      task: selectionTask,
+      repo,
+      subtaskCount: typeof params?.agents === "string" || typeof content.agents === "string" ? (params?.agents ?? content.agents).split("|").map((value) => value.trim()).filter(Boolean).length || 1 : 1
+    });
+    const defaultAgentType = normalizeAgentType(rawAgentType);
     const customCredentialKeys = runtime.getSetting("CUSTOM_CREDENTIAL_KEYS");
     let customCredentials;
     if (customCredentialKeys) {
@@ -13544,6 +15125,8 @@ var startCodingTaskAction = {
           customCredentials[key] = val;
       }
     }
+    const rawAnthropicKey = runtime.getSetting("ANTHROPIC_API_KEY");
+    customCredentials = sanitizeCustomCredentials(customCredentials, isAnthropicOAuthToken(rawAnthropicKey) ? [rawAnthropicKey] : []);
     let credentials;
     try {
       credentials = buildAgentCredentials(runtime);
@@ -13568,6 +15151,7 @@ var startCodingTaskAction = {
       repo,
       defaultAgentType,
       rawAgentType,
+      agentTypeExplicit: Boolean(explicitRawType),
       agentSelectionStrategy: ptyService.agentSelectionStrategy,
       memoryContent,
       approvalPreset,
@@ -13692,6 +15276,15 @@ var stopAgentAction = {
     }
   },
   handler: async (runtime, message, state, options, callback) => {
+    const access = await requireTaskAgentAccess(runtime, message, "interact");
+    if (!access.allowed) {
+      if (callback) {
+        await callback({
+          text: access.reason
+        });
+      }
+      return { success: false, error: "FORBIDDEN", text: access.reason };
+    }
     const ptyService = runtime.getService("PTY_SERVICE");
     if (!ptyService) {
       if (callback) {
@@ -14055,9 +15648,9 @@ var activeWorkspaceContextProvider = {
 };
 
 // src/services/workspace-service.ts
-import * as os8 from "node:os";
-import * as path10 from "node:path";
-import * as fs5 from "node:fs/promises";
+import * as os9 from "node:os";
+import * as path13 from "node:path";
+import * as fs6 from "node:fs/promises";
 import {
   CredentialService,
   GitHubPatClient as GitHubPatClient2,
@@ -14270,23 +15863,23 @@ async function createPR(workspaceService, workspace, workspaceId, options, log)
 }
 
 // src/services/workspace-lifecycle.ts
-import * as fs4 from "node:fs";
-import * as os7 from "node:os";
-import * as path9 from "node:path";
+import * as fs5 from "node:fs";
+import * as os8 from "node:os";
+import * as path12 from "node:path";
 async function removeScratchDir(dirPath, baseDir, log, allowedDirs) {
-  const resolved = path9.resolve(dirPath);
-  const expandTilde = (p) => p.startsWith("~") ? path9.join(os7.homedir(), p.slice(1)) : p;
+  const resolved = path12.resolve(dirPath);
+  const expandTilde = (p) => p.startsWith("~") ? path12.join(os8.homedir(), p.slice(1)) : p;
   const allAllowed = [baseDir, ...allowedDirs ?? []];
   const isAllowed = allAllowed.some((dir) => {
-    const resolvedDir = path9.resolve(expandTilde(dir)) + path9.sep;
-    return resolved.startsWith(resolvedDir) || resolved === path9.resolve(expandTilde(dir));
+    const resolvedDir = path12.resolve(expandTilde(dir)) + path12.sep;
+    return resolved.startsWith(resolvedDir) || resolved === path12.resolve(expandTilde(dir));
   });
   if (!isAllowed) {
     console.warn(`[CodingWorkspaceService] Refusing to remove dir outside allowed paths: ${resolved}`);
     return;
   }
   try {
-    await fs4.promises.rm(resolved, { recursive: true, force: true });
+    await fs5.promises.rm(resolved, { recursive: true, force: true });
     log(`Removed scratch dir ${resolved}`);
   } catch (err) {
     console.warn(`[CodingWorkspaceService] Failed to remove scratch dir ${resolved}:`, err);
@@ -14299,7 +15892,7 @@ async function gcOrphanedWorkspaces(baseDir, workspaceTtlMs, trackedWorkspaceIds
   }
   let entries;
   try {
-    entries = await fs4.promises.readdir(baseDir, { withFileTypes: true });
+    entries = await fs5.promises.readdir(baseDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -14313,12 +15906,12 @@ async function gcOrphanedWorkspaces(baseDir, workspaceTtlMs, trackedWorkspaceIds
       skipped++;
       continue;
     }
-    const dirPath = path9.join(baseDir, entry.name);
+    const dirPath = path12.join(baseDir, entry.name);
     try {
-      const stat3 = await fs4.promises.stat(dirPath);
+      const stat3 = await fs5.promises.stat(dirPath);
       const age = now - stat3.mtimeMs;
       if (age > workspaceTtlMs) {
-        await fs4.promises.rm(dirPath, { recursive: true, force: true });
+        await fs5.promises.rm(dirPath, { recursive: true, force: true });
         removed++;
       } else {
         skipped++;
@@ -14353,7 +15946,7 @@ class CodingWorkspaceService {
   constructor(runtime, config = {}) {
     this.runtime = runtime;
     this.serviceConfig = {
-      baseDir: config.baseDir ?? path10.join(os8.homedir(), ".milady", "workspaces"),
+      baseDir: config.baseDir ?? path13.join(os9.homedir(), ".milady", "workspaces"),
       branchPrefix: config.branchPrefix ?? "milady",
       debug: config.debug ?? false,
       workspaceTtlMs: config.workspaceTtlMs ?? 24 * 60 * 60 * 1000
@@ -14610,7 +16203,7 @@ class CodingWorkspaceService {
   }
   async removeScratchDir(dirPath) {
     const rawCodingDir = this.runtime.getSetting("PARALLAX_CODING_DIRECTORY") ?? this.readConfigEnvKey("PARALLAX_CODING_DIRECTORY") ?? process.env.PARALLAX_CODING_DIRECTORY;
-    const codingDir = rawCodingDir?.trim() ? rawCodingDir.trim().startsWith("~") ? path10.join(os8.homedir(), rawCodingDir.trim().slice(1)) : path10.resolve(rawCodingDir.trim()) : undefined;
+    const codingDir = rawCodingDir?.trim() ? rawCodingDir.trim().startsWith("~") ? path13.join(os9.homedir(), rawCodingDir.trim().slice(1)) : path13.resolve(rawCodingDir.trim()) : undefined;
     const allowedDirs = codingDir ? [codingDir] : undefined;
     return removeScratchDir(dirPath, this.serviceConfig.baseDir, (msg) => this.log(msg), allowedDirs);
   }
@@ -14687,14 +16280,14 @@ class CodingWorkspaceService {
     const suggestedName = this.sanitizeWorkspaceName(name2 || record.label);
     const targetPath = await this.allocatePromotedPath(baseDir, suggestedName);
     try {
-      await fs5.rename(record.path, targetPath);
+      await fs6.rename(record.path, targetPath);
     } catch (error) {
       const isExdev = typeof error === "object" && error !== null && "code" in error && error.code === "EXDEV";
       if (!isExdev)
         throw error;
-      await fs5.cp(record.path, targetPath, { recursive: true });
-      await fs5.access(targetPath);
-      await fs5.rm(record.path, { recursive: true, force: true });
+      await fs6.cp(record.path, targetPath, { recursive: true });
+      await fs6.access(targetPath);
+      await fs6.rm(record.path, { recursive: true, force: true });
     }
     const next = {
       ...record,
@@ -14775,15 +16368,15 @@ class CodingWorkspaceService {
     return compact || `scratch-${Date.now().toString(36)}`;
   }
   async allocatePromotedPath(baseDir, baseName) {
-    const baseResolved = path10.resolve(baseDir);
+    const baseResolved = path13.resolve(baseDir);
     for (let i = 0;i < 1000; i++) {
       const candidateName = i === 0 ? baseName : `${baseName}-${i}`;
-      const candidate = path10.resolve(baseResolved, candidateName);
-      if (candidate !== baseResolved && !candidate.startsWith(`${baseResolved}${path10.sep}`)) {
+      const candidate = path13.resolve(baseResolved, candidateName);
+      if (candidate !== baseResolved && !candidate.startsWith(`${baseResolved}${path13.sep}`)) {
         continue;
       }
       try {
-        await fs5.access(candidate);
+        await fs6.access(candidate);
       } catch {
         return candidate;
       }
@@ -14793,9 +16386,9 @@ class CodingWorkspaceService {
 }
 // src/api/agent-routes.ts
 import { access as access2, readFile as readFile4, realpath, rm as rm2 } from "node:fs/promises";
-import { createHash as createHash2 } from "node:crypto";
-import * as os9 from "node:os";
-import * as path11 from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import * as os10 from "node:os";
+import * as path14 from "node:path";
 import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 var execFileAsync2 = promisify2(execFile2);
@@ -14807,23 +16400,23 @@ function shouldAutoPreflight() {
   return false;
 }
 function isPathInside(parent, candidate) {
-  return candidate === parent || candidate.startsWith(`${parent}${path11.sep}`);
+  return candidate === parent || candidate.startsWith(`${parent}${path14.sep}`);
 }
 async function resolveSafeVenvPath(workdir, venvDirRaw) {
   const venvDir = venvDirRaw.trim();
   if (!venvDir) {
     throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV must be non-empty");
   }
-  if (path11.isAbsolute(venvDir)) {
+  if (path14.isAbsolute(venvDir)) {
     throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV must be relative to workdir");
   }
-  const normalized = path11.normalize(venvDir);
-  if (normalized === "." || normalized === ".." || normalized.startsWith(`..${path11.sep}`)) {
+  const normalized = path14.normalize(venvDir);
+  if (normalized === "." || normalized === ".." || normalized.startsWith(`..${path14.sep}`)) {
     throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV must stay within workdir");
   }
-  const workdirResolved = path11.resolve(workdir);
+  const workdirResolved = path14.resolve(workdir);
   const workdirReal = await realpath(workdirResolved);
-  const resolved = path11.resolve(workdirReal, normalized);
+  const resolved = path14.resolve(workdirReal, normalized);
   if (!isPathInside(workdirReal, resolved)) {
     throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV resolves outside workdir");
   }
@@ -14839,7 +16432,7 @@ async function resolveSafeVenvPath(workdir, venvDirRaw) {
     const maybeErr = err;
     if (maybeErr?.code !== "ENOENT")
       throw err;
-    const parentReal = await realpath(path11.dirname(resolved));
+    const parentReal = await realpath(path14.dirname(resolved));
     if (!isPathInside(workdirReal, parentReal)) {
       throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV parent resolves outside workdir");
     }
@@ -14855,10 +16448,10 @@ async function fileExists(filePath) {
   }
 }
 async function resolveRequirementsPath(workdir) {
-  const workdirReal = await realpath(path11.resolve(workdir));
+  const workdirReal = await realpath(path14.resolve(workdir));
   const candidates = [
-    path11.join(workdir, "apps", "api", "requirements.txt"),
-    path11.join(workdir, "requirements.txt")
+    path14.join(workdir, "apps", "api", "requirements.txt"),
+    path14.join(workdir, "requirements.txt")
   ];
   for (const candidate of candidates) {
     if (!await fileExists(candidate))
@@ -14873,7 +16466,7 @@ async function resolveRequirementsPath(workdir) {
 }
 async function fingerprintRequirementsFile(requirementsPath) {
   const file = await readFile4(requirementsPath);
-  return createHash2("sha256").update(file).digest("hex");
+  return createHash3("sha256").update(file).digest("hex");
 }
 async function runBenchmarkPreflight(workdir) {
   if (!shouldAutoPreflight())
@@ -14885,7 +16478,7 @@ async function runBenchmarkPreflight(workdir) {
   const mode = process.env.PARALLAX_BENCHMARK_PREFLIGHT_MODE?.toLowerCase() === "warm" ? "warm" : "cold";
   const venvDir = process.env.PARALLAX_BENCHMARK_PREFLIGHT_VENV || ".benchmark-venv";
   const venvPath = await resolveSafeVenvPath(workdir, venvDir);
-  const pythonInVenv = path11.join(venvPath, process.platform === "win32" ? "Scripts" : "bin", process.platform === "win32" ? "python.exe" : "python");
+  const pythonInVenv = path14.join(venvPath, process.platform === "win32" ? "Scripts" : "bin", process.platform === "win32" ? "python.exe" : "python");
   const key = `${workdir}::${mode}::${venvPath}::${requirementsFingerprint}`;
   if (PREFLIGHT_DONE.has(key)) {
     if (await fileExists(pythonInVenv))
@@ -15128,21 +16721,21 @@ async function handleAgentRoutes(req, res, pathname, ctx) {
         customCredentials,
         metadata
       } = body;
-      const workspaceBaseDir = path11.join(os9.homedir(), ".milady", "workspaces");
-      const workspaceBaseDirResolved = path11.resolve(workspaceBaseDir);
-      const cwdResolved = path11.resolve(process.cwd());
+      const workspaceBaseDir = path14.join(os10.homedir(), ".milady", "workspaces");
+      const workspaceBaseDirResolved = path14.resolve(workspaceBaseDir);
+      const cwdResolved = path14.resolve(process.cwd());
       const workspaceBaseDirReal = await realpath(workspaceBaseDirResolved).catch(() => workspaceBaseDirResolved);
       const cwdReal = await realpath(cwdResolved).catch(() => cwdResolved);
       const allowedPrefixes = [workspaceBaseDirReal, cwdReal];
       let workdir = rawWorkdir;
       if (workdir) {
-        const resolved = path11.resolve(workdir);
+        const resolved = path14.resolve(workdir);
         const resolvedReal = await realpath(resolved).catch(() => null);
         if (!resolvedReal) {
           sendError(res, "workdir must exist", 403);
           return true;
         }
-        const isAllowed = allowedPrefixes.some((prefix2) => resolvedReal === prefix2 || resolvedReal.startsWith(prefix2 + path11.sep));
+        const isAllowed = allowedPrefixes.some((prefix2) => resolvedReal === prefix2 || resolvedReal.startsWith(prefix2 + path14.sep));
         if (!isAllowed) {
           sendError(res, "workdir must be within workspace base directory or cwd", 403);
           return true;
@@ -15162,12 +16755,15 @@ async function handleAgentRoutes(req, res, pathname, ctx) {
           console.warn(`[coding-agent] benchmark preflight failed for ${workdir}:`, preflightError);
         }
       }
-      const credentials = {
-        anthropicKey: ctx.runtime.getSetting("ANTHROPIC_API_KEY"),
-        openaiKey: ctx.runtime.getSetting("OPENAI_API_KEY"),
-        googleKey: ctx.runtime.getSetting("GOOGLE_GENERATIVE_AI_API_KEY"),
-        githubToken: ctx.runtime.getSetting("GITHUB_TOKEN")
-      };
+      const rawAnthropicKey = ctx.runtime.getSetting("ANTHROPIC_API_KEY");
+      let credentials;
+      try {
+        credentials = buildAgentCredentials(ctx.runtime);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to build credentials";
+        sendError(res, message, 400);
+        return true;
+      }
       const agentStr = agentType ? agentType.toLowerCase() : await ctx.ptyService.resolveAgentType();
       const piRequested = isPiAgentType(agentStr);
       const normalizedType = normalizeAgentType(agentStr);
@@ -15204,7 +16800,7 @@ async function handleAgentRoutes(req, res, pathname, ctx) {
         memoryContent,
         credentials,
         approvalPreset,
-        customCredentials,
+        customCredentials: sanitizeCustomCredentials(customCredentials, isAnthropicOAuthToken(rawAnthropicKey) ? [rawAnthropicKey] : []),
         metadata: {
           threadId: taskThread?.id ?? requestedThreadId,
           requestedType: agentStr,
@@ -16136,5 +17732,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=EA5312D04A2FFC5264756E2164756E21
+//# debugId=FCF9DB7BF01E156E64756E2164756E21
 //# sourceMappingURL=index.js.map