@markus-global/cli 0.6.7 → 0.6.8

package/dist/markus.mjs

@@ -4216,7 +4216,7 @@ function withJitter(baseMs, factor = 0.2) {
   const jitter = baseMs * factor * (2 * Math.random() - 1);
   return Math.max(0, Math.round(baseMs + jitter));
 }
-var TASK_GET_NOTES_DEFAULT, TASK_GET_DELIVERABLES_DEFAULT, TASK_GET_STATUS_HISTORY_DEFAULT, REQUIREMENT_LIST_DEFAULT, ENTITY_COMMENTS_DEFAULT, PROMPT_TASK_NOTES_MAX, PROMPT_TASK_NOTE_CHARS, PROMPT_DEP_NOTES_MAX, PROMPT_DEP_NOTE_CHARS, PROMPT_DEP_DESC_CHARS, PROMPT_EXECUTION_ROUNDS_MAX, PROMPT_LOG_ENTRY_CHARS, PROMPT_RECENT_ERRORS_MAX, PROMPT_HUMAN_COMMENTS_MAX, REVIEWER_NOTES_MAX, SYSTEM_MY_TASKS_MAX, SYSTEM_TEAM_TASKS_MAX, SYSTEM_TASK_DESC_CHARS, PROMPT_PROJECT_DESC_CHARS, PROMPT_REQUIREMENT_DESC_CHARS, REVIEWER_FILE_LIST_MAX, DELIVERABLE_TITLE_CHARS, REVISION_REASON_CHARS, TASK_MAX_RETRIES, MAILBOX_ITEM_MAX_RETRIES, COMPLETION_MARKER, COMPLETION_MARKER_INSTRUCTION, TASK_MAX_NO_SUBMIT_RETRIES, TASK_RETRY_DELAYS_MS, PREEMPT_REQUEUE_DELAY_MS, SYSTEM_KNOWLEDGE_CHARS, SYSTEM_SOPS_CHARS, SYSTEM_LONGTERM_MEMORY_CHARS, MEMORY_MD_SECTION_MAX_CHARS, MEMORY_MD_TOTAL_MAX_CHARS, SYSTEM_LESSON_ENTRIES_MAX, SYSTEM_BEST_PRACTICE_ENTRIES_MAX, SYSTEM_DELIVERABLES_CHARS, SYSTEM_DAILY_LOG_CHARS, SYSTEM_DAILY_LOG_DAYS, SYSTEM_USER_PROFILE_CHARS, SYSTEM_CHAT_SESSIONS_MAX, HEARTBEAT_DAILY_LOG_CHARS, SYSTEM_PROJECT_DESC_CHARS, SYSTEM_DELIVERABLE_PREVIEW_CHARS, SYSTEM_MAILBOX_MERGED_CHARS, SYSTEM_MAILBOX_ITEM_PREVIEW_CHARS, TASK_LIST_PAGE_SIZE, TASK_LIST_PAGE_MAX, ARCHIVE_COMPLETED_AFTER_DAYS, ARCHIVE_TERMINAL_AFTER_DAYS, ARCHIVE_REQUIREMENT_AFTER_DAYS, ARCHIVE_SCAN_INTERVAL_MS, MAILBOX_QUEUED_TTL_MS, MAILBOX_PROCESSING_TIMEOUT_MS, WATCHDOG_INTERVAL_MS, WATCHDOG_DRIFT_THRESHOLD_MS, TRIAGE_PROMPT_MAX_ITEMS, TRIAGE_MAX_TOKENS, TRIAGE_TEMPERATURE, TRIAGE_CONTEXT_MESSAGES_MAX, TRIAGE_CONTEXT_MSG_CHARS, TRIAGE_ITEM_CONTENT_CHARS, TRIAGE_STALE_INFO_TTL_MS, TRIAGE_STALE_DROP_TYPES, TRIAGE_MAX_TOOL_ITERATIONS, TRIAGE_ALLOWED_TOOLS, SUBAGENT_TASK_PREVIEW_CHARS, SUBAGENT_THINKING_PREVIEW_CHARS, SUBAGENT_RESULT_PREVIEW_CHARS, SUBAGENT_LOG_ENTRY_CHARS, SUBAGENT_ERROR_PREVIEW_CHARS, SUBAGENT_MAX_PARALLEL, SUBAGENT_MAX_LLM_RETRIES, SUBAGENT_RETRY_BASE_MS, SHELL_TIMEOUT_DEFAULT_MS, SHELL_TIMEOUT_MAX_MS, APPROVAL_WAIT_TIMEOUT_MS, HEARTBEAT_MIN_INITIAL_DELAY_MS, HEARTBEAT_STARTUP_JITTER_MS, LLM_CIRCUIT_RESET_RATE_LIMIT_MS, LLM_MAX_CONCURRENT_PER_PROVIDER, LLM_CONCURRENCY_JITTER_BASE_MS;
+var TASK_GET_NOTES_DEFAULT, TASK_GET_DELIVERABLES_DEFAULT, TASK_GET_STATUS_HISTORY_DEFAULT, REQUIREMENT_LIST_DEFAULT, ENTITY_COMMENTS_DEFAULT, PROMPT_TASK_NOTES_MAX, PROMPT_TASK_NOTE_CHARS, PROMPT_DEP_NOTES_MAX, PROMPT_DEP_NOTE_CHARS, PROMPT_DEP_DESC_CHARS, PROMPT_EXECUTION_ROUNDS_MAX, PROMPT_LOG_ENTRY_CHARS, PROMPT_RECENT_ERRORS_MAX, PROMPT_HUMAN_COMMENTS_MAX, REVIEWER_NOTES_MAX, SYSTEM_MY_TASKS_MAX, SYSTEM_TEAM_TASKS_MAX, SYSTEM_TASK_DESC_CHARS, PROMPT_PROJECT_DESC_CHARS, PROMPT_REQUIREMENT_DESC_CHARS, REVIEWER_FILE_LIST_MAX, DELIVERABLE_TITLE_CHARS, REVISION_REASON_CHARS, TASK_MAX_RETRIES, MAILBOX_ITEM_MAX_RETRIES, COMPLETION_MARKER, COMPLETION_MARKER_INSTRUCTION, TASK_MAX_NO_SUBMIT_RETRIES, TASK_RETRY_DELAYS_MS, PREEMPT_REQUEUE_DELAY_MS, SYSTEM_KNOWLEDGE_CHARS, SYSTEM_SOPS_CHARS, SYSTEM_LONGTERM_MEMORY_CHARS, MEMORY_MD_SECTION_MAX_CHARS, MEMORY_MD_TOTAL_MAX_CHARS, SYSTEM_LESSON_ENTRIES_MAX, SYSTEM_BEST_PRACTICE_ENTRIES_MAX, SYSTEM_DELIVERABLES_CHARS, SYSTEM_DAILY_LOG_CHARS, SYSTEM_DAILY_LOG_DAYS, SYSTEM_USER_PROFILE_CHARS, SYSTEM_CHAT_SESSIONS_MAX, HEARTBEAT_DAILY_LOG_CHARS, SYSTEM_PROJECT_DESC_CHARS, SYSTEM_DELIVERABLE_PREVIEW_CHARS, SYSTEM_MAILBOX_MERGED_CHARS, SYSTEM_MAILBOX_ITEM_PREVIEW_CHARS, TASK_LIST_PAGE_SIZE, TASK_LIST_PAGE_MAX, ARCHIVE_COMPLETED_AFTER_DAYS, ARCHIVE_TERMINAL_AFTER_DAYS, ARCHIVE_REQUIREMENT_AFTER_DAYS, ARCHIVE_SCAN_INTERVAL_MS, MAILBOX_QUEUED_TTL_MS, MAILBOX_PROCESSING_TIMEOUT_MS, WATCHDOG_INTERVAL_MS, WATCHDOG_DRIFT_THRESHOLD_MS, TRIAGE_PROMPT_MAX_ITEMS, TRIAGE_MAX_TOKENS, TRIAGE_TEMPERATURE, TRIAGE_CONTEXT_MESSAGES_MAX, TRIAGE_CONTEXT_MSG_CHARS, TRIAGE_ITEM_CONTENT_CHARS, TRIAGE_STALE_INFO_TTL_MS, TRIAGE_STALE_DROP_TYPES, TRIAGE_MAX_TOOL_ITERATIONS, TRIAGE_ALLOWED_TOOLS, DELIBERATION_MAX_TOOL_ITERATIONS, DELIBERATION_ALLOWED_TOOLS, SUBAGENT_TASK_PREVIEW_CHARS, SUBAGENT_THINKING_PREVIEW_CHARS, SUBAGENT_RESULT_PREVIEW_CHARS, SUBAGENT_LOG_ENTRY_CHARS, SUBAGENT_ERROR_PREVIEW_CHARS, SUBAGENT_MAX_PARALLEL, SUBAGENT_MAX_LLM_RETRIES, SUBAGENT_RETRY_BASE_MS, SHELL_TIMEOUT_DEFAULT_MS, SHELL_TIMEOUT_MAX_MS, SHELL_MAX_SESSIONS_PER_AGENT, SHELL_SESSION_IDLE_TIMEOUT_MS, SHELL_SESSION_MAX_OUTPUT_BYTES, APPROVAL_WAIT_TIMEOUT_MS, HEARTBEAT_MIN_INITIAL_DELAY_MS, HEARTBEAT_STARTUP_JITTER_MS, LLM_CIRCUIT_RESET_RATE_LIMIT_MS, LLM_MAX_CONCURRENT_PER_PROVIDER, LLM_CONCURRENCY_JITTER_BASE_MS;
 var init_limits = __esm({
   "../shared/dist/limits.js"() {
     "use strict";
@@ -4292,14 +4292,41 @@ var init_limits = __esm({
       "memory_consolidation",
       "daily_report"
     ];
-    TRIAGE_MAX_TOOL_ITERATIONS = 3;
+    TRIAGE_MAX_TOOL_ITERATIONS = 6;
     TRIAGE_ALLOWED_TOOLS = [
       "task_list",
       "task_get",
       "requirement_list",
       "requirement_get",
       "list_projects",
-      "team_list"
+      "team_list",
+      "recall_activity",
+      "memory_search",
+      "memory_search_longterm"
+    ];
+    DELIBERATION_MAX_TOOL_ITERATIONS = 10;
+    DELIBERATION_ALLOWED_TOOLS = [
+      // Context gathering (read-only)
+      "task_list",
+      "task_get",
+      "requirement_list",
+      "requirement_get",
+      "list_projects",
+      "team_list",
+      "team_status",
+      "recall_activity",
+      "memory_search",
+      "memory_search_longterm",
+      // Inline action (lightweight communication)
+      "notify_user",
+      "task_comment",
+      "requirement_comment",
+      "agent_send_message",
+      "agent_send_group_message",
+      "agent_create_group_chat",
+      "agent_list_group_chats",
+      // Decision output
+      "complete_deliberation"
     ];
     SUBAGENT_TASK_PREVIEW_CHARS = 500;
     SUBAGENT_THINKING_PREVIEW_CHARS = 1e3;
@@ -4311,6 +4338,9 @@ var init_limits = __esm({
     SUBAGENT_RETRY_BASE_MS = 2e3;
     SHELL_TIMEOUT_DEFAULT_MS = 6e4;
     SHELL_TIMEOUT_MAX_MS = 3e5;
+    SHELL_MAX_SESSIONS_PER_AGENT = 3;
+    SHELL_SESSION_IDLE_TIMEOUT_MS = 10 * 6e4;
+    SHELL_SESSION_MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
     APPROVAL_WAIT_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
     HEARTBEAT_MIN_INITIAL_DELAY_MS = 5e3;
     HEARTBEAT_STARTUP_JITTER_MS = 1e4;
@@ -4320,6 +4350,40 @@ var init_limits = __esm({
   }
 });
 
+// ../shared/dist/sanitize.js
+function sanitizeForLLM(text) {
+  return text.replace(ANSI_CSI, "").replace(ANSI_OSC, "").replace(ANSI_OTHER, "").replace(C0_CONTROL, "").replace(C1_CONTROL, "").replace(LONE_HIGH_SURROGATE, "\uFFFD").replace(LONE_LOW_SURROGATE, "\uFFFD");
+}
+function safeSlice(text, start, end) {
+  let result = text.slice(start, end);
+  if (result.length === 0)
+    return result;
+  const first = result.charCodeAt(0);
+  if (first >= 56320 && first <= 57343) {
+    result = result.slice(1);
+  }
+  if (result.length === 0)
+    return result;
+  const last = result.charCodeAt(result.length - 1);
+  if (last >= 55296 && last <= 56319) {
+    result = result.slice(0, -1);
+  }
+  return result;
+}
+var ANSI_CSI, ANSI_OSC, ANSI_OTHER, C0_CONTROL, C1_CONTROL, LONE_HIGH_SURROGATE, LONE_LOW_SURROGATE;
+var init_sanitize = __esm({
+  "../shared/dist/sanitize.js"() {
+    "use strict";
+    ANSI_CSI = /\x1b\[[0-9;]*[a-zA-Z]/g;
+    ANSI_OSC = /\x1b\][^\x07]*(?:\x07|\x1b\\)/g;
+    ANSI_OTHER = /\x1b[^[\]].?/g;
+    C0_CONTROL = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
+    C1_CONTROL = /[\x80-\x9f]/g;
+    LONE_HIGH_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])/g;
+    LONE_LOW_SURROGATE = /(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+  }
+});
+
 // ../shared/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -4332,6 +4396,8 @@ __export(dist_exports, {
   COMPLETION_MARKER: () => COMPLETION_MARKER,
   COMPLETION_MARKER_INSTRUCTION: () => COMPLETION_MARKER_INSTRUCTION,
   CognitiveDepth: () => CognitiveDepth,
+  DELIBERATION_ALLOWED_TOOLS: () => DELIBERATION_ALLOWED_TOOLS,
+  DELIBERATION_MAX_TOOL_ITERATIONS: () => DELIBERATION_MAX_TOOL_ITERATIONS,
   DELIVERABLE_TITLE_CHARS: () => DELIVERABLE_TITLE_CHARS,
   ENTITY_COMMENTS_DEFAULT: () => ENTITY_COMMENTS_DEFAULT,
   HEARTBEAT_DAILY_LOG_CHARS: () => HEARTBEAT_DAILY_LOG_CHARS,
@@ -4368,6 +4434,9 @@ __export(dist_exports, {
   REVIEWER_FILE_LIST_MAX: () => REVIEWER_FILE_LIST_MAX,
   REVIEWER_NOTES_MAX: () => REVIEWER_NOTES_MAX,
   REVISION_REASON_CHARS: () => REVISION_REASON_CHARS,
+  SHELL_MAX_SESSIONS_PER_AGENT: () => SHELL_MAX_SESSIONS_PER_AGENT,
+  SHELL_SESSION_IDLE_TIMEOUT_MS: () => SHELL_SESSION_IDLE_TIMEOUT_MS,
+  SHELL_SESSION_MAX_OUTPUT_BYTES: () => SHELL_SESSION_MAX_OUTPUT_BYTES,
   SHELL_TIMEOUT_DEFAULT_MS: () => SHELL_TIMEOUT_DEFAULT_MS,
   SHELL_TIMEOUT_MAX_MS: () => SHELL_TIMEOUT_MAX_MS,
   SUBAGENT_ERROR_PREVIEW_CHARS: () => SUBAGENT_ERROR_PREVIEW_CHARS,
@@ -4437,6 +4506,8 @@ __export(dist_exports, {
   orgId: () => orgId,
   readManifest: () => readManifest,
   requirementId: () => requirementId,
+  safeSlice: () => safeSlice,
+  sanitizeForLLM: () => sanitizeForLLM,
   saveConfig: () => saveConfig,
   stripInternalBlocks: () => stripInternalBlocks,
   taskId: () => taskId,
@@ -4468,6 +4539,7 @@ var init_dist = __esm({
     init_version();
     init_update_checker();
     init_limits();
+    init_sanitize();
   }
 });
 
@@ -5464,6 +5536,10 @@ import { join as join6 } from "node:path";
 function freshCounters() {
   return {
     totalTokens: 0,
+    promptTokens: 0,
+    completionTokens: 0,
+    estimatedCost: 0,
+    costToday: 0,
     requestCount: 0,
     toolCalls: 0,
     errorCount: 0,
@@ -5507,6 +5583,7 @@ var init_agent_metrics = __esm({
           c.tokensToday = 0;
           c.requestsToday = 0;
           c.toolCallsToday = 0;
+          c.costToday = 0;
           c.todayCutoffDate = today;
         }
         c.totalEvents++;
@@ -5517,6 +5594,12 @@ var init_agent_metrics = __esm({
         if (event.type === "llm_request") {
           const tokens = event.tokensUsed ?? 0;
           c.totalTokens += tokens;
+          c.promptTokens += event.inputTokens ?? 0;
+          c.completionTokens += event.outputTokens ?? 0;
+          if (event.cost) {
+            c.estimatedCost += event.cost;
+            c.costToday += event.cost;
+          }
           c.requestCount++;
           c.tokensToday += tokens;
           c.requestsToday++;
@@ -5575,19 +5658,29 @@ var init_agent_metrics = __esm({
        */
       getUsageStats() {
         const c = this.counters;
-        const input = Math.round(c.totalTokens * 0.7);
-        const output = c.totalTokens - input;
-        const estimatedCost = input / 1e6 * 3 + output / 1e6 * 15;
+        let cost = c.estimatedCost;
+        let costToday = c.costToday;
+        if (cost === 0 && c.totalTokens > 0) {
+          const input = Math.round(c.totalTokens * 0.7);
+          const output = c.totalTokens - input;
+          cost = input / 1e6 * 3 + output / 1e6 * 15;
+        }
+        if (costToday === 0 && c.tokensToday > 0) {
+          const input = Math.round(c.tokensToday * 0.7);
+          const output = c.tokensToday - input;
+          costToday = input / 1e6 * 3 + output / 1e6 * 15;
+        }
         return {
           totalTokens: c.totalTokens,
-          promptTokens: input,
-          completionTokens: output,
+          promptTokens: c.promptTokens || Math.round(c.totalTokens * 0.7),
+          completionTokens: c.completionTokens || c.totalTokens - Math.round(c.totalTokens * 0.7),
           requestCount: c.requestCount,
           toolCalls: c.toolCalls,
           tokensToday: c.tokensToday,
           requestsToday: c.requestsToday,
           toolCallsToday: c.toolCallsToday,
-          estimatedCost: Math.round(estimatedCost * 1e4) / 1e4
+          estimatedCost: Math.round(cost * 1e4) / 1e4,
+          costToday: Math.round(costToday * 1e4) / 1e4
         };
       }
       /**
@@ -5609,9 +5702,12 @@ var init_agent_metrics = __esm({
         return Math.round(Math.min(100, heartbeatComponent + taskComponent + errorComponent + recencyComponent));
       }
       computeTokenUsageFromCounters(c) {
-        const input = Math.round(c.totalTokens * 0.7);
-        const output = c.totalTokens - input;
-        const cost = input / 1e6 * 3 + output / 1e6 * 15;
+        const input = c.promptTokens || Math.round(c.totalTokens * 0.7);
+        const output = c.completionTokens || c.totalTokens - input;
+        let cost = c.estimatedCost;
+        if (cost === 0 && c.totalTokens > 0) {
+          cost = input / 1e6 * 3 + output / 1e6 * 15;
+        }
         return { input, output, cost: Math.round(cost * 1e4) / 1e4 };
       }
       computeTaskMetrics(tasks) {
@@ -6403,6 +6499,13 @@ var init_context_engine = __esm({
           stable.push("**Built-in tools over CLI**: ALWAYS prefer built-in tools (`task_create`, `task_assign`, `package_install`, `agent_send_message`, `memory_save`, etc.) over running `markus` CLI commands via `shell_execute`. The CLI is for human operators \u2014 agents must use their native tool interface. Only fall back to CLI if no built-in tool exists for the operation.");
           stable.push('**No auto-install/deploy**: NEVER automatically install or deploy agents, teams, or skills via `package_install` or `hub_install` unless explicitly requested by a human team member (e.g., "install", "deploy", "hire", "start"). Creating an artifact (writing files to `builder-artifacts/`) is separate from deploying it into the live organization.');
           stable.push("");
+          stable.push("\n## Deliverable & Report Output Format");
+          stable.push("When creating deliverable files (reports, analysis, documentation, etc.), choose the most appropriate format:");
+          stable.push("- **Markdown (.md)**: Use for simple, short, or text-heavy content \u2014 READMEs, notes, status summaries, concise reports. Preferred when content is linear and doesn't need interactive elements.");
+          stable.push("- **HTML (.html)**: Use for complex, data-rich, or interactive content \u2014 dashboards, multi-section reports with charts/tables, comparative analyses, visual summaries, or any content where layout, color-coding, or collapsible sections would help the reader absorb information faster. Include inline CSS for styling. You may embed lightweight JavaScript for interactivity (collapsible sections, sortable tables, tab switching, chart rendering via CDN libraries like Chart.js or ECharts).");
+          stable.push("- **Other formats**: Use the format that best fits the content (e.g., JSON for structured data, CSV for tabular exports, SVG for diagrams).");
+          stable.push("Default to markdown for brevity; escalate to HTML when richness helps comprehension. Always use the correct file extension so the platform can detect and render it properly.");
+          stable.push("");
           stable.push("\n## Task & Requirement Workflow");
           stable.push("");
           stable.push("**Requirements** (governance gate):");
@@ -6747,6 +6850,8 @@ ${ctx.mergedContent.slice(0, SYSTEM_MAILBOX_MERGED_CHARS)}`);
             lines.push("**After creating tasks, STOP.** Do NOT execute the task work yourself. The task runs in its own isolated context after user approval. Reply with a summary of created tasks, assignees, and dependency structure. Tell the requester to review and approve.");
             lines.push("");
             lines.push("Keep responses concise and human-friendly. The user should not see raw tool outputs or complex operations.");
+            lines.push("");
+            lines.push("**Notification context**: Previous messages in this session may contain `<!-- notify_context: ... -->` metadata comments from your earlier `notify_user` calls. These embed `task_id`, `requirement_id`, and `priority` references. When the human replies to such a message, use these references to retrieve full context (e.g. via `recall_activity`, `search_tasks`) before responding.");
             break;
           case "task_execution":
             lines.push("You are in **task execution mode** \u2014 an isolated session for focused, thorough work.");
@@ -6875,6 +6980,40 @@ ${ctx.mergedContent.slice(0, SYSTEM_MAILBOX_MERGED_CHARS)}`);
             lines.push("Do NOT call any tools. Do NOT take any actions. Do NOT discuss tasks or projects.");
             lines.push("Respond with ONLY the JSON object as specified in the user message.");
             break;
+          case "deliberation":
+            lines.push("You are in **deliberation mode** \u2014 reviewing your mailbox before committing to work.");
+            lines.push("");
+            lines.push("**Purpose**: You have multiple pending items. Take a moment to understand the full picture before deciding what to focus on.");
+            lines.push("");
+            lines.push("**What you can do**:");
+            lines.push("1. **Gather context**: Call tools like recall_activity, task_get, memory_search to understand history and commitments.");
+            lines.push("2. **Handle simple items inline**: For trivial acknowledgments or quick notifications, use notify_user, task_comment, or agent_send_message now. Mark them as inline_completed in your final decision.");
+            lines.push("3. **Choose your focus**: Decide which complex item deserves your full attention next.");
+            lines.push("4. **Defer or drop**: Explicitly defer items for later or drop stale/redundant ones.");
+            lines.push("");
+            lines.push("**Rules**:");
+            lines.push("- Human messages and comments are ALWAYS highest priority.");
+            lines.push("- Consider your active tasks, pending commitments, and recent conversation context.");
+            lines.push("- Stale informational items (old heartbeats, status updates) should be dropped aggressively.");
+            lines.push("- When done, you MUST call the `complete_deliberation` tool with your decision.");
+            lines.push("");
+            lines.push("**Communication channel**: Your text output is NOT visible to anyone. Only tool calls have effect. To reach humans, use `notify_user`. To reach agents, use `agent_send_message`.");
+            break;
+          case "requirement_action":
+            lines.push("You are processing a **requirement update that requires action** (e.g., all tasks completed and requirement needs review, or a human approved/rejected your proposed requirement).");
+            lines.push("");
+            lines.push("**Communication channel**: Your text output is **NOT visible** to any human or agent. You MUST use tools to take action and communicate. Simply writing text and ending your turn accomplishes nothing.");
+            lines.push("");
+            lines.push("**Required actions** \u2014 you MUST do at least one of the following:");
+            lines.push("1. **Update requirement status**: `requirement_update_status` to mark the requirement as completed, or keep it active if more work is needed.");
+            lines.push("2. **Create follow-up tasks**: `task_create` with the `requirement_id` if additional work is needed to fulfill the requirement.");
+            lines.push("3. **Post a comment**: `requirement_comment` to leave notes or reasoning visible in the requirement thread.");
+            lines.push("4. **Notify a human**: `notify_user` if the requirement outcome needs human attention or decision.");
+            lines.push("");
+            lines.push("**MANDATORY**: Before deciding, call `requirement_get` to understand the full current state of the requirement, including linked tasks, status, and comments.");
+            lines.push("");
+            lines.push("**CRITICAL**: You MUST call at least one action tool before finishing. Do NOT just output text \u2014 it will be lost.");
+            break;
         }
         return lines.join("\n");
       }
@@ -7273,12 +7412,12 @@ ${heuristicSummary}
               return m;
             const headSize = Math.min(Math.floor(effectiveCap * 0.65), isResearch ? 4e3 : 1500);
             const tailSize = Math.min(Math.floor(effectiveCap * 0.25), isResearch ? 1500 : 800);
-            const head = text.slice(0, headSize);
-            const tail = text.slice(-tailSize);
-            const omitted = text.length - headSize - tailSize;
+            const head = safeSlice(text, 0, headSize);
+            const tail = safeSlice(text, text.length - tailSize);
+            const omitted = text.length - head.length - tail.length;
             return {
               ...m,
-              content: `[Tool result compacted: showing ${headSize} head + ${tailSize} tail of ${text.length} chars.]
+              content: `[Tool result compacted: showing ${head.length} head + ${tail.length} tail of ${text.length} chars.]
 ${head}
 [... ${omitted} chars omitted ...]
 ${tail}`
@@ -7288,7 +7427,7 @@ ${tail}`
             return m;
           return {
             ...m,
-            content: text.slice(0, maxChars) + `
+            content: safeSlice(text, 0, maxChars) + `
 
 [... content trimmed from ${text.length} chars]`
           };
@@ -7748,6 +7887,7 @@ var init_cognitive2 = __esm({
       a2a: CognitiveDepth.D1_Reactive,
       comment_response: CognitiveDepth.D1_Reactive,
       review: CognitiveDepth.D1_Reactive,
+      requirement_action: CognitiveDepth.D1_Reactive,
       task_execution: CognitiveDepth.D2_Deliberative
     };
     CognitivePreparation = class {
@@ -8432,7 +8572,8 @@ var init_tool_selector = __esm({
               title: { type: "string", description: "Short headline (1 line)" },
               body: { type: "string", description: "Full message content. Be thorough \u2014 this is what the recipient reads in chat." },
               priority: { type: "string", enum: ["low", "normal", "high", "urgent"], description: "Default: normal" },
-              related_task_id: { type: "string", description: "If related to a task, include the task ID for deep-linking" }
+              related_task_id: { type: "string", description: "If related to a task, include the task ID for deep-linking" },
+              target_user_id: { type: "string", description: "User ID to send the message to. If omitted, sends to the user you are currently interacting with (or the team owner)." }
             },
             required: ["title", "body"]
           }
@@ -8480,6 +8621,22 @@ var init_tool_selector = __esm({
             required: ["operation"]
           }
         });
+        pushUnique({
+          name: "complete_deliberation",
+          description: "Finalize your mailbox deliberation. Declare which item to process next, which to defer/drop, and which you handled inline. Only available in deliberation mode.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              process_item_id: { type: "string", description: "ID of the mailbox item to process in full next" },
+              defer_item_ids: { type: "array", items: { type: "string" }, description: "IDs of items to defer for later" },
+              drop_item_ids: { type: "array", items: { type: "string" }, description: "IDs of stale/redundant items to drop" },
+              inline_completed_ids: { type: "array", items: { type: "string" }, description: "IDs of items you already handled inline during this deliberation (e.g., sent a notification, posted a comment)" },
+              reasoning: { type: "string", description: "1-2 sentence explanation of your decision" },
+              situational_awareness: { type: "string", description: "Your current understanding of the situation \u2014 injected into future prompts for continuity" }
+            },
+            required: ["process_item_id", "reasoning"]
+          }
+        });
         log10.debug("Tool selection complete", {
           total: opts.allTools.size,
           selected: result.length,
@@ -8644,8 +8801,310 @@ var init_security = __esm({
   }
 });
 
-// ../core/dist/tools/shell.js
+// ../core/dist/tools/shell-session.js
 import { spawn } from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
+function makeSentinel() {
+  return SENTINEL_PREFIX + randomBytes2(8).toString("hex");
+}
+function getShellSessionManager() {
+  if (!_defaultManager) {
+    _defaultManager = new ShellSessionManager();
+  }
+  return _defaultManager;
+}
+var SENTINEL_PREFIX, ManagedSession, ShellSessionManager, _defaultManager;
+var init_shell_session = __esm({
+  "../core/dist/tools/shell-session.js"() {
+    "use strict";
+    init_dist();
+    SENTINEL_PREFIX = "__MARKUS_DONE_";
+    ManagedSession = class {
+      id;
+      agentId;
+      process;
+      createdAt = Date.now();
+      lastUsedAt = Date.now();
+      alive = true;
+      pending = null;
+      dataBuffer = "";
+      idleTimer = null;
+      constructor(id, agentId2, proc) {
+        this.id = id;
+        this.agentId = agentId2;
+        this.process = proc;
+        proc.stdout?.on("data", (chunk) => this.onData(chunk.toString()));
+        proc.stderr?.on("data", (chunk) => this.onData(chunk.toString()));
+        proc.on("exit", () => {
+          this.alive = false;
+          this.rejectPending("Shell session exited unexpectedly");
+        });
+        proc.on("error", () => {
+          this.alive = false;
+          this.rejectPending("Shell session error");
+        });
+        this.resetIdleTimer();
+      }
+      onData(data) {
+        if (!this.pending)
+          return;
+        this.pending.output += data;
+        if (this.pending.output.length > SHELL_SESSION_MAX_OUTPUT_BYTES) {
+          const keep = SHELL_SESSION_MAX_OUTPUT_BYTES - 1e3;
+          this.pending.output = "[... truncated ...]\n" + this.pending.output.slice(-keep);
+        }
+        const sentinelRe = new RegExp(`${this.pending.sentinel}_(\\d+)_
+?$`);
+        const match2 = this.pending.output.match(sentinelRe);
+        if (match2) {
+          const exitCode = parseInt(match2[1], 10);
+          const output = this.pending.output.slice(0, match2.index).replace(/^\n/, "");
+          clearTimeout(this.pending.timer);
+          const p = this.pending;
+          this.pending = null;
+          this.resetIdleTimer();
+          p.resolve({ stdout: output, exitCode });
+        }
+      }
+      rejectPending(reason) {
+        if (this.pending) {
+          clearTimeout(this.pending.timer);
+          const p = this.pending;
+          this.pending = null;
+          p.resolve({ stdout: p.output + `
+[${reason}]`, exitCode: -1 });
+        }
+      }
+      resetIdleTimer() {
+        if (this.idleTimer)
+          clearTimeout(this.idleTimer);
+        this.idleTimer = setTimeout(() => this.kill(), SHELL_SESSION_IDLE_TIMEOUT_MS);
+      }
+      /**
+       * Execute a command in this session.  Returns when the sentinel is detected
+       * or the timeout fires.
+       */
+      execute(command, timeoutMs, onOutput) {
+        if (!this.alive) {
+          return Promise.resolve({
+            stdout: "[Session is no longer alive]",
+            exitCode: -1
+          });
+        }
+        if (this.pending) {
+          return Promise.resolve({
+            stdout: "[Session is busy with another command]",
+            exitCode: -1
+          });
+        }
+        this.lastUsedAt = Date.now();
+        if (this.idleTimer)
+          clearTimeout(this.idleTimer);
+        const sentinel = makeSentinel();
+        return new Promise((resolve20) => {
+          const timer = setTimeout(() => {
+            const partial = this.pending?.output ?? "";
+            this.pending = null;
+            this.resetIdleTimer();
+            resolve20({
+              stdout: partial + `
+[Command timed out after ${timeoutMs}ms]`,
+              exitCode: -1
+            });
+          }, timeoutMs);
+          this.pending = { sentinel, output: "", resolve: resolve20, timer };
+          if (onOutput) {
+            const origOnData = this.onData.bind(this);
+            const origPendingRef = this.pending;
+            let lastLen = 0;
+            const outputPoll = setInterval(() => {
+              if (this.pending !== origPendingRef) {
+                clearInterval(outputPoll);
+                return;
+              }
+              const newContent = this.pending.output.slice(lastLen);
+              if (newContent) {
+                const cleaned = newContent.replace(new RegExp(`echo ${sentinel}_\\$\\?_`), "");
+                if (cleaned)
+                  onOutput(cleaned);
+                lastLen = this.pending.output.length;
+              }
+            }, 200);
+            const origResolve = this.pending.resolve;
+            this.pending.resolve = (result) => {
+              clearInterval(outputPoll);
+              origResolve(result);
+            };
+          }
+          const script = `${command}
+echo ${sentinel}_$?_
+`;
+          this.process.stdin?.write(script);
+        });
+      }
+      kill() {
+        if (this.idleTimer)
+          clearTimeout(this.idleTimer);
+        this.alive = false;
+        this.rejectPending("Session killed");
+        try {
+          this.process.kill("SIGTERM");
+          setTimeout(() => {
+            try {
+              this.process.kill("SIGKILL");
+            } catch {
+            }
+          }, 1e3);
+        } catch {
+        }
+      }
+      toInfo() {
+        return {
+          id: this.id,
+          agentId: this.agentId,
+          process: this.process,
+          cwd: "",
+          createdAt: this.createdAt,
+          lastUsedAt: this.lastUsedAt,
+          alive: this.alive
+        };
+      }
+    };
+    ShellSessionManager = class {
+      sessions = /* @__PURE__ */ new Map();
+      agentSessions = /* @__PURE__ */ new Map();
+      /**
+       * Get or create the default session for an agent.
+       * If no session exists, one is lazily created.
+       */
+      getOrCreateDefault(agentId2, cwd) {
+        const defaultId = `${agentId2}:default`;
+        const existing = this.sessions.get(defaultId);
+        if (existing?.alive)
+          return existing;
+        if (existing && !existing.alive) {
+          this.removeSession(defaultId);
+        }
+        return this.createSession(defaultId, agentId2, cwd);
+      }
+      /**
+       * Create a named session for an agent.
+       */
+      create(agentId2, sessionName, cwd) {
+        const sessionId = `${agentId2}:${sessionName}`;
+        if (this.sessions.has(sessionId)) {
+          const s2 = this.sessions.get(sessionId);
+          if (s2.alive)
+            return s2;
+          this.removeSession(sessionId);
+        }
+        const agentSet = this.agentSessions.get(agentId2) ?? /* @__PURE__ */ new Set();
+        if (agentSet.size >= SHELL_MAX_SESSIONS_PER_AGENT) {
+          return null;
+        }
+        return this.createSession(sessionId, agentId2, cwd);
+      }
+      get(sessionId) {
+        const s2 = this.sessions.get(sessionId);
+        if (s2 && !s2.alive) {
+          this.removeSession(sessionId);
+          return void 0;
+        }
+        return s2;
+      }
+      /**
+       * Execute a command in the given session (or agent default).
+       */
+      async execute(agentId2, command, options) {
+        const timeoutMs = Math.min(options?.timeoutMs ?? SHELL_TIMEOUT_DEFAULT_MS, SHELL_TIMEOUT_MAX_MS);
+        let session;
+        if (options?.sessionId) {
+          session = this.get(options.sessionId);
+          if (!session) {
+            return { stdout: `[Session ${options.sessionId} not found]`, exitCode: -1 };
+          }
+        } else {
+          session = this.getOrCreateDefault(agentId2, options?.cwd);
+        }
+        if (options?.cwd) {
+          const cdResult = await session.execute(`cd ${JSON.stringify(options.cwd)} 2>/dev/null`, 5e3);
+          if (cdResult.exitCode !== 0) {
+            return { stdout: `[Failed to cd to ${options.cwd}]`, exitCode: -1 };
+          }
+        }
+        return session.execute(command, timeoutMs, options?.onOutput);
+      }
+      listForAgent(agentId2) {
+        const ids = this.agentSessions.get(agentId2);
+        if (!ids)
+          return [];
+        const result = [];
+        for (const id of ids) {
+          const s2 = this.sessions.get(id);
+          if (s2?.alive)
+            result.push(s2.toInfo());
+        }
+        return result;
+      }
+      killSession(sessionId) {
+        const s2 = this.sessions.get(sessionId);
+        if (!s2)
+          return false;
+        s2.kill();
+        this.removeSession(sessionId);
+        return true;
+      }
+      killAllForAgent(agentId2) {
+        const ids = this.agentSessions.get(agentId2);
+        if (!ids)
+          return;
+        for (const id of [...ids]) {
+          this.killSession(id);
+        }
+      }
+      destroyAll() {
+        for (const [id, s2] of this.sessions) {
+          s2.kill();
+        }
+        this.sessions.clear();
+        this.agentSessions.clear();
+      }
+      createSession(sessionId, agentId2, cwd) {
+        const shell = process.env["SHELL"] || "/bin/sh";
+        const child = spawn(shell, ["--norc", "--noprofile", "-i"], {
+          cwd: cwd ?? process.cwd(),
+          stdio: ["pipe", "pipe", "pipe"],
+          env: {
+            ...process.env,
+            PS1: "",
+            PS2: "",
+            PROMPT_COMMAND: "",
+            TERM: "dumb"
+          }
+        });
+        const session = new ManagedSession(sessionId, agentId2, child);
+        this.sessions.set(sessionId, session);
+        const agentSet = this.agentSessions.get(agentId2) ?? /* @__PURE__ */ new Set();
+        agentSet.add(sessionId);
+        this.agentSessions.set(agentId2, agentSet);
+        return session;
+      }
+      removeSession(sessionId) {
+        const s2 = this.sessions.get(sessionId);
+        if (s2) {
+          const agentSet = this.agentSessions.get(s2.agentId);
+          agentSet?.delete(sessionId);
+          if (agentSet?.size === 0)
+            this.agentSessions.delete(s2.agentId);
+        }
+        this.sessions.delete(sessionId);
+      }
+    };
+  }
+});
+
+// ../core/dist/tools/shell.js
+import { spawn as spawn2 } from "node:child_process";
 import { resolve as resolve4, normalize, sep } from "node:path";
 function injectGitCommitMeta(command, meta) {
   if (!meta)
@@ -8718,6 +9177,10 @@ function createShellTool(security, workspacePath, agentMeta, policy, onCommandAp
         timeout_ms: {
           type: "number",
           description: `Timeout in milliseconds (default: ${SHELL_TIMEOUT_DEFAULT_MS}, max: ${SHELL_TIMEOUT_MAX_MS})`
+        },
+        session_id: {
+          type: "string",
+          description: "Reuse a persistent shell session by name. State (cwd, env vars, shell variables) persists across calls with the same session_id. Omit to use the default session."
         }
       },
       required: ["command"]
@@ -8774,22 +9237,71 @@ function createShellTool(security, workspacePath, agentMeta, policy, onCommandAp
         }
       }
       const finalCommand = injectGitCommitMeta(command, agentMeta);
+      const sessionId = args["session_id"];
+      if (agentMeta?.agentId) {
+        try {
+          const mgr = getShellSessionManager();
+          const result = await mgr.execute(agentMeta.agentId, finalCommand, {
+            sessionId: sessionId ? `${agentMeta.agentId}:${sessionId}` : void 0,
+            cwd: effectiveCwd ?? void 0,
+            timeoutMs,
+            onOutput: onOutput ? (chunk) => onOutput(sanitizeForLLM(chunk)) : void 0
+          });
+          const stdout = sanitizeForLLM(result.stdout);
+          if (result.exitCode !== 0) {
+            return JSON.stringify({
+              status: "error",
+              error: `Process exited with code ${result.exitCode}`,
+              exitCode: result.exitCode,
+              stdout: stdout.slice(0, 4e3)
+            });
+          }
+          return JSON.stringify({
+            status: "success",
+            stdout: stdout.trim() || void 0
+          });
+        } catch {
+        }
+      }
       return new Promise((resolve20) => {
-        const child = spawn("sh", ["-c", finalCommand], {
+        let settled = false;
+        const settle = (result) => {
+          if (settled)
+            return;
+          settled = true;
+          resolve20(result);
+        };
+        const child = spawn2("sh", ["-c", finalCommand], {
           cwd: effectiveCwd ?? void 0,
           stdio: ["ignore", "pipe", "pipe"],
+          detached: true,
           env: { ...process.env }
         });
+        child.unref();
         let stdout = "";
         let stderr = "";
         let killed = false;
         const maxBuffer = 10 * 1024 * 1024;
         const timeout = setTimeout(() => {
           killed = true;
-          child.kill("SIGTERM");
+          try {
+            process.kill(-child.pid, "SIGTERM");
+          } catch {
+          }
           setTimeout(() => {
-            if (!child.killed)
-              child.kill("SIGKILL");
+            try {
+              process.kill(-child.pid, "SIGKILL");
+            } catch {
+            }
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            settle(JSON.stringify({
+              status: "error",
+              error: `Command timed out after ${timeoutMs}ms`,
+              exitCode: null,
+              stdout: sanitizeForLLM(stdout).slice(0, 4e3),
+              stderr: sanitizeForLLM(stderr).slice(0, 4e3)
+            }));
           }, 2e3);
         }, timeoutMs);
         let outputBuffer = "";
@@ -8828,27 +9340,29 @@ function createShellTool(security, workspacePath, agentMeta, policy, onCommandAp
             clearTimeout(flushTimer);
             flushOutput();
           }
+          const cleanOut = sanitizeForLLM(stdout);
+          const cleanErr = sanitizeForLLM(stderr);
           if (killed) {
-            resolve20(JSON.stringify({
+            settle(JSON.stringify({
               status: "error",
               error: `Command timed out after ${timeoutMs}ms`,
               exitCode: code,
-              stdout: stdout.slice(0, 4e3),
-              stderr: stderr.slice(0, 4e3)
+              stdout: cleanOut.slice(0, 4e3),
+              stderr: cleanErr.slice(0, 4e3)
             }));
           } else if (code !== 0) {
-            resolve20(JSON.stringify({
+            settle(JSON.stringify({
               status: "error",
-              error: stderr.trim() || `Process exited with code ${code}`,
+              error: cleanErr.trim() || `Process exited with code ${code}`,
               exitCode: code,
-              stdout: stdout.slice(0, 4e3),
-              stderr: stderr.slice(0, 4e3)
+              stdout: cleanOut.slice(0, 4e3),
+              stderr: cleanErr.slice(0, 4e3)
             }));
           } else {
-            resolve20(JSON.stringify({
+            settle(JSON.stringify({
               status: "success",
-              stdout: stdout.trim() || void 0,
-              stderr: stderr.trim() || void 0
+              stdout: cleanOut.trim() || void 0,
+              stderr: cleanErr.trim() || void 0
             }));
           }
         });
@@ -8858,11 +9372,11 @@ function createShellTool(security, workspacePath, agentMeta, policy, onCommandAp
             clearTimeout(flushTimer);
             flushOutput();
           }
-          resolve20(JSON.stringify({
+          settle(JSON.stringify({
             status: "error",
             error: err.message,
-            stdout: stdout.slice(0, 4e3),
-            stderr: stderr.slice(0, 4e3)
+            stdout: sanitizeForLLM(stdout).slice(0, 4e3),
+            stderr: sanitizeForLLM(stderr).slice(0, 4e3)
           }));
         });
       });
@@ -8875,6 +9389,7 @@ var init_shell = __esm({
     "use strict";
     init_dist();
     init_security();
+    init_shell_session();
     GIT_ALWAYS_DENY = [];
     GIT_NEEDS_APPROVAL = [
       { pattern: /\bgit\s+push\s+--force/, label: "force push (--force)" },
@@ -41343,44 +41858,32 @@ async function searchBrave(query2, maxResults) {
     date: r.page_age
   }));
 }
-async function searchBing(query2, maxResults) {
-  const encoded = encodeURIComponent(query2);
+async function searchBocha(query2, maxResults) {
+  const apiKey = process.env["BOCHA_API_KEY"];
+  if (!apiKey)
+    throw new Error("BOCHA_API_KEY not configured");
   let res;
   try {
-    res = await proxyFetch(`https://www.bing.com/search?q=${encoded}`, {
-      headers: { "User-Agent": BING_UA }
+    res = await proxyFetch("https://api.bochaai.com/v1/web-search", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ query: query2, count: maxResults, summary: true })
     });
   } catch (err) {
     throw new Error(`Network error: ${err instanceof Error ? err.message : String(err)}`);
   }
   if (!res.ok)
     throw new Error(`HTTP ${res.status} ${res.statusText}`);
-  const html = await res.text();
-  const results = parseBingHtml(html, maxResults);
-  if (results.length === 0)
-    throw new Error("Parsed 0 results from Bing");
-  return results;
-}
-function parseBingHtml(html, max) {
-  const results = [];
-  const algoRegex = /<li[^>]*class="b_algo"[^>]*>([\s\S]*?)<\/li>/g;
-  let match2;
-  while ((match2 = algoRegex.exec(html)) !== null) {
-    if (results.length >= max)
-      break;
-    const item = match2[1];
-    const linkMatch = item.match(/<a[^>]+href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/i);
-    if (!linkMatch)
-      continue;
-    const url = linkMatch[1];
-    const title = stripHtml(linkMatch[2]);
-    if (!url || !title)
-      continue;
-    const snippetMatch = item.match(/<p[^>]*>([\s\S]*?)<\/p>/i);
-    const snippet = snippetMatch ? stripHtml(snippetMatch[1]) : "";
-    results.push({ title, url, snippet });
-  }
-  return results;
+  const data = await res.json();
+  return (data.webPages?.value ?? []).slice(0, maxResults).map((r) => ({
+    title: r.name,
+    url: r.url,
+    snippet: r.summary || r.snippet,
+    date: r.datePublished
+  }));
 }
 async function searchDuckDuckGo(query2, maxResults) {
   const encoded = encodeURIComponent(query2);
@@ -41470,7 +41973,7 @@ function parseDDGHtml(html, maxResults) {
 function stripHtml(html) {
   return html.replace(/<[^>]*>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#x27;/g, "'").replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
 }
-var SEARCH_TIMEOUT_MS, _dispatcher, WebSearchTool, BING_UA, DDG_UA, DDG_ENDPOINTS;
+var SEARCH_TIMEOUT_MS, _dispatcher, WebSearchTool, DDG_UA, DDG_ENDPOINTS;
 var init_web_search = __esm({
   "../core/dist/tools/web-search.js"() {
     "use strict";
@@ -41499,7 +42002,7 @@ var init_web_search = __esm({
         const backends = [
           { name: "Serper", fn: searchSerper },
           { name: "Brave", fn: searchBrave },
-          { name: "Bing", fn: searchBing },
+          { name: "Bocha", fn: searchBocha },
           { name: "DuckDuckGo", fn: searchDuckDuckGo }
         ];
         const errors = [];
@@ -41531,7 +42034,6 @@ var init_web_search = __esm({
         });
       }
     };
-    BING_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
     DDG_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
     DDG_ENDPOINTS = [
       "https://lite.duckduckgo.com/lite/",
@@ -42106,7 +42608,7 @@ var init_patch = __esm({
 });
 
 // ../core/dist/tools/process-manager.js
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { resolve as resolve7 } from "node:path";
 function onBackgroundCompletion(cb) {
   completionListeners.push(cb);
@@ -42174,7 +42676,7 @@ function createBackgroundExecTool(workspacePath) {
         return JSON.stringify({ status: "denied", error: "Working directory must be within workspace" });
       }
       const id = `bg_${++sessionCounter}_${Date.now()}`;
-      const child = spawn2("sh", ["-c", command], {
+      const child = spawn3("sh", ["-c", command], {
         cwd: effectiveCwd,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -43392,6 +43894,8 @@ var init_attention = __esm({
       triageToolHandlers;
       triageChatFn;
       lastTriageResult;
+      /** True while a full-session deliberation is in progress (suppresses yield points). */
+      isDeliberating = false;
       /** Tracks whether the last yield-point decision was 'cancel' vs 'preempt'. */
       lastYieldDecision;
       unsubscribeNewItem;
@@ -43534,50 +44038,22 @@ var init_attention = __esm({
             }
           }
           let triaged = false;
-          if (this.mailbox.depth > 0 && this.triageJudge && this.needsLLMTriage(item)) {
-            const triageResult = await this.performTriage(item);
-            if (triageResult) {
-              triaged = true;
-              if (triageResult.processItemId !== item.id) {
-                this.mailbox.putBack(item);
-                const chosen = this.mailbox.dequeueById(triageResult.processItemId);
-                if (chosen) {
-                  item = chosen;
-                } else {
-                  const redequeued = this.mailbox.dequeueById(item.id);
-                  if (redequeued)
-                    item = redequeued;
-                }
+          if (this.mailbox.depth > 0 && this.needsLLMTriage(item) && (this.delegate?.performDeliberation || this.triageJudge)) {
+            if (this.delegate?.performDeliberation) {
+              const allItems = [item, ...this.mailbox.getQueuedItems()];
+              this.isDeliberating = true;
+              const deliberationResult = await this.delegate.performDeliberation(item, allItems);
+              this.isDeliberating = false;
+              if (deliberationResult) {
+                triaged = true;
+                item = this.applyDeliberationResult(item, deliberationResult);
               }
-              const queueSnapshot = this.mailbox.getQueuedItems();
-              const isProtected = (id) => {
-                const it = queueSnapshot.find((i) => i.id === id);
-                if (!it)
-                  return false;
-                if (it.sourceType === "human_chat")
-                  return true;
-                if (it.payload.extra?.triggerExecution)
-                  return true;
-                return false;
-              };
-              for (const deferId of triageResult.deferItemIds) {
-                if (isProtected(deferId))
-                  continue;
-                this.mailbox.defer(deferId);
-              }
-              for (const dropId of triageResult.dropItemIds) {
-                if (isProtected(dropId))
-                  continue;
-                this.mailbox.drop(dropId);
+            } else {
+              const triageResult = await this.performTriage(item);
+              if (triageResult) {
+                triaged = true;
+                item = this.applyTriageResult(item, triageResult);
               }
-              this.lastTriageResult = { ...triageResult, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
-              this.delegate?.onTriageCompleted?.(triageResult);
-              this.eventBus.emit("attention:triage", {
-                agentId: this.agentId,
-                triage: this.lastTriageResult
-              });
-              const triageDecision = this.recordDecision("triage", item, triageResult.reasoning);
-              this.delegate?.onDecisionMade(triageDecision);
             }
           }
           if (!triaged) {
@@ -43744,6 +44220,9 @@ var init_attention = __esm({
        * - 'merge' → item was absorbed into current work (caller may inject into session)
        */
       async checkYieldPoint() {
+        if (this.isDeliberating) {
+          return { decision: "continue" };
+        }
         if (!this.interruptSignal || !this.currentFocus) {
           return { decision: "continue" };
         }
@@ -43959,8 +44438,10 @@ var init_attention = __esm({
               description: t.description,
               inputSchema: t.inputSchema
             }));
+            const triageAgentName = ctx?.agentName ?? "Agent";
+            const triageRoleHint = ctx?.agentRole ? ` Your role: ${ctx.agentRole}.` : "";
             const messages = [
-              { role: "system", content: "You are a mailbox triage assistant. You may call read-only tools to gather context before making your decision. When ready, output ONLY a single JSON object \u2014 no explanation, no markdown fences, no <think> tags. Start your response with {" },
+              { role: "system", content: `You are ${triageAgentName}, deliberating over your mailbox.${triageRoleHint} You may call tools to gather context before making your decision. When ready, output ONLY a single JSON object \u2014 no explanation, no markdown fences, no <think> tags. Start your response with {` },
               { role: "user", content: prompt }
             ];
             let iterations = 0;
@@ -44028,6 +44509,120 @@ var init_attention = __esm({
           return null;
         }
       }
+      /**
+       * Apply a TriageResult to the mailbox: reorder, defer, drop items.
+       * Returns the item to process next.
+       */
+      applyTriageResult(currentItem, triageResult) {
+        let item = currentItem;
+        if (triageResult.processItemId !== item.id) {
+          this.mailbox.putBack(item);
+          const chosen = this.mailbox.dequeueById(triageResult.processItemId);
+          if (chosen) {
+            item = chosen;
+          } else {
+            const redequeued = this.mailbox.dequeueById(currentItem.id);
+            if (redequeued)
+              item = redequeued;
+          }
+        }
+        const queueSnapshot = this.mailbox.getQueuedItems();
+        const isProtected = (id) => {
+          const it = queueSnapshot.find((i) => i.id === id);
+          if (!it)
+            return false;
+          if (it.sourceType === "human_chat")
+            return true;
+          if (it.payload.extra?.triggerExecution)
+            return true;
+          return false;
+        };
+        for (const deferId of triageResult.deferItemIds) {
+          if (isProtected(deferId))
+            continue;
+          this.mailbox.defer(deferId);
+        }
+        for (const dropId of triageResult.dropItemIds) {
+          if (isProtected(dropId))
+            continue;
+          this.mailbox.drop(dropId);
+        }
+        this.lastTriageResult = { ...triageResult, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+        this.delegate?.onTriageCompleted?.(triageResult);
+        this.eventBus.emit("attention:triage", {
+          agentId: this.agentId,
+          triage: this.lastTriageResult
+        });
+        const triageDecision = this.recordDecision("triage", item, triageResult.reasoning);
+        this.delegate?.onDecisionMade(triageDecision);
+        return item;
+      }
+      /**
+       * Apply a DeliberationResult to the mailbox: handle inline completions, reorder, defer, drop.
+       * Returns the item to process next.
+       */
+      applyDeliberationResult(currentItem, result) {
+        let item = currentItem;
+        const queueSnapshot = this.mailbox.getQueuedItems();
+        const isProtected = (id) => {
+          const it = queueSnapshot.find((i) => i.id === id);
+          if (!it)
+            return false;
+          if (it.sourceType === "human_chat")
+            return true;
+          if (it.payload.extra?.triggerExecution)
+            return true;
+          return false;
+        };
+        for (const completedId of result.inlineCompletedIds) {
+          if (isProtected(completedId))
+            continue;
+          if (completedId === currentItem.id)
+            continue;
+          const completedItem = queueSnapshot.find((i) => i.id === completedId);
+          this.mailbox.complete(completedId);
+          if (completedItem) {
+            this.recordDecision("complete", completedItem, "Handled inline during deliberation");
+          }
+        }
+        if (result.processItemId !== item.id) {
+          this.mailbox.putBack(item);
+          const chosen = this.mailbox.dequeueById(result.processItemId);
+          if (chosen) {
+            item = chosen;
+          } else {
+            const redequeued = this.mailbox.dequeueById(currentItem.id);
+            if (redequeued)
+              item = redequeued;
+          }
+        }
+        for (const deferId of result.deferItemIds) {
+          if (isProtected(deferId))
+            continue;
+          this.mailbox.defer(deferId);
+        }
+        for (const dropId of result.dropItemIds) {
+          if (isProtected(dropId))
+            continue;
+          this.mailbox.drop(dropId);
+        }
+        const triageEquivalent = {
+          processItemId: result.processItemId,
+          deferItemIds: result.deferItemIds,
+          dropItemIds: result.dropItemIds,
+          inlineCompletedIds: result.inlineCompletedIds,
+          reasoning: result.reasoning
+        };
+        this.lastTriageResult = { ...triageEquivalent, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+        this.delegate?.onDeliberationCompleted?.(result);
+        this.eventBus.emit("attention:triage", {
+          agentId: this.agentId,
+          triage: this.lastTriageResult
+        });
+        const triageDecision = this.recordDecision("triage", item, `[deliberation] ${result.reasoning}`);
+        this.delegate?.onDecisionMade(triageDecision);
+        return item;
+      }
       buildTriagePrompt(headItem, ctx) {
         const agentName = ctx?.agentName ?? "Agent";
         const queuedItems = this.mailbox.getQueuedItems();
@@ -44149,6 +44744,7 @@ var init_attention = __esm({
             processedItemId: this.lastTriageResult.processItemId,
             deferredItemIds: this.lastTriageResult.deferItemIds,
             droppedItemIds: this.lastTriageResult.dropItemIds,
+            inlineCompletedIds: this.lastTriageResult.inlineCompletedIds ?? [],
             timestamp: this.lastTriageResult.timestamp
           } : void 0
         };
@@ -44952,7 +45548,8 @@ var init_tool_loop_detector = __esm({
       detectors: {
         genericRepeat: true,
         pingPong: true,
-        noProgress: true
+        noProgress: true,
+        sameToolBurst: true
       }
     };
     ToolLoopDetector = class {
@@ -44991,6 +45588,11 @@ var init_tool_loop_detector = __esm({
           if (result.detected)
             return result;
         }
+        if (this.config.detectors.sameToolBurst) {
+          const result = this.detectSameToolBurst();
+          if (result.detected)
+            return result;
+        }
         return { detected: false, severity: "none", pattern: "", message: "" };
       }
       /**
@@ -45085,6 +45687,38 @@ var init_tool_loop_detector = __esm({
         }
         return noDetection();
       }
+      /**
+       * Detects: a single tool called many times consecutively, even with different
+       * args/results each time. Catches "semantic loops" where the agent retries
+       * variations of the same approach (e.g., different shell commands to debug
+       * the same failing server) without switching strategy.
+       */
+      detectSameToolBurst() {
+        if (this.history.length < this.config.warningThreshold)
+          return noDetection();
+        const last = this.history[this.history.length - 1];
+        let streak = 1;
+        for (let i = this.history.length - 2; i >= 0; i--) {
+          if (this.history[i].name === last.name) {
+            streak++;
+          } else {
+            break;
+          }
+        }
+        const burstCritical = this.config.criticalThreshold + 2;
+        const burstWarning = this.config.warningThreshold + 2;
+        if (streak >= burstCritical) {
+          const msg = `Critical: "${last.name}" called ${streak} times consecutively (with varying arguments) \u2014 likely stuck in a retry loop`;
+          log15.warn(msg);
+          return { detected: true, severity: "critical", pattern: "sameToolBurst", message: msg };
+        }
+        if (streak >= burstWarning) {
+          const msg = `Warning: "${last.name}" called ${streak} times consecutively \u2014 consider a different approach`;
+          log15.warn(msg);
+          return { detected: true, severity: "warning", pattern: "sameToolBurst", message: msg };
+        }
+        return noDetection();
+      }
       reset() {
         this.history = [];
       }
@@ -45314,6 +45948,7 @@ var init_agent2 = __esm({
       semanticSearch;
       currentSessionId;
       currentInteractingUserId;
+      pendingDeliberationResult;
       dbSessionMap = /* @__PURE__ */ new Map();
       orgContext;
       contextMdPath;
@@ -45722,6 +46357,12 @@ ${notification.stdoutTail}`);
       getAttentionController() {
         return this.attentionController;
       }
+      /** Retrieve and clear the pending deliberation result (set by complete_deliberation tool). */
+      consumeDeliberationResult() {
+        const result = this.pendingDeliberationResult;
+        this.pendingDeliberationResult = void 0;
+        return result;
+      }
       /**
        * Check yield point during task execution — called between LLM turns.
        * Returns decision info so the tool loop can act on preemption or merges.
@@ -45770,12 +46411,20 @@ ${notification.stdoutTail}`);
             const messages = this.currentSessionId ? this.memory.getRecentMessages(this.currentSessionId, TRIAGE_CONTEXT_MESSAGES_MAX * 2).filter((m) => m.role === "user" || m.role === "assistant").slice(-TRIAGE_CONTEXT_MESSAGES_MAX).map((m) => ({ role: m.role, content: typeof m.content === "string" ? m.content.slice(0, TRIAGE_CONTEXT_MSG_CHARS) : String(m.content).slice(0, TRIAGE_CONTEXT_MSG_CHARS) })) : [];
             const activities = this.recentActivitySummaries();
             const activeTaskIds = Array.from(this.activeTasks);
-            return { agentName: this.config.name, recentMainSessionMessages: messages, recentActivitySummaries: activities, activeTaskIds };
+            return { agentName: this.config.name, agentRole: this.role.name, recentMainSessionMessages: messages, recentActivitySummaries: activities, activeTaskIds };
           },
           onTriageCompleted: (result) => {
             if (!result)
               return;
             this.updateCognition(result);
+          },
+          performDeliberation: async (headItem, allItems) => {
+            return this.performDeliberation(headItem, allItems);
+          },
+          onDeliberationCompleted: (result) => {
+            if (!result)
+              return;
+            this.updateCognitionFromDeliberation(result);
           }
         };
       }
@@ -45874,7 +46523,7 @@ ${notification.stdoutTail}`);
             case "requirement_update": {
               if (extra.actionRequired) {
                 const reqId = item.payload.requirementId ?? "unknown";
-                const reply = await this.handleMessage(item.payload.content + markerSuffix, item.metadata?.senderId, senderInfo, buildHandleOpts({ sessionId: `requirement_${reqId}_${ts}`, scenario: "requirement_action" }));
+                const reply = await this.handleMessage(item.payload.content + COMPLETION_MARKER_INSTRUCTION, item.metadata?.senderId, senderInfo, buildHandleOpts({ sessionId: `requirement_${reqId}_${ts}`, scenario: "requirement_action" }));
                 resolveResponse(reply);
                 return reply;
               }
@@ -45887,7 +46536,7 @@ ${notification.stdoutTail}`);
             }
             case "requirement_comment": {
               const reqId = item.payload.requirementId ?? "unknown";
-              const reply = await this.handleMessage(item.payload.content + markerSuffix, item.metadata?.senderId, senderInfo, buildHandleOpts({ sessionId: `comment_${reqId}_${ts}`, scenario: "comment_response" }));
+              const reply = await this.handleMessage(item.payload.content + COMPLETION_MARKER_INSTRUCTION, item.metadata?.senderId, senderInfo, buildHandleOpts({ sessionId: `comment_${reqId}_${ts}`, scenario: "comment_response" }));
               resolveResponse(reply);
               return reply;
             }
@@ -45899,7 +46548,7 @@ ${notification.stdoutTail}`);
                 this.injectUserMessage(sessionId, item.payload.content);
               } else {
                 const commentTaskId = taskId2 ?? "unknown";
-                await this.handleMessage(item.payload.content + markerSuffix, item.metadata?.senderId, senderInfo, buildHandleOpts({ sessionId: `comment_${commentTaskId}_${ts}`, scenario: "comment_response" }));
+                await this.handleMessage(item.payload.content + COMPLETION_MARKER_INSTRUCTION, item.metadata?.senderId, senderInfo, buildHandleOpts({ sessionId: `comment_${commentTaskId}_${ts}`, scenario: "comment_response" }));
               }
               resolveResponse("");
               return;
@@ -46407,7 +47056,7 @@ ${conversationText}`
           const filename = `${toolName}_${++this.toolResultCounter}_${Date.now()}.txt`;
           const filepath = join9(offloadDir, filename);
           writeFileSync8(filepath, result);
-          const preview = result.slice(0, previewSize);
+          const preview = safeSlice(result, 0, previewSize);
           const lineCount = result.split("\n").length;
           return [
             `[FULL output (${result.length} chars, ${lineCount} lines) saved to: ${filepath}]`,
@@ -46416,11 +47065,11 @@ ${conversationText}`
             ``,
             preview,
             ``,
-            `[... remaining ${result.length - previewSize} chars in file ...]`
+            `[... remaining ${result.length - preview.length} chars in file ...]`
           ].join("\n");
         } catch {
           const fallbackSize = isBrowserTool ? 3e4 : 8e3;
-          return result.slice(0, fallbackSize) + `
+          return safeSlice(result, 0, fallbackSize) + `
 
 [... output truncated at ${fallbackSize} of ${result.length} total chars due to file-save failure ...]`;
         }
@@ -46635,6 +47284,109 @@ ${conversationText}`
         lines.push(`Reasoning: ${result.reasoning}`);
         this.currentCognition = lines.join("\n");
       }
+      updateCognitionFromDeliberation(result) {
+        if (result.situationalAwareness) {
+          this.currentCognition = `## Current Situational Awareness (deliberation)
+${result.situationalAwareness}`;
+        } else {
+          const lines = [];
+          lines.push("## Current Situational Awareness (deliberation)");
+          lines.push(`Decision: Processing item [${result.processItemId}]`);
+          if (result.inlineCompletedIds.length > 0) {
+            lines.push(`Handled ${result.inlineCompletedIds.length} item(s) inline`);
+          }
+          if (result.deferItemIds.length > 0) {
+            lines.push(`Deferred ${result.deferItemIds.length} item(s)`);
+          }
+          if (result.dropItemIds.length > 0) {
+            lines.push(`Dropped ${result.dropItemIds.length} item(s)`);
+          }
+          lines.push(`Reasoning: ${result.reasoning}`);
+          this.currentCognition = lines.join("\n");
+        }
+      }
+      /**
+       * Full-session deliberation: the agent deliberates over all queued items as itself,
+       * with access to its full tool set (filtered to deliberation-safe tools).
+       */
+      async performDeliberation(headItem, allItems) {
+        const formatAge = (ms) => {
+          if (ms < 6e4)
+            return `${Math.round(ms / 1e3)}s`;
+          if (ms < 36e5)
+            return `${Math.round(ms / 6e4)}min`;
+          return `${(ms / 36e5).toFixed(1)}h`;
+        };
+        const formatItem = (item, idx) => {
+          const pri = PRIORITY_LABELS?.[item.priority] ?? `p${item.priority}`;
+          const ageMs = Date.now() - new Date(item.queuedAt).getTime();
+          const contentPreview = item.payload.content ? `
+    content: "${item.payload.content.slice(0, TRIAGE_ITEM_CONTENT_CHARS)}"` : "";
+          return [
+            `[${idx + 1}] id="${item.id}"`,
+            `    type=${item.sourceType}  priority=${pri}  age=${formatAge(ageMs)}`,
+            `    summary: "${item.payload.summary}"`,
+            item.payload.taskId ? `    taskId: ${item.payload.taskId}` : null,
+            item.metadata?.senderName ? `    from: ${item.metadata.senderName} (${item.metadata?.senderRole ?? "unknown"})` : null,
+            contentPreview || null
+          ].filter(Boolean).join("\n");
+        };
+        const itemsSection = allItems.map(formatItem).join("\n\n");
+        const deliberationPrompt = [
+          "[DELIBERATION MODE]",
+          "",
+          `You have ${allItems.length} items in your mailbox that need attention. Before diving into work, take a moment to deliberate.`,
+          "",
+          "## Your Mailbox",
+          itemsSection,
+          "",
+          "## What You Can Do",
+          "1. **Gather context**: Use recall_activity, task_get, memory_search to understand the full picture.",
+          "2. **Handle simple items inline**: For trivial acknowledgments, quick replies, or status notifications, handle them now using notify_user, task_comment, or agent_send_message. Mark them as inline_completed in your final decision.",
+          "3. **Choose your focus**: Decide which complex item deserves your full attention next.",
+          "4. **Defer or drop**: Explicitly defer items for later or drop stale/redundant ones.",
+          "",
+          "When ready, call `complete_deliberation` with your decision."
+        ].join("\n");
+        this.pendingDeliberationResult = void 0;
+        const prevMailboxItemId = this.processingMailboxItemId;
+        this.processingMailboxItemId = headItem.id;
+        try {
+          const allowedTools = new Set(DELIBERATION_ALLOWED_TOOLS);
+          await this.handleMessage(deliberationPrompt, void 0, void 0, {
+            sessionId: `deliberation_${this.id}_${Date.now()}`,
+            scenario: "deliberation",
+            maxToolIterations: DELIBERATION_MAX_TOOL_ITERATIONS,
+            allowedTools
+          });
+          const result = this.consumeDeliberationResult();
+          if (result) {
+            log17.info("Deliberation completed", {
+              agentId: this.id,
+              processItemId: result.processItemId,
+              inlineCompleted: result.inlineCompletedIds.length,
+              deferred: result.deferItemIds.length,
+              dropped: result.dropItemIds.length
+            });
+            for (const completedId of result.inlineCompletedIds) {
+              const completedItem = allItems.find((i) => i.id === completedId);
+              if (!completedItem)
+                continue;
+              const inlineActId = this.startActivity("inline_deliberation", `Handled inline: ${completedItem.payload.summary.slice(0, 80)}`, { mailboxItemId: completedId });
+              this.emitActivityLog(inlineActId, "text", `This item was handled inline during deliberation. Reasoning: ${result.reasoning}`);
+              this.endActivity(inlineActId);
+            }
+            return result;
+          }
+          log17.warn("Deliberation session ended without complete_deliberation call", { agentId: this.id });
+          return null;
+        } catch (err) {
+          log17.warn("Deliberation failed", { agentId: this.id, error: String(err) });
+          return null;
+        } finally {
+          this.processingMailboxItemId = prevMailboxItemId;
+        }
+      }
       getDynamicContext() {
         const parts = [...this.dynamicContextProviders.values()].map((p) => p()).filter(Boolean);
         for (const [name, instructions] of this.activatedSkillInstructions) {
@@ -46718,6 +47470,12 @@ ${instructions}
       getUsageStats() {
         return this.metricsCollector.getUsageStats();
       }
+      computeCallCost(inputTokens, outputTokens) {
+        const modelCost = this.llmRouter.getModelCost(this.getEffectiveProvider());
+        if (!modelCost)
+          return 0;
+        return inputTokens / 1e6 * modelCost.input + outputTokens / 1e6 * modelCost.output;
+      }
       emitAudit(event) {
         this.metricsCollector.recordAudit(event);
         this.auditCallback?.(event);
@@ -47136,12 +47894,16 @@ ${block}
             type: "llm_request",
             action: "chat",
             tokensUsed: tokensThisCall,
+            inputTokens: response.usage.inputTokens,
+            outputTokens: response.usage.outputTokens,
+            cost: this.computeCallCost(response.usage.inputTokens, response.usage.outputTokens),
             durationMs: Date.now() - llmStart,
             success: true
           });
           let toolIterations = 0;
           const effectiveMaxIter = options?.maxToolIterations ?? this._maxToolIterations;
           const commentToolUsed = /* @__PURE__ */ new Set();
+          const requirementActionToolUsed = /* @__PURE__ */ new Set();
           while (response.finishReason === "tool_use" && response.toolCalls?.length || response.finishReason === "max_tokens") {
             if (++toolIterations > effectiveMaxIter) {
               log17.warn("Tool loop hit max iterations", {
@@ -47242,6 +48004,10 @@ ${block}
                 if (tc.name === "task_comment" || tc.name === "requirement_comment") {
                   commentToolUsed.add(tc.name);
                 }
+                const REQ_ACTION_TOOLS = ["requirement_update_status", "requirement_comment", "task_create", "notify_user", "request_user_approval"];
+                if (REQ_ACTION_TOOLS.includes(tc.name)) {
+                  requirementActionToolUsed.add(tc.name);
+                }
               }
               const loopCheck = this.loopDetector.check();
               if (loopCheck.detected) {
@@ -47310,6 +48076,9 @@ ${chatYield.item.payload.content}`;
               type: "llm_request",
               action: "chat",
               tokensUsed: tokens2,
+              inputTokens: response.usage.inputTokens,
+              outputTokens: response.usage.outputTokens,
+              cost: this.computeCallCost(response.usage.inputTokens, response.usage.outputTokens),
               durationMs: Date.now() - llmStart2,
               success: true
             });
@@ -47401,6 +48170,92 @@ ${chatYield.item.payload.content}`;
               }, this.getEffectiveProvider()), "Chat LLM comment-reminder-final");
             }
           }
+          if (scenario === "requirement_action" && requirementActionToolUsed.size === 0 && toolIterations < effectiveMaxIter) {
+            this.memory.appendMessage(sessionId, {
+              role: "assistant",
+              content: response.content,
+              toolCalls: response.toolCalls,
+              reasoningContent: response.reasoningContent
+            });
+            this.memory.appendMessage(sessionId, {
+              role: "user",
+              content: "[SYSTEM] You are about to end your turn WITHOUT taking any action. In requirement_action mode your text output is NOT visible to anyone. You MUST call at least one action tool: requirement_update_status, requirement_comment, task_create, or notify_user. Call requirement_get first if you need context, then take action."
+            });
+            const reminderMessages = this.memory.getRecentMessages(sessionId, maxHistory);
+            const preparedReminder = await this.contextEngine.prepareMessages({
+              systemPrompt,
+              sessionMessages: reminderMessages,
+              memory: this.memory,
+              sessionId,
+              agentId: this.id,
+              modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
+              modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
+              toolDefinitions: llmTools,
+              systemCacheSegments
+            });
+            response = await this.withNetworkRetry(() => this.llmRouter.chat({
+              messages: preparedReminder.messages,
+              tools: llmTools.length > 0 ? llmTools : void 0,
+              metadata: this.getLLMMetadata(sessionId),
+              compaction: useCompaction,
+              systemCacheSegments
+            }, this.getEffectiveProvider()), "Chat LLM requirement-action-reminder");
+            if (response.finishReason === "tool_use" && response.toolCalls?.length) {
+              const currentActId = this.state.currentActivity?.id;
+              this.memory.appendMessage(sessionId, {
+                role: "assistant",
+                content: response.content,
+                toolCalls: response.toolCalls,
+                reasoningContent: response.reasoningContent
+              });
+              const toolResults = await Promise.all(response.toolCalls.map(async (tc) => {
+                const toolStart = Date.now();
+                if (currentActId) {
+                  this.emitActivityLog(currentActId, "tool_start", tc.name, { arguments: tc.arguments });
+                }
+                try {
+                  let result = await this.executeTool(tc, void 0, sessionId);
+                  result = this.offloadLargeResult(tc.name, result);
+                  if (currentActId) {
+                    this.emitActivityLog(currentActId, "tool_end", tc.name, {
+                      durationMs: Date.now() - toolStart,
+                      success: !isErrorResult2(result),
+                      arguments: tc.arguments,
+                      result
+                    });
+                  }
+                  return { toolCallId: tc.id, content: result, error: false };
+                } catch (toolErr) {
+                  if (currentActId) {
+                    this.emitActivityLog(currentActId, "error", `Tool ${tc.name} failed: ${String(toolErr)}`);
+                  }
+                  return { toolCallId: tc.id, content: `Error: ${String(toolErr)}`, error: true };
+                }
+              }));
+              for (const tr of toolResults) {
+                this.memory.appendMessage(sessionId, { role: "tool", content: tr.content, toolCallId: tr.toolCallId });
+              }
+              const finalMessages = this.memory.getRecentMessages(sessionId, maxHistory);
+              const preparedFinal = await this.contextEngine.prepareMessages({
+                systemPrompt,
+                sessionMessages: finalMessages,
+                memory: this.memory,
+                sessionId,
+                agentId: this.id,
+                modelContextWindow: this.llmRouter.getModelContextWindow(this.getEffectiveProvider()),
+                modelMaxOutput: this.llmRouter.getModelMaxOutput(this.getEffectiveProvider()),
+                toolDefinitions: llmTools,
+                systemCacheSegments
+              });
+              response = await this.withNetworkRetry(() => this.llmRouter.chat({
+                messages: preparedFinal.messages,
+                tools: llmTools.length > 0 ? llmTools : void 0,
+                metadata: this.getLLMMetadata(sessionId),
+                compaction: useCompaction,
+                systemCacheSegments
+              }, this.getEffectiveProvider()), "Chat LLM requirement-action-reminder-final");
+            }
+          }
           const rawReply = sanitizeLLMReply(response.content);
           const displayReply = stripCompletionMarker(rawReply);
           const outputCheck = await this.guardrails.checkOutput(displayReply, { agentId: this.id });
@@ -47569,6 +48424,9 @@ ${chatYield.item.payload.content}`;
             type: "llm_request",
             action: "chat_stream",
             tokensUsed: tokensThisCall,
+            inputTokens: response.usage.inputTokens,
+            outputTokens: response.usage.outputTokens,
+            cost: this.computeCallCost(response.usage.inputTokens, response.usage.outputTokens),
             durationMs: Date.now() - llmStart,
             success: true
           });
@@ -47747,6 +48605,9 @@ ${streamYield.item.payload.content}`;
               type: "llm_request",
               action: "chat_stream",
               tokensUsed: tokens2,
+              inputTokens: response.usage.inputTokens,
+              outputTokens: response.usage.outputTokens,
+              cost: this.computeCallCost(response.usage.inputTokens, response.usage.outputTokens),
               durationMs: Date.now() - llmStart2,
               success: true
             });
@@ -48052,7 +48913,7 @@ ${streamYield.item.payload.content}`;
           let taskLlmTokens = response.usage.inputTokens + response.usage.outputTokens;
           this.updateTokensUsed(taskLlmTokens);
           this.calibrateTokenCounter(response.usage.inputTokens);
-          this.emitAudit({ type: "llm_request", action: "task_execution", tokensUsed: taskLlmTokens, durationMs: Date.now() - taskLlmStart, success: true });
+          this.emitAudit({ type: "llm_request", action: "task_execution", tokensUsed: taskLlmTokens, inputTokens: response.usage.inputTokens, outputTokens: response.usage.outputTokens, cost: this.computeCallCost(response.usage.inputTokens, response.usage.outputTokens), durationMs: Date.now() - taskLlmStart, success: true });
           while (response.finishReason === "tool_use" && response.toolCalls?.length || response.finishReason === "max_tokens") {
             taskToolIterations++;
             if (cancelToken?.cancelled) {
@@ -48244,7 +49105,7 @@ ${yieldResult.item.payload.content}`
             taskLlmTokens = response.usage.inputTokens + response.usage.outputTokens;
             this.updateTokensUsed(taskLlmTokens);
             this.calibrateTokenCounter(response.usage.inputTokens);
-            this.emitAudit({ type: "llm_request", action: "task_execution", tokensUsed: taskLlmTokens, durationMs: Date.now() - taskLlmStart, success: true });
+            this.emitAudit({ type: "llm_request", action: "task_execution", tokensUsed: taskLlmTokens, inputTokens: response.usage.inputTokens, outputTokens: response.usage.outputTokens, cost: this.computeCallCost(response.usage.inputTokens, response.usage.outputTokens), durationMs: Date.now() - taskLlmStart, success: true });
           }
           if (cancelToken?.cancelled) {
             flushText();
@@ -48484,7 +49345,7 @@ ${yieldResult.item.payload.content}`
           let risTokens = response.usage.inputTokens + response.usage.outputTokens;
           this.updateTokensUsed(risTokens);
           this.calibrateTokenCounter(response.usage.inputTokens);
-          this.emitAudit({ type: "llm_request", action: "respond_in_session", tokensUsed: risTokens, durationMs: Date.now() - risLlmStart, success: true });
+          this.emitAudit({ type: "llm_request", action: "respond_in_session", tokensUsed: risTokens, inputTokens: response.usage.inputTokens, outputTokens: response.usage.outputTokens, cost: this.computeCallCost(response.usage.inputTokens, response.usage.outputTokens), durationMs: Date.now() - risLlmStart, success: true });
           let toolIter = 0;
           while (response.finishReason === "tool_use" && response.toolCalls?.length || response.finishReason === "max_tokens") {
             if (++toolIter > 200)
@@ -48513,6 +49374,7 @@ ${yieldResult.item.payload.content}`
                   continue;
                 }
                 emit("tool_start", tc.name, { arguments: tc.arguments });
+                this.emitActivityLog(actId, "tool_start", tc.name, { arguments: tc.arguments });
                 const toolStart = Date.now();
                 try {
                   let result = await this.executeTool(tc, void 0, sessionId);
@@ -48520,11 +49382,13 @@ ${yieldResult.item.payload.content}`
                   const isErr = isErrorResult2(result);
                   const durationMs = Date.now() - toolStart;
                   emit("tool_end", tc.name, { success: !isErr, durationMs, arguments: tc.arguments, result });
+                  this.emitActivityLog(actId, "tool_end", tc.name, { durationMs, success: !isErr, arguments: tc.arguments, result });
                   this.emitAudit({ type: "tool_call", action: tc.name, durationMs, success: !isErr });
                   this.memory.appendMessage(sessionId, { role: "tool", content: result, toolCallId: tc.id });
                 } catch (toolErr) {
                   const durationMs = Date.now() - toolStart;
                   emit("tool_end", tc.name, { success: false, durationMs, arguments: tc.arguments, error: String(toolErr) });
+                  this.emitActivityLog(actId, "tool_end", tc.name, { durationMs, success: false, arguments: tc.arguments, error: String(toolErr) });
                   this.emitAudit({ type: "tool_call", action: tc.name, durationMs, success: false });
                   this.memory.appendMessage(sessionId, { role: "tool", content: `Error: ${String(toolErr)}`, toolCallId: tc.id });
                 }
@@ -48546,11 +49410,14 @@ ${yieldResult.item.payload.content}`
             risTokens = response.usage.inputTokens + response.usage.outputTokens;
             this.updateTokensUsed(risTokens);
             this.calibrateTokenCounter(response.usage.inputTokens);
-            this.emitAudit({ type: "llm_request", action: "respond_in_session", tokensUsed: risTokens, durationMs: Date.now() - risLlmStart, success: true });
+            this.emitAudit({ type: "llm_request", action: "respond_in_session", tokensUsed: risTokens, inputTokens: response.usage.inputTokens, outputTokens: response.usage.outputTokens, cost: this.computeCallCost(response.usage.inputTokens, response.usage.outputTokens), durationMs: Date.now() - risLlmStart, success: true });
           }
           flushText();
           const rawReply = sanitizeLLMReply(response.content);
           const displayReply = stripCompletionMarker(rawReply);
+          if (displayReply.trim()) {
+            this.emitActivityLog(actId, "text", displayReply);
+          }
           this.memory.appendMessage(sessionId, { role: "assistant", content: displayReply, reasoningContent: response.reasoningContent });
           return rawReply;
         } catch (error) {
@@ -48834,9 +49701,20 @@ ${d.text}
             const explicitTaskId = toolCall.arguments.related_task_id;
             const taskId2 = explicitTaskId ?? this.getCurrentTaskId();
             const requirementId2 = this.getCurrentRequirementId();
+            const explicitTargetUser = toolCall.arguments.target_user_id;
+            const contextParts = [];
+            if (taskId2)
+              contextParts.push(`task_id=${taskId2}`);
+            if (requirementId2)
+              contextParts.push(`requirement_id=${requirementId2}`);
+            if (priority && priority !== "normal")
+              contextParts.push(`priority=${priority}`);
+            const contextSuffix = contextParts.length > 0 ? `
+
+<!-- notify_context: ${contextParts.join(", ")} -->` : "";
             const formattedMsg = `**${title}**
 
-${body}`;
+${body}${contextSuffix}`;
             if (this.currentSessionId) {
               this.memory.appendMessage(this.currentSessionId, {
                 role: "assistant",
@@ -48850,7 +49728,7 @@ ${body}`;
             this.eventBus.emit("agent:notify-user", {
               agentId: this.id,
               sessionId: this.currentSessionId,
-              targetUserId: this.currentInteractingUserId,
+              targetUserId: explicitTargetUser ?? this.currentInteractingUserId,
               title,
               body,
               priority,
@@ -48903,6 +49781,21 @@ ${body}`;
             return JSON.stringify({ status: "error", message: `Failed to get user approval: ${String(err)}` });
           }
         }
+        if (toolCall.name === "complete_deliberation") {
+          const processItemId = toolCall.arguments.process_item_id;
+          if (!processItemId) {
+            return JSON.stringify({ status: "error", message: "process_item_id is required" });
+          }
+          this.pendingDeliberationResult = {
+            processItemId,
+            deferItemIds: toolCall.arguments.defer_item_ids ?? [],
+            dropItemIds: toolCall.arguments.drop_item_ids ?? [],
+            inlineCompletedIds: toolCall.arguments.inline_completed_ids ?? [],
+            reasoning: toolCall.arguments.reasoning ?? "",
+            situationalAwareness: toolCall.arguments.situational_awareness
+          };
+          return JSON.stringify({ status: "ok", message: "Deliberation decision recorded. Proceeding to focused processing." });
+        }
         const profile = this.config.profile;
         if (profile) {
           if (profile.toolWhitelist && !profile.toolWhitelist.includes(toolCall.name)) {
@@ -49174,6 +50067,9 @@ ${todayLog.slice(0, HEARTBEAT_DAILY_LOG_CHARS)}
             "**Report format** \u2014 create a deliverable via `deliverable_create`:",
             `- **title**: "Daily Report \u2014 ${todayDate}"`,
             '- **type**: "file"',
+            "- **format**: Choose based on content complexity:",
+            '  - Use **"markdown"** (file extension `.md`) for simple, text-heavy reports with few metrics',
+            '  - Use **"html"** (file extension `.html`) when the report includes dashboards, tables with many columns, charts, color-coded status indicators, or interactive elements that help readers quickly grasp team status',
             "- **Content must be concise, clear, and accurate**:",
             "  1. **My work today**: What you personally accomplished (tasks reviewed, approved/rejected, decisions made)",
             "  2. **My team progress**: What each member of YOUR team accomplished today (use `team_status` to check). Focus on your own team only.",
@@ -49880,21 +50776,52 @@ ${sharedContent}` : roleContent;
 });
 
 // ../core/dist/tools/mcp-client.js
-import { spawn as spawn3 } from "node:child_process";
-var log18, MCPClientManager;
+import { spawn as spawn4 } from "node:child_process";
+var log18, DEFAULT_IDLE_TIMEOUT_MS, MCPClientManager;
 var init_mcp_client = __esm({
   "../core/dist/tools/mcp-client.js"() {
     "use strict";
     init_dist();
     log18 = createLogger("mcp-client");
+    DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
     MCPClientManager = class _MCPClientManager {
       servers = /* @__PURE__ */ new Map();
+      serverConfigs = /* @__PURE__ */ new Map();
       requestId = 0;
       pendingRequests = /* @__PURE__ */ new Map();
       stdoutBuffers = /* @__PURE__ */ new Map();
+      idleTimers = /* @__PURE__ */ new Map();
+      idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS;
       static scopedKey(name, scopeId) {
         return `${name}::${scopeId}`;
       }
+      setIdleTimeout(ms) {
+        this.idleTimeoutMs = ms;
+      }
+      resetIdleTimer(key2) {
+        const existing = this.idleTimers.get(key2);
+        if (existing)
+          clearTimeout(existing);
+        if (this.idleTimeoutMs <= 0)
+          return;
+        const timer = setTimeout(() => {
+          this.idleTimers.delete(key2);
+          if (this.servers.has(key2)) {
+            log18.info(`MCP server idle timeout reached, disconnecting: ${key2}`);
+            this.disconnectServer(key2).catch(() => {
+            });
+          }
+        }, this.idleTimeoutMs);
+        timer.unref();
+        this.idleTimers.set(key2, timer);
+      }
+      clearIdleTimer(key2) {
+        const timer = this.idleTimers.get(key2);
+        if (timer) {
+          clearTimeout(timer);
+          this.idleTimers.delete(key2);
+        }
+      }
       /**
        * Spawn an MCP server process, run JSON-RPC init handshake, list tools,
        * and store under the given internal key. Shared by connect and connectScoped.
@@ -49905,8 +50832,9 @@ var init_mcp_client = __esm({
           log18.info(`MCP server ${displayName} already connected, reusing (${existing.tools.length} tools)`);
           return existing.tools;
         }
+        this.serverConfigs.set(key2, { displayName, config });
         log18.info(`Connecting to MCP server: ${displayName}`, { command: config.command, key: key2 });
-        const proc = spawn3(config.command, config.args ?? [], {
+        const proc = spawn4(config.command, config.args ?? [], {
           stdio: ["pipe", "pipe", "pipe"],
           env: { ...process.env, ...config.env },
           shell: process.platform === "win32"
@@ -49931,6 +50859,7 @@ var init_mcp_client = __esm({
           }
           this.servers.delete(key2);
           this.stdoutBuffers.delete(proc);
+          this.clearIdleTimer(key2);
           for (const [id, req] of this.pendingRequests) {
             if (req.proc !== proc)
               continue;
@@ -49951,6 +50880,7 @@ var init_mcp_client = __esm({
           const toolsResult = await this.sendRequest(proc, "tools/list", {});
           const tools = toolsResult?.tools ?? [];
           this.servers.set(key2, { process: proc, tools });
+          this.resetIdleTimer(key2);
           log18.info(`MCP server ${displayName} connected with ${tools.length} tools`);
           return tools;
         } catch (err) {
@@ -49970,19 +50900,27 @@ var init_mcp_client = __esm({
         const key2 = _MCPClientManager.scopedKey(name, scopeId);
         return this.connectByKey(key2, `${name}[${scopeId}]`, config);
       }
-      callToolByKey(key2, toolName, args) {
-        const server = this.servers.get(key2);
-        if (!server)
-          throw new Error(`MCP server not found: ${key2}`);
-        return this.sendRequest(server.process, "tools/call", {
+      async callToolByKey(key2, toolName, args) {
+        let server = this.servers.get(key2);
+        if (!server) {
+          const saved = this.serverConfigs.get(key2);
+          if (saved) {
+            log18.info(`MCP server ${key2} not running, auto-reconnecting...`);
+            await this.connectByKey(key2, saved.displayName, saved.config);
+            server = this.servers.get(key2);
+          }
+          if (!server)
+            throw new Error(`MCP server not found: ${key2}`);
+        }
+        this.resetIdleTimer(key2);
+        const result = await this.sendRequest(server.process, "tools/call", {
           name: toolName,
           arguments: args
-        }).then((result) => {
-          const content = result?.content;
-          if (content?.[0]?.text)
-            return content[0].text;
-          return JSON.stringify(result);
         });
+        const content = result?.content;
+        if (content?.[0]?.text)
+          return content[0].text;
+        return JSON.stringify(result);
       }
       async callTool(serverName, toolName, args) {
         return this.callToolByKey(serverName, toolName, args);
@@ -50023,6 +50961,7 @@ var init_mcp_client = __esm({
       async disconnectServer(name) {
         const server = this.servers.get(name);
         if (server) {
+          this.clearIdleTimer(name);
           server.process.kill();
           this.servers.delete(name);
           this.stdoutBuffers.delete(server.process);
@@ -50036,6 +50975,7 @@ var init_mcp_client = __esm({
       /**
        * Disconnect all scoped server instances belonging to a given scope (e.g. agent).
        * Shared (non-scoped) servers are not affected.
+       * The server configs are retained so the server can auto-reconnect on next tool call.
        */
       async disconnectAllForScope(scopeId) {
         const suffix = `::${scopeId}`;
@@ -50045,10 +50985,28 @@ var init_mcp_client = __esm({
           }
         }
       }
+      /**
+       * Permanently disconnect and forget all scoped servers for a scope.
+       * Used when an agent is removed and will never reconnect.
+       */
+      async removeAllForScope(scopeId) {
+        const suffix = `::${scopeId}`;
+        for (const key2 of [...this.servers.keys()]) {
+          if (key2.endsWith(suffix)) {
+            await this.disconnectServer(key2);
+          }
+        }
+        for (const key2 of [...this.serverConfigs.keys()]) {
+          if (key2.endsWith(suffix)) {
+            this.serverConfigs.delete(key2);
+          }
+        }
+      }
       async disconnectAll() {
         for (const name of [...this.servers.keys()]) {
           await this.disconnectServer(name);
         }
+        this.serverConfigs.clear();
       }
       /**
        * Accumulates stdout data into a line buffer and dispatches
@@ -52664,6 +53622,10 @@ function createProjectTools(ctx) {
               type: "string",
               description: "Path to the file or directory that contains the actual content (must already exist)"
             },
+            format: {
+              type: "string",
+              description: "Content format of the deliverable file: markdown, html, text, json, csv, etc. Auto-detected from file extension if omitted."
+            },
             tags: { type: "string", description: "Comma-separated tags for discoverability" }
           },
           required: ["type", "title", "summary"]
@@ -52675,6 +53637,7 @@ function createProjectTools(ctx) {
               title: args["title"],
               summary: args["summary"],
               reference: args["reference"],
+              format: args["format"],
               tags: args["tags"]
             });
             const resp = {
@@ -53961,6 +54924,9 @@ var init_agent_manager = __esm({
       escalationHandler;
       approvalHandler;
       stateChangeHandler;
+      /** Grace timers for releasing scoped MCP processes after agent goes idle */
+      mcpReleaseTimers = /* @__PURE__ */ new Map();
+      static MCP_IDLE_GRACE_MS = 3e4;
       activityCallbacks;
       recallCallbacks;
       delegationManager;
@@ -54027,6 +54993,7 @@ var init_agent_manager = __esm({
               title: opts.title,
               summary: opts.summary,
               reference: opts.reference,
+              format: opts.format,
               tags,
               agentId: agentId2,
               projectId
@@ -54823,9 +55790,7 @@ Known issues: ${knownIssues}` : ""}`
           const ah = this.approvalHandler;
           agent.setApprovalCallback(async (req) => ah(id, req));
         }
-        if (this.stateChangeHandler) {
-          agent.setStateChangeCallback(this.stateChangeHandler);
-        }
+        agent.setStateChangeCallback(this.buildStateChangeCallback());
         if (this.activityCallbacks) {
           agent.setActivityCallbacks(this.activityCallbacks);
         }
@@ -55374,9 +56339,7 @@ Known issues: ${knownIssues}` : ""}`
           const ah = this.approvalHandler;
           agent.setApprovalCallback(async (req) => ah(id, req));
         }
-        if (this.stateChangeHandler) {
-          agent.setStateChangeCallback(this.stateChangeHandler);
-        }
+        agent.setStateChangeCallback(this.buildStateChangeCallback());
         if (this.activityCallbacks) {
           agent.setActivityCallbacks(this.activityCallbacks);
         }
@@ -55440,6 +56403,9 @@ Known issues: ${knownIssues}` : ""}`
       async stopAgent(agentId2) {
         const agent = this.getAgent(agentId2);
         await agent.stop();
+        this.cancelMcpRelease(agentId2);
+        this.browserSessionManager.cleanupAgent(agentId2);
+        await this.mcpManager.removeAllForScope(agentId2);
       }
       async removeAgent(agentId2, opts) {
         const agent = this.agents.get(agentId2);
@@ -55448,8 +56414,9 @@ Known issues: ${knownIssues}` : ""}`
             await agent.stop();
           } catch {
           }
+          this.cancelMcpRelease(agentId2);
           this.browserSessionManager.cleanupAgent(agentId2);
-          await this.mcpManager.disconnectAllForScope(agentId2);
+          await this.mcpManager.removeAllForScope(agentId2);
           this.delegationManager.unregisterAgentCard(agentId2);
           this.agents.delete(agentId2);
           this.eventBus.emit("agent:removed", { agentId: agentId2 });
@@ -55517,13 +56484,49 @@ Known issues: ${knownIssues}` : ""}`
           agent.setApprovalCallback(async (req) => handler4(id, req));
         }
       }
-      setStateChangeHandler(handler4) {
-        this.stateChangeHandler = (agentId2, state) => {
-          handler4(agentId2, state);
+      /**
+       * Build the combined state-change callback for an agent. Handles:
+       * 1. MCP scoped-process lifecycle (release on idle, cancel release on working)
+       * 2. DelegationManager status sync
+       * 3. External handler forwarding (DB persistence, WS broadcast, etc.)
+       */
+      buildStateChangeCallback() {
+        return (agentId2, state) => {
+          if (state.status === "idle" && state.activeTaskIds.length === 0) {
+            this.scheduleMcpRelease(agentId2);
+          } else if (state.status === "working") {
+            this.cancelMcpRelease(agentId2);
+          }
           this.delegationManager.updateAgentStatus(agentId2, state.status);
+          if (this.stateChangeHandler) {
+            this.stateChangeHandler(agentId2, state);
+          }
         };
+      }
+      scheduleMcpRelease(agentId2) {
+        if (this.mcpReleaseTimers.has(agentId2))
+          return;
+        const timer = setTimeout(() => {
+          this.mcpReleaseTimers.delete(agentId2);
+          this.browserSessionManager.cleanupAgent(agentId2);
+          this.mcpManager.disconnectAllForScope(agentId2).catch(() => {
+          });
+          log32.info(`Released scoped MCP processes for idle agent: ${agentId2}`);
+        }, _AgentManager.MCP_IDLE_GRACE_MS);
+        timer.unref();
+        this.mcpReleaseTimers.set(agentId2, timer);
+      }
+      cancelMcpRelease(agentId2) {
+        const timer = this.mcpReleaseTimers.get(agentId2);
+        if (timer) {
+          clearTimeout(timer);
+          this.mcpReleaseTimers.delete(agentId2);
+        }
+      }
+      setStateChangeHandler(handler4) {
+        this.stateChangeHandler = handler4;
         for (const [, agent] of this.agents) {
-          agent.setStateChangeCallback(this.stateChangeHandler);
+          agent.setStateChangeCallback(this.buildStateChangeCallback());
         }
       }
       /**
@@ -55544,6 +56547,10 @@ Known issues: ${knownIssues}` : ""}`
           "agent:resumed",
           "agent:focus-changed",
           "agent:message",
+          "agent:notify-user",
+          "agent:escalation",
+          "agent:activity-log",
+          "agent:activity_log",
           "task:completed",
           "task:failed",
           "mailbox:new-item",
@@ -55781,6 +56788,7 @@ Known issues: ${knownIssues}` : ""}`
           } catch {
           }
         }
+        await this.mcpManager.disconnectAll();
         log32.info("AgentManager shutdown complete \u2014 all metrics flushed");
       }
       // ─── Role Template Versioning & Sync ──────────────────────────────────────
@@ -56198,7 +57206,7 @@ var init_anthropic = __esm({
                 {
                   type: "tool_result",
                   tool_use_id: m.toolCallId ?? "",
-                  content: getTextContent(m.content)
+                  content: sanitizeForLLM(getTextContent(m.content))
                 }
               ]
             };
@@ -56391,7 +57399,7 @@ var init_openai = __esm({
           if (m.role === "tool") {
             return {
               role: "tool",
-              content: getTextContent(m.content),
+              content: sanitizeForLLM(getTextContent(m.content)),
               tool_call_id: m.toolCallId ?? ""
             };
           }
@@ -56795,7 +57803,7 @@ var init_google = __esm({
               parts: [{
                 functionResponse: {
                   name: msg.toolCallId ?? "unknown",
-                  response: { result: getTextContent(msg.content) }
+                  response: { result: sanitizeForLLM(getTextContent(msg.content)) }
                 }
               }]
             });
@@ -57017,7 +58025,7 @@ var init_ollama = __esm({
       convertMessages(messages) {
         return messages.map((m) => {
           if (m.role === "tool") {
-            return { role: "tool", content: getTextContent(m.content) };
+            return { role: "tool", content: sanitizeForLLM(getTextContent(m.content)) };
           }
           if (m.toolCalls?.length) {
             return {
@@ -57253,9 +58261,9 @@ var init_auth_profiles = __esm({
 
 // ../core/dist/llm/oauth-manager.js
 import { createServer } from "node:http";
-import { randomBytes as randomBytes2, createHash } from "node:crypto";
+import { randomBytes as randomBytes3, createHash } from "node:crypto";
 function generatePKCE() {
-  const verifier = randomBytes2(32).toString("base64url");
+  const verifier = randomBytes3(32).toString("base64url");
   const challenge = createHash("sha256").update(verifier).digest("base64url");
   return { verifier, challenge };
 }
@@ -57336,7 +58344,7 @@ var init_oauth_manager = __esm({
           throw new Error(`Unknown OAuth provider: ${provider}`);
         this.cancelPendingLogin(provider);
         const { verifier, challenge } = generatePKCE();
-        const state = randomBytes2(16).toString("hex");
+        const state = randomBytes3(16).toString("hex");
         const port = config.callbackPort ?? 1455;
         const redirectUri = `http://localhost:${port}/auth/callback`;
         const promise = new Promise((resolve20, reject) => {
@@ -57625,6 +58633,7 @@ var init_router = __esm({
       autoSelect = false;
       providerTiers = [];
       fallbackOrder = [];
+      _autoFallback = true;
       /** Health tracked per model: key = "providerName:modelId" */
       modelHealth = /* @__PURE__ */ new Map();
       /** Provider-level degradation for non-retryable (auth/billing) errors */
@@ -57913,6 +58922,12 @@ var init_router = __esm({
       setFallbackOrder(order) {
         this.fallbackOrder = order.filter((n2) => this.providers.has(n2));
       }
+      get autoFallback() {
+        return this._autoFallback;
+      }
+      setAutoFallback(enabled) {
+        this._autoFallback = enabled;
+      }
       static assessComplexity(request) {
         const totalChars = request.messages.reduce((s2, m) => s2 + getTextContent(m.content).length, 0);
         const toolCount = request.tools?.length ?? 0;
@@ -57964,6 +58979,8 @@ var init_router = __esm({
         return this.defaultProvider;
       }
       getFallbacks(primary) {
+        if (!this._autoFallback)
+          return [];
         const order = this.fallbackOrder.length > 0 ? this.fallbackOrder : [...this.providers.keys()];
         return order.filter((n2) => n2 !== primary && this.isAvailable(n2));
       }
@@ -58082,7 +59099,7 @@ var init_router = __esm({
         } catch (error) {
           lastError = error;
           log35.error(`LLM request failed for ${primary}:${provider.model}`, { error: String(error) });
-          if (!_LLMRouter.isNonRetryableError(error)) {
+          if (this._autoFallback && !_LLMRouter.isNonRetryableError(error)) {
             const altModel = this.findHealthyModel(primary);
             if (altModel && altModel !== provider.model) {
               log35.info(`Trying alternate model ${altModel} on ${primary}`);
@@ -58173,7 +59190,7 @@ var init_router = __esm({
             throw lastError;
           }
           log35.error(`LLM stream request failed for ${primary}:${provider.model}`, { error: String(error) });
-          if (!_LLMRouter.isNonRetryableError(error)) {
+          if (this._autoFallback && !_LLMRouter.isNonRetryableError(error)) {
             const altModel = this.findHealthyModel(primary);
             if (altModel && altModel !== provider.model) {
               log35.info(`Stream: trying alternate model ${altModel} on ${primary}`);
@@ -58304,7 +59321,7 @@ var init_router = __esm({
             };
           }
         }
-        return { defaultProvider: this.defaultProvider, providers };
+        return { defaultProvider: this.defaultProvider, autoFallback: this._autoFallback, providers };
       }
       updateProviderModelConfig(providerName, config) {
         this.customModelConfigs.set(providerName, {
@@ -58401,6 +59418,17 @@ var init_router = __esm({
         const provider = this.providers.get(name);
         return provider?.model ?? "";
       }
+      getModelCost(providerName) {
+        const name = providerName ?? this.defaultProvider;
+        const provider = this.providers.get(name);
+        if (!provider)
+          return void 0;
+        const custom = this.customModelConfigs.get(name);
+        if (custom?.cost)
+          return custom.cost;
+        const catalogEntry = BUILTIN_MODEL_CATALOG.find((m) => m.id === provider.model && m.provider === name) ?? BUILTIN_MODEL_CATALOG.find((m) => m.id === provider.model) ?? this.customModelCatalog.get(name)?.find((m) => m.id === provider.model);
+        return catalogEntry?.cost;
+      }
       getModelInputTypes(providerName) {
         const name = providerName ?? this.defaultProvider;
         const provider = this.providers.get(name);
@@ -58559,7 +59587,7 @@ var init_enhanced_role_loader = __esm({
 });
 
 // ../core/dist/external-gateway.js
-import { createHmac, randomBytes as randomBytes3, timingSafeEqual } from "node:crypto";
+import { createHmac, randomBytes as randomBytes4, timingSafeEqual } from "node:crypto";
 var log37, ExternalAgentGateway, GatewayError;
 var init_external_gateway = __esm({
   "../core/dist/external-gateway.js"() {
@@ -58738,7 +59766,7 @@ var init_external_gateway = __esm({
         return payload;
       }
       async routeMessage(token, message) {
-        const messageId = `gwmsg_${Date.now()}_${randomBytes3(4).toString("hex")}`;
+        const messageId = `gwmsg_${Date.now()}_${randomBytes4(4).toString("hex")}`;
         const key2 = this.registrationKey(token.externalAgentId, token.orgId);
         const registration = this.registrations.get(key2);
         if (registration) {
@@ -61352,39 +62380,28 @@ var init_org_service = __esm({
         return p;
       }
       /**
-       * Seed a default team ("My Team") for a fresh organization.
-       * Creates the team, adds the owner as a human member, and hires a Secretary agent
-       * as the team manager. Skips if any teams already exist for the org.
+       * Seed a Secretary agent for a fresh organization.
+       * The Secretary is hired without a team — users create teams explicitly.
+       * Skips if any agents already exist for the org.
        */
-      async seedDefaultTeam(orgId2, ownerUserId) {
-        const existing = this.listTeams(orgId2);
-        if (existing.length > 0)
+      async seedDefaultTeam(orgId2, _ownerUserId) {
+        const existingAgents = this.agentManager.listAgents();
+        if (existingAgents.length > 0)
           return;
-        log49.info("Seeding default team for org", { orgId: orgId2 });
+        log49.info("Seeding Secretary agent for org", { orgId: orgId2 });
         try {
-          const team = await this.createTeam(orgId2, "My Team", "Your primary team \u2014 you and your personal AI Secretary.");
-          const owner = this.humans.get(ownerUserId);
-          if (owner) {
-            this.addMemberToTeam(team.id, ownerUserId, "human");
-          }
           const secretary = await this.hireAgent({
             name: "Secretary",
             roleName: "secretary",
             orgId: orgId2,
-            teamId: team.id,
-            agentRole: "manager",
+            agentRole: "worker",
             skills: ["agent-building", "team-building", "skill-building"]
           });
-          await this.updateTeam(team.id, {
-            managerId: secretary.id,
-            managerType: "agent"
-          });
-          log49.info("Default team seeded", {
-            teamId: team.id,
+          log49.info("Secretary agent seeded", {
             secretaryId: secretary.id
           });
         } catch (error) {
-          log49.warn("Failed to seed default team", { error: String(error) });
+          log49.warn("Failed to seed Secretary agent", { error: String(error) });
         }
       }
       static BUILDING_SKILLS = /* @__PURE__ */ new Set(["agent-building", "team-building", "skill-building"]);
@@ -72202,6 +73219,9 @@ ${deliverablesSummary}` : ""
           ],
           allowFreeform: true
         }).then((result) => {
+          const current = this.tasks.get(task.id);
+          if (!current || current.status !== "review")
+            return;
           if (result.approved) {
             this.updateTaskStatus(task.id, "completed", task.reviewerId, false, false, "human", "Review approved");
           } else {
@@ -72470,6 +73490,7 @@ Action: ${guidance}` : ""
         };
         for (const t of tasks)
           statusCounts[t.status]++;
+        const stuckBlockedCount = tasks.filter((t) => t.status === "blocked" && this.areBlockersSatisfied(t)).length;
         const agentMap = /* @__PURE__ */ new Map();
         for (const t of tasks) {
           if (!t.assignedAgentId)
@@ -72502,6 +73523,7 @@ Action: ${guidance}` : ""
         return {
           statusCounts,
           totalTasks: tasks.length,
+          stuckBlockedCount,
           agentWorkload,
           recentActivity,
           averageCompletionTimeMs
@@ -77830,6 +78852,7 @@ ${cleanText}`,
               title: body["title"],
               summary: body["summary"],
               reference: body["reference"],
+              format: body["format"],
               tags: body["tags"],
               taskId: body["taskId"],
               agentId: body["agentId"],
@@ -77857,6 +78880,7 @@ ${cleanText}`,
               title: body["title"],
               summary: body["summary"],
               reference: body["reference"],
+              format: body["format"],
               tags: body["tags"],
               status: body["status"],
               type: body["type"]
@@ -79434,6 +80458,7 @@ EXPLANATION_END`;
               title: body["title"],
               summary: body["summary"] ?? body["content"],
               reference: body["reference"],
+              format: body["format"],
               tags: body["tags"],
               agentId: token.markusAgentId,
               projectId: body["projectId"]
@@ -81142,12 +82167,6 @@ EXPLANATION_END`;
             } catch {
             }
           }
-          const billingSummary = this.billingService?.getUsageSummary(orgId2);
-          if (billingSummary) {
-            llmTokens = Math.max(llmTokens, billingSummary.llmTokens);
-            toolCalls = Math.max(toolCalls, billingSummary.toolCalls);
-            messages = Math.max(messages, billingSummary.messages);
-          }
           this.json(res, 200, {
             usage: {
               orgId: orgId2,
@@ -81155,7 +82174,7 @@ EXPLANATION_END`;
               llmTokens,
               toolCalls,
               messages,
-              storageBytes: billingSummary?.storageBytes ?? 0
+              storageBytes: this.billingService?.getUsageSummary(orgId2)?.storageBytes ?? 0
             },
             plan
           });
@@ -81180,7 +82199,8 @@ EXPLANATION_END`;
                 requestCount: stats.requestCount,
                 toolCalls: stats.toolCalls,
                 messages: stats.requestsToday,
-                estimatedCost: stats.estimatedCost
+                estimatedCost: stats.estimatedCost,
+                costToday: stats.costToday
               };
             } catch {
               return {
@@ -81195,7 +82215,8 @@ EXPLANATION_END`;
                 requestCount: 0,
                 toolCalls: 0,
                 messages: 0,
-                estimatedCost: 0
+                estimatedCost: 0,
+                costToday: 0
               };
             }
           });
@@ -81427,23 +82448,31 @@ EXPLANATION_END`;
             return;
           }
           const body = await this.readBody(req);
-          const { defaultProvider } = body;
-          if (!defaultProvider) {
-            this.json(res, 400, { error: "defaultProvider is required" });
+          const { defaultProvider, autoFallback } = body;
+          if (!defaultProvider && autoFallback === void 0) {
+            this.json(res, 400, { error: "defaultProvider or autoFallback is required" });
             return;
           }
           try {
-            this.llmRouter.setDefaultProvider(defaultProvider);
+            const configUpdates = {};
+            if (defaultProvider) {
+              this.llmRouter.setDefaultProvider(defaultProvider);
+              configUpdates.defaultProvider = defaultProvider;
+            }
+            if (typeof autoFallback === "boolean") {
+              this.llmRouter.setAutoFallback(autoFallback);
+              configUpdates.autoFallback = autoFallback;
+            }
             try {
-              saveConfig({ llm: { defaultProvider } }, this.markusConfigPath);
+              saveConfig({ llm: configUpdates }, this.markusConfigPath);
             } catch (e) {
-              log56.warn("Failed to persist defaultProvider to config file", { error: String(e) });
+              log56.warn("Failed to persist LLM settings to config file", { error: String(e) });
             }
             this.auditService?.record({
               orgId: "system",
               type: "settings_changed",
-              action: "llm_default_provider",
-              detail: `defaultProvider=${defaultProvider}`,
+              action: "llm_settings",
+              detail: `${defaultProvider ? `defaultProvider=${defaultProvider}` : ""}${autoFallback !== void 0 ? ` autoFallback=${autoFallback}` : ""}`.trim(),
               userId: auth.userId,
               success: true
             });
@@ -81567,6 +82596,70 @@ EXPLANATION_END`;
           });
           return;
         }
+        if (path === "/api/settings/search" && req.method === "GET") {
+          const { loadConfig: loadCfg } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+          const currentConfig = loadCfg(this.markusConfigPath);
+          const search = currentConfig.integrations?.search ?? {};
+          const mask = (key2) => key2 ? "***" + key2.slice(-4) : "";
+          this.json(res, 200, {
+            serper: { configured: !!search.serperApiKey || !!process.env["SERPER_API_KEY"], preview: mask(search.serperApiKey || process.env["SERPER_API_KEY"]) },
+            brave: { configured: !!search.braveApiKey || !!process.env["BRAVE_SEARCH_API_KEY"], preview: mask(search.braveApiKey || process.env["BRAVE_SEARCH_API_KEY"]) },
+            bocha: { configured: !!search.bochaApiKey || !!process.env["BOCHA_API_KEY"], preview: mask(search.bochaApiKey || process.env["BOCHA_API_KEY"]) }
+          });
+          return;
+        }
+        if (path === "/api/settings/search" && req.method === "POST") {
+          const auth = await this.requireAuth(req, res);
+          if (!auth)
+            return;
+          const body = await this.readBody(req);
+          const updates = {};
+          if (typeof body["serperApiKey"] === "string") {
+            updates.serperApiKey = body["serperApiKey"] || void 0;
+            if (body["serperApiKey"])
+              process.env["SERPER_API_KEY"] = body["serperApiKey"];
+            else
+              delete process.env["SERPER_API_KEY"];
+          }
+          if (typeof body["braveApiKey"] === "string") {
+            updates.braveApiKey = body["braveApiKey"] || void 0;
+            if (body["braveApiKey"])
+              process.env["BRAVE_SEARCH_API_KEY"] = body["braveApiKey"];
+            else
+              delete process.env["BRAVE_SEARCH_API_KEY"];
+          }
+          if (typeof body["bochaApiKey"] === "string") {
+            updates.bochaApiKey = body["bochaApiKey"] || void 0;
+            if (body["bochaApiKey"])
+              process.env["BOCHA_API_KEY"] = body["bochaApiKey"];
+            else
+              delete process.env["BOCHA_API_KEY"];
+          }
+          try {
+            saveConfig({ integrations: { search: updates } }, this.markusConfigPath);
+          } catch (e) {
+            log56.warn("Failed to persist search settings", { error: String(e) });
+          }
+          this.auditService?.record({
+            orgId: "system",
+            type: "settings_changed",
+            action: "search",
+            detail: "Search API key settings updated",
+            userId: auth.userId,
+            success: true,
+            metadata: { keys: Object.keys(updates) }
+          });
+          const { loadConfig: loadCfg } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+          const currentConfig = loadCfg(this.markusConfigPath);
+          const search = currentConfig.integrations?.search ?? {};
+          const mask = (key2) => key2 ? "***" + key2.slice(-4) : "";
+          this.json(res, 200, {
+            serper: { configured: !!search.serperApiKey || !!process.env["SERPER_API_KEY"], preview: mask(search.serperApiKey || process.env["SERPER_API_KEY"]) },
+            brave: { configured: !!search.braveApiKey || !!process.env["BRAVE_SEARCH_API_KEY"], preview: mask(search.braveApiKey || process.env["BRAVE_SEARCH_API_KEY"]) },
+            bocha: { configured: !!search.bochaApiKey || !!process.env["BOCHA_API_KEY"], preview: mask(search.bochaApiKey || process.env["BOCHA_API_KEY"]) }
+          });
+          return;
+        }
         if (path === "/api/settings/llm/models" && req.method === "GET") {
           if (!this.llmRouter) {
             this.json(res, 200, { models: [] });
@@ -82833,6 +83926,8 @@ EXPLANATION_END`;
             const home = homedir22();
             const results = {};
             const mdExts = [".md", ".markdown"];
+            const htmlExts = [".html", ".htm"];
+            const jsonExts = [".json"];
             const imageExts = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"];
             for (const p of paths.slice(0, 50)) {
               try {
@@ -82848,6 +83943,10 @@ EXPLANATION_END`;
                 let type = "text";
                 if (mdExts.includes(ext))
                   type = "markdown";
+                else if (htmlExts.includes(ext))
+                  type = "html";
+                else if (jsonExts.includes(ext))
+                  type = "json";
                 else if (imageExts.includes(ext))
                   type = "image";
                 else if (!isFile)
@@ -82881,6 +83980,27 @@ EXPLANATION_END`;
               return;
             }
             const stat = statSync6(resolved);
+            if (stat.isDirectory()) {
+              const { readdirSync: readdirSync13 } = await import("node:fs");
+              const { join: join30, extname: extDir } = await import("node:path");
+              const entries2 = readdirSync13(resolved, { withFileTypes: true }).filter((e) => !e.name.startsWith(".")).map((e) => {
+                const full = join30(resolved, e.name);
+                const isDir = e.isDirectory();
+                let size;
+                try {
+                  if (!isDir)
+                    size = statSync6(full).size;
+                } catch {
+                }
+                return { name: e.name, path: full, isDirectory: isDir, size, ext: isDir ? "" : extDir(e.name).toLowerCase() };
+              }).sort((a, b) => {
+                if (a.isDirectory !== b.isDirectory)
+                  return a.isDirectory ? -1 : 1;
+                return a.name.localeCompare(b.name);
+              });
+              this.json(res, 200, { type: "directory", name: resolved.split("/").pop(), path: resolved, entries: entries2 });
+              return;
+            }
             if (!stat.isFile()) {
               this.json(res, 400, { error: "Path is not a file" });
               return;
@@ -82904,8 +84024,20 @@ EXPLANATION_END`;
             } else {
               const content = readFileSync26(resolved, "utf-8");
               const mdExts = [".md", ".markdown"];
+              const htmlExts = [".html", ".htm"];
+              const jsonExts = [".json"];
+              const csvExts = [".csv", ".tsv"];
+              let fileType = "text";
+              if (mdExts.includes(ext))
+                fileType = "markdown";
+              else if (htmlExts.includes(ext))
+                fileType = "html";
+              else if (jsonExts.includes(ext))
+                fileType = "json";
+              else if (csvExts.includes(ext))
+                fileType = "csv";
               this.json(res, 200, {
-                type: mdExts.includes(ext) ? "markdown" : "text",
+                type: fileType,
                 name: resolved.split("/").pop(),
                 content
               });
@@ -83845,6 +84977,7 @@ EXPLANATION_END`;
           exact("/api/settings/llm/models", "GET"),
           exact("/api/settings/agent", "GET", "POST"),
           exact("/api/settings/browser", "GET", "POST"),
+          exact("/api/settings/search", "GET", "POST"),
           exact("/api/settings/env-models", "GET", "POST"),
           exact("/api/settings/detect-ollama", "GET"),
           exact("/api/settings/export", "POST"),
@@ -84068,6 +85201,7 @@ EXPLANATION_END`;
             statusCounts: taskDashboard.statusCounts,
             successRate: taskSuccessRate,
             blockedCount: blockedTasks,
+            stuckBlockedCount: taskDashboard.stuckBlockedCount,
             averageCompletionTimeMs: taskDashboard.averageCompletionTimeMs,
             recentActivity: taskDashboard.recentActivity.slice(0, 10)
           },
@@ -84680,7 +85814,7 @@ var init_hitl_service = __esm({
 });
 
 // ../org-manager/dist/billing-service.js
-import { randomBytes as randomBytes4 } from "node:crypto";
+import { randomBytes as randomBytes5 } from "node:crypto";
 var log58, DEFAULT_PLANS, keyCounter, BillingService;
 var init_billing_service = __esm({
   "../org-manager/dist/billing-service.js"() {
@@ -84814,7 +85948,7 @@ var init_billing_service = __esm({
       }
       createAPIKey(orgId2, name, scopes = ["*"], expiresInDays) {
         const id = `mk_${(++keyCounter).toString(36)}_${Date.now().toString(36)}`;
-        const key2 = `mk_${randomBytes4(32).toString("hex")}`;
+        const key2 = `mk_${randomBytes5(32).toString("hex")}`;
         const now3 = /* @__PURE__ */ new Date();
         const apiKey = {
           id,
@@ -86166,6 +87300,8 @@ var init_deliverable_service = __esm({
               summary: opts.summary,
               tags: opts.tags ?? existing.tags
             };
+            if (opts.format !== void 0)
+              patch.format = opts.format;
             if (opts.artifactType !== void 0)
               patch.artifactType = opts.artifactType;
             if (opts.artifactData !== void 0)
@@ -86194,6 +87330,7 @@ var init_deliverable_service = __esm({
           title: opts.title,
           summary: opts.summary,
           reference: ref ?? "",
+          format: opts.format,
           tags: opts.tags ?? [],
           status: "active",
           taskId: opts.taskId,
@@ -86214,6 +87351,7 @@ var init_deliverable_service = __esm({
           title: opts.title,
           summary: opts.summary,
           reference: ref ?? "",
+          format: opts.format,
           tags: opts.tags ?? [],
           status: "active",
           taskId: opts.taskId,
@@ -86301,6 +87439,8 @@ var init_deliverable_service = __esm({
           d.summary = data.summary;
         if (data.reference !== void 0)
           d.reference = data.reference;
+        if (data.format !== void 0)
+          d.format = data.format;
         if (data.tags !== void 0)
           d.tags = data.tags;
         if (data.status !== void 0)
@@ -86480,6 +87620,7 @@ var init_deliverable_service = __esm({
           title: r.title,
           summary: r.summary,
           reference: r.reference,
+          format: r.format ?? void 0,
           tags: this.parseTags(r.tags),
           status: r.status,
           taskId: r.taskId ?? void 0,
@@ -86736,12 +87877,16 @@ var init_report_service = __esm({
       }
       buildCostSummary(scopeId, start, end) {
         const usage = this.billingService.getUsageSummaryForPeriod(scopeId, start, end);
+        const input = Math.round(usage.llmTokens * 0.7);
+        const output = usage.llmTokens - input;
+        const estimatedCost = input / 1e6 * 3 + output / 1e6 * 15;
+        const cost = Math.round(estimatedCost * 1e4) / 1e4;
         return {
           totalTokens: usage.llmTokens,
-          totalEstimatedCost: usage.llmTokens * 3e-6,
+          totalEstimatedCost: cost,
           byAgent: [],
           byCategory: [
-            { category: "llm_tokens", tokens: usage.llmTokens, cost: usage.llmTokens * 3e-6 },
+            { category: "llm_tokens", tokens: usage.llmTokens, cost },
             { category: "tool_calls", tokens: 0, cost: 0 }
           ],
           trend: "stable"
@@ -87065,17 +88210,21 @@ var init_stale_detector = __esm({
 });
 
 // ../org-manager/dist/scheduled-task-runner.js
-var log69, ScheduledTaskRunner;
+var log69, MIN_STAGGER_MS, MAX_STAGGER_MS, ScheduledTaskRunner;
 var init_scheduled_task_runner = __esm({
   "../org-manager/dist/scheduled-task-runner.js"() {
     "use strict";
     init_dist();
     log69 = createLogger("scheduled-task-runner");
+    MIN_STAGGER_MS = 2 * 6e4;
+    MAX_STAGGER_MS = 15 * 6e4;
     ScheduledTaskRunner = class {
       taskService;
       pollIntervalMs;
       timer;
+      staggerTimers = [];
       running = false;
+      startedAt = 0;
       constructor(taskService, pollIntervalMs = 6e4) {
         this.taskService = taskService;
         this.pollIntervalMs = pollIntervalMs;
@@ -87084,6 +88233,8 @@ var init_scheduled_task_runner = __esm({
         if (this.running)
           return;
         this.running = true;
+        this.startedAt = Date.now();
+        this.tick().catch((e) => log69.error("Initial scheduled task tick failed", { error: String(e) }));
         this.timer = setInterval(() => {
           this.tick().catch((e) => log69.error("Scheduled task tick failed", { error: String(e) }));
         }, this.pollIntervalMs);
@@ -87094,15 +88245,26 @@ var init_scheduled_task_runner = __esm({
           clearInterval(this.timer);
           this.timer = void 0;
         }
+        for (const t of this.staggerTimers)
+          clearTimeout(t);
+        this.staggerTimers = [];
         this.running = false;
         log69.info("ScheduledTaskRunner stopped");
       }
       isRunning() {
         return this.running;
       }
+      /**
+       * Returns true during the startup grace period (first poll cycle after
+       * start).  Used to stagger overdue tasks instead of firing them all at once.
+       */
+      isStartupPhase() {
+        return Date.now() - this.startedAt < this.pollIntervalMs;
+      }
       async tick() {
         const scheduledTasks = this.taskService.listScheduledTasks();
         const now3 = Date.now();
+        const startup = this.isStartupPhase();
         for (const task of scheduledTasks) {
           if (!task.scheduleConfig)
             continue;
@@ -87119,6 +88281,22 @@ var init_scheduled_task_runner = __esm({
           if (config.paused) {
             continue;
           }
+          if (startup && nextRun < this.startedAt) {
+            const delay = MIN_STAGGER_MS + Math.random() * (MAX_STAGGER_MS - MIN_STAGGER_MS);
+            log69.info("Staggering overdue scheduled task", {
+              taskId: task.id,
+              title: task.title,
+              overdueBy: `${Math.round((now3 - nextRun) / 6e4)}m`,
+              firingIn: `${Math.round(delay / 6e4)}m`
+            });
+            const timer = setTimeout(() => {
+              if (!this.running)
+                return;
+              this.fireScheduledTask(task).catch((e) => log69.error("Failed to fire staggered scheduled task", { taskId: task.id, error: String(e) }));
+            }, delay);
+            this.staggerTimers.push(timer);
+            continue;
+          }
           try {
             await this.fireScheduledTask(task);
           } catch (e) {
@@ -87218,7 +88396,8 @@ function openSqlite(dbPath) {
     { table: "projects", column: "created_by", sql: "ALTER TABLE projects ADD COLUMN created_by TEXT" },
     { table: "approvals", column: "target_user_id", sql: "ALTER TABLE approvals ADD COLUMN target_user_id TEXT" },
     { table: "users", column: "deleted_at", sql: "ALTER TABLE users ADD COLUMN deleted_at TEXT" },
-    { table: "agents", column: "deleted_at", sql: "ALTER TABLE agents ADD COLUMN deleted_at TEXT" }
+    { table: "agents", column: "deleted_at", sql: "ALTER TABLE agents ADD COLUMN deleted_at TEXT" },
+    { table: "deliverables", column: "format", sql: "ALTER TABLE deliverables ADD COLUMN format TEXT" }
   ];
   for (const m of migrations) {
     const cols = _db.prepare(`PRAGMA table_info(${m.table})`).all();
@@ -87523,6 +88702,7 @@ CREATE TABLE IF NOT EXISTS deliverables (
   title TEXT NOT NULL,
   summary TEXT NOT NULL DEFAULT '',
   reference TEXT NOT NULL DEFAULT '',
+  format TEXT,
   tags TEXT NOT NULL DEFAULT '[]',
   status TEXT NOT NULL DEFAULT 'active',
   task_id TEXT,
@@ -89500,11 +90680,11 @@ CREATE INDEX IF NOT EXISTS idx_st_entity ON status_transitions(entity_type, enti
       async create(data) {
         const n2 = now2();
         this.db.prepare(`
-      INSERT INTO deliverables (id, type, title, summary, reference, tags, status,
+      INSERT INTO deliverables (id, type, title, summary, reference, format, tags, status,
         task_id, agent_id, project_id, requirement_id, diff_stats, test_results,
         artifact_type, artifact_data, access_count, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
-    `).run(data.id, data.type, data.title, data.summary, data.reference ?? "", toJson(data.tags ?? []), data.status ?? "active", data.taskId ?? null, data.agentId ?? null, data.projectId ?? null, data.requirementId ?? null, data.diffStats ? toJson(data.diffStats) : null, data.testResults ? toJson(data.testResults) : null, data.artifactType ?? null, data.artifactData ? toJson(data.artifactData) : null, n2, n2);
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+    `).run(data.id, data.type, data.title, data.summary, data.reference ?? "", data.format ?? null, toJson(data.tags ?? []), data.status ?? "active", data.taskId ?? null, data.agentId ?? null, data.projectId ?? null, data.requirementId ?? null, data.diffStats ? toJson(data.diffStats) : null, data.testResults ? toJson(data.testResults) : null, data.artifactType ?? null, data.artifactData ? toJson(data.artifactData) : null, n2, n2);
         return this.findById(data.id);
       }
       async findById(id) {
@@ -89567,6 +90747,10 @@ CREATE INDEX IF NOT EXISTS idx_st_entity ON status_transitions(entity_type, enti
           sets.push("reference = ?");
           vals.push(patch.reference);
         }
+        if (patch.format !== void 0) {
+          sets.push("format = ?");
+          vals.push(patch.format);
+        }
         if (patch.type !== void 0) {
           sets.push("type = ?");
           vals.push(patch.type);
@@ -89615,6 +90799,7 @@ CREATE INDEX IF NOT EXISTS idx_st_entity ON status_transitions(entity_type, enti
           title: r["title"],
           summary: r["summary"],
           reference: r["reference"],
+          format: r["format"] ?? null,
           tags: fromJson(r["tags"]) ?? [],
           status: r["status"],
           taskId: r["task_id"],
@@ -91154,6 +92339,7 @@ var init_logger2 = __esm({
 
 // src/utils/browser.ts
 import { exec } from "node:child_process";
+import { get as httpGet } from "node:http";
 import { platform as platform2 } from "node:os";
 function openBrowser(url) {
   if (process.env["NO_BROWSER"]) return;
@@ -91164,6 +92350,27 @@ function openBrowser(url) {
     }
   });
 }
+function openBrowserAfterHealthCheck(uiUrl, healthUrl, intervalMs = 500, maxMs = 3e4) {
+  if (process.env["NO_BROWSER"]) return;
+  const deadline = Date.now() + maxMs;
+  const check2 = () => {
+    const req = httpGet(healthUrl, (res) => {
+      res.resume();
+      if (res.statusCode && res.statusCode >= 200 && res.statusCode < 400) {
+        openBrowser(uiUrl);
+      } else if (Date.now() < deadline) {
+        setTimeout(check2, intervalMs);
+      }
+    });
+    req.on("error", () => {
+      if (Date.now() < deadline) setTimeout(check2, intervalMs);
+    });
+    req.setTimeout(2e3, () => {
+      req.destroy();
+    });
+  };
+  check2();
+}
 var init_browser = __esm({
   "src/utils/browser.ts"() {
     "use strict";
@@ -92106,6 +93313,9 @@ async function createServices(config) {
       llmRouter.setProviderEnabled(name, false);
     }
   }
+  if (config.llm.autoFallback === false) {
+    llmRouter.setAutoFallback(false);
+  }
   if (config.llm.customModels) {
     for (const [providerName, models] of Object.entries(config.llm.customModels)) {
       for (const model of models) {
@@ -92280,6 +93490,9 @@ async function startServer(config, values) {
   if (config.integrations?.search?.braveApiKey && !process.env["BRAVE_SEARCH_API_KEY"]) {
     process.env["BRAVE_SEARCH_API_KEY"] = config.integrations.search.braveApiKey;
   }
+  if (config.integrations?.search?.bochaApiKey && !process.env["BOCHA_API_KEY"]) {
+    process.env["BOCHA_API_KEY"] = config.integrations.search.bochaApiKey;
+  }
   const apiPort = Number(values["port"]) || config.server.apiPort;
   const {
     orgService,
@@ -92529,20 +93742,37 @@ async function startServer(config, values) {
         const sessionUserId = targetUserId || defaultSessionUserId;
         const mainSession = storage.chatSessionRepo.getOrCreateMainSession(agentId2, sessionUserId);
         const agent = agentManager.getAgent(agentId2);
+        const contextParts = [];
+        if (taskId2) contextParts.push(`task_id=${taskId2}`);
+        if (requirementId2) contextParts.push(`requirement_id=${requirementId2}`);
+        if (priority && priority !== "normal") contextParts.push(`priority=${priority}`);
+        const contextSuffix = contextParts.length > 0 ? `
+
+<!-- notify_context: ${contextParts.join(", ")} -->` : "";
         const formattedMsg = `**${title}**
 
-${body}`;
+${body}${contextSuffix}`;
+        const msgMetadata = {
+          notifyUser: true,
+          priority: priority ?? "normal",
+          ...taskId2 ? { taskId: taskId2 } : {},
+          ...requirementId2 ? { requirementId: requirementId2 } : {}
+        };
         const msg = storage.chatSessionRepo.appendMessage(
           mainSession.id,
           agentId2,
           "assistant",
           formattedMsg,
           0,
-          {}
+          msgMetadata
         );
         storage.chatSessionRepo.updateLastMessage(mainSession.id);
         ws.broadcastProactiveMessage(agentId2, agent.config.name, mainSession.id, msg.id, formattedMsg, {
-          isMainSession: true
+          isMainSession: true,
+          notifyUser: true,
+          priority: priority ?? "normal",
+          taskId: taskId2,
+          requirementId: requirementId2
         }, sessionUserId);
         const hasTask = !!taskId2;
         hitlService.notify({
@@ -93186,13 +94416,9 @@ ${reason}`;
   const logFile = getStartupLogFile();
   const logFileName = logFile.split("/").pop() ?? logFile;
   const uiUrl = `http://localhost:${apiPort}`;
+  progress.finish(uiUrl);
   if (!process.env["NO_BROWSER"] && webUiDir) {
-    progress.finish(uiUrl);
-    setTimeout(() => {
-      openBrowser(uiUrl);
-    }, 500);
-  } else {
-    progress.finish(uiUrl);
+    openBrowserAfterHealthCheck(uiUrl, `${uiUrl}/api/health`);
   }
   checkForUpdate().then((info4) => {
     if (info4.updateAvailable) {
@@ -96301,7 +97527,7 @@ var connect_exports = {};
 __export(connect_exports, {
   registerConnectCommands: () => registerConnectCommands
 });
-import { randomBytes as randomBytes5 } from "node:crypto";
+import { randomBytes as randomBytes6 } from "node:crypto";
 function registerConnectCommands(program2) {
   const root = program2.command("connect").description("Connect / disconnect external agent platforms");
   root.command("scan").description("Scan for installed agent platforms that can be connected").action(async (_opts, cmd) => {
@@ -96360,7 +97586,7 @@ function registerConnectCommands(program2) {
       fail(`Unknown platform "${platform3}". Run \`markus connect list\` to see available connectors.`);
       return;
     }
-    const agentId2 = opts.agentId || `${platform3}-${randomBytes5(4).toString("hex")}`;
+    const agentId2 = opts.agentId || `${platform3}-${randomBytes6(4).toString("hex")}`;
     const agentName = opts.agentName || connector.defaultAgentName || `${connector.displayName} Agent`;
     const capabilities = opts.capabilities ? String(opts.capabilities).split(",").map((s2) => s2.trim()).filter(Boolean) : connector.defaultCapabilities ?? [];
     const client = createClient(g);
@@ -96534,7 +97760,7 @@ __export(install_agent_exports, {
   registerInstallAgentCommands: () => registerInstallAgentCommands
 });
 import { execSync as execSync5 } from "node:child_process";
-import { randomBytes as randomBytes6 } from "node:crypto";
+import { randomBytes as randomBytes7 } from "node:crypto";
 function registerInstallAgentCommands(program2) {
   program2.command("install <platform>").description("Install an external agent platform and connect it to Markus").option("--org-id <id>", "Organization ID", "default").option("--agent-name <name>", "Agent display name").option("--skip-install", "Skip npm install (platform already installed)").option("--skip-init", "Skip platform initialization").option("--skip-connect", "Only install, do not register with Markus").action(async (platform3, opts, cmd) => {
     const g = cmd.optsWithGlobals();
@@ -96590,7 +97816,7 @@ function registerInstallAgentCommands(program2) {
     }
     const client = createClient(g);
     const serverUrl = g.server || process.env["MARKUS_API_URL"] || "http://localhost:8056";
-    const agentId2 = `${platform3}-${randomBytes6(4).toString("hex")}`;
+    const agentId2 = `${platform3}-${randomBytes7(4).toString("hex")}`;
     const agentName = opts.agentName || connector.defaultAgentName || `${connector.displayName} Agent`;
     const capabilities = connector.defaultCapabilities ?? [];
     try {