@elizaos/plugin-agent-orchestrator 0.3.0 → 0.3.3

package/dist/index.js

@@ -1,12 +1,16 @@
-import {createRequire} from "node:module";
+import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -21,7 +25,8 @@ function stripAnsi(raw) {
 }
 function cleanForChat(raw) {
   const stripped = applyAnsiStrip(raw);
-  return stripped.replace(TUI_DECORATIVE, " ").replace(/\xa0/g, " ").split("\n").filter((line) => {
+  return stripped.replace(TUI_DECORATIVE, " ").replace(/\xa0/g, " ").split(`
+`).filter((line) => {
     const trimmed = line.trim();
     if (!trimmed)
       return false;
@@ -32,7 +37,10 @@ function cleanForChat(raw) {
     if (!/[a-zA-Z0-9]/.test(trimmed))
       return false;
     return true;
-  }).map((line) => line.replace(/ {2,}/g, " ").trim()).filter((line) => line.length > 0).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+  }).map((line) => line.replace(/ {2,}/g, " ").trim()).filter((line) => line.length > 0).join(`
+`).replace(/\n{3,}/g, `
+
+`).trim();
 }
 function extractCompletionSummary(raw) {
   const stripped = applyAnsiStrip(raw);
@@ -57,7 +65,8 @@ function extractCompletionSummary(raw) {
     for (const m of diffStat)
       lines.push(m.trim());
   }
-  return lines.join("\n");
+  return lines.join(`
+`);
 }
 function extractDevServerUrl(raw) {
   const stripped = applyAnsiStrip(raw);
@@ -71,7 +80,8 @@ function captureTaskResponse(sessionId, buffers, markers) {
     return "";
   const responseLines = buffer.slice(marker);
   markers.delete(sessionId);
-  return cleanForChat(responseLines.join("\n"));
+  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;
 var init_ansi_utils = __esm(() => {
@@ -90,54 +100,208 @@ var init_ansi_utils = __esm(() => {
 
 // src/services/swarm-coordinator-prompts.ts
 function buildCoordinationPrompt(taskCtx, promptText, recentOutput, decisionHistory) {
-  const historySection = decisionHistory.length > 0 ? `\nPrevious decisions for this session:\n${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.promptText}" \u2192 ${d.action}${d.response ? ` ("${d.response}")` : ""} \u2014 ${d.reasoning}`).join("\n")}\n` : "";
-  return `You are Milady, an AI orchestrator managing a swarm of coding agents. ` + `A ${taskCtx.agentType} coding agent ("${taskCtx.label}", session: ${taskCtx.sessionId}) ` + `is blocked and waiting for input.\n\n` + `Original task: "${taskCtx.originalTask}"\n` + `Working directory: ${taskCtx.workdir}\n` + `Repository: ${taskCtx.repo ?? "none (scratch directory)"}\n` + historySection + `\nRecent terminal output (last 50 lines):\n` + `---\n${recentOutput.slice(-3000)}\n---\n\n` + `The agent is showing this blocking prompt:\n` + `"${promptText}"\n\n` + `Decide how to respond. Your options:\n\n` + `1. "respond" \u2014 Send a response to unblock the agent. For text prompts (Y/n, questions), ` + `set "response" to the text to send. For TUI menus or interactive prompts that need ` + `special keys, set "useKeys": true and "keys" to the key sequence ` + `(e.g. ["enter"], ["down","enter"], ["y","enter"]).\n\n` + `2. "complete" \u2014 The original task has been fulfilled. The agent has finished its work ` + `(e.g. code written, PR created, tests passed) and is back at the idle prompt. ` + `Use this when the terminal output shows the task objectives have been met.\n\n` + `3. "escalate" \u2014 The prompt requires human judgment (e.g. design decisions, ` + `ambiguous requirements, security-sensitive actions). Do NOT respond yourself.\n\n` + `4. "ignore" \u2014 The prompt is not actually blocking or is already being handled.
+  const historySection = decisionHistory.length > 0 ? `
+Previous decisions for this session:
+${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.promptText}" → ${d.action}${d.response ? ` ("${d.response}")` : ""} — ${d.reasoning}`).join(`
+`)}
+` : "";
+  return `You are Milady, an AI orchestrator managing a swarm of coding agents. ` + `A ${taskCtx.agentType} coding agent ("${taskCtx.label}", session: ${taskCtx.sessionId}) ` + `is blocked and waiting for input.
+
+` + `Original task: "${taskCtx.originalTask}"
+` + `Working directory: ${taskCtx.workdir}
+` + `Repository: ${taskCtx.repo ?? "none (scratch directory)"}
+` + historySection + `
+Recent terminal output (last 50 lines):
+` + `---
+${recentOutput.slice(-3000)}
+---
+
+` + `The agent is showing this blocking prompt:
+` + `"${promptText}"
+
+` + `Decide how to respond. Your options:
+
+` + `1. "respond" — Send a response to unblock the agent. For text prompts (Y/n, questions), ` + `set "response" to the text to send. For TUI menus or interactive prompts that need ` + `special keys, set "useKeys": true and "keys" to the key sequence ` + `(e.g. ["enter"], ["down","enter"], ["y","enter"]).
+
+` + `2. "complete" — The original task has been fulfilled. The agent has finished its work ` + `(e.g. code written, PR created, tests passed) and is back at the idle prompt. ` + `Use this when the terminal output shows the task objectives have been met.
 
-` + `Guidelines:\n` + `- IMPORTANT: If the prompt asks to approve access to files or directories OUTSIDE the working ` + `directory (${taskCtx.workdir}), DECLINE the request and REDIRECT the agent. Do NOT approve ` + `access to paths like /etc, ~/.ssh, ~/, /tmp, or any path that doesn't start with the working ` + `directory. Instead, respond with "n" (or the decline option) and tell the agent: ` + `"That path is outside your workspace. Use ${taskCtx.workdir} instead \u2014 ` + `create any files or directories you need there." This keeps the agent moving without ` + `granting out-of-scope access. The coordinator will also notify the human in case ` + `broader access was intended.\n` + `- For tool approval prompts (file writes, shell commands, etc.), respond "y" or use keys:["enter"] to approve.\n` + `- For Y/n confirmations that align with the original task, respond "y".\n` + `- For design questions or choices that could go either way, escalate.\n` + `- For error recovery prompts, try to respond if the path forward is clear.\n` + `- If the output shows a PR was just created (e.g. "Created pull request #N"), do NOT use "complete" yet. ` + `Instead respond with "Review your PR, run each test plan item to verify it works, update the PR to check off each item, then confirm all items pass".\n` + `- Only use "complete" if the agent confirmed it verified ALL test plan items after creating the PR.\n` + `- If the agent is asking for information that was NOT provided in the original task ` + `(e.g. which repository to use, project requirements, credentials), ESCALATE. ` + `The coordinator does not have this information \u2014 the human must provide it.
-` + `- When in doubt, escalate \u2014 it's better to ask the human than to make a wrong choice.
+` + `3. "escalate" — The prompt requires human judgment (e.g. design decisions, ` + `ambiguous requirements, security-sensitive actions). Do NOT respond yourself.
 
-` + `Respond with ONLY a JSON object:\n` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}`;
+` + `4. "ignore" — The prompt is not actually blocking or is already being handled.
+
+` + `Guidelines:
+` + `- IMPORTANT: If the prompt asks to approve access to files or directories OUTSIDE the working ` + `directory (${taskCtx.workdir}), DECLINE the request and REDIRECT the agent. Do NOT approve ` + `access to paths like /etc, ~/.ssh, ~/, /tmp, or any path that doesn't start with the working ` + `directory. Instead, respond with "n" (or the decline option) and tell the agent: ` + `"That path is outside your workspace. Use ${taskCtx.workdir} instead — ` + `create any files or directories you need there." This keeps the agent moving without ` + `granting out-of-scope access. The coordinator will also notify the human in case ` + `broader access was intended.
+` + `- For tool approval prompts (file writes, shell commands, etc.), respond "y" or use keys:["enter"] to approve.
+` + `- For Y/n confirmations that align with the original task, respond "y".
+` + `- For design questions or choices that could go either way, escalate.
+` + `- For error recovery prompts, try to respond if the path forward is clear.
+` + `- If the output shows a PR was just created (e.g. "Created pull request #N"), do NOT use "complete" yet. ` + `Instead respond with "Review your PR, run each test plan item to verify it works, update the PR to check off each item, then confirm all items pass".
+` + `- Only use "complete" if the agent confirmed it verified ALL test plan items after creating the PR.
+` + `- If the agent is asking for information that was NOT provided in the original task ` + `(e.g. which repository to use, project requirements, credentials), ESCALATE. ` + `The coordinator does not have this information — the human must provide it.
+` + `- When in doubt, escalate — it's better to ask the human than to make a wrong choice.
+
+` + `Respond with ONLY a JSON object:
+` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}`;
 }
 function buildIdleCheckPrompt(taskCtx, recentOutput, idleMinutes, idleCheckNumber, maxIdleChecks, decisionHistory) {
-  const historySection = decisionHistory.length > 0 ? `\nPrevious decisions for this session:\n${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.promptText}" \u2192 ${d.action}${d.response ? ` ("${d.response}")` : ""} \u2014 ${d.reasoning}`).join("\n")}\n` : "";
-  return `You are Milady, an AI orchestrator managing a swarm of coding agents. ` + `A ${taskCtx.agentType} coding agent ("${taskCtx.label}", session: ${taskCtx.sessionId}) ` + `has been idle for ${idleMinutes} minutes with no events or output changes.\n\n` + `Original task: "${taskCtx.originalTask}"\n` + `Working directory: ${taskCtx.workdir}\n` + `Repository: ${taskCtx.repo ?? "none (scratch directory)"}\n` + `Idle check: ${idleCheckNumber} of ${maxIdleChecks} (session will be force-escalated after ${maxIdleChecks})\n` + historySection + `\nRecent terminal output (last 50 lines):\n` + `---\n${recentOutput.slice(-3000)}\n---\n\n` + `The session has gone silent. Analyze the terminal output and decide:\n\n` + `1. "complete" \u2014 The task is FULLY done. ALL objectives in the original task were met ` + `AND the final deliverable is visible in the output (e.g. a PR URL was printed, or the ` + `task explicitly did not require a PR). The agent is back at the idle prompt.\n\n` + `2. "respond" \u2014 The agent appears stuck or waiting for input that wasn't detected ` + `as a blocking prompt. Send a message to nudge it (e.g. "continue", or answer a question ` + `visible in the output). If code was committed but no PR was created yet, respond with ` + `"please create a pull request with your changes" or similar.\n\n` + `3. "escalate" \u2014 Something looks wrong or unclear. The human should review.
+  const historySection = decisionHistory.length > 0 ? `
+Previous decisions for this session:
+${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.promptText}" → ${d.action}${d.response ? ` ("${d.response}")` : ""} — ${d.reasoning}`).join(`
+`)}
+` : "";
+  return `You are Milady, an AI orchestrator managing a swarm of coding agents. ` + `A ${taskCtx.agentType} coding agent ("${taskCtx.label}", session: ${taskCtx.sessionId}) ` + `has been idle for ${idleMinutes} minutes with no events or output changes.
+
+` + `Original task: "${taskCtx.originalTask}"
+` + `Working directory: ${taskCtx.workdir}
+` + `Repository: ${taskCtx.repo ?? "none (scratch directory)"}
+` + `Idle check: ${idleCheckNumber} of ${maxIdleChecks} (session will be force-escalated after ${maxIdleChecks})
+` + historySection + `
+Recent terminal output (last 50 lines):
+` + `---
+${recentOutput.slice(-3000)}
+---
+
+` + `The session has gone silent. Analyze the terminal output and decide:
+
+` + `1. "complete" — The task is FULLY done. ALL objectives in the original task were met ` + `AND the final deliverable is visible in the output (e.g. a PR URL was printed, or the ` + `task explicitly did not require a PR). The agent is back at the idle prompt.
+
+` + `2. "respond" — The agent appears stuck or waiting for input that wasn't detected ` + `as a blocking prompt. Send a message to nudge it (e.g. "continue", or answer a question ` + `visible in the output). If code was committed but no PR was created yet, respond with ` + `"please create a pull request with your changes" or similar.
+
+` + `3. "escalate" — Something looks wrong or unclear. The human should review.
 
-` + `4. "ignore" \u2014 The agent is still actively working (e.g. compiling, running tests, ` + `pushing to remote, creating a PR). The idle period is expected and it will produce output soon.\n\n` + `Guidelines:\n` + `- IMPORTANT: Do NOT mark "complete" if the original task involves creating a PR and no PR URL ` + `(e.g. github.com/...pull/...) appears in the output. Instead use "respond" to nudge the agent ` + `to create the PR.\n` + `- Do NOT mark "complete" just because code was committed \u2014 commits alone don't finish a task ` + `that requires a PR.\n` + `- Network operations (git push, gh pr create, API calls) can cause several minutes of silence \u2014 ` + `prefer "ignore" for early idle checks if the agent was mid-workflow.\n` + `- If the output ends with a command prompt (\$ or >) and ALL task objectives are confirmed met, use "complete".\n` + `- If the output shows an error or the agent seems stuck in a loop, escalate.\n` + `- If the agent is clearly mid-operation (build output, test runner, git operations), use "ignore".\n` + `- On check ${idleCheckNumber} of ${maxIdleChecks} \u2014 if unsure, lean toward "respond" with a nudge rather than "complete".
+` + `4. "ignore" — The agent is still actively working (e.g. compiling, running tests, ` + `pushing to remote, creating a PR). The idle period is expected and it will produce output soon.
 
-` + `Respond with ONLY a JSON object:\n` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}`;
+` + `Guidelines:
+` + `- IMPORTANT: Do NOT mark "complete" if the original task involves creating a PR and no PR URL ` + `(e.g. github.com/...pull/...) appears in the output. Instead use "respond" to nudge the agent ` + `to create the PR.
+` + `- Do NOT mark "complete" just because code was committed — commits alone don't finish a task ` + `that requires a PR.
+` + `- Network operations (git push, gh pr create, API calls) can cause several minutes of silence — ` + `prefer "ignore" for early idle checks if the agent was mid-workflow.
+` + `- If the output ends with a command prompt ($ or >) and ALL task objectives are confirmed met, use "complete".
+` + `- If the output shows an error or the agent seems stuck in a loop, escalate.
+` + `- If the agent is clearly mid-operation (build output, test runner, git operations), use "ignore".
+` + `- On check ${idleCheckNumber} of ${maxIdleChecks} — if unsure, lean toward "respond" with a nudge rather than "complete".
+
+` + `Respond with ONLY a JSON object:
+` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}`;
 }
 function buildTurnCompletePrompt(taskCtx, turnOutput, decisionHistory) {
-  const historySection = decisionHistory.length > 0 ? `\nPrevious decisions for this session:\n${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.promptText}" \u2192 ${d.action}${d.response ? ` ("${d.response}")` : ""} \u2014 ${d.reasoning}`).join("\n")}\n` : "";
-  return `You are Milady, an AI orchestrator managing a swarm of coding agents. ` + `A ${taskCtx.agentType} coding agent ("${taskCtx.label}", session: ${taskCtx.sessionId}) ` + `just finished a turn and is back at the idle prompt waiting for input.\n\n` + `Original task: "${taskCtx.originalTask}"\n` + `Working directory: ${taskCtx.workdir}\n` + `Repository: ${taskCtx.repo ?? "none (scratch directory)"}\n` + historySection + `\nOutput from this turn:\n` + `---\n${turnOutput.slice(-3000)}\n---\n\n` + `The agent completed a turn. Decide if the OVERALL task is done or if more work is needed.\n\n` + `IMPORTANT: Coding agents work in multiple turns. A single turn completing does NOT mean ` + `the task is done. You must verify that EVERY objective in the original task has been addressed ` + `in the output before declaring "complete".\n\n` + `Your options:\n\n` + `1. "respond" \u2014 The agent finished a step but the overall task is NOT done yet. ` + `Send a follow-up instruction to continue. Set "response" to the next instruction ` + `(e.g. "Now run the tests", "Create a PR with these changes", "Continue with the next part"). ` + `THIS IS THE DEFAULT \u2014 most turns are intermediate steps, not the final result.
+  const historySection = decisionHistory.length > 0 ? `
+Previous decisions for this session:
+${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] prompt="${d.promptText}" → ${d.action}${d.response ? ` ("${d.response}")` : ""} — ${d.reasoning}`).join(`
+`)}
+` : "";
+  return `You are Milady, an AI orchestrator managing a swarm of coding agents. ` + `A ${taskCtx.agentType} coding agent ("${taskCtx.label}", session: ${taskCtx.sessionId}) ` + `just finished a turn and is back at the idle prompt waiting for input.
+
+` + `Original task: "${taskCtx.originalTask}"
+` + `Working directory: ${taskCtx.workdir}
+` + `Repository: ${taskCtx.repo ?? "none (scratch directory)"}
+` + historySection + `
+Output from this turn:
+` + `---
+${turnOutput.slice(-3000)}
+---
+
+` + `The agent completed a turn. Decide if the OVERALL task is done or if more work is needed.
+
+` + `IMPORTANT: Coding agents work in multiple turns. A single turn completing does NOT mean ` + `the task is done. You must verify that EVERY objective in the original task has been addressed ` + `in the output before declaring "complete".
+
+` + `Your options:
+
+` + `1. "respond" — The agent finished a step but the overall task is NOT done yet. ` + `Send a follow-up instruction to continue. Set "response" to the next instruction ` + `(e.g. "Now run the tests", "Create a PR with these changes", "Continue with the next part"). ` + `THIS IS THE DEFAULT — most turns are intermediate steps, not the final result.
+
+` + `2. "complete" — The original task objectives have ALL been fully met. For repo-based tasks, ` + `this means code was written, changes were committed, pushed, AND a pull request was created. ` + `Only use this when you can point to specific evidence in the output for EVERY objective ` + `(e.g. "Created pull request #N" in the output).
 
-` + `2. "complete" \u2014 The original task objectives have ALL been fully met. For repo-based tasks, ` + `this means code was written, changes were committed, pushed, AND a pull request was created. ` + `Only use this when you can point to specific evidence in the output for EVERY objective ` + `(e.g. "Created pull request #N" in the output).\n\n` + `3. "escalate" \u2014 Something looks wrong or you're unsure whether the task is complete. ` + `Let the human decide.\n\n` + `4. "ignore" \u2014 Should not normally be used here.
+` + `3. "escalate" — Something looks wrong or you're unsure whether the task is complete. ` + `Let the human decide.
 
-` + `Guidelines:\n` + `- BEFORE choosing "complete", enumerate each objective from the original task and verify ` + `evidence in the output. If ANY objective lacks evidence, use "respond" with the missing work.\n` + `- A PR being created does NOT mean the task is done \u2014 check that the PR covers ALL requested changes.
-` + `- If the task mentions multiple features/fixes, verify EACH one is addressed, not just the first.\n` + `- If the agent only analyzed code or read files, it hasn't done the actual work yet \u2014 send a follow-up.
-` + `- If the agent wrote code but didn't test it and testing seems appropriate, ask it to run tests.\n` + `- If the output shows errors or failed tests, send a follow-up to fix them.\n` + `- IMPORTANT: If the working directory is a git repository clone (not a scratch dir), the agent ` + `MUST commit its changes, push them, and create a pull request before the task can be "complete". ` + `If the output only shows code edits with no git commit or PR, respond with "Now commit your changes, push, and create a pull request".\n` + `- IMPORTANT: Creating a PR is NOT the final step. If this is the turn where the PR was created ` + `(i.e. "Created pull request" or a PR URL appears for the FIRST time and no previous decision ` + `already sent a review follow-up), respond with "Review your PR, run each test plan item to verify ` + `it works, update the PR to check off each item, then confirm all items pass".\n` + `- If a previous decision ALREADY sent a review/verification follow-up (check the decision history), ` + `and the agent has now responded with its review results, you MAY mark "complete" if the agent ` + `indicates the work is done (e.g. "Done", "verified", "all checks pass", "Here's what I did", ` + `or a clear summary of completed work). Do NOT require exact phrases \u2014 use judgment.
-` + `- Keep follow-up instructions concise and specific.\n` + `- Default to "respond" \u2014 only use "complete" when you're certain ALL work is done.
+` + `4. "ignore" — Should not normally be used here.
 
-` + `Respond with ONLY a JSON object:\n` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}`;
+` + `Guidelines:
+` + `- BEFORE choosing "complete", enumerate each objective from the original task and verify ` + `evidence in the output. If ANY objective lacks evidence, use "respond" with the missing work.
+` + `- A PR being created does NOT mean the task is done — check that the PR covers ALL requested changes.
+` + `- If the task mentions multiple features/fixes, verify EACH one is addressed, not just the first.
+` + `- If the agent only analyzed code or read files, it hasn't done the actual work yet — send a follow-up.
+` + `- If the agent wrote code but didn't test it and testing seems appropriate, ask it to run tests.
+` + `- If the output shows errors or failed tests, send a follow-up to fix them.
+` + `- IMPORTANT: If the working directory is a git repository clone (not a scratch dir), the agent ` + `MUST commit its changes, push them, and create a pull request before the task can be "complete". ` + `If the output only shows code edits with no git commit or PR, respond with "Now commit your changes, push, and create a pull request".
+` + `- IMPORTANT: Creating a PR is NOT the final step. If this is the turn where the PR was created ` + `(i.e. "Created pull request" or a PR URL appears for the FIRST time and no previous decision ` + `already sent a review follow-up), respond with "Review your PR, run each test plan item to verify ` + `it works, update the PR to check off each item, then confirm all items pass".
+` + `- If a previous decision ALREADY sent a review/verification follow-up (check the decision history), ` + `and the agent has now responded with its review results, you MAY mark "complete" if the agent ` + `indicates the work is done (e.g. "Done", "verified", "all checks pass", "Here's what I did", ` + `or a clear summary of completed work). Do NOT require exact phrases — use judgment.
+` + `- Keep follow-up instructions concise and specific.
+` + `- When asking agents to verify work, prefer CLI tools (gh, curl, cat, git diff, etc.) over ` + `browser automation. Browser tools may not be available in headless environments and can cause delays.
+` + `- Default to "respond" — only use "complete" when you're certain ALL work is done.
+
+` + `Respond with ONLY a JSON object:
+` + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}`;
 }
 function buildBlockedEventMessage(taskCtx, promptText, recentOutput, decisionHistory) {
-  const historySection = decisionHistory.length > 0 ? `\nPrevious decisions:\n${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] "${d.promptText}" \u2192 ${d.action}${d.response ? ` ("${d.response}")` : ""} \u2014 ${d.reasoning}`).join("\n")}\n` : "";
-  return `[Coding Agent Event] A ${taskCtx.agentType} agent ("${taskCtx.label}") is blocked and waiting for input.\n\n` + `Task: "${taskCtx.originalTask}"\n` + `Workdir: ${taskCtx.workdir}\n` + `Repo: ${taskCtx.repo ?? "none (scratch directory)"}\n` + historySection + `\nRecent terminal output:\n---\n${recentOutput.slice(-3000)}\n---\n\n` + `Blocking prompt: "${promptText}"\n\n` + `Decide how to handle this. Options:\n` + `- "respond" \u2014 send text or keys to unblock the agent
-` + `- "complete" \u2014 the task is fully done
-` + `- "escalate" \u2014 you need the user's input
-` + `- "ignore" \u2014 not actually blocking
+  const historySection = decisionHistory.length > 0 ? `
+Previous decisions:
+${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] "${d.promptText}" → ${d.action}${d.response ? ` ("${d.response}")` : ""} — ${d.reasoning}`).join(`
+`)}
+` : "";
+  return `[Coding Agent Event] A ${taskCtx.agentType} agent ("${taskCtx.label}") is blocked and waiting for input.
+
+` + `Task: "${taskCtx.originalTask}"
+` + `Workdir: ${taskCtx.workdir}
+` + `Repo: ${taskCtx.repo ?? "none (scratch directory)"}
+` + historySection + `
+Recent terminal output:
+---
+${recentOutput.slice(-3000)}
+---
+
+` + `Blocking prompt: "${promptText}"
+
+` + `Decide how to handle this. Options:
+` + `- "respond" — send text or keys to unblock the agent
+` + `- "complete" — the task is fully done
+` + `- "escalate" — you need the user's input
+` + `- "ignore" — not actually blocking
 
-` + `Guidelines:\n` + `- For tool approvals / Y/n that align with the task, respond "y" or keys:["enter"].\n` + `- If the prompt asks for info NOT in the original task, escalate.\n` + `- Decline access to paths outside ${taskCtx.workdir}.\n` + `- If a PR was just created, respond to review & verify test plan items before completing.\n` + `- When in doubt, escalate.\n\n` + `Include a JSON action block at the end of your response:\n` + "```json\n" + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}\n` + "```";
+` + `Guidelines:
+` + `- For tool approvals / Y/n that align with the task, respond "y" or keys:["enter"].
+` + `- If the prompt asks for info NOT in the original task, escalate.
+` + `- Decline access to paths outside ${taskCtx.workdir}.
+` + `- If a PR was just created, respond to review & verify test plan items before completing.
+` + `- When in doubt, escalate.
+
+` + `Include a JSON action block at the end of your response:
+` + "```json\n" + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}
+` + "```";
 }
 function buildTurnCompleteEventMessage(taskCtx, turnOutput, decisionHistory) {
-  const historySection = decisionHistory.length > 0 ? `\nPrevious decisions:\n${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] "${d.promptText}" \u2192 ${d.action}${d.response ? ` ("${d.response}")` : ""} \u2014 ${d.reasoning}`).join("\n")}\n` : "";
-  return `[Coding Agent Event] A ${taskCtx.agentType} agent ("${taskCtx.label}") just finished a turn and is idle.\n\n` + `Task: "${taskCtx.originalTask}"\n` + `Workdir: ${taskCtx.workdir}\n` + `Repo: ${taskCtx.repo ?? "none (scratch directory)"}\n` + historySection + `\nTurn output:\n---\n${turnOutput.slice(-3000)}\n---\n\n` + `Decide if the overall task is done or if the agent needs more work.\n\n` + `Options:\n` + `- "respond" \u2014 send a follow-up instruction (DEFAULT for intermediate steps)
-` + `- "complete" \u2014 ALL task objectives met (code written, committed, PR created & verified)
-` + `- "escalate" \u2014 something looks wrong, ask the user
-` + `- "ignore" \u2014 should not normally be used here
+  const historySection = decisionHistory.length > 0 ? `
+Previous decisions:
+${decisionHistory.slice(-5).map((d, i) => `  ${i + 1}. [${d.event}] "${d.promptText}" → ${d.action}${d.response ? ` ("${d.response}")` : ""} — ${d.reasoning}`).join(`
+`)}
+` : "";
+  return `[Coding Agent Event] A ${taskCtx.agentType} agent ("${taskCtx.label}") just finished a turn and is idle.
+
+` + `Task: "${taskCtx.originalTask}"
+` + `Workdir: ${taskCtx.workdir}
+` + `Repo: ${taskCtx.repo ?? "none (scratch directory)"}
+` + historySection + `
+Turn output:
+---
+${turnOutput.slice(-3000)}
+---
+
+` + `Decide if the overall task is done or if the agent needs more work.
 
-` + `Guidelines:\n` + `- Verify evidence for EVERY objective before using "complete".\n` + `- If code was written but not committed/pushed/PR'd, respond with next step.\n` + `- If a PR was just created, respond to review & verify test plan items.\n` + `- Default to "respond" \u2014 only "complete" when certain ALL work is done.
+` + `Options:
+` + `- "respond" — send a follow-up instruction (DEFAULT for intermediate steps)
+` + `- "complete" — ALL task objectives met (code written, committed, PR created & verified)
+` + `- "escalate" — something looks wrong, ask the user
+` + `- "ignore" — should not normally be used here
 
-` + `Include a JSON action block at the end of your response:\n` + "```json\n" + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}\n` + "```";
+` + `Guidelines:
+` + `- Verify evidence for EVERY objective before using "complete".
+` + `- If code was written but not committed/pushed/PR'd, respond with next step.
+` + `- If a PR was just created, respond to review & verify test plan items.
+` + `- When asking agents to verify work, prefer CLI tools (gh, curl, cat, etc.) over browser automation.
+` + `- Default to "respond" — only "complete" when certain ALL work is done.
+
+` + `Include a JSON action block at the end of your response:
+` + "```json\n" + `{"action": "respond|complete|escalate|ignore", "response": "...", "useKeys": false, "keys": [], "reasoning": "..."}
+` + "```";
 }
 function parseCoordinationResponse(llmOutput) {
   const jsonMatch = llmOutput.match(/\{[\s\S]*\}/);
@@ -169,7 +333,7 @@ function parseCoordinationResponse(llmOutput) {
 }
 
 // src/services/swarm-event-triage.ts
-import {ModelType as ModelType2} from "@elizaos/core";
+import { ModelType as ModelType2 } from "@elizaos/core";
 function classifyByHeuristic(ctx) {
   if (ctx.promptType) {
     if (ROUTINE_PROMPT_TYPES.has(ctx.promptType))
@@ -196,8 +360,17 @@ function classifyByHeuristic(ctx) {
   return null;
 }
 function buildTriagePrompt(ctx) {
-  const eventDesc = ctx.eventType === "blocked" ? `BLOCKED prompt: "${ctx.promptText.slice(0, 300)}"` : `TURN COMPLETE. Recent output:\n${(ctx.recentOutput ?? "").slice(-500)}`;
-  return `Classify this coding agent event as "routine" or "creative".\n\n` + `Task: ${ctx.originalTask.slice(0, 200)}\n` + `Event: ${eventDesc}\n\n` + `"routine" = simple approval, permission, config, yes/no, tool consent, obvious pass/fail.\n` + `"creative" = needs task context, error recovery, design choice, ambiguous situation, approach selection.\n\n` + `Respond with ONLY a JSON object: {"tier": "routine"} or {"tier": "creative"}`;
+  const eventDesc = ctx.eventType === "blocked" ? `BLOCKED prompt: "${ctx.promptText.slice(0, 300)}"` : `TURN COMPLETE. Recent output:
+${(ctx.recentOutput ?? "").slice(-500)}`;
+  return `Classify this coding agent event as "routine" or "creative".
+
+` + `Task: ${ctx.originalTask.slice(0, 200)}
+` + `Event: ${eventDesc}
+
+` + `"routine" = simple approval, permission, config, yes/no, tool consent, obvious pass/fail.
+` + `"creative" = needs task context, error recovery, design choice, ambiguous situation, approach selection.
+
+` + `Respond with ONLY a JSON object: {"tier": "routine"} or {"tier": "creative"}`;
 }
 function parseTriageResponse(llmOutput) {
   const matches = llmOutput.matchAll(/\{[\s\S]*?\}/g);
@@ -207,15 +380,14 @@ function parseTriageResponse(llmOutput) {
       if (parsed.tier === "routine" || parsed.tier === "creative") {
         return parsed.tier;
       }
-    } catch {
-    }
+    } catch {}
   }
   return null;
 }
 async function classifyEventTier(runtime, ctx, log) {
   const heuristicResult = classifyByHeuristic(ctx);
   if (heuristicResult) {
-    log(`Triage: heuristic \u2192 ${heuristicResult}`);
+    log(`Triage: heuristic → ${heuristicResult}`);
     return heuristicResult;
   }
   try {
@@ -223,12 +395,12 @@ async function classifyEventTier(runtime, ctx, log) {
     const result = await runtime.useModel(ModelType2.TEXT_SMALL, { prompt });
     const tier = parseTriageResponse(result);
     if (tier) {
-      log(`Triage: LLM \u2192 ${tier}`);
+      log(`Triage: LLM → ${tier}`);
       return tier;
     }
-    log(`Triage: LLM returned unparseable response \u2014 defaulting to creative`);
+    log(`Triage: LLM returned unparseable response — defaulting to creative`);
   } catch (err) {
-    log(`Triage: LLM classifier failed: ${err} \u2014 defaulting to creative`);
+    log(`Triage: LLM classifier failed: ${err} — defaulting to creative`);
   }
   return "creative";
 }
@@ -298,7 +470,7 @@ __export(exports_swarm_decision_loop, {
   checkAllTasksComplete: () => checkAllTasksComplete
 });
 import * as path from "node:path";
-import {ModelType as ModelType3} from "@elizaos/core";
+import { ModelType as ModelType3 } from "@elizaos/core";
 function toContextSummary(taskCtx) {
   return {
     sessionId: taskCtx.sessionId,
@@ -422,10 +594,11 @@ async function executeDecision(ctx, sessionId, decision) {
       try {
         const rawOutput = await ctx.ptyService.getSessionOutput(sessionId, 50);
         summary = extractCompletionSummary(rawOutput);
-      } catch {
-      }
-      ctx.sendChatMessage(summary ? `Finished "${taskCtx?.label ?? sessionId}".\n\n${summary}` : `Finished "${taskCtx?.label ?? sessionId}".`, "coding-agent");
-      ctx.ptyService.stopSession(sessionId).catch((err) => {
+      } catch {}
+      ctx.sendChatMessage(summary ? `Finished "${taskCtx?.label ?? sessionId}".
+
+${summary}` : `Finished "${taskCtx?.label ?? sessionId}".`, "coding-agent");
+      ctx.ptyService.stopSession(sessionId, true).catch((err) => {
         ctx.log(`Failed to stop session after LLM-detected completion: ${err}`);
       });
       checkAllTasksComplete(ctx);
@@ -469,7 +642,7 @@ async function handleBlocked(ctx, sessionId, taskCtx, data) {
       });
       ctx.sendChatMessage(`[${taskCtx.label}] WARNING: Auto-approved access to path outside workspace (${taskCtx.workdir}). ` + `Prompt: "${promptText.slice(0, 150)}". Stopping session for safety.`, "coding-agent");
       taskCtx.status = "error";
-      ctx.ptyService?.stopSession(sessionId).catch((err) => {
+      ctx.ptyService?.stopSession(sessionId, true).catch((err) => {
         ctx.log(`Failed to stop session after out-of-scope auto-approval: ${err}`);
       });
       return;
@@ -541,7 +714,7 @@ async function handleBlocked(ctx, sessionId, taskCtx, data) {
         event: "blocked",
         promptText,
         decision: "escalate",
-        reasoning: "Supervision level is notify \u2014 broadcasting only"
+        reasoning: "Supervision level is notify — broadcasting only"
       });
       break;
   }
@@ -553,7 +726,7 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
   }
   ctx.inFlightDecisions.add(sessionId);
   try {
-    ctx.log(`Turn complete for "${taskCtx.label}" \u2014 assessing whether task is done`);
+    ctx.log(`Turn complete for "${taskCtx.label}" — assessing whether task is done`);
     const rawResponse = data.response ?? "";
     let turnOutput = cleanForChat(rawResponse);
     if (!turnOutput) {
@@ -588,7 +761,7 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
           if (decision)
             decisionFromPipeline = true;
         } catch (err) {
-          ctx.log(`Agent decision callback failed for turn-complete: ${err} \u2014 falling back to small LLM`);
+          ctx.log(`Agent decision callback failed for turn-complete: ${err} — falling back to small LLM`);
         }
       }
       if (!decision) {
@@ -604,13 +777,13 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
       }
     }
     if (!decision) {
-      ctx.log(`Turn-complete for "${taskCtx.label}": all decision paths failed \u2014 escalating`);
+      ctx.log(`Turn-complete for "${taskCtx.label}": all decision paths failed — escalating`);
       decision = {
         action: "escalate",
-        reasoning: "All decision paths returned invalid response \u2014 escalating for human review"
+        reasoning: "All decision paths returned invalid response — escalating for human review"
       };
     }
-    ctx.log(`Turn assessment for "${taskCtx.label}": ${decision.action}${decision.action === "respond" ? ` \u2192 "${(decision.response ?? "").slice(0, 80)}"` : ""} \u2014 ${decision.reasoning.slice(0, 120)}`);
+    ctx.log(`Turn assessment for "${taskCtx.label}": ${decision.action}${decision.action === "respond" ? ` → "${(decision.response ?? "").slice(0, 80)}"` : ""} — ${decision.reasoning.slice(0, 120)}`);
     taskCtx.decisions.push({
       timestamp: Date.now(),
       event: "turn_complete",
@@ -634,7 +807,7 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
         const preview = instruction.length > 120 ? `${instruction.slice(0, 120)}...` : instruction;
         ctx.sendChatMessage(`[${taskCtx.label}] Turn done, continuing: ${preview}`, "coding-agent");
       } else if (decision.action === "escalate") {
-        ctx.sendChatMessage(`[${taskCtx.label}] Turn finished \u2014 needs your attention: ${decision.reasoning}`, "coding-agent");
+        ctx.sendChatMessage(`[${taskCtx.label}] Turn finished — needs your attention: ${decision.reasoning}`, "coding-agent");
       }
     }
     await executeDecision(ctx, sessionId, decision);
@@ -674,7 +847,7 @@ async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, rec
           if (decision)
             decisionFromPipeline = true;
         } catch (err) {
-          ctx.log(`Agent decision callback failed: ${err} \u2014 falling back to small LLM`);
+          ctx.log(`Agent decision callback failed: ${err} — falling back to small LLM`);
         }
       }
       if (!decision) {
@@ -703,7 +876,7 @@ async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, rec
     if (decision.action === "respond" && isOutOfScopeAccess(promptText, taskCtx.workdir)) {
       decision = {
         action: "respond",
-        response: `No \u2014 that path is outside your workspace. Use ${taskCtx.workdir} instead. Create any files or directories you need there.`,
+        response: `No — that path is outside your workspace. Use ${taskCtx.workdir} instead. Create any files or directories you need there.`,
         reasoning: `Declined out-of-scope access (outside ${taskCtx.workdir}) and redirected agent to workspace.`
       };
       ctx.sendChatMessage(`[${taskCtx.label}] Declined out-of-scope access and redirected to workspace (${taskCtx.workdir}). If you intended broader access, send the agent an override.`, "coding-agent");
@@ -733,7 +906,7 @@ async function handleAutonomousDecision(ctx, sessionId, taskCtx, promptText, rec
       if (decision.action === "respond") {
         const actionDesc = decision.useKeys ? `Sent keys: ${decision.keys?.join(", ")}` : decision.response ? `Responded: ${decision.response.length > 100 ? `${decision.response.slice(0, 100)}...` : decision.response}` : "Responded";
         const reasonExcerpt = decision.reasoning.length > 150 ? `${decision.reasoning.slice(0, 150)}...` : decision.reasoning;
-        ctx.sendChatMessage(`[${taskCtx.label}] ${actionDesc} \u2014 ${reasonExcerpt}`, "coding-agent");
+        ctx.sendChatMessage(`[${taskCtx.label}] ${actionDesc} — ${reasonExcerpt}`, "coding-agent");
       } else if (decision.action === "escalate") {
         ctx.sendChatMessage(`[${taskCtx.label}] Needs your attention: ${decision.reasoning}`, "coding-agent");
       }
@@ -773,7 +946,7 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
           if (decision)
             decisionFromPipeline = true;
         } catch (err) {
-          ctx.log(`Agent decision callback failed (confirm): ${err} \u2014 falling back to small LLM`);
+          ctx.log(`Agent decision callback failed (confirm): ${err} — falling back to small LLM`);
         }
       }
       if (!decision) {
@@ -787,7 +960,7 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
         recentOutput: output,
         llmDecision: {
           action: "escalate",
-          reasoning: "All decision paths returned invalid response \u2014 needs human review"
+          reasoning: "All decision paths returned invalid response — needs human review"
         },
         taskContext: taskCtx,
         createdAt: Date.now()
@@ -911,7 +1084,9 @@ var finalizeWorkspaceAction = {
           data: { workspaceId, status }
         };
       }
-      const commitMessage = content.commitMessage ?? `feat: automated changes from coding agent\n\nGenerated by Milady coding agent plugin.`;
+      const commitMessage = content.commitMessage ?? `feat: automated changes from coding agent
+
+Generated by Milady coding agent plugin.`;
       const commitHash = await workspaceService.commit(workspaceId, {
         message: commitMessage,
         all: true
@@ -920,7 +1095,15 @@ var finalizeWorkspaceAction = {
       let prInfo = null;
       if (!content.skipPR) {
         const prTitle = content.prTitle ?? `[Milady] ${workspace.branch}`;
-        const prBody = content.prBody ?? `## Summary\n\nAutomated changes generated by Milady coding agent.\n\n` + `**Branch:** ${workspace.branch}\n` + `**Commit:** ${commitHash}\n\n` + `---\n*Generated by @elizaos/plugin-agent-orchestrator*`;
+        const prBody = content.prBody ?? `## Summary
+
+Automated changes generated by Milady coding agent.
+
+` + `**Branch:** ${workspace.branch}
+` + `**Commit:** ${commitHash}
+
+` + `---
+*Generated by @elizaos/plugin-agent-orchestrator*`;
         prInfo = await workspaceService.createPR(workspaceId, {
           title: prTitle,
           body: prBody,
@@ -931,11 +1114,14 @@ var finalizeWorkspaceAction = {
       if (callback) {
         if (prInfo) {
           await callback({
-            text: `Workspace finalized!\n` + `Commit: ${commitHash.slice(0, 8)}\n` + `PR #${prInfo.number}: ${prInfo.url}`
+            text: `Workspace finalized!
+` + `Commit: ${commitHash.slice(0, 8)}
+` + `PR #${prInfo.number}: ${prInfo.url}`
           });
         } else {
           await callback({
-            text: `Workspace changes committed and pushed.\n` + `Commit: ${commitHash.slice(0, 8)}`
+            text: `Workspace changes committed and pushed.
+` + `Commit: ${commitHash.slice(0, 8)}`
           });
         }
       }
@@ -1079,18 +1265,23 @@ var listAgentsAction = {
     }));
     const lines = sessions.map((session, index) => {
       const statusEmoji = {
-        running: "\u25B6\uFE0F",
-        idle: "\u23F8\uFE0F",
-        blocked: "\u26A0\uFE0F",
-        completed: "\u2705",
-        error: "\u274C"
-      }[session.status] ?? "\u2753";
+        running: "▶️",
+        idle: "⏸️",
+        blocked: "⚠️",
+        completed: "✅",
+        error: "❌"
+      }[session.status] ?? "❓";
       return `${index + 1}. ${statusEmoji} ${session.agentType} (${session.id.slice(0, 8)}...)
-   \uD83D\uDCC1 ${session.workdir}\n   Status: ${session.status}`;
+   \uD83D\uDCC1 ${session.workdir}
+   Status: ${session.status}`;
     });
     if (callback) {
       await callback({
-        text: `Active coding agents:\n\n${lines.join("\n\n")}`
+        text: `Active coding agents:
+
+${lines.join(`
+
+`)}`
       });
     }
     return {
@@ -1103,6 +1294,150 @@ var listAgentsAction = {
 };
 
 // src/actions/manage-issues.ts
+var manageIssuesAction = {
+  name: "MANAGE_ISSUES",
+  similes: [
+    "CREATE_ISSUE",
+    "LIST_ISSUES",
+    "CLOSE_ISSUE",
+    "COMMENT_ISSUE",
+    "UPDATE_ISSUE",
+    "GET_ISSUE"
+  ],
+  description: "Manage GitHub issues for a repository. " + "Supports creating issues, listing issues, getting issue details, " + "adding comments, updating, closing, and reopening issues.",
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Create an issue on the testbed repo to add a login page"
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll create that issue for you.",
+          action: "MANAGE_ISSUES"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "List the open issues on HaruHunab1320/git-workspace-service-testbed"
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Let me check the open issues for that repo.",
+          action: "MANAGE_ISSUES"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Close issue #3 on the testbed repo" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll close that issue.",
+          action: "MANAGE_ISSUES"
+        }
+      }
+    ]
+  ],
+  validate: async (runtime, _message) => {
+    const workspaceService = runtime.getService("CODING_WORKSPACE_SERVICE");
+    return workspaceService != null;
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const workspaceService = runtime.getService("CODING_WORKSPACE_SERVICE");
+    if (!workspaceService) {
+      if (callback) {
+        await callback({ text: "Workspace Service is not available." });
+      }
+      return { success: false, error: "SERVICE_UNAVAILABLE" };
+    }
+    workspaceService.setAuthPromptCallback((prompt) => {
+      if (callback) {
+        callback({
+          text: `I need GitHub access to manage issues. Please authorize me:
+
+` + `Go to: ${prompt.verificationUri}
+` + `Enter code: **${prompt.userCode}**
+
+` + `This code expires in ${Math.floor(prompt.expiresIn / 60)} minutes. ` + `I'll wait for you to complete authorization...`
+        });
+      }
+    });
+    const params = options?.parameters;
+    const content = message.content;
+    const text = content.text ?? "";
+    const operation = params?.operation ?? content.operation ?? inferOperation(text);
+    const repo = params?.repo ?? content.repo;
+    if (!repo) {
+      const urlMatch = text?.match(/(?:https?:\/\/github\.com\/)?([a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+)/);
+      if (!urlMatch) {
+        if (callback) {
+          await callback({
+            text: "Please specify a repository (e.g., owner/repo or a GitHub URL)."
+          });
+        }
+        return { success: false, error: "MISSING_REPO" };
+      }
+      return handleOperation(workspaceService, urlMatch[1], operation, params ?? content, text, callback);
+    }
+    return handleOperation(workspaceService, repo, operation, params ?? content, text, callback);
+  },
+  parameters: [
+    {
+      name: "operation",
+      description: "The operation to perform: create, list, get, update, comment, close, reopen, add_labels",
+      required: true,
+      schema: { type: "string" }
+    },
+    {
+      name: "repo",
+      description: "Repository in owner/repo format or full GitHub URL.",
+      required: true,
+      schema: { type: "string" }
+    },
+    {
+      name: "title",
+      description: "Issue title (for create operation).",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "body",
+      description: "Issue body/description (for create or comment operations).",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "issueNumber",
+      description: "Issue number (for get, update, comment, close, reopen operations).",
+      required: false,
+      schema: { type: "number" }
+    },
+    {
+      name: "labels",
+      description: "Labels to add (comma-separated string or array).",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "state",
+      description: "Filter by state: open, closed, or all (for list operation).",
+      required: false,
+      schema: { type: "string" }
+    }
+  ]
+};
 async function handleOperation(service, repo, operation, params, originalText, callback) {
   try {
     switch (operation.toLowerCase()) {
@@ -1123,9 +1458,12 @@ async function handleOperation(service, repo, operation, params, originalText, c
               created.push(issue2);
             }
             if (callback) {
-              const summary = created.map((i) => `#${i.number}: ${i.title}\n  ${i.url}`).join("\n");
+              const summary = created.map((i) => `#${i.number}: ${i.title}
+  ${i.url}`).join(`
+`);
               await callback({
-                text: `Created ${created.length} issues:\n${summary}`
+                text: `Created ${created.length} issues:
+${summary}`
               });
             }
             return { success: true, data: { issues: created } };
@@ -1142,7 +1480,8 @@ async function handleOperation(service, repo, operation, params, originalText, c
         });
         if (callback) {
           await callback({
-            text: `Created issue #${issue.number}: ${issue.title}\n${issue.url}`
+            text: `Created issue #${issue.number}: ${issue.title}
+${issue.url}`
           });
         }
         return { success: true, data: { issue } };
@@ -1160,8 +1499,10 @@ async function handleOperation(service, repo, operation, params, originalText, c
               text: `No ${stateFilter} issues found in ${repo}.`
             });
           } else {
-            const summary = issues.map((i) => `#${i.number} [${i.state}] ${i.title}${i.labels.length > 0 ? ` (${i.labels.join(", ")})` : ""}`).join("\n");
-            await callback({ text: `Issues in ${repo}:\n${summary}` });
+            const summary = issues.map((i) => `#${i.number} [${i.state}] ${i.title}${i.labels.length > 0 ? ` (${i.labels.join(", ")})` : ""}`).join(`
+`);
+            await callback({ text: `Issues in ${repo}:
+${summary}` });
           }
         }
         return { success: true, data: { issues } };
@@ -1176,7 +1517,12 @@ async function handleOperation(service, repo, operation, params, originalText, c
         const issue = await service.getIssue(repo, issueNumber);
         if (callback) {
           await callback({
-            text: `Issue #${issue.number}: ${issue.title} [${issue.state}]\n\n${issue.body}\n\nLabels: ${issue.labels.join(", ") || "none"}\n${issue.url}`
+            text: `Issue #${issue.number}: ${issue.title} [${issue.state}]
+
+${issue.body}
+
+Labels: ${issue.labels.join(", ") || "none"}
+${issue.url}`
           });
         }
         return { success: true, data: { issue } };
@@ -1345,145 +1691,6 @@ function parseLabels(input) {
     return input.split(",").map((s) => s.trim()).filter(Boolean);
   return [];
 }
-var manageIssuesAction = {
-  name: "MANAGE_ISSUES",
-  similes: [
-    "CREATE_ISSUE",
-    "LIST_ISSUES",
-    "CLOSE_ISSUE",
-    "COMMENT_ISSUE",
-    "UPDATE_ISSUE",
-    "GET_ISSUE"
-  ],
-  description: "Manage GitHub issues for a repository. " + "Supports creating issues, listing issues, getting issue details, " + "adding comments, updating, closing, and reopening issues.",
-  examples: [
-    [
-      {
-        name: "{{user1}}",
-        content: {
-          text: "Create an issue on the testbed repo to add a login page"
-        }
-      },
-      {
-        name: "{{agentName}}",
-        content: {
-          text: "I'll create that issue for you.",
-          action: "MANAGE_ISSUES"
-        }
-      }
-    ],
-    [
-      {
-        name: "{{user1}}",
-        content: {
-          text: "List the open issues on HaruHunab1320/git-workspace-service-testbed"
-        }
-      },
-      {
-        name: "{{agentName}}",
-        content: {
-          text: "Let me check the open issues for that repo.",
-          action: "MANAGE_ISSUES"
-        }
-      }
-    ],
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "Close issue #3 on the testbed repo" }
-      },
-      {
-        name: "{{agentName}}",
-        content: {
-          text: "I'll close that issue.",
-          action: "MANAGE_ISSUES"
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, _message) => {
-    const workspaceService = runtime.getService("CODING_WORKSPACE_SERVICE");
-    return workspaceService != null;
-  },
-  handler: async (runtime, message, _state, options, callback) => {
-    const workspaceService = runtime.getService("CODING_WORKSPACE_SERVICE");
-    if (!workspaceService) {
-      if (callback) {
-        await callback({ text: "Workspace Service is not available." });
-      }
-      return { success: false, error: "SERVICE_UNAVAILABLE" };
-    }
-    workspaceService.setAuthPromptCallback((prompt) => {
-      if (callback) {
-        callback({
-          text: `I need GitHub access to manage issues. Please authorize me:\n\n` + `Go to: ${prompt.verificationUri}\n` + `Enter code: **${prompt.userCode}**\n\n` + `This code expires in ${Math.floor(prompt.expiresIn / 60)} minutes. ` + `I'll wait for you to complete authorization...`
-        });
-      }
-    });
-    const params = options?.parameters;
-    const content = message.content;
-    const text = content.text ?? "";
-    const operation = params?.operation ?? content.operation ?? inferOperation(text);
-    const repo = params?.repo ?? content.repo;
-    if (!repo) {
-      const urlMatch = text?.match(/(?:https?:\/\/github\.com\/)?([a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+)/);
-      if (!urlMatch) {
-        if (callback) {
-          await callback({
-            text: "Please specify a repository (e.g., owner/repo or a GitHub URL)."
-          });
-        }
-        return { success: false, error: "MISSING_REPO" };
-      }
-      return handleOperation(workspaceService, urlMatch[1], operation, params ?? content, text, callback);
-    }
-    return handleOperation(workspaceService, repo, operation, params ?? content, text, callback);
-  },
-  parameters: [
-    {
-      name: "operation",
-      description: "The operation to perform: create, list, get, update, comment, close, reopen, add_labels",
-      required: true,
-      schema: { type: "string" }
-    },
-    {
-      name: "repo",
-      description: "Repository in owner/repo format or full GitHub URL.",
-      required: true,
-      schema: { type: "string" }
-    },
-    {
-      name: "title",
-      description: "Issue title (for create operation).",
-      required: false,
-      schema: { type: "string" }
-    },
-    {
-      name: "body",
-      description: "Issue body/description (for create or comment operations).",
-      required: false,
-      schema: { type: "string" }
-    },
-    {
-      name: "issueNumber",
-      description: "Issue number (for get, update, comment, close, reopen operations).",
-      required: false,
-      schema: { type: "number" }
-    },
-    {
-      name: "labels",
-      description: "Labels to add (comma-separated string or array).",
-      required: false,
-      schema: { type: "string" }
-    },
-    {
-      name: "state",
-      description: "Filter by state: open, closed, or all (for list operation).",
-      required: false,
-      schema: { type: "string" }
-    }
-  ]
-};
 
 // src/actions/provision-workspace.ts
 var provisionWorkspaceAction = {
@@ -1596,7 +1803,9 @@ var provisionWorkspaceAction = {
       }
       if (callback) {
         await callback({
-          text: `Created workspace at ${workspace.path}\n` + `Branch: ${workspace.branch}\n` + `Type: ${workspace.isWorktree ? "worktree" : "clone"}`
+          text: `Created workspace at ${workspace.path}
+` + `Branch: ${workspace.branch}
+` + `Type: ${workspace.isWorktree ? "worktree" : "clone"}`
         });
       }
       return {
@@ -1805,19 +2014,19 @@ var sendToAgentAction = {
 import * as os from "node:os";
 import * as path2 from "node:path";
 import {
-logger as logger3
+  logger as logger3
 } from "@elizaos/core";
 
 // src/services/pty-service.ts
-import {mkdir, readFile, writeFile} from "node:fs/promises";
-import {dirname, join} from "node:path";
-import {logger as logger2} from "@elizaos/core";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { logger as logger2 } from "@elizaos/core";
 import {
-checkAdapters,
-createAdapter,
-generateApprovalConfig
+  checkAdapters,
+  createAdapter,
+  generateApprovalConfig
 } from "coding-agent-adapters";
-import {PTYConsoleBridge} from "pty-console";
+import { PTYConsoleBridge } from "pty-console";
 
 // src/services/agent-metrics.ts
 class AgentMetricsTracker {
@@ -1873,6 +2082,7 @@ function computeAgentScore(metrics) {
   const speedPenalty = Math.min(avgCompletionMs / 300000, 1) * 0.1;
   return Math.max(0, successRate - stallPenalty - speedPenalty);
 }
+var DEFAULT_ORDER = ["claude", "gemini", "codex", "aider"];
 function selectAgentType(ctx) {
   if (ctx.config.strategy === "fixed") {
     return ctx.config.fixedAgentType;
@@ -1894,7 +2104,6 @@ function selectAgentType(ctx) {
   }
   return bestAgent;
 }
-var DEFAULT_ORDER = ["claude", "gemini", "codex", "aider"];
 
 // src/services/pty-auto-response.ts
 async function pushDefaultRules(ctx, sessionId, agentType) {
@@ -1972,14 +2181,27 @@ async function handleGeminiAuth(ctx, sessionId, sendKeysToSession) {
 
 // src/services/pty-init.ts
 init_ansi_utils();
-import {createRequire as createRequire2} from "node:module";
-import {createAllAdapters} from "coding-agent-adapters";
+import { createRequire as createRequire2 } from "node:module";
+import { createAllAdapters } from "coding-agent-adapters";
 import {
-BunCompatiblePTYManager,
-isBun,
-PTYManager,
-ShellAdapter
+  BunCompatiblePTYManager,
+  isBun,
+  PTYManager,
+  ShellAdapter
 } from "pty-manager";
+var _require = createRequire2(import.meta.url);
+var resolvedAdapterModule = "coding-agent-adapters";
+try {
+  resolvedAdapterModule = _require.resolve("coding-agent-adapters");
+} catch {}
+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 });
+}
 async function initializePTYManager(ctx) {
   const usingBunWorker = isBun();
   if (usingBunWorker) {
@@ -1996,11 +2218,7 @@ 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 });
-      if (ctx.hasActiveTask?.(session.id) && ctx.taskResponseMarkers.has(session.id)) {
-        const response = captureTaskResponse(session.id, ctx.sessionOutputBuffers, ctx.taskResponseMarkers);
-        ctx.log(`session_ready for active task ${session.id} \u2014 forwarding as task_complete (stall classifier path)`);
-        ctx.emitEvent(session.id, "task_complete", { session, response });
-      }
+      forwardReadyAsTaskComplete(ctx, session);
     });
     bunManager.on("session_exit", (id, code) => {
       ctx.emitEvent(id, "stopped", { reason: `exit code ${code}` });
@@ -2027,7 +2245,7 @@ async function initializePTYManager(ctx) {
       ctx.emitEvent(session.id, "task_complete", { session, response });
     });
     bunManager.on("tool_running", (session, info) => {
-      ctx.log(`tool_running for ${session.id}: ${info.toolName}${info.description ? ` \u2014 ${info.description}` : ""}`);
+      ctx.log(`tool_running for ${session.id}: ${info.toolName}${info.description ? ` — ${info.description}` : ""}`);
       ctx.emitEvent(session.id, "tool_running", { session, ...info });
     });
     bunManager.on("message", (message) => {
@@ -2079,11 +2297,7 @@ async function initializePTYManager(ctx) {
   }
   nodeManager.on("session_ready", (session) => {
     ctx.emitEvent(session.id, "ready", { session });
-    if (ctx.hasActiveTask?.(session.id) && ctx.taskResponseMarkers.has(session.id)) {
-      const response = captureTaskResponse(session.id, ctx.sessionOutputBuffers, ctx.taskResponseMarkers);
-      ctx.log(`session_ready for active task ${session.id} \u2014 forwarding as task_complete (stall classifier path)`);
-      ctx.emitEvent(session.id, "task_complete", { session, response });
-    }
+    forwardReadyAsTaskComplete(ctx, session);
   });
   nodeManager.on("blocking_prompt", (session, promptInfo, autoResponded) => {
     ctx.emitEvent(session.id, "blocked", { promptInfo, autoResponded });
@@ -2102,7 +2316,7 @@ async function initializePTYManager(ctx) {
     ctx.emitEvent(session.id, "task_complete", { session, response });
   });
   nodeManager.on("tool_running", (session, info) => {
-    ctx.log(`tool_running for ${session.id}: ${info.toolName}${info.description ? ` \u2014 ${info.description}` : ""}`);
+    ctx.log(`tool_running for ${session.id}: ${info.toolName}${info.description ? ` — ${info.description}` : ""}`);
     ctx.emitEvent(session.id, "tool_running", { session, ...info });
   });
   nodeManager.on("session_stopped", (session, reason) => {
@@ -2116,12 +2330,6 @@ async function initializePTYManager(ctx) {
   });
   return { manager: nodeManager, usingBunWorker: false };
 }
-var _require = createRequire2(import.meta.url);
-var resolvedAdapterModule = "coding-agent-adapters";
-try {
-  resolvedAdapterModule = _require.resolve("coding-agent-adapters");
-} catch {
-}
 
 // src/services/pty-session-io.ts
 async function sendToSession(ctx, sessionId, input) {
@@ -2151,26 +2359,39 @@ async function sendKeysToSession(ctx, sessionId, keys) {
     ptySession.sendKeys(keys);
   }
 }
-async function stopSession(ctx, sessionId, sessionMetadata, sessionWorkdirs, log) {
-  const session = ctx.manager.get(sessionId);
-  if (!session) {
-    throw new Error(`Session ${sessionId} not found`);
-  }
-  if (ctx.usingBunWorker) {
-    await ctx.manager.kill(sessionId);
-  } else {
-    await ctx.manager.stop(sessionId);
-  }
-  const unsubscribe = ctx.outputUnsubscribers.get(sessionId);
-  if (unsubscribe) {
-    unsubscribe();
+async function stopSession(ctx, sessionId, sessionMetadata, sessionWorkdirs, log, force = false) {
+  try {
+    const session = ctx.manager.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    if (ctx.usingBunWorker) {
+      if (force) {
+        await ctx.manager.kill(sessionId, "SIGKILL");
+      } else {
+        await ctx.manager.kill(sessionId);
+      }
+    } else {
+      if (force) {
+        await ctx.manager.stop(sessionId, { force: true });
+      } else {
+        await ctx.manager.stop(sessionId);
+      }
+    }
+  } finally {
+    try {
+      const unsubscribe = ctx.outputUnsubscribers.get(sessionId);
+      if (unsubscribe) {
+        unsubscribe();
+      }
+    } catch {}
     ctx.outputUnsubscribers.delete(sessionId);
+    sessionMetadata.delete(sessionId);
+    sessionWorkdirs.delete(sessionId);
+    ctx.sessionOutputBuffers.delete(sessionId);
+    ctx.taskResponseMarkers.delete(sessionId);
+    log(`Stopped session ${sessionId}`);
   }
-  sessionMetadata.delete(sessionId);
-  sessionWorkdirs.delete(sessionId);
-  ctx.sessionOutputBuffers.delete(sessionId);
-  ctx.taskResponseMarkers.delete(sessionId);
-  log(`Stopped session ${sessionId}`);
 }
 function subscribeToOutput(ctx, sessionId, callback) {
   if (ctx.usingBunWorker) {
@@ -2193,7 +2414,8 @@ async function getSessionOutput(ctx, sessionId, lines) {
     if (!buffer)
       return "";
     const tail = lines ?? buffer.length;
-    return buffer.slice(-tail).join("\n");
+    return buffer.slice(-tail).join(`
+`);
   }
   const output = [];
   for await (const line of ctx.manager.logs(sessionId, {
@@ -2201,10 +2423,26 @@ async function getSessionOutput(ctx, sessionId, lines) {
   })) {
     output.push(line);
   }
-  return output.join("\n");
+  return output.join(`
+`);
 }
 
 // src/services/pty-spawn.ts
+var ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "USER",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "TZ",
+  "TMPDIR",
+  "XDG_RUNTIME_DIR",
+  "NODE_OPTIONS",
+  "BUN_INSTALL"
+];
 function buildSanitizedBaseEnv() {
   const env = {};
   for (const key of ENV_ALLOWLIST) {
@@ -2218,7 +2456,8 @@ function setupOutputBuffer(ctx, sessionId) {
   const buffer = [];
   ctx.sessionOutputBuffers.set(sessionId, buffer);
   const unsubscribe = ctx.manager.onSessionData(sessionId, (data) => {
-    const lines = data.split("\n");
+    const lines = data.split(`
+`);
     buffer.push(...lines);
     while (buffer.length > (ctx.serviceConfig.maxLogLines ?? 1000)) {
       buffer.shift();
@@ -2241,17 +2480,17 @@ function setupDeferredTaskDelivery(ctx, session, task, agentType) {
   const sendTaskWithRetry = (attempt) => {
     const buffer = ctx.sessionOutputBuffers.get(sid);
     const baselineLength = buffer?.length ?? 0;
-    ctx.log(`Session ${sid} \u2014 sending task (attempt ${attempt + 1}, ${settleMs}ms settle, baseline ${baselineLength} lines)`);
+    ctx.log(`Session ${sid} — sending task (attempt ${attempt + 1}, ${settleMs}ms settle, baseline ${baselineLength} lines)`);
     ctx.sendToSession(sid, task).catch((err) => ctx.log(`Failed to send deferred task to ${sid}: ${err}`));
     if (attempt < MAX_RETRIES) {
       setTimeout(() => {
         const currentLength = buffer?.length ?? 0;
         const newLines = currentLength - baselineLength;
         if (newLines < MIN_NEW_LINES) {
-          ctx.log(`Session ${sid} \u2014 task may not have been accepted (only ${newLines} new lines after ${VERIFY_DELAY_MS}ms). Retrying (attempt ${attempt + 2}/${MAX_RETRIES + 1})`);
+          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 {
-          ctx.log(`Session ${sid} \u2014 task accepted (${newLines} new lines after ${VERIFY_DELAY_MS}ms)`);
+          ctx.log(`Session ${sid} — task accepted (${newLines} new lines after ${VERIFY_DELAY_MS}ms)`);
         }
       }, VERIFY_DELAY_MS);
     }
@@ -2315,21 +2554,6 @@ function buildSpawnConfig(sessionId, options, workdir) {
     }
   };
 }
-var ENV_ALLOWLIST = [
-  "PATH",
-  "HOME",
-  "USER",
-  "SHELL",
-  "LANG",
-  "LC_ALL",
-  "LC_CTYPE",
-  "TERM",
-  "TZ",
-  "TMPDIR",
-  "XDG_RUNTIME_DIR",
-  "NODE_OPTIONS",
-  "BUN_INSTALL"
-];
 
 // src/services/pty-types.ts
 var PI_AGENT_ALIASES = new Set([
@@ -2374,17 +2598,39 @@ var toPiCommand = (task) => {
 
 // src/services/stall-classifier.ts
 init_ansi_utils();
-import {ModelType} from "@elizaos/core";
+import { ModelType } from "@elizaos/core";
 import {
-buildTaskCompletionTimeline,
-extractTaskCompletionTraceRecords
+  buildTaskCompletionTimeline,
+  extractTaskCompletionTraceRecords
 } from "pty-manager";
 function buildStallClassificationPrompt(agentType, sessionId, output) {
-  return `You are Milady, an AI orchestrator managing coding agent sessions. ` + `A ${agentType} coding agent (session: ${sessionId}) appears to have stalled \u2014 ` + `it has stopped producing output while in a busy state.\n\n` + `Here is the recent terminal output:\n` + `---\n${output.slice(-1500)}\n---\n\n` + `Classify what's happening. Read the output carefully and choose the MOST specific match:\n\n` + `1. "task_complete" \u2014 The agent FINISHED its task and returned to its idle prompt. ` + `Strong indicators: a summary of completed work ("Done", "All done", "Here's what was completed"), ` + `timing info ("Baked for", "Churned for", "Crunched for", "Cooked for", "Worked for"), ` + `or the agent's main prompt symbol (\u276F) appearing AFTER completion output. ` + `If the output contains evidence of completed work followed by an idle prompt, this is ALWAYS task_complete, ` + `even though the agent is technically "waiting" \u2014 it is waiting for a NEW task, not asking a question.
+  return `You are Milady, an AI orchestrator managing coding agent sessions. ` + `A ${agentType} coding agent (session: ${sessionId}) appears to have stalled — ` + `it has stopped producing output while in a busy state.
+
+` + `Here is the recent terminal output:
+` + `---
+${output.slice(-1500)}
+---
+
+` + `Classify what's happening. Read the output carefully and choose the MOST specific match:
 
-` + `2. "waiting_for_input" \u2014 The agent is MID-TASK and blocked on a specific question or permission prompt. ` + `The agent has NOT finished its work \u2014 it needs a response to continue. ` + `Examples: Y/n confirmation, file permission dialogs, "Do you want to proceed?", ` + `tool approval prompts, or interactive menus. ` + `This is NOT the same as the agent sitting at its idle prompt after finishing work.\n\n` + `3. "still_working" \u2014 The agent is actively processing (API call, compilation, thinking, etc.) ` + `and has not produced final output yet. No prompt or completion summary visible.\n\n` + `4. "error" \u2014 The agent hit an error state (crash, unrecoverable error, stack trace).
+` + `1. "task_complete" — The agent FINISHED its task and returned to its idle prompt. ` + `Strong indicators: a summary of completed work ("Done", "All done", "Here's what was completed"), ` + `timing info ("Baked for", "Churned for", "Crunched for", "Cooked for", "Worked for"), ` + `or the agent's main prompt symbol (❯) appearing AFTER completion output. ` + `If the output contains evidence of completed work followed by an idle prompt, this is ALWAYS task_complete, ` + `even though the agent is technically "waiting" — it is waiting for a NEW task, not asking a question.
 
-` + `5. "tool_running" \u2014 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.\n\n` + `IMPORTANT: If you see BOTH completed work output AND an idle prompt (\u276F), choose "task_complete". ` + `Only choose "waiting_for_input" if the agent is clearly asking a question mid-task.\n\n` + `If "waiting_for_input", also provide:\n` + `- "prompt": the text of what it's asking\n` + `- "suggestedResponse": what to type/send. Use "keys:enter" for TUI menu confirmation, ` + `"keys:down,enter" to select a non-default option, or plain text like "y" for text prompts.\n\n` + `Respond with ONLY a JSON object:\n` + `{"state": "...", "prompt": "...", "suggestedResponse": "..."}`;
+` + `2. "waiting_for_input" — The agent is MID-TASK and blocked on a specific question or permission prompt. ` + `The agent has NOT finished its work — it needs a response to continue. ` + `Examples: Y/n confirmation, file permission dialogs, "Do you want to proceed?", ` + `tool approval prompts, or interactive menus. ` + `This is NOT the same as the agent sitting at its idle prompt after finishing work.
+
+` + `3. "still_working" — The agent is actively processing (API call, compilation, thinking, etc.) ` + `and has not produced final output yet. No prompt or completion summary visible.
+
+` + `4. "error" — The agent hit an error state (crash, unrecoverable error, stack trace).
+
+` + `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.
+
+` + `If "waiting_for_input", also provide:
+` + `- "prompt": the text of what it's asking
+` + `- "suggestedResponse": what to type/send. Use "keys:enter" for TUI menu confirmation, ` + `"keys:down,enter" to select a non-default option, or plain text like "y" for text prompts.
+
+` + `Respond with ONLY a JSON object:
+` + `{"state": "...", "prompt": "...", "suggestedResponse": "..."}`;
 }
 async function writeStallSnapshot(sessionId, agentType, recentOutput, effectiveOutput, buffers, traceEntries, log) {
   try {
@@ -2394,7 +2640,8 @@ async function writeStallSnapshot(sessionId, agentType, recentOutput, effectiveO
     const snapshotDir = path.join(os.homedir(), ".milady", "debug");
     fs.mkdirSync(snapshotDir, { recursive: true });
     const ourBuffer = buffers.get(sessionId);
-    const ourTail = ourBuffer ? ourBuffer.slice(-100).join("\n") : "(no buffer)";
+    const ourTail = ourBuffer ? ourBuffer.slice(-100).join(`
+`) : "(no buffer)";
     let traceTimeline = "(no trace entries)";
     try {
       const records = extractTaskCompletionTraceRecords(traceEntries);
@@ -2417,14 +2664,15 @@ async function writeStallSnapshot(sessionId, agentType, recentOutput, effectiveO
       traceTimeline,
       ``,
       `--- raw trace entries (last 20 of ${traceEntries.length}) ---`,
-      traceEntries.slice(-20).join("\n"),
+      traceEntries.slice(-20).join(`
+`),
       ``
-    ].join("\n");
+    ].join(`
+`);
     const snapshotPath = path.join(snapshotDir, `stall-snapshot-${sessionId}.txt`);
     fs.writeFileSync(snapshotPath, snapshot);
-    log(`Stall snapshot \u2192 ${snapshotPath}`);
-  } catch (_) {
-  }
+    log(`Stall snapshot → ${snapshotPath}`);
+  } catch (_) {}
 }
 async function classifyStallOutput(ctx) {
   const {
@@ -2443,7 +2691,8 @@ async function classifyStallOutput(ctx) {
   if (!recentOutput || recentOutput.trim().length < 200) {
     const ourBuffer = buffers.get(sessionId);
     if (ourBuffer && ourBuffer.length > 0) {
-      const rawTail = ourBuffer.slice(-100).join("\n");
+      const rawTail = ourBuffer.slice(-100).join(`
+`);
       const stripped = stripAnsi(rawTail);
       if (stripped.length > effectiveOutput.length) {
         effectiveOutput = stripped;
@@ -2483,7 +2732,7 @@ async function classifyStallOutput(ctx) {
       prompt: parsed.prompt,
       suggestedResponse: parsed.suggestedResponse
     };
-    log(`Stall classification for ${sessionId}: ${classification.state}${classification.suggestedResponse ? ` \u2192 "${classification.suggestedResponse}"` : ""}`);
+    log(`Stall classification for ${sessionId}: ${classification.state}${classification.suggestedResponse ? ` → "${classification.suggestedResponse}"` : ""}`);
     if (classification.state === "task_complete") {
       const session = manager?.get(sessionId);
       const durationMs = session?.startedAt ? Date.now() - new Date(session.startedAt).getTime() : 0;
@@ -2499,12 +2748,14 @@ async function classifyStallOutput(ctx) {
 // src/services/swarm-coordinator.ts
 init_ansi_utils();
 init_swarm_decision_loop();
-import {logger} from "@elizaos/core";
+import { logger } from "@elizaos/core";
 
 // src/services/swarm-idle-watchdog.ts
 init_ansi_utils();
 init_swarm_decision_loop();
-import {ModelType as ModelType4} from "@elizaos/core";
+import { ModelType as ModelType4 } from "@elizaos/core";
+var IDLE_THRESHOLD_MS = 5 * 60 * 1000;
+var MAX_IDLE_CHECKS = 4;
 async function scanIdleSessions(ctx) {
   const now = Date.now();
   for (const taskCtx of ctx.tasks.values()) {
@@ -2513,7 +2764,7 @@ async function scanIdleSessions(ctx) {
     if (ctx.ptyService) {
       const session = ctx.ptyService.getSession(taskCtx.sessionId);
       if (!session) {
-        ctx.log(`Idle watchdog: "${taskCtx.label}" \u2014 PTY session no longer exists, marking as stopped`);
+        ctx.log(`Idle watchdog: "${taskCtx.label}" — PTY session no longer exists, marking as stopped`);
         taskCtx.status = "stopped";
         taskCtx.decisions.push({
           timestamp: now,
@@ -2528,7 +2779,7 @@ async function scanIdleSessions(ctx) {
           timestamp: now,
           data: { reason: "pty_session_gone" }
         });
-        ctx.sendChatMessage(`[${taskCtx.label}] Session lost \u2014 the agent process is no longer running (likely killed during a restart).`, "coding-agent");
+        ctx.sendChatMessage(`[${taskCtx.label}] Session lost — the agent process is no longer running (likely killed during a restart).`, "coding-agent");
         checkAllTasksComplete(ctx);
         continue;
       }
@@ -2547,11 +2798,10 @@ async function scanIdleSessions(ctx) {
         if (currentOutput !== lastSeen) {
           taskCtx.lastActivityAt = now;
           taskCtx.idleCheckCount = 0;
-          ctx.log(`Idle watchdog: "${taskCtx.label}" has fresh PTY output \u2014 not idle`);
+          ctx.log(`Idle watchdog: "${taskCtx.label}" has fresh PTY output — not idle`);
           continue;
         }
-      } catch {
-      }
+      } catch {}
     }
     taskCtx.idleCheckCount++;
     const idleMinutes = Math.round(idleMs / 60000);
@@ -2576,10 +2826,10 @@ async function scanIdleSessions(ctx) {
           idleCheckCount: taskCtx.idleCheckCount
         }
       });
-      ctx.sendChatMessage(`[${taskCtx.label}] Session stopped \u2014 idle for ${idleMinutes} minutes with no progress.`, "coding-agent");
+      ctx.sendChatMessage(`[${taskCtx.label}] Session stopped — idle for ${idleMinutes} minutes with no progress.`, "coding-agent");
       if (ctx.ptyService) {
         try {
-          await ctx.ptyService.stopSession(taskCtx.sessionId);
+          await ctx.ptyService.stopSession(taskCtx.sessionId, true);
         } catch (err) {
           ctx.log(`Idle watchdog: failed to stop session ${taskCtx.sessionId}: ${err}`);
           taskCtx.status = "error";
@@ -2635,8 +2885,8 @@ async function handleIdleCheck(ctx, taskCtx, idleMinutes) {
       ctx.log(`Idle check LLM call failed: ${err}`);
     }
     if (!decision) {
-      ctx.log(`Idle check for "${taskCtx.label}": LLM returned invalid response \u2014 escalating`);
-      ctx.sendChatMessage(`[${taskCtx.label}] Session idle for ${idleMinutes}m \u2014 couldn't determine status. Needs your attention.`, "coding-agent");
+      ctx.log(`Idle check for "${taskCtx.label}": LLM returned invalid response — escalating`);
+      ctx.sendChatMessage(`[${taskCtx.label}] Session idle for ${idleMinutes}m — couldn't determine status. Needs your attention.`, "coding-agent");
       return;
     }
     taskCtx.decisions.push({
@@ -2658,22 +2908,19 @@ async function handleIdleCheck(ctx, taskCtx, idleMinutes) {
         reasoning: decision.reasoning
       }
     });
-    if (decision.action === "complete") {
-    } else if (decision.action === "respond") {
+    if (decision.action === "complete") {} else if (decision.action === "respond") {
       const actionDesc = decision.useKeys ? `Sent keys: ${decision.keys?.join(", ")}` : `Nudged: ${decision.response ?? ""}`;
-      ctx.sendChatMessage(`[${taskCtx.label}] Idle for ${idleMinutes}m \u2014 ${actionDesc}`, "coding-agent");
+      ctx.sendChatMessage(`[${taskCtx.label}] Idle for ${idleMinutes}m — ${actionDesc}`, "coding-agent");
     } else if (decision.action === "escalate") {
-      ctx.sendChatMessage(`[${taskCtx.label}] Idle for ${idleMinutes}m \u2014 needs your attention: ${decision.reasoning}`, "coding-agent");
+      ctx.sendChatMessage(`[${taskCtx.label}] Idle for ${idleMinutes}m — needs your attention: ${decision.reasoning}`, "coding-agent");
     } else if (decision.action === "ignore") {
-      ctx.log(`Idle check for "${taskCtx.label}": LLM says still working \u2014 ${decision.reasoning}`);
+      ctx.log(`Idle check for "${taskCtx.label}": LLM says still working — ${decision.reasoning}`);
     }
     await executeDecision(ctx, sessionId, decision);
   } finally {
     ctx.inFlightDecisions.delete(sessionId);
   }
 }
-var IDLE_THRESHOLD_MS = 5 * 60 * 1000;
-var MAX_IDLE_CHECKS = 4;
 
 // src/services/swarm-coordinator.ts
 var UNREGISTERED_BUFFER_MS = 2000;
@@ -2713,7 +2960,7 @@ class SwarmCoordinator {
   }
   setAgentDecisionCallback(cb) {
     this.agentDecisionCb = cb;
-    this.log("Agent decision callback wired \u2014 events will route through Milaidy");
+    this.log("Agent decision callback wired — events will route through Milaidy");
   }
   getAgentDecisionCallback() {
     return this.agentDecisionCb;
@@ -2776,7 +3023,7 @@ class SwarmCoordinator {
     if (this._paused)
       return;
     this._paused = true;
-    this.log("Coordinator paused \u2014 buffering LLM decisions until user message is processed");
+    this.log("Coordinator paused — buffering LLM decisions until user message is processed");
     this.broadcast({ type: "coordinator_paused", sessionId: "", timestamp: Date.now(), data: {} });
     this.pauseTimeout = setTimeout(() => {
       if (this._paused) {
@@ -2793,7 +3040,7 @@ class SwarmCoordinator {
       clearTimeout(this.pauseTimeout);
       this.pauseTimeout = null;
     }
-    this.log(`Coordinator resumed \u2014 replaying ${this.pauseBuffer.length} buffered events`);
+    this.log(`Coordinator resumed — replaying ${this.pauseBuffer.length} buffered events`);
     this.broadcast({ type: "coordinator_resumed", sessionId: "", timestamp: Date.now(), data: {} });
     const buffered = [...this.pauseBuffer];
     this.pauseBuffer = [];
@@ -2888,9 +3135,10 @@ class SwarmCoordinator {
   }
   writeSseEvent(res, event) {
     try {
-      res.write(`data: ${JSON.stringify(event)}\n\n`);
-    } catch {
-    }
+      res.write(`data: ${JSON.stringify(event)}
+
+`);
+    } catch {}
   }
   async handleSessionEvent(sessionId, event, data) {
     const taskCtx = this.tasks.get(sessionId);
@@ -2909,8 +3157,7 @@ class SwarmCoordinator {
             if (ctx) {
               this.unregisteredBuffer.delete(sessionId);
               for (const entry of stillBuffered) {
-                this.handleSessionEvent(sessionId, entry.event, entry.data).catch(() => {
-                });
+                this.handleSessionEvent(sessionId, entry.event, entry.data).catch(() => {});
               }
             } else {
               this.unregisteredBuffer.delete(sessionId);
@@ -3016,10 +3263,9 @@ class SwarmCoordinator {
               if (devUrl) {
                 urlSuffix = ` Dev server running at ${devUrl}`;
               }
-            } catch {
-            }
+            } catch {}
           }
-          this.sendChatMessage(`[${taskCtx.label}] Running ${toolDesc}.${urlSuffix} The agent is working outside the terminal \u2014 I'll let it finish.`, "coding-agent");
+          this.sendChatMessage(`[${taskCtx.label}] Running ${toolDesc}.${urlSuffix} The agent is working outside the terminal — I'll let it finish.`, "coding-agent");
         }
         break;
       }
@@ -3158,14 +3404,21 @@ class PTYService {
     const config = runtime.getSetting("PTY_SERVICE_CONFIG");
     const service = new PTYService(runtime, config ?? {});
     await service.initialize();
-    try {
-      const coordinator = new SwarmCoordinator(runtime);
-      coordinator.start(service);
-      service.coordinator = coordinator;
-      runtime.services.set("SWARM_COORDINATOR", [coordinator]);
-      logger2.info("[PTYService] SwarmCoordinator wired and started");
-    } catch (err) {
-      logger2.error(`[PTYService] Failed to wire SwarmCoordinator: ${err}`);
+    const servicesMap = runtime.services;
+    const existing = servicesMap?.get?.("SWARM_COORDINATOR");
+    if (existing && existing.length > 0) {
+      service.coordinator = existing[0];
+      logger2.info("[PTYService] SwarmCoordinator already registered, skipping duplicate start");
+    } else {
+      try {
+        const coordinator = new SwarmCoordinator(runtime);
+        coordinator.start(service);
+        service.coordinator = coordinator;
+        servicesMap?.set?.("SWARM_COORDINATOR", [coordinator]);
+        logger2.info("[PTYService] SwarmCoordinator wired and started");
+      } catch (err) {
+        logger2.error(`[PTYService] Failed to wire SwarmCoordinator: ${err}`);
+      }
     }
     return service;
   }
@@ -3193,6 +3446,13 @@ class PTYService {
           return false;
         const taskCtx = coordinator.getTaskContext(sessionId);
         return taskCtx?.status === "active";
+      },
+      hasTaskActivity: (sessionId) => {
+        const coordinator = this.coordinator;
+        if (!coordinator)
+          return false;
+        const taskCtx = coordinator.getTaskContext(sessionId);
+        return (taskCtx?.decisions.length ?? 0) > 0;
       }
     });
     this.manager = result.manager;
@@ -3284,8 +3544,7 @@ class PTYService {
         let settings = {};
         try {
           settings = JSON.parse(await readFile(settingsPath, "utf-8"));
-        } catch {
-        }
+        } catch {}
         const permissions = settings.permissions ?? {};
         permissions.allowedDirectories = [workdir];
         settings.permissions = permissions;
@@ -3361,10 +3620,10 @@ class PTYService {
       throw new Error("PTYService not initialized");
     return sendKeysToSession(this.ioContext(), sessionId, keys);
   }
-  async stopSession(sessionId) {
+  async stopSession(sessionId, force = false) {
     if (!this.manager)
       throw new Error("PTYService not initialized");
-    return stopSession(this.ioContext(), sessionId, this.sessionMetadata, this.sessionWorkdirs, (msg) => this.log(msg));
+    return stopSession(this.ioContext(), sessionId, this.sessionMetadata, this.sessionWorkdirs, (msg) => this.log(msg), force);
   }
   get defaultApprovalPreset() {
     const fromEnv = this.runtime.getSetting("PARALLAX_DEFAULT_APPROVAL_PRESET");
@@ -3657,7 +3916,9 @@ var spawnAgentAction = {
         if (preflight && !preflight.installed) {
           if (callback) {
             await callback({
-              text: `${preflight.adapter} CLI is not installed.\n` + `Install with: ${preflight.installCommand}\n` + `Docs: ${preflight.docsUrl}`
+              text: `${preflight.adapter} CLI is not installed.
+` + `Install with: ${preflight.installCommand}
+` + `Docs: ${preflight.docsUrl}`
             });
           }
           return { success: false, error: "AGENT_NOT_INSTALLED" };
@@ -3783,16 +4044,16 @@ var spawnAgentAction = {
 
 // src/actions/coding-task-handlers.ts
 import {
-logger as logger5
+  logger as logger5
 } from "@elizaos/core";
 
 // src/actions/coding-task-helpers.ts
-import {randomUUID} from "node:crypto";
+import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as os2 from "node:os";
 import * as path3 from "node:path";
 import {
-logger as logger4
+  logger as logger4
 } from "@elizaos/core";
 function createScratchDir() {
   const baseDir = path3.join(os2.homedir(), ".milady", "workspaces");
@@ -3831,10 +4092,12 @@ function registerSessionEvents(ptyService, runtime, sessionId, label, scratchDir
           const response = data.response ?? "";
           const preview = response.length > 500 ? `${response.slice(0, 500)}...` : response;
           callback({
-            text: preview ? `Agent "${label}" completed the task.\n\n${preview}` : `Agent "${label}" completed the task.`
+            text: preview ? `Agent "${label}" completed the task.
+
+${preview}` : `Agent "${label}" completed the task.`
           });
         }
-        ptyService.stopSession(sessionId).catch((err) => {
+        ptyService.stopSession(sessionId, true).catch((err) => {
           logger4.warn(`[START_CODING_TASK] Failed to stop session for "${label}" after task complete: ${err}`);
         });
       }
@@ -3856,6 +4119,7 @@ function registerSessionEvents(ptyService, runtime, sessionId, label, scratchDir
 }
 
 // src/actions/coding-task-handlers.ts
+var MAX_CONCURRENT_AGENTS = 8;
 async function handleMultiAgent(ctx, agentsParam) {
   const {
     runtime,
@@ -4036,7 +4300,8 @@ async function handleMultiAgent(ctx, agentsParam) {
     `Launched ${succeeded.length}/${agentSpecs.length} agents${repo ? ` on ${repo}` : ""}:`,
     ...succeeded.map((r) => `  - "${r.label}" (${r.agentType}) [session: ${r.sessionId}]`),
     ...failed.length > 0 ? [`Failed: ${failed.map((r) => `"${r.label}": ${r.error}`).join(", ")}`] : []
-  ].join("\n");
+  ].join(`
+`);
   if (callback) {
     await callback({ text: summary });
   }
@@ -4117,7 +4382,9 @@ async function handleSingleAgent(ctx, task) {
         logger5.warn(`[START_CODING_TASK] ${preflight.adapter} CLI not installed`);
         if (callback) {
           await callback({
-            text: `${preflight.adapter} CLI is not installed.\nInstall with: ${preflight.installCommand}\nDocs: ${preflight.docsUrl}`
+            text: `${preflight.adapter} CLI is not installed.
+Install with: ${preflight.installCommand}
+Docs: ${preflight.docsUrl}`
           });
         }
         return { success: false, error: "AGENT_NOT_INSTALLED" };
@@ -4170,7 +4437,8 @@ async function handleSingleAgent(ctx, task) {
     }
     const summary = repo ? `Cloned ${repo} and started ${displayType} agent as "${label}"${task ? ` with task: "${task}"` : ""}` : `Started ${displayType} agent as "${label}" in scratch workspace${task ? ` with task: "${task}"` : ""}`;
     if (callback) {
-      await callback({ text: `${summary}\nSession ID: ${session.id}` });
+      await callback({ text: `${summary}
+Session ID: ${session.id}` });
     }
     return {
       success: true,
@@ -4196,7 +4464,6 @@ async function handleSingleAgent(ctx, task) {
     return { success: false, error: errorMessage };
   }
 }
-var MAX_CONCURRENT_AGENTS = 8;
 
 // src/actions/start-coding-task.ts
 var startCodingTaskAction = {
@@ -4208,7 +4475,7 @@ var startCodingTaskAction = {
     "SPAWN_AND_PROVISION",
     "CODE_THIS"
   ],
-  description: "Start a coding task: optionally clone a repo, then spawn a coding agent (Claude Code, Codex, Gemini, Aider, Pi) " + "to work on it. If no repo is provided, the agent runs in a safe scratch directory. " + "Use this whenever the user asks to work on code, research something with an agent, or run any agent task. " + "IMPORTANT: If the user references a repository from conversation history (e.g. 'in the same repo', " + "'on that project', 'add a feature to it'), you MUST include the repo URL in the `repo` parameter. " + "If the task involves code changes to a real project but you don't know the repo URL, ASK the user for it " + "before calling this action \u2014 do not default to a scratch directory for real project work.",
+  description: "Start a coding task: optionally clone a repo, then spawn a coding agent (Claude Code, Codex, Gemini, Aider, Pi) " + "to work on it. If no repo is provided, the agent runs in a safe scratch directory. " + "Use this whenever the user asks to work on code, research something with an agent, or run any agent task. " + "IMPORTANT: If the user references a repository from conversation history (e.g. 'in the same repo', " + "'on that project', 'add a feature to it'), you MUST include the repo URL in the `repo` parameter. " + "If the task involves code changes to a real project but you don't know the repo URL, ASK the user for it " + "before calling this action — do not default to a scratch directory for real project work.",
   examples: [
     [
       {
@@ -4368,7 +4635,7 @@ var startCodingTaskAction = {
 
 // src/actions/stop-agent.ts
 import {
-logger as logger6
+  logger as logger6
 } from "@elizaos/core";
 var stopAgentAction = {
   name: "STOP_CODING_AGENT",
@@ -4531,15 +4798,6 @@ var stopAgentAction = {
 };
 
 // src/providers/action-examples.ts
-function formatExample(ex) {
-  const actionTags = ex.actions.map((a) => `  <action>${a}</action>`).join("\n");
-  const paramBlocks = Object.entries(ex.params ?? {}).map(([actionName, params]) => {
-    const inner = Object.entries(params).map(([k, v]) => `    <${k}>${v}</${k}>`).join("\n");
-    return `  <${actionName}>\n${inner}\n  </${actionName}>`;
-  }).join("\n");
-  const paramsSection = paramBlocks ? `\n<params>\n${paramBlocks}\n</params>` : "";
-  return `User: ${ex.user}\nAssistant:\n<actions>\n${actionTags}\n</actions>${paramsSection}`;
-}
 var CODING_AGENT_EXAMPLES = [
   {
     user: "Can you set up a workspace for https://github.com/acme/my-app and have Claude fix the login bug?",
@@ -4548,7 +4806,7 @@ var CODING_AGENT_EXAMPLES = [
       START_CODING_TASK: {
         repo: "https://github.com/acme/my-app",
         agentType: "claude",
-        task: "Fix the login bug in src/auth.ts \u2014 users are getting 401 errors after token refresh"
+        task: "Fix the login bug in src/auth.ts — users are getting 401 errors after token refresh"
       }
     }
   },
@@ -4601,7 +4859,28 @@ var CODING_AGENT_EXAMPLES = [
     }
   }
 ];
-var MULTI_AGENT_EXAMPLE = `User: Spin up 3 agents on https://github.com/acme/app \u2014 one to fix auth, one to write tests, one to update docs
+function formatExample(ex) {
+  const actionTags = ex.actions.map((a) => `  <action>${a}</action>`).join(`
+`);
+  const paramBlocks = Object.entries(ex.params ?? {}).map(([actionName, params]) => {
+    const inner = Object.entries(params).map(([k, v]) => `    <${k}>${v}</${k}>`).join(`
+`);
+    return `  <${actionName}>
+${inner}
+  </${actionName}>`;
+  }).join(`
+`);
+  const paramsSection = paramBlocks ? `
+<params>
+${paramBlocks}
+</params>` : "";
+  return `User: ${ex.user}
+Assistant:
+<actions>
+${actionTags}
+</actions>${paramsSection}`;
+}
+var MULTI_AGENT_EXAMPLE = `User: Spin up 3 agents on https://github.com/acme/app — one to fix auth, one to write tests, one to update docs
 Assistant:
 <actions>
   <action>REPLY</action>
@@ -4610,7 +4889,7 @@ Assistant:
 <params>
   <START_CODING_TASK>
     <repo>https://github.com/acme/app</repo>
-    <agents>Fix the authentication bug in src/auth.ts \u2014 users get 401 after token refresh. Your unique identifier is "alpha". | Write comprehensive unit tests for the auth module in src/auth.ts. Your unique identifier is "beta". | Update the API documentation in docs/ to reflect the new auth flow. Your unique identifier is "gamma".</agents>
+    <agents>Fix the authentication bug in src/auth.ts — users get 401 after token refresh. Your unique identifier is "alpha". | Write comprehensive unit tests for the auth module in src/auth.ts. Your unique identifier is "beta". | Update the API documentation in docs/ to reflect the new auth flow. Your unique identifier is "gamma".</agents>
   </START_CODING_TASK>
 </params>`;
 var codingAgentExamplesProvider = {
@@ -4618,12 +4897,14 @@ var codingAgentExamplesProvider = {
   description: "Structured examples showing how to use coding agent actions with parameters",
   position: -1,
   get: async (_runtime, _message, _state) => {
-    const examples = CODING_AGENT_EXAMPLES.map(formatExample).join("\n\n");
+    const examples = CODING_AGENT_EXAMPLES.map(formatExample).join(`
+
+`);
     const text = [
       "# Coding Agent Action Call Examples",
       "When the user asks you to work on code, clone repos, spawn agents, or run agent tasks,",
       "you MUST select the appropriate actions and include parameters. Do NOT just describe",
-      "what you would do \u2014 actually select the actions.",
+      "what you would do — actually select the actions.",
       "",
       "IMPORTANT: Use START_CODING_TASK to launch coding agents. It handles workspace setup",
       "automatically. If a repo URL is provided, it clones it first. If no repo, the agent",
@@ -4641,7 +4922,8 @@ var codingAgentExamplesProvider = {
       "and unique identifiers so their work is clearly differentiated.",
       "",
       MULTI_AGENT_EXAMPLE
-    ].join("\n");
+    ].join(`
+`);
     return {
       data: { codingAgentExamples: CODING_AGENT_EXAMPLES },
       values: { codingAgentExamples: text },
@@ -4674,7 +4956,7 @@ function formatWorkspaceLine(ws, sessions) {
   const label = ws.label || ws.id.slice(0, 8);
   const agents = sessions.filter((s) => s.workdir === ws.path);
   const agentSummary = agents.length > 0 ? agents.map((a) => `${a.agentType}:${formatStatus(a.status)}`).join(", ") : "no agents";
-  return `  - "${label}" \u2192 ${ws.repo} (branch: ${ws.branch}, ${agentSummary})`;
+  return `  - "${label}" → ${ws.repo} (branch: ${ws.branch}, ${agentSummary})`;
 }
 var activeWorkspaceContextProvider = {
   name: "ACTIVE_WORKSPACE_CONTEXT",
@@ -4703,7 +4985,8 @@ var activeWorkspaceContextProvider = {
         "# Active Workspaces & Agents",
         "No active workspaces or coding agent sessions.",
         "Use START_CODING_TASK to launch a new coding agent."
-      ].join("\n");
+      ].join(`
+`);
       return {
         data: { activeWorkspaces: [], activeSessions: [] },
         values: { activeWorkspaceContext: text2 },
@@ -4733,9 +5016,9 @@ var activeWorkspaceContextProvider = {
       const supervisionLevel = coordinator.getSupervisionLevel();
       if (pending.length > 0) {
         lines.push("");
-        lines.push(`## Pending Confirmations (${pending.length}) \u2014 supervision: ${supervisionLevel}`);
+        lines.push(`## Pending Confirmations (${pending.length}) — supervision: ${supervisionLevel}`);
         for (const p of pending) {
-          lines.push(`  - "${p.taskContext.label}" blocked: "${p.promptText}" \u2192 suggested: ${p.llmDecision.action}`);
+          lines.push(`  - "${p.taskContext.label}" blocked: "${p.promptText}" → suggested: ${p.llmDecision.action}`);
         }
       } else if (supervisionLevel !== "autonomous") {
         lines.push("");
@@ -4746,7 +5029,8 @@ var activeWorkspaceContextProvider = {
       lines.push("");
       lines.push("You can interact with agents using SEND_TO_CODING_AGENT (pass sessionId), " + "stop them with STOP_CODING_AGENT, or finalize their work with FINALIZE_WORKSPACE.");
     }
-    const text = lines.join("\n");
+    const text = lines.join(`
+`);
     return {
       data: {
         activeWorkspaces: workspaces.map((ws) => ({
@@ -4774,16 +5058,16 @@ var activeWorkspaceContextProvider = {
 import * as os3 from "node:os";
 import * as path5 from "node:path";
 import {
-CredentialService,
-GitHubPatClient as GitHubPatClient2,
-MemoryTokenStore,
-WorkspaceService
+  CredentialService,
+  GitHubPatClient as GitHubPatClient2,
+  MemoryTokenStore,
+  WorkspaceService
 } from "git-workspace-service";
 
 // src/services/workspace-github.ts
 import {
-GitHubPatClient,
-OAuthDeviceFlow
+  GitHubPatClient,
+  OAuthDeviceFlow
 } from "git-workspace-service";
 function parseOwnerRepo(repo) {
   const match = repo.match(/(?:github\.com\/)?([^/]+)\/([^/.]+)/);
@@ -4839,7 +5123,9 @@ async function performOAuthFlow(ctx, clientId) {
       expiresIn: deviceCode.expiresIn
     });
   } else {
-    console.log(`\n[GitHub Auth] Go to ${deviceCode.verificationUri} and enter code: ${deviceCode.userCode}\n`);
+    console.log(`
+[GitHub Auth] Go to ${deviceCode.verificationUri} and enter code: ${deviceCode.userCode}
+`);
   }
   const token = await oauth.pollForToken(deviceCode);
   const client = new GitHubPatClient({ token: token.accessToken });
@@ -4908,7 +5194,8 @@ async function getStatus(workspacePath) {
     cwd: workspacePath,
     encoding: "utf-8"
   }).trim();
-  const lines = statusOutput.split("\n").filter(Boolean);
+  const lines = statusOutput.split(`
+`).filter(Boolean);
   const modified = [];
   const staged = [];
   const untracked = [];
@@ -5616,6 +5903,7 @@ async function handleAgentRoutes(req, res, pathname, ctx) {
 }
 
 // src/api/coordinator-routes.ts
+var COORDINATOR_PREFIX = "/api/coding-agents/coordinator";
 async function handleCoordinatorRoutes(req, res, pathname, ctx) {
   if (!pathname.startsWith(COORDINATOR_PREFIX)) {
     return false;
@@ -5633,7 +5921,9 @@ async function handleCoordinatorRoutes(req, res, pathname, ctx) {
       "Cache-Control": "no-cache",
       Connection: "keep-alive"
     });
-    res.write(":ok\n\n");
+    res.write(`:ok
+
+`);
     const unsubscribe = coordinator.addSseClient(res);
     req.on("close", unsubscribe);
     const keepAlive = setInterval(() => {
@@ -5641,7 +5931,9 @@ async function handleCoordinatorRoutes(req, res, pathname, ctx) {
         clearInterval(keepAlive);
         return;
       }
-      res.write(":ping\n\n");
+      res.write(`:ping
+
+`);
     }, 30000);
     req.on("close", () => clearInterval(keepAlive));
     return true;
@@ -5726,7 +6018,6 @@ async function handleCoordinatorRoutes(req, res, pathname, ctx) {
   }
   return false;
 }
-var COORDINATOR_PREFIX = "/api/coding-agents/coordinator";
 
 // src/api/issue-routes.ts
 async function handleIssueRoutes(req, res, pathname, ctx) {
@@ -5958,6 +6249,7 @@ async function handleWorkspaceRoutes(req, res, pathname, ctx) {
 }
 
 // src/api/routes.ts
+var MAX_BODY_SIZE = 1024 * 1024;
 async function parseBody(req) {
   return new Promise((resolve5, reject) => {
     let body = "";
@@ -6014,7 +6306,6 @@ function createCodingAgentRouteHandler(runtime, coordinator) {
   };
   return (req, res, pathname) => handleCodingAgentRoutes(req, res, pathname, ctx);
 }
-var MAX_BODY_SIZE = 1024 * 1024;
 
 // src/index.ts
 var codingAgentPlugin = {
@@ -6059,5 +6350,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=0100F6538A0A9D6264756E2164756E21
+//# debugId=A1B0DE07402807E864756E2164756E21
 //# sourceMappingURL=index.js.map