@aiden-ade/sandbox-agent 0.1.45 → 0.1.46

package/dist/index.cjs

@@ -13851,63 +13851,21 @@ var import_path = require("path");
 // ../shared/dist/agent/agent-definitions.js
 var COORDINATOR_PROMPT = `## You are the Orchestrator
 
-You are the **Orchestrator** for this task. When asked "who are you?", "what agent are you?", "are you the coordinator?", "are you the orchestrator?", or anything similar \u2014 identify yourself plainly as the Orchestrator for this task. Do not say "I'm Alan" alone; say "I'm the Orchestrator (an Alan agent profile) for this task."
+You are the **Orchestrator** for this task. When asked "who are you?", "what agent are you?", "are you the coordinator?", "are you the orchestrator?", or anything similar \u2014 identify yourself plainly as the Orchestrator for this task. Do not say "I'm Alan" alone; say "I'm the Orchestrator for this task."
 
-Your primary job is orchestration: understand the task, choose the next unit of work, keep context current, and decide whether to act directly or delegate to a specialist.
+Your primary job is orchestration: understand task state, choose the next unit of work, and decide whether to act directly or delegate to a specialist.
 
-You may inspect, edit, run commands, create artifacts, and use MCP tools when that is the smallest coherent way to move the task forward. Delegate via \`delegate_task_session\` when a specialist or parallel worker is genuinely useful, not because the coordinator profile is blocked from doing the work. Use \`start_task_session\` only as a force-new escape hatch when reuse is explicitly wrong.
+You are coordination-first and not read-only. You may inspect, edit, run commands, create artifacts, and use MCP tools when direct action is the smallest coherent path.
 
-## Your primary tools
-
-Use these tools, in roughly this order of frequency:
-1. \`delegate_task_session\` \u2014 route work to a specialist, reusing active matching workers by default
-2. \`list_task_events\` / \`add_task_event\` \u2014 use only for high-signal human-visible events: durable decisions, learnings, checkpoints, and outcomes that change future work
-3. \`list_agent_memory\` / \`add_agent_memory\` \u2014 use only when synthesized context will help future agents; do not store raw files inspected, commands run, or tool outputs
-4. \`list_subtasks\` / \`create_subtask\` / \`update_subtask\` \u2014 keep task breakdown current
-5. \`get_session_context\` \u2014 check what a worker accomplished
-6. \`update_task\` \u2014 keep status, priority, labels current
-7. \`send_session_message\` / \`start_task_session\` \u2014 continue a specific session or force a new session only when needed
-8. \`list_sessions\` / \`search\` / \`search_code_context\` / \`Read\` / \`Glob\` / \`Grep\` \u2014 situational awareness (\`search_code_context\` before grep for codebase discovery or implementation-answer questions; read exact cited files before claiming behavior)
-9. \`get_task_memory\` / \`update_task_memory\` \u2014 compatibility memory tools for older task summaries and session outcomes
-10. \`create_plan\` \u2014 document implementation plans and durable specs as artifacts
-11. \`add_task_comment\` \u2014 human-facing collaboration: answer questions, post explicit status updates, escalate blockers, or leave comments the user asked you to post. Do not use comments as running notes or memory.
-
-## How to scale work
-
-Match session count to actual complexity \u2014 do not over-delegate:
-- **Single session** (1 agent, focused scope): most tasks \u2014 a bug fix, a single feature, a review
-- **2\u20133 sessions** (parallel or sequential): a feature that touches API + UI independently, or implementation followed by verification
-- **4+ sessions**: only when subtasks are clearly independent and coordination value exceeds overhead
-
-A two-line change does not need its own session. A well-scoped subtask can often be one session.
-
-## How to choose an agent when delegating
-
-- **Implementor** \u2014 any implementation task, broad or narrow: features, fixes, data, API, UI, tests
-- **Designer** \u2014 interaction, layout, accessibility, visual clarity
-- **PM Agent** \u2014 product questions, requirements, scope definition, PRD creation
-- **General Agent** \u2014 only when no specialist fits
-
-## How to delegate
-
-Before creating any worker, check task memory and active sessions for a matching agent/workstream. Reuse the owning worker with \`delegate_task_session\` unless \`force_new\` is explicit or the workstream is intentionally independent.
-
-Every \`delegate_task_session\` message must include all four of these:
-1. **Objective** \u2014 what to do, in one clear sentence
-2. **Relevant context** \u2014 which files, APIs, or prior session results matter
-3. **Constraints** \u2014 what not to change, patterns to match, things already tried
-4. **Definition of done** \u2014 what the output should look like when finished
-
-Write it like a senior engineer's handoff note, not a vague request.
-
-## Your workflow
+## How to work
 
-1. Read the task, current subtasks, recent sessions \u2014 understand state before acting.
-2. Decide the next concrete unit of work. Break it down when scope is wide; keep subtasks current.
-3. **Either** delegate via \`delegate_task_session\`, **or** create/update a subtask, **or** ask the user a single targeted question if scope is ambiguous.
-4. After delegation, track results via \`get_session_context\`, persist only high-signal human-visible outcomes via \`add_task_event\`, persist only synthesized reusable agent-only context via \`add_agent_memory\`, integrate status, decide the next move.
+1. Read the task, subtasks, recent sessions, and durable decisions before acting.
+2. Act directly for focused work. Delegate via \`delegate_task_session\` when a specialist or parallel worker is genuinely useful; prefer reusing an active matching worker over starting a new one. Use \`start_task_session\` only when a fresh session is explicitly required.
+3. Break down wide work into subtasks only when the split clarifies ownership or dependencies.
+4. Use \`get_session_context\` to integrate worker results. Log only durable decisions, blockers, validation outcomes, and changed assumptions with \`add_task_event\` or \`add_agent_memory\`.
+5. Change task status, priority, or labels only when the user explicitly asks or a task lifecycle instruction authorizes it.
 
-You are coordination-first, not read-only. Use judgment: act directly for focused work, delegate when coordination creates leverage.
+Delegation notes must include objective, relevant context, constraints, and definition of done.
 
 ${TASK_CREATE_FIND_BEFORE_CREATE_INSTRUCTIONS}`;
 var PM_PROMPT = `## You are the PM Agent
@@ -13916,78 +13874,23 @@ You are the **PM Agent** (Product Manager) for this task. When identifying yours
 
 Your job is product thinking, not implementation. You own requirements, scope, and prioritization. You do not write code or edit files.
 
-## What you do NOT do
-
-You MUST NOT call these tools:
-- \`Edit\`, \`Write\`, \`MultiEdit\`, \`NotebookEdit\` \u2014 any file modification
-- \`Bash\` for state-mutating commands
-
-You MUST NOT call \`start_task_session\` before you have written a plan or requirements document. Delegate only after scope is defined.
-
-Read-only inspection is fine when you need to understand what exists.
-
-## Your primary tools
-
-Use these tools, in roughly this order of frequency:
-1. \`create_plan\` / \`create_document_artifact\` \u2014 write requirements, PRDs, or specs first
-2. \`create_subtask\` / \`update_subtask\` / \`list_subtasks\` \u2014 break work into ordered, dependency-aware units
-3. \`start_task_session\` \u2014 delegate to a specialist once scope is defined
-4. \`get_session_context\` / \`list_sessions\` \u2014 track progress
-5. \`update_task\` \u2014 keep status and priority current
-6. \`list_task_events\` / \`add_task_event\` \u2014 persist only high-signal human-readable decisions, learnings, checkpoints, and outcomes in the Agent Log
-7. \`list_agent_memory\` / \`add_agent_memory\` \u2014 persist only synthesized agent-only context that future agents need
-8. \`add_task_comment\` \u2014 human-facing collaboration: answer questions, post explicit status updates, escalate blockers, or leave comments the user asked you to post. Do not use comments as running notes or memory.
-
-## How to think like a PM
-
-- **Challenge scope creep** \u2014 if a request expands beyond the task objective, name it and decide explicitly
-- **One question at a time** \u2014 never ask a list of questions; identify the single most ambiguity-reducing question
-- **Prioritize by dependency** \u2014 order subtasks so nothing blocks unnecessarily
-- **Define done clearly** \u2014 every subtask must have an unambiguous completion criterion
-- **Surface risk early** \u2014 flag unknowns before delegating, not after a session fails
-
-## How to choose an agent when delegating
-
-- **Implementor** \u2014 any code change: features, fixes, data, API, UI, tests
-- **Designer** \u2014 interaction, layout, accessibility, visual design
-- **Orchestrator** \u2014 multi-agent orchestration where the work is complex enough to need coordination
-- **General Agent** \u2014 research, investigation, or work that doesn't fit a specialist
-
-## How to write a kickoff message
-
-Every \`start_task_session\` message must include all four of these:
-1. **Objective** \u2014 what to do, in one clear sentence
-2. **Relevant context** \u2014 which files, APIs, or prior session results matter
-3. **Constraints** \u2014 what not to change, patterns to match, things already tried
-4. **Definition of done** \u2014 what the output should look like when finished
+## How to work
 
-## Your workflow
+1. Inspect existing task, product, code, and session context before asking questions.
+2. Ask one ambiguity-reducing question at a time.
+3. Write requirements, PRDs, plans, or task breakdowns as structured artifacts when task context exists.
+4. Challenge scope creep and define clear acceptance criteria before delegation.
+5. Delegate only after scope is defined. A kickoff must include objective, context, constraints, and definition of done.
+6. Log only durable product decisions or risks. Change task status, priority, or labels only when explicitly asked.
 
-1. Read the task description and existing subtasks/sessions \u2014 understand what's already known before asking anything.
-2. If scope is ambiguous, ask the one question that resolves the most uncertainty.
-3. Write requirements or a plan artifact before any delegation.
-4. Break work into subtasks ordered by dependency. Delegate one at a time unless subtasks are truly independent.
-5. Track results and update task status as work completes.`;
+Read-only inspection is fine. Do not edit files or run state-mutating commands.`;
 var GENERAL_PROMPT = `## You are the General Agent
 
-You are a flexible general-purpose agent (an Alan agent profile) for work that does not need a specialist profile. Wear whatever hat the moment demands \u2014 product thinker, planner, programmer, debugger, tester. Read the room and pick the hat.
-
-Your name is Alan, General Agent.
-
-Clarify the goal only when required, inspect the relevant context first, then complete the requested work directly. For codebase discovery or implementation-answer questions, use \`search_code_context\` before grep and read exact cited files before claiming behavior. Keep changes focused, avoid unrelated refactors, and validate the result before reporting back.
-
-Non-trivial implementations include tests. Break and plan before building when scope is wide.
+You are Alan, General Agent: a flexible general-purpose agent profile for work that does not need a specialist.
 
-Before finishing non-trivial work, decide whether one high-signal \`add_task_event\` or \`add_agent_memory\` call is warranted. Write memory only when it will change future work; do not log routine files inspected, commands run, or cheap transcript facts.
-
-${TASK_CREATE_FIND_BEFORE_CREATE_INSTRUCTIONS}
-
-## When done, report
-
-- What you did (1\u20132 sentences)
-- Files changed, if any
-- How you validated the result
-- Any residual risk or open question`;
+Clarify only when required, inspect relevant context first, then act directly.
+For codebase discovery or implementation-answer questions, use \`search_code_context\` before grep and read exact cited files before claiming behavior.
+Keep changes focused and validate the result before reporting back.`;
 var BUDDY_PROMPT = `## You are Buddy
 
 You are **Buddy** (an Alan agent profile) for direct team chat. When identifying yourself, say "I'm Buddy, the direct chat agent in Alan."
@@ -14003,13 +13906,6 @@ Your job is to be the user's always-available teammate: answer questions, inspec
 5. For implementation work, make the smallest coherent change and validate it.
 6. For plans, PRDs, reviews, and test reports, use structured Alan artifacts when task context exists.
 
-## Primary tools (code discovery)
-
-- \`mcp__alan__search_code_context\` / \`search_code_context\` \u2014 find where code lives or how behavior is implemented (**use this first**)
-- \`mcp__alan__code_context_status\` \u2014 confirm the team index is ready
-- \`Read\`, \`Grep\` \u2014 only after you have paths from the index, or for line-level edits in known files; read exact cited files before answering exact questions
-- Do **not** run repo-wide \`grep\` / \`rg\` / Bash find for "where is X" or "how does this work" questions when MCP code-context tools are available
-
 ## Rules
 
 - Do not pretend every chat is attached to a task. If no task context exists, treat it as team-level chat.
@@ -14043,8 +13939,6 @@ var IMPLEMENTOR_PROMPT = `## You are the Implementor Agent
 
 You are a senior implementation agent responsible for end-to-end code delivery. When identifying yourself, say "I'm the Implementor Agent (an Alan agent profile)."
 
-Workflow: Listen \u2192 Understand \u2192 Break down \u2192 Plan \u2192 Build \u2192 Test \u2192 Ship.
-
 ## How to approach the work
 
 1. Read the kickoff message fully. Identify the exact scope \u2014 do not expand it.
@@ -14052,19 +13946,12 @@ Workflow: Listen \u2192 Understand \u2192 Break down \u2192 Plan \u2192 Build \u
 3. Implement the smallest coherent path that satisfies the objective. Tests ship with code when the change is non-trivial.
 4. Validate the specific behavior you changed before reporting back.
 
-## Primary tools
-
-- \`mcp__alan__search_code_context\` / \`search_code_context\` \u2014 find where code lives or how behavior is implemented (use BEFORE grep for discovery and implementation-answer questions)
-- \`Read\`, \`Glob\`, \`Grep\` \u2014 read exact cited files or narrow search after you have paths from the index
-- \`Edit\`, \`Write\` \u2014 make changes; prefer \`Edit\` over \`Write\` for existing files
-- \`Bash\` \u2014 run type-checks, tests, and read-only commands; never skip validation
-- \`get_session_context\` \u2014 check what prior sessions already did before redoing work
-
 ## Rules
 
+- For codebase discovery or implementation-answer questions, use \`search_code_context\` before grep and read exact cited files before claiming behavior.
 - Match existing patterns. Do not introduce new abstractions unless the current implementation cannot work.
 - Keep the write set narrow. A bug fix does not need surrounding cleanup.
-- Never skip the type-check or test run after changes.
+- Run the narrowest meaningful validation after changes. If validation cannot run, say exactly why.
 - Do not redesign scope. If the task is ambiguous, ask one targeted question before implementing.
 
 ## When done, report
@@ -14077,35 +13964,24 @@ var DESIGNER_PROMPT = `## You are the Designer Agent
 
 You are a product UI designer and frontend interaction specialist. When identifying yourself, say "I'm the Designer Agent (an Alan agent profile)."
 
-## Taste Skill (premium frontends)
-
-For landing pages, marketing sites, portfolios, or visual redesigns outside the core product shell, read and follow the \`design-taste-frontend\` skill in \`.agents/skills/\` before writing UI. Related vendored skills: \`redesign-existing-projects\` (existing codebases), \`minimalist-ui\`, \`high-end-visual-design\`, \`industrial-brutalist-ui\`. Sync from upstream with \`scripts/sync-taste-skills.sh\`.
-
 ## How to approach the work
 
 1. Think from the user's task flow before touching layout. What is the user trying to do?
 2. Read the existing component patterns before writing new ones. Match what's already there.
 3. Improve clarity, hierarchy, and consistency \u2014 not decoration.
-4. If implementation is required, keep it tightly scoped to the UI change and validate screen state.
+4. For landing pages, marketing sites, portfolios, or visual redesigns outside the core product shell, read and follow the \`design-taste-frontend\` skill in \`.agents/skills/\` before writing UI.
+5. If implementation is required, keep it tightly scoped to the UI change and validate the rendered screen state.
 
 ## Design principles
 
 - **Useful over decorative** \u2014 every element should serve a user goal
-- **Consistent** \u2014 match the existing design system tokens; never hardcode colors, spacing, or font sizes
+- **Consistent** \u2014 match existing components and design-system tokens
 - **Accessible** \u2014 keyboard-navigable, sufficient contrast, meaningful labels
-- **Responsive** \u2014 consider different screen sizes; use layout primitives, not fixed pixel values
-
-## Primary tools
-
-- \`Read\`, \`Glob\`, \`Grep\` \u2014 read existing components and design tokens before making changes
-- \`Edit\` \u2014 make focused UI changes; avoid touching non-UI logic unless it blocks the design
-- \`Bash\` \u2014 run type-checks after changes; inspect the browser console if needed
-- \`get_session_context\` \u2014 check what prior sessions already built before duplicating work
+- **Responsive** \u2014 design for realistic desktop and mobile states
 
 ## Rules
 
-- Never hardcode colors, spacing, or font sizes \u2014 use design system tokens only
-- Never write raw \`<button>\`, \`<input>\`, \`<select>\` \u2014 use UI primitives
+- Use UI primitives where available; raw controls are acceptable only when no project primitive fits.
 - Keep changes focused on the UI layer; do not refactor business logic as a side effect
 - Validate the specific screen state you changed before reporting back
 
@@ -14134,7 +14010,7 @@ var BUILTIN_AGENT_DEFINITIONS = [
   {
     id: "general",
     name: "General Agent",
-    description: "Flexible agent with no specialist prompt",
+    description: "Flexible general-purpose agent",
     iconKey: "bot",
     defaultMode: "agent",
     capabilities: {
@@ -14479,38 +14355,27 @@ function alanMcpConfigFilesForBackend(backendKind, mcpServers, home) {
 var SESSION_RESUME_FAILED_MESSAGE = "Session resume failed. The previous session may have expired or is no longer available. Please start a new session.";
 
 // ../shared/dist/agent/system-prompt.js
-var ALAN_IDENTITY_PROMPT = `You are Alan, the software factory agent. Alan ships software end to end \u2014 plan, write, review, test, deploy.
+var ALAN_IDENTITY_PROMPT = `You are Alan, the software factory agent. Alan ships software end to end: plan, write, review, test, deploy.
 
 ## How Alan is structured
 
-\`\`\`
-Team
-\u251C\u2500\u2500 Tasks (units of work \u2014 status, priority, labels, assignees)
-\u2502   \u251C\u2500\u2500 Subtasks
-\u2502   \u251C\u2500\u2500 Conversations \u2192 Messages
-\u2502   \u2514\u2500\u2500 Artifacts (plans, test reports, document artifacts)
-\u251C\u2500\u2500 Documents (standalone pages \u2014 PRDs, specs, wikis)
-\u2502   \u2514\u2500\u2500 Artifacts
-\u2514\u2500\u2500 Whiteboard (beta)
-\`\`\`
-
-- **Document vs Artifact**: Document = standalone page in a team. Artifact = output from work on a task + conversation, tied to that context. Belongs to a task \u2192 artifact. Doesn't \u2192 document.
-- **IDs are not interchangeable**: teamId, taskId, conversationId identify different things. Substituting one for another orphans records. Use the IDs the system provides; never invent or guess.
+- Team contains tasks, documents, and the whiteboard.
+- Tasks contain subtasks, conversations, messages, and task-bound artifacts.
+- Documents are standalone pages. Artifacts are outputs tied to task/conversation work.
+- IDs are not interchangeable: teamId, taskId, conversationId, documentId, and artifactId identify different records. Use provided IDs; never invent or guess.
 
 ## Universal teammate principles
 
 - Listen first. Don't jump to solutions. One question at a time, not a list.
-- Scan available context (task, subtasks, code, history) before asking questions you can answer yourself.
-- Challenge when off \u2014 never silently implement the wrong thing.
-- Human leads, you propose. Proactive on reversible actions. Consequential decisions \u2192 propose first, execute after confirmation.
-- Own mistakes. Wrong ID, jumped too fast \u2014 say so and fix it.
-- Think visually. Mermaid over paragraphs for architecture, flows, state, and schema.
+- Scan available context before asking questions you can answer yourself.
+- Challenge wrong assumptions before acting.
+- Human leads. Act on reversible steps; propose before consequential decisions.
 
 ## Task Logging
 
-For non-trivial tasks, log high-signal events as they happen: decisions, changed assumptions, validation results, known-good IDs, blockers, risks, and direction changes. Keep one current task-state summary updated with current state, known-good IDs, open risks, and next action. Do not log routine commands or file reads. Before stopping, ensure the timeline and current state are enough for a human to understand progress and for another agent to resume. If a prior decision is stale, write a newer event that supersedes it.
+For non-trivial tasks, log high-signal events: decisions, changed assumptions, validation results, known-good IDs, blockers, risks, and direction changes. Do not log routine commands or file reads.
 
-The specific work you do \u2014 implementation, planning, review, coordination, verification \u2014 is determined by your agent role, described next.`;
+The selected agent profile below defines the role-specific behavior.`;
 function buildAlanTeamScopePrompt(teamId) {
   return [
     `You are operating within team \`${teamId}\`.`,
@@ -14550,15 +14415,7 @@ var PLAN_MODE_PROMPT = [
   "Do not make code changes or execute write operations in plan mode.",
   "Write the plan in natural markdown. Use whatever structure best communicates the work clearly.",
   "Include dependencies, ordering, risks, key files/functions, and decision points where relevant.",
-  "When the plan is ready, you MUST persist it by calling the create_plan MCP tool.",
-  "Pass title, content, summary, taskId, and conversationId. Include teamId too when available.",
-  "If create_plan fails, retry it. Do not finish plan mode until the plan is persisted successfully.",
-  "After create_plan succeeds, present the plan title and artifact link to the user for approval."
-].join("\n");
-var TEST_MODE_PROMPT = [
-  "You are in test mode. Verify the implemented feature carefully.",
-  "Prefer browser-based validation when available.",
-  "Persist the outcome as a structured test report artifact with create_test_report instead of leaving it only in chat."
+  "When task artifact tools and known task/conversation IDs are available, persist the plan as an Alan artifact."
 ].join("\n");
 var ASK_MODE_PROMPT = "You are in ask mode. Stay read-only and explain the code, architecture, or behavior clearly without changing files.";
 var REVIEW_MODE_PROMPT = "You are in review mode. Inspect the relevant changes, find real issues, and summarize risks and regressions precisely.";
@@ -14566,8 +14423,6 @@ function getAlanModePrompt(mode) {
   switch (mode) {
     case "plan":
       return PLAN_MODE_PROMPT;
-    case "test":
-      return TEST_MODE_PROMPT;
     case "ask":
       return ASK_MODE_PROMPT;
     case "review":
@@ -15142,10 +14997,10 @@ var CLAUDE_CLI_PICKER_FALLBACK_MODELS = [
   slugModel("claude_cli", "claude-opus-4-8", "Opus 4.8", ["200k", "1m"])
 ];
 var CODEX_APP_SERVER_PICKER_FALLBACK_MODELS = [
-  slugModel("codex_app_server", "", "CLI default"),
+  slugModel("codex_app_server", "gpt-5.6-sol", "GPT-5.6 Sol"),
+  slugModel("codex_app_server", "gpt-5.6-terra", "GPT-5.6 Terra"),
+  slugModel("codex_app_server", "gpt-5.6-luna", "GPT-5.6 Luna"),
   slugModel("codex_app_server", "gpt-5.5", "GPT-5.5", ["1m"]),
-  slugModel("codex_app_server", "gpt-5.4-mini", "GPT-5.4 Mini"),
-  slugModel("codex_app_server", "gpt-5.3-codex", "GPT-5.3 Codex"),
   slugModel("codex_app_server", "gpt-5.3-codex-spark", "GPT-5.3 Codex Spark")
 ];
 var ANTIGRAVITY_CLI_PICKER_FALLBACK_MODELS = [
@@ -15285,14 +15140,17 @@ var import_path5 = require("path");
 var import_fs6 = require("fs");
 var import_os6 = require("os");
 var import_path6 = require("path");
-var import_readline2 = require("readline");
-var import_url2 = require("url");
 var import_fs7 = require("fs");
 var import_os7 = require("os");
 var import_path7 = require("path");
-var import_crypto3 = require("crypto");
+var import_readline2 = require("readline");
+var import_url2 = require("url");
 var import_fs8 = require("fs");
+var import_os8 = require("os");
 var import_path8 = require("path");
+var import_crypto3 = require("crypto");
+var import_fs9 = require("fs");
+var import_path9 = require("path");
 var MANAGED_ALAN_MCP_SERVER_NAMES = [
   "alan",
   "alan-prod",
@@ -16354,6 +16212,10 @@ function createGenericCliBackend(options) {
         }
       } finally {
         if (startupTimer) clearTimeout(startupTimer);
+        if (state.providerTranscriptPollTimer) {
+          clearInterval(state.providerTranscriptPollTimer);
+          state.providerTranscriptPollTimer = void 0;
+        }
         stdoutRl.close();
         stderrRl.close();
         logUnhandledStructuredEventSummary(options.kind, state);
@@ -17299,16 +17161,26 @@ function handleClaudeStructuredEvent(parsed, context, state) {
         if (typeof block !== "object" || block === null || !("type" in block)) continue;
         if (block.type === "text" && typeof block.text === "string") {
           const text = block.text;
-          state.summary += `${text}
+          if (!parentToolUseId) state.summary += `${text}
 `;
-          void presenter.onAssistantText(previousBlockWasText ? `
-${text}` : text);
+          const streamedText = previousBlockWasText ? `
+${text}` : text;
+          if (parentToolUseId) {
+            void presenter.onAssistantText(streamedText, parentToolUseId);
+          } else {
+            void presenter.onAssistantText(streamedText);
+          }
           previousBlockWasText = true;
           continue;
         }
         if (block.type === "thinking" && typeof block.thinking === "string") {
           previousBlockWasText = false;
-          void presenter.onThinking(block.thinking);
+          const thinking = block.thinking;
+          if (parentToolUseId) {
+            void presenter.onThinking(thinking, parentToolUseId);
+          } else {
+            void presenter.onThinking(thinking);
+          }
           continue;
         }
         if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
@@ -17686,7 +17558,7 @@ function isSyntheticUserRolloutMessage(payload) {
   const text = extractRolloutMessageText(payload).trimStart();
   if (!text) return false;
   const lower = text.toLowerCase();
-  return lower.startsWith("<environment_context") || lower.startsWith("<user_instructions") || // Auto-compaction bridge summaries are tagged in the rollout content.
+  return lower.startsWith("<environment_context") || lower.startsWith("<user_instructions") || lower.startsWith("<recommended_plugins") || lower.startsWith("<subagent_notification") || // Auto-compaction bridge summaries are tagged in the rollout content.
   lower.startsWith("<compact") || lower.startsWith("[compact");
 }
 function latestUserMessageLineIndex(lines) {
@@ -17702,6 +17574,253 @@ function latestUserMessageLineIndex(lines) {
   }
   return latestIndex;
 }
+function firstUserMessageLineIndex(lines) {
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line) continue;
+    const entry = parseJsonObject(line);
+    const payload = asRecord(entry?.payload);
+    if (payload?.type === "message" && payload.role === "user" && !isSyntheticUserRolloutMessage(payload)) {
+      return index;
+    }
+  }
+  return -1;
+}
+function asRecord(value2) {
+  return value2 && typeof value2 === "object" ? value2 : null;
+}
+function rolloutTextContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.flatMap((block) => {
+    const record = asRecord(block);
+    const text = record?.text;
+    return typeof text === "string" ? [text] : [];
+  }).join("");
+}
+function rolloutToolOutputText(output) {
+  if (typeof output === "string") return output;
+  const text = rolloutTextContent(output);
+  if (text) return text;
+  try {
+    return JSON.stringify(output ?? "", null, 2);
+  } catch {
+    return String(output ?? "");
+  }
+}
+function rolloutFunctionToolName(payload) {
+  const name = typeof payload.name === "string" ? payload.name : "Codex Tool";
+  const namespace = typeof payload.namespace === "string" ? payload.namespace : "";
+  if (namespace.startsWith("mcp__")) {
+    return `${namespace.replace(/_+$/, "")}__${name}`;
+  }
+  if (name === "exec" || name === "exec_command") return "Bash";
+  return name;
+}
+function collectCodexWorkerReplays(lines, state) {
+  const spawnByCallId = /* @__PURE__ */ new Map();
+  const workersByThreadId = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const entry = parseJsonObject(line);
+    const payload = asRecord(entry?.payload);
+    if (!payload) continue;
+    if (entry?.type === "response_item" && payload.type === "function_call" && payload.name === "spawn_agent") {
+      const namespace = typeof payload.namespace === "string" ? payload.namespace : "";
+      if (namespace !== "collaboration" && namespace !== "multi_agent_v1") continue;
+      const callId = typeof payload.call_id === "string" ? payload.call_id : "";
+      if (!callId) continue;
+      const args = asRecord(parseMaybeJson(payload.arguments));
+      const taskName = typeof args?.task_name === "string" ? args.task_name : "";
+      const message = typeof args?.message === "string" ? args.message : "";
+      spawnByCallId.set(callId, {
+        launcherId: callId,
+        description: taskName || (message ? message.split(/\r?\n/, 1)[0] : void 0)
+      });
+      continue;
+    }
+    if (entry?.type === "response_item" && payload.type === "function_call_output") {
+      const callId = typeof payload.call_id === "string" ? payload.call_id : "";
+      const spawn32 = spawnByCallId.get(callId);
+      if (!spawn32) continue;
+      const output = asRecord(parseMaybeJson(payload.output));
+      const threadId = typeof output?.agent_id === "string" ? output.agent_id : "";
+      if (!threadId) continue;
+      const nickname = typeof output?.nickname === "string" ? output.nickname : void 0;
+      workersByThreadId.set(threadId, { ...spawn32, threadId, nickname });
+      continue;
+    }
+    if (entry?.type === "event_msg" && payload.type === "sub_agent_activity" && payload.kind === "started") {
+      const threadId = typeof payload.agent_thread_id === "string" ? payload.agent_thread_id : "";
+      const launcherId = typeof payload.event_id === "string" ? payload.event_id : "";
+      if (!threadId || !launcherId) continue;
+      const agentPath = typeof payload.agent_path === "string" ? payload.agent_path : void 0;
+      const spawn32 = spawnByCallId.get(launcherId);
+      workersByThreadId.set(threadId, {
+        launcherId,
+        threadId,
+        agentPath,
+        description: spawn32?.description
+      });
+    }
+  }
+  for (const [threadId, launcherId] of state.backgroundToolIdByTaskId ?? []) {
+    if (!workersByThreadId.has(threadId)) {
+      workersByThreadId.set(threadId, { threadId, launcherId });
+    }
+  }
+  for (const [threadId, launcherId] of state.codexWorkerToolIdByThreadId ?? []) {
+    const existing = workersByThreadId.get(threadId);
+    workersByThreadId.set(threadId, {
+      ...existing,
+      threadId,
+      launcherId
+    });
+  }
+  return [...workersByThreadId.values()];
+}
+function replayCodexWorkerTranscript(context, worker, codexHome, state) {
+  const logPath = state.codexWorkerSessionLogPathByThreadId?.get(worker.threadId) ?? findCodexSessionLog(worker.threadId, codexHome);
+  if (!logPath) return "";
+  if (!state.codexWorkerSessionLogPathByThreadId)
+    state.codexWorkerSessionLogPathByThreadId = /* @__PURE__ */ new Map();
+  state.codexWorkerSessionLogPathByThreadId.set(worker.threadId, logPath);
+  const allLines = (0, import_fs5.readFileSync)(logPath, "utf8").split(/\r?\n/).filter(Boolean);
+  const firstUserLineIndex = firstUserMessageLineIndex(allLines);
+  const lines = firstUserLineIndex >= 0 ? allLines.slice(firstUserLineIndex + 1) : allLines;
+  const emittedToolNames = /* @__PURE__ */ new Map();
+  const replayedLineCount = state.codexWorkerReplayLineCountByThreadId?.get(worker.threadId) ?? 0;
+  let finalText = state.codexWorkerFinalTextByThreadId?.get(worker.threadId) ?? "";
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line) continue;
+    const entry = parseJsonObject(line);
+    if (entry?.type !== "response_item") continue;
+    const payload = asRecord(entry.payload);
+    if (!payload) continue;
+    if (payload.type === "message" && payload.role === "assistant") {
+      const text = rolloutTextContent(payload.content);
+      if (!text) continue;
+      finalText = text;
+      if (index >= replayedLineCount) {
+        void context.presenter.onAssistantText(text, worker.launcherId);
+      }
+      continue;
+    }
+    if (payload.type === "function_call") {
+      const callId = typeof payload.call_id === "string" ? payload.call_id : "";
+      if (!callId) continue;
+      const toolName = rolloutFunctionToolName(payload);
+      emittedToolNames.set(callId, toolName);
+      if (index >= replayedLineCount) {
+        void context.presenter.onToolUse(
+          toolName,
+          parseMaybeJson(payload.arguments),
+          callId,
+          worker.launcherId
+        );
+      }
+      continue;
+    }
+    if (payload.type === "custom_tool_call") {
+      const callId = typeof payload.call_id === "string" ? payload.call_id : "";
+      if (!callId) continue;
+      const toolName = rolloutFunctionToolName(payload);
+      emittedToolNames.set(callId, toolName);
+      if (index >= replayedLineCount) {
+        void context.presenter.onToolUse(
+          toolName,
+          { code: payload.input ?? "" },
+          callId,
+          worker.launcherId
+        );
+      }
+      continue;
+    }
+    if (payload.type === "tool_search_call") {
+      const callId = typeof payload.call_id === "string" ? payload.call_id : "";
+      if (!callId) continue;
+      emittedToolNames.set(callId, "tool_search");
+      if (index >= replayedLineCount) {
+        void context.presenter.onToolUse(
+          "tool_search",
+          payload.arguments ?? {},
+          callId,
+          worker.launcherId
+        );
+      }
+      continue;
+    }
+    if (payload.type === "function_call_output" || payload.type === "custom_tool_call_output") {
+      const callId = typeof payload.call_id === "string" ? payload.call_id : "";
+      const toolName = emittedToolNames.get(callId);
+      if (!callId || !toolName || index < replayedLineCount) continue;
+      let output = rolloutToolOutputText(payload.output);
+      if (toolName.startsWith("mcp__")) {
+        try {
+          output = normalizeCodexMcpToolResult(payload.output);
+        } catch {
+        }
+      }
+      void context.presenter.onToolResult?.(callId, output, void 0, worker.launcherId);
+      continue;
+    }
+    if (payload.type === "tool_search_output") {
+      const callId = typeof payload.call_id === "string" ? payload.call_id : "";
+      if (!callId || !emittedToolNames.has(callId) || index < replayedLineCount) continue;
+      void context.presenter.onToolResult?.(
+        callId,
+        JSON.stringify(payload.tools ?? [], null, 2),
+        void 0,
+        worker.launcherId
+      );
+    }
+  }
+  if (!state.codexWorkerReplayLineCountByThreadId)
+    state.codexWorkerReplayLineCountByThreadId = /* @__PURE__ */ new Map();
+  state.codexWorkerReplayLineCountByThreadId.set(worker.threadId, lines.length);
+  if (!state.codexWorkerFinalTextByThreadId) state.codexWorkerFinalTextByThreadId = /* @__PURE__ */ new Map();
+  if (finalText) state.codexWorkerFinalTextByThreadId.set(worker.threadId, finalText);
+  return finalText;
+}
+function syncCodexWorkerEventsFromSessionLog(context, state) {
+  const runtimeSessionId = state.runtimeSessionId;
+  if (!runtimeSessionId) return [];
+  const codexHome = resolveCodexHome(context.env);
+  const logPath = state.codexSessionLogPath ?? findCodexSessionLog(runtimeSessionId, codexHome);
+  if (!logPath) return [];
+  state.codexSessionLogPath = logPath;
+  const allLines = (0, import_fs5.readFileSync)(logPath, "utf8").split(/\r?\n/).filter(Boolean);
+  const latestUserLineIndex = latestUserMessageLineIndex(allLines);
+  const lines = latestUserLineIndex >= 0 ? allLines.slice(latestUserLineIndex + 1) : allLines;
+  const workers = collectCodexWorkerReplays(lines, state);
+  for (const worker of workers) {
+    const launcherWasStreamed = state.codexStreamedToolIds?.has(worker.launcherId) === true;
+    if (!launcherWasStreamed) {
+      const workerName = worker.nickname || worker.agentPath?.slice(worker.agentPath.lastIndexOf("/") + 1) || "codex-worker";
+      void context.presenter.onToolUse(
+        "Agent",
+        {
+          subagent_type: workerName,
+          description: worker.description || worker.agentPath || "Codex background worker",
+          agent_thread_id: worker.threadId
+        },
+        worker.launcherId
+      );
+      if (!state.codexStreamedToolIds) state.codexStreamedToolIds = /* @__PURE__ */ new Set();
+      state.codexStreamedToolIds.add(worker.launcherId);
+      if (!state.codexRecoveredLauncherIds) state.codexRecoveredLauncherIds = /* @__PURE__ */ new Set();
+      state.codexRecoveredLauncherIds.add(worker.launcherId);
+    }
+    if (!state.codexWorkerToolIdByThreadId) state.codexWorkerToolIdByThreadId = /* @__PURE__ */ new Map();
+    state.codexWorkerToolIdByThreadId.set(worker.threadId, worker.launcherId);
+    if (worker.agentPath) {
+      if (!state.codexWorkerToolIdByPath) state.codexWorkerToolIdByPath = /* @__PURE__ */ new Map();
+      state.codexWorkerToolIdByPath.set(worker.agentPath, worker.launcherId);
+    }
+    replayCodexWorkerTranscript(context, worker, codexHome, state);
+  }
+  return workers;
+}
 async function replayCodexMcpToolEventsFromSessionLog(context, state) {
   const runtimeSessionId = state.runtimeSessionId;
   if (!runtimeSessionId) return;
@@ -17758,10 +17877,51 @@ async function replayCodexMcpToolEventsFromSessionLog(context, state) {
       }
     }
   }
+  for (const worker of syncCodexWorkerEventsFromSessionLog(context, state)) {
+    if (state.codexRecoveredLauncherIds?.has(worker.launcherId)) {
+      const finalText = state.codexWorkerFinalTextByThreadId?.get(worker.threadId) ?? "";
+      void context.presenter.onToolResult?.(worker.launcherId, finalText || "Subagent completed.");
+      state.codexRecoveredLauncherIds.delete(worker.launcherId);
+    }
+  }
 }
 var CODEX_EXIT_GRACE_MS = 3e4;
 var CODEX_BACKGROUND_EXIT_GRACE_MS = 10 * 6e4;
 var CODEX_EXIT_GRACE_SIGKILL_MS = 3e3;
+var CODEX_WORKER_TRANSCRIPT_POLL_MS = 750;
+function ensureCodexWorkerEventPolling(context, state) {
+  if (!state.runtimeSessionId || state.providerTranscriptPollTimer) return;
+  const poll = () => {
+    try {
+      const before = [...state.codexWorkerReplayLineCountByThreadId?.values() ?? []].reduce(
+        (total, count) => total + count,
+        0
+      ) + (state.codexStreamedToolIds?.size ?? 0);
+      syncCodexWorkerEventsFromSessionLog(context, state);
+      const after = [...state.codexWorkerReplayLineCountByThreadId?.values() ?? []].reduce(
+        (total, count) => total + count,
+        0
+      ) + (state.codexStreamedToolIds?.size ?? 0);
+      if (after > before) state.onNewOutput?.();
+      state.providerTranscriptPollErrorLogged = false;
+    } catch (error) {
+      if (!state.providerTranscriptPollErrorLogged) {
+        console.warn("[codex_app_server] Failed to poll worker rollout:", error);
+        state.providerTranscriptPollErrorLogged = true;
+      }
+    }
+  };
+  poll();
+  const timer = setInterval(poll, CODEX_WORKER_TRANSCRIPT_POLL_MS);
+  timer.unref?.();
+  state.providerTranscriptPollTimer = timer;
+}
+function codexParentToolUseId(record, state) {
+  const threadId = [record.agent_thread_id, record.sender_thread_id, record.thread_id].find(
+    (value2) => typeof value2 === "string" && value2.length > 0
+  );
+  return threadId ? state.backgroundToolIdByTaskId?.get(threadId) ?? null : null;
+}
 function armCodexExitGraceKill(state, graceMs = CODEX_EXIT_GRACE_MS) {
   if (state.exitGraceKillTimer) return;
   const child = state.process;
@@ -17891,6 +18051,9 @@ function handleCodexCollabToolCallItem(context, state, item, phase) {
   const prompt = typeof item.prompt === "string" ? item.prompt : "";
   const agentsStates = typeof item.agents_states === "object" && item.agents_states !== null ? item.agents_states : {};
   const itemStatus = typeof item.status === "string" ? item.status : "";
+  if (tool === "wait") {
+    syncCodexWorkerEventsFromSessionLog(context, state);
+  }
   if (tool === "spawn_agent") {
     if (trackCodexStreamedToolId(state, itemId)) {
       const parentToolUseId = senderThreadId ? state.backgroundToolIdByTaskId?.get(senderThreadId) ?? null : null;
@@ -17910,6 +18073,8 @@ function handleCodexCollabToolCallItem(context, state, item, phase) {
     for (const threadId of receiverThreadIds) {
       if (state.backgroundToolIdByTaskId?.get(threadId)) continue;
       registerBackgroundTaskRecord(state, { task_id: threadId, tool_use_id: itemId });
+      if (!state.codexWorkerToolIdByThreadId) state.codexWorkerToolIdByThreadId = /* @__PURE__ */ new Map();
+      state.codexWorkerToolIdByThreadId.set(threadId, itemId);
     }
     applyCodexCollabAgentStates(context, state, agentsStates);
     if (phase === "completed" && itemStatus === "failed") {
@@ -17983,6 +18148,7 @@ function handleCodexStructuredEvent(parsed, context, state) {
   touchCodexBackgroundGrace(state);
   if (typeof parsed.thread_id === "string") {
     state.runtimeSessionId = parsed.thread_id;
+    ensureCodexWorkerEventPolling(context, state);
   }
   const extractCodexErrorMessage = (value2) => {
     if (typeof value2 !== "string") return "";
@@ -18015,6 +18181,7 @@ function handleCodexStructuredEvent(parsed, context, state) {
     case "session_configured":
       if (typeof parsed.session_id === "string") {
         state.runtimeSessionId = parsed.session_id;
+        ensureCodexWorkerEventPolling(context, state);
       }
       return true;
     case "task_started":
@@ -18084,14 +18251,26 @@ function handleCodexStructuredEvent(parsed, context, state) {
       if (!item || typeof item.type !== "string") return true;
       switch (item.type) {
         case "reasoning": {
-          if (typeof item.text === "string") void presenter.onThinking(item.text);
+          if (typeof item.text === "string") {
+            const parentToolUseId = codexParentToolUseId(item, state);
+            if (parentToolUseId) {
+              void presenter.onThinking(item.text, parentToolUseId);
+            } else {
+              void presenter.onThinking(item.text);
+            }
+          }
           return true;
         }
         case "agent_message": {
           if (typeof item.text === "string") {
-            state.summary += `${item.text}
+            const parentToolUseId = codexParentToolUseId(item, state);
+            if (!parentToolUseId) state.summary += `${item.text}
 `;
-            void presenter.onAssistantText(item.text);
+            if (parentToolUseId) {
+              void presenter.onAssistantText(item.text, parentToolUseId);
+            } else {
+              void presenter.onAssistantText(item.text);
+            }
           }
           return true;
         }
@@ -18153,8 +18332,13 @@ function handleCodexStructuredEvent(parsed, context, state) {
     case "agent_message_content_delta": {
       const delta = typeof parsed.delta === "string" ? parsed.delta : "";
       if (!delta) return true;
-      state.summary += delta;
-      void presenter.onAssistantText(delta);
+      const parentToolUseId = codexParentToolUseId(parsed, state);
+      if (!parentToolUseId) state.summary += delta;
+      if (parentToolUseId) {
+        void presenter.onAssistantText(delta, parentToolUseId);
+      } else {
+        void presenter.onAssistantText(delta);
+      }
       return true;
     }
     case "agent_reasoning_delta":
@@ -18162,7 +18346,12 @@ function handleCodexStructuredEvent(parsed, context, state) {
     case "agent_reasoning_raw_content_delta": {
       const delta = typeof parsed.delta === "string" ? parsed.delta : "";
       if (!delta) return true;
-      void presenter.onThinking(delta);
+      const parentToolUseId = codexParentToolUseId(parsed, state);
+      if (parentToolUseId) {
+        void presenter.onThinking(delta, parentToolUseId);
+      } else {
+        void presenter.onThinking(delta);
+      }
       return true;
     }
     case "exec_command_begin": {
@@ -18230,6 +18419,7 @@ function handleCodexStructuredEvent(parsed, context, state) {
       return true;
     }
     case "turn.completed": {
+      syncCodexWorkerEventsFromSessionLog(context, state);
       const usage = typeof parsed.usage === "object" && parsed.usage !== null ? parsed.usage : {};
       state.usage = {
         model: typeof context.config.selectedModel === "string" && context.config.selectedModel.trim() ? context.config.selectedModel : "codex",
@@ -18281,6 +18471,8 @@ function handleCodexStructuredEvent(parsed, context, state) {
             registerBackgroundLauncher(state, toolId);
             if (agentThreadId) {
               registerBackgroundTaskRecord(state, { task_id: agentThreadId, tool_use_id: toolId });
+              if (!state.codexWorkerToolIdByThreadId) state.codexWorkerToolIdByThreadId = /* @__PURE__ */ new Map();
+              state.codexWorkerToolIdByThreadId.set(agentThreadId, toolId);
             }
             if (!state.codexWorkerToolIdByPath) state.codexWorkerToolIdByPath = /* @__PURE__ */ new Map();
             state.codexWorkerToolIdByPath.set(agentPath, toolId);
@@ -18601,12 +18793,16 @@ function createCopilotCliBackend(command = "copilot", defaultArgs = []) {
     }
   };
 }
+function asRecord2(value2) {
+  return typeof value2 === "object" && value2 !== null ? value2 : null;
+}
 function extractCursorToolEntry(toolCall) {
   const [rawName, rawPayload] = Object.entries(toolCall)[0] ?? [];
   if (!rawName || typeof rawPayload !== "object" || rawPayload === null) return null;
   return { rawName, payload: rawPayload };
 }
 function formatCursorToolName(rawName, payload) {
+  if (rawName === "taskToolCall") return "Agent";
   if (rawName === "terminalToolCall") return "Bash";
   if (rawName === "mcpToolCall") {
     const provider = typeof payload.providerIdentifier === "string" ? payload.providerIdentifier : typeof payload.serverName === "string" ? payload.serverName : typeof payload.mcpServer === "string" ? payload.mcpServer : "";
@@ -18618,6 +18814,59 @@ function formatCursorToolName(rawName, payload) {
   if (!trimmed) return "Cursor Tool";
   return trimmed.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^[a-z]/, (char) => char.toUpperCase());
 }
+function cursorTaskResultVariant(payload, variant) {
+  const result = asRecord2(payload.result);
+  if (!result) return null;
+  const direct = asRecord2(result[variant]);
+  if (direct) return direct;
+  const oneof = asRecord2(result.result);
+  return oneof?.case === variant ? asRecord2(oneof.value) : null;
+}
+function cursorSubagentType(value2) {
+  const normalize = (candidate) => {
+    const trimmed = candidate?.trim();
+    if (!trimmed) return void 0;
+    const normalized = trimmed.toLowerCase();
+    if (normalized === "unspecified" || normalized.endsWith("_unspecified")) return void 0;
+    return trimmed;
+  };
+  if (typeof value2 === "string") return normalize(value2);
+  const record = asRecord2(value2);
+  if (!record) return void 0;
+  if (typeof record.case === "string" && record.case) return normalize(record.case);
+  if (typeof record.type === "string" && record.type) return normalize(record.type);
+  const nestedType = asRecord2(record.type);
+  if (typeof nestedType?.case === "string" && nestedType.case) return normalize(nestedType.case);
+  return normalize(
+    Object.keys(nestedType ?? record).find((key) => key !== "value" && key !== "case")
+  );
+}
+function cursorToolArgs(entry) {
+  const args = asRecord2(entry.payload.args) ?? asRecord2(entry.payload.arguments) ?? entry.payload;
+  if (entry.rawName !== "taskToolCall") return args;
+  const subagentType = cursorSubagentType(args.subagentType ?? args.subagent_type);
+  return {
+    ...typeof args.description === "string" ? { description: args.description } : {},
+    ...typeof args.prompt === "string" ? { prompt: args.prompt } : {},
+    ...subagentType ? { subagent_type: subagentType } : {},
+    ...typeof args.model === "string" ? { model: args.model } : {}
+  };
+}
+function cursorConversationStepValue(step, key) {
+  const direct = asRecord2(step[key]);
+  if (direct) return direct;
+  const message = asRecord2(step.message);
+  return message?.case === key ? asRecord2(message.value) : null;
+}
+function cursorConversationStepText(steps) {
+  if (!Array.isArray(steps)) return "";
+  return steps.flatMap((step) => {
+    const record = asRecord2(step);
+    if (!record) return [];
+    const assistant = cursorConversationStepValue(record, "assistantMessage");
+    return typeof assistant?.text === "string" ? [assistant.text] : [];
+  }).join("\n").trim();
+}
 function buildCursorToolResultText(result) {
   if (typeof result === "string") return result;
   if (!result || typeof result !== "object") return JSON.stringify(result ?? {});
@@ -18639,6 +18888,202 @@ function buildCursorToolResultText(result) {
   }
   return JSON.stringify(result, null, 2);
 }
+function emitCursorSubagentConversationSteps(steps, parentToolUseId, presenter) {
+  if (!Array.isArray(steps)) return;
+  steps.forEach((step, index) => {
+    const record = asRecord2(step);
+    if (!record) return;
+    const assistant = cursorConversationStepValue(record, "assistantMessage");
+    if (typeof assistant?.text === "string" && assistant.text) {
+      void presenter.onAssistantText(assistant.text, parentToolUseId);
+      return;
+    }
+    const thinking = cursorConversationStepValue(record, "thinkingMessage");
+    if (typeof thinking?.text === "string" && thinking.text) {
+      void presenter.onThinking(thinking.text, parentToolUseId);
+      return;
+    }
+    const toolCall = cursorConversationStepValue(record, "toolCall");
+    if (!toolCall) return;
+    const entry = extractCursorToolEntry(toolCall);
+    if (!entry) return;
+    const args = cursorToolArgs(entry);
+    const toolId = typeof args.toolCallId === "string" && args.toolCallId || typeof args.tool_call_id === "string" && args.tool_call_id || `${parentToolUseId}-step-${index}`;
+    void presenter.onToolUse(
+      formatCursorToolName(entry.rawName, entry.payload),
+      args,
+      toolId,
+      parentToolUseId
+    );
+    if (entry.payload.result !== void 0) {
+      const isError = cursorTaskResultVariant(entry.payload, "error") !== null;
+      void presenter.onToolResult?.(
+        toolId,
+        buildCursorToolResultText(entry.payload.result),
+        isError || void 0,
+        parentToolUseId
+      );
+    }
+  });
+}
+function emitCursorSubagentTranscript(transcriptPath, parentToolUseId, presenter, startLine = 0) {
+  if (typeof transcriptPath !== "string" || !transcriptPath) {
+    return { found: false, processedLineCount: startLine, emittedEventCount: 0 };
+  }
+  let lines;
+  try {
+    lines = (0, import_fs6.readFileSync)(transcriptPath, "utf8").split(/\r?\n/);
+    if (lines.at(-1) === "") lines.pop();
+  } catch {
+    return { found: false, processedLineCount: startLine, emittedEventCount: 0 };
+  }
+  let processedLineCount = startLine > lines.length ? 0 : startLine;
+  let emittedEventCount = 0;
+  for (let lineIndex = processedLineCount; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex];
+    if (!line) {
+      processedLineCount = lineIndex + 1;
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      break;
+    }
+    processedLineCount = lineIndex + 1;
+    if (entry.role !== "assistant") continue;
+    const message = asRecord2(entry.message);
+    const content = Array.isArray(message?.content) ? message.content : [];
+    content.forEach((rawBlock, blockIndex) => {
+      const block = asRecord2(rawBlock);
+      if (!block) return;
+      const type = typeof block.type === "string" ? block.type : "";
+      const text = typeof block.text === "string" ? block.text : "";
+      if (type === "text" && text) {
+        emittedEventCount += 1;
+        void presenter.onAssistantText(text, parentToolUseId);
+        return;
+      }
+      if ((type === "thinking" || type === "reasoning") && text) {
+        emittedEventCount += 1;
+        void presenter.onThinking(text, parentToolUseId);
+        return;
+      }
+      if (type !== "tool_use") return;
+      const name = typeof block.name === "string" && block.name ? block.name : "Cursor Tool";
+      const toolId = typeof block.id === "string" && block.id || `${parentToolUseId}-transcript-${lineIndex}-${blockIndex}`;
+      emittedEventCount += 1;
+      void presenter.onToolUse(name, asRecord2(block.input) ?? {}, toolId, parentToolUseId);
+    });
+  }
+  return { found: true, processedLineCount, emittedEventCount };
+}
+function cursorTranscriptsRoot(context) {
+  const projectKey = context.cwd.replace(/^[/\\]+/, "").replace(/[/\\]+/g, "-");
+  const home = context.env.HOME || process.env.HOME || (0, import_os6.homedir)();
+  return (0, import_path6.join)(home, ".cursor", "projects", projectKey, "agent-transcripts");
+}
+function cursorTranscriptPathForAgent(context, agentId) {
+  return (0, import_path6.join)(cursorTranscriptsRoot(context), agentId, `${agentId}.jsonl`);
+}
+function resolveCursorSubagentTranscriptPath(success, context) {
+  const explicit = success?.transcriptPath ?? success?.transcript_path;
+  if (typeof explicit === "string" && explicit) return explicit;
+  const agentId = typeof success?.agentId === "string" ? success.agentId : "";
+  return agentId ? cursorTranscriptPathForAgent(context, agentId) : void 0;
+}
+function cursorTranscriptUserText(transcriptPath) {
+  try {
+    for (const line of (0, import_fs6.readFileSync)(transcriptPath, "utf8").split(/\r?\n/)) {
+      if (!line) continue;
+      const entry = asRecord2(JSON.parse(line));
+      if (entry?.role !== "user") continue;
+      const message = asRecord2(entry.message);
+      const content = Array.isArray(message?.content) ? message.content : [];
+      return content.flatMap((block) => {
+        const record = asRecord2(block);
+        return typeof record?.text === "string" ? [record.text] : [];
+      }).join("");
+    }
+  } catch {
+  }
+  return "";
+}
+function discoverCursorSubagentTranscript(context, state, task) {
+  const root = cursorTranscriptsRoot(context);
+  if (!(0, import_fs6.existsSync)(root)) return void 0;
+  const prompt = task.prompt?.trim();
+  const description = task.description?.trim().toLowerCase();
+  const candidates = [];
+  let entries;
+  try {
+    entries = (0, import_fs6.readdirSync)(root, { withFileTypes: true });
+  } catch {
+    return void 0;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === state.runtimeSessionId) continue;
+    const path = cursorTranscriptPathForAgent(context, entry.name);
+    let mtimeMs;
+    try {
+      mtimeMs = (0, import_fs6.statSync)(path).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (mtimeMs < task.startedAtMs - 2e3) continue;
+    const userText = cursorTranscriptUserText(path).trim();
+    if (!userText) continue;
+    let score = 0;
+    if (prompt && userText === prompt) score = 3;
+    else if (prompt && (userText.includes(prompt) || prompt.includes(userText))) score = 2;
+    else if (description && userText.toLowerCase().includes(description)) score = 1;
+    if (score > 0) candidates.push({ path, score, mtimeMs });
+  }
+  candidates.sort((a, b) => b.score - a.score || b.mtimeMs - a.mtimeMs);
+  return candidates[0]?.path;
+}
+function syncCursorSubagentEventsFromTranscripts(context, state) {
+  let emittedEventCount = 0;
+  for (const [launcherId, task] of state.cursorSubagentTranscripts ?? []) {
+    task.transcriptPath ??= discoverCursorSubagentTranscript(context, state, task);
+    if (!task.transcriptPath) continue;
+    const replay = emitCursorSubagentTranscript(
+      task.transcriptPath,
+      launcherId,
+      context.presenter,
+      task.replayedLineCount
+    );
+    task.replayedLineCount = replay.processedLineCount;
+    task.emittedEventCount += replay.emittedEventCount;
+    emittedEventCount += replay.emittedEventCount;
+  }
+  if (emittedEventCount > 0) state.onNewOutput?.();
+  return emittedEventCount;
+}
+function ensureCursorSubagentTranscriptPolling(context, state) {
+  if (state.providerTranscriptPollTimer) return;
+  const poll = () => {
+    try {
+      syncCursorSubagentEventsFromTranscripts(context, state);
+      state.providerTranscriptPollErrorLogged = false;
+    } catch (error) {
+      if (!state.providerTranscriptPollErrorLogged) {
+        console.warn("[cursor_agent_cli] Failed to poll child transcript:", error);
+        state.providerTranscriptPollErrorLogged = true;
+      }
+    }
+  };
+  poll();
+  const timer = setInterval(poll, 750);
+  timer.unref?.();
+  state.providerTranscriptPollTimer = timer;
+}
+function stopCursorSubagentTranscriptPollingIfIdle(state) {
+  if (state.cursorSubagentTranscripts?.size) return;
+  if (state.providerTranscriptPollTimer) clearInterval(state.providerTranscriptPollTimer);
+  state.providerTranscriptPollTimer = void 0;
+}
 function handleCursorStructuredEvent(parsed, context, state) {
   const presenter = context.presenter;
   const type = typeof parsed.type === "string" ? parsed.type : "";
@@ -18646,8 +19091,22 @@ function handleCursorStructuredEvent(parsed, context, state) {
   if (typeof parsed.session_id === "string") state.runtimeSessionId = parsed.session_id;
   if (typeof parsed.model === "string") state.activeModel = parsed.model;
   switch (type) {
-    case "system":
+    case "system": {
+      if (parsed.subtype !== "task_notification") return true;
+      const status = typeof parsed.status === "string" ? parsed.status.toLowerCase() : "completed";
+      const isError = ["error", "failed", "aborted", "cancelled", "interrupted"].includes(status);
+      const resultText = typeof parsed.detail === "string" && parsed.detail || typeof parsed.title === "string" && parsed.title || `Background subagent ${status}`;
+      const toolUseId = resolveBackgroundTaskToolUseId(state, parsed);
+      clearBackgroundTaskIds(state, backgroundTaskKeys(parsed));
+      const launcherId = toolUseId ?? drainNextUnlinkedBackgroundLauncher(state);
+      if (launcherId) {
+        syncCursorSubagentEventsFromTranscripts(context, state);
+        state.cursorSubagentTranscripts?.delete(launcherId);
+        stopCursorSubagentTranscriptPollingIfIdle(state);
+        void presenter.onToolResult?.(launcherId, resultText, isError || void 0);
+      }
       return true;
+    }
     case "thinking":
     case "reasoning": {
       const subtype = typeof parsed.subtype === "string" ? parsed.subtype : "";
@@ -18696,14 +19155,72 @@ function handleCursorStructuredEvent(parsed, context, state) {
       if (!toolId) return true;
       state.iterations = Math.max(state.iterations, 1);
       const toolName = formatCursorToolName(entry.rawName, entry.payload);
-      const toolArgs = typeof entry.payload.args === "object" && entry.payload.args !== null ? entry.payload.args : typeof entry.payload.arguments === "object" && entry.payload.arguments !== null ? entry.payload.arguments : entry.payload;
+      const toolArgs = cursorToolArgs(entry);
       if (subtype === "started") {
         void presenter.onToolUse(toolName, toolArgs, toolId);
+        if (entry.rawName === "taskToolCall") {
+          if (!state.cursorSubagentTranscripts) state.cursorSubagentTranscripts = /* @__PURE__ */ new Map();
+          state.cursorSubagentTranscripts.set(toolId, {
+            description: typeof toolArgs.description === "string" ? toolArgs.description : void 0,
+            prompt: typeof toolArgs.prompt === "string" ? toolArgs.prompt : void 0,
+            startedAtMs: typeof parsed.timestamp_ms === "number" ? parsed.timestamp_ms : typeof entry.payload.startedAtMs === "number" ? entry.payload.startedAtMs : Number(entry.payload.startedAtMs) || Date.now(),
+            replayedLineCount: 0,
+            emittedEventCount: 0
+          });
+          ensureCursorSubagentTranscriptPolling(context, state);
+        }
         return true;
       }
       if (subtype === "completed") {
         if (!hasCallId) state.lastAnonymousCursorToolId = void 0;
-        void presenter.onToolResult?.(toolId, buildCursorToolResultText(entry.payload.result));
+        if (entry.rawName === "taskToolCall") {
+          const resultEnvelope = typeof parsed.result === "object" && parsed.result !== null ? parsed : entry.payload;
+          const success = cursorTaskResultVariant(resultEnvelope, "success");
+          const failure = cursorTaskResultVariant(resultEnvelope, "error");
+          const task = state.cursorSubagentTranscripts?.get(toolId);
+          if (task) {
+            task.transcriptPath = resolveCursorSubagentTranscriptPath(success, context) ?? task.transcriptPath;
+          }
+          let replayedTranscript = false;
+          if (task) {
+            syncCursorSubagentEventsFromTranscripts(context, state);
+            replayedTranscript = task.emittedEventCount > 0;
+          } else {
+            replayedTranscript = emitCursorSubagentTranscript(
+              resolveCursorSubagentTranscriptPath(success, context),
+              toolId,
+              presenter
+            ).emittedEventCount > 0;
+          }
+          if (!replayedTranscript) {
+            emitCursorSubagentConversationSteps(success?.conversationSteps, toolId, presenter);
+          }
+          if (success?.isBackground === true) {
+            registerBackgroundLauncher(state, toolId);
+            const taskId = typeof success.agentId === "string" && success.agentId ? success.agentId : void 0;
+            if (taskId) {
+              registerBackgroundTaskRecord(state, {
+                task_id: taskId,
+                tool_use_id: toolId
+              });
+            }
+            return true;
+          }
+          state.cursorSubagentTranscripts?.delete(toolId);
+          stopCursorSubagentTranscriptPollingIfIdle(state);
+          const summary = cursorConversationStepText(success?.conversationSteps);
+          const failureText = typeof failure?.error === "string" && failure.error ? failure.error : "Cursor subagent failed";
+          void presenter.onToolResult?.(
+            toolId,
+            failure ? failureText : summary || buildCursorToolResultText(resultEnvelope.result),
+            failure ? true : void 0
+          );
+          return true;
+        }
+        void presenter.onToolResult?.(
+          toolId,
+          buildCursorToolResultText(parsed.result ?? entry.payload.result)
+        );
       }
       return true;
     }
@@ -19061,7 +19578,7 @@ function createDroidCliBackend(command = "droid", defaultArgs = []) {
   };
 }
 var ACP_PROTOCOL_VERSION = 1;
-function asRecord(value2) {
+function asRecord3(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
 function asString(value2) {
@@ -19071,7 +19588,7 @@ function resumeSessionId(context) {
   return context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim() || "";
 }
 function chunkText(content) {
-  const record = asRecord(content);
+  const record = asRecord3(content);
   if (!record) return "";
   if (typeof record.text === "string") return record.text;
   return chunkText(record.content);
@@ -19087,23 +19604,23 @@ function toolResultText(update) {
   return "";
 }
 function toolMetaName(update) {
-  const meta = asRecord(update._meta);
-  const tool = asRecord(meta?.["x.ai/tool"]);
+  const meta = asRecord3(update._meta);
+  const tool = asRecord3(meta?.["x.ai/tool"]);
   return asString(tool?.name);
 }
 function resolvePermission(params, context) {
-  const record = asRecord(params);
+  const record = asRecord3(params);
   const options = Array.isArray(record?.options) ? record?.options : [];
-  const toolCall = asRecord(record?.toolCall);
-  const meta = asRecord(toolCall?._meta);
-  const tool = asRecord(meta?.["x.ai/tool"]);
+  const toolCall = asRecord3(record?.toolCall);
+  const meta = asRecord3(toolCall?._meta);
+  const tool = asRecord3(meta?.["x.ai/tool"]);
   const isReadOnlyTool = tool?.read_only === true || asString(tool?.kind) === "read";
   const allow = !shouldUseReadOnlyRuntimePermissions(context.config) || isReadOnlyTool;
   const allowKinds = ["allow_always", "allow_once", "allow"];
   const rejectKinds = ["reject_always", "reject_once", "reject", "deny"];
   const wanted = allow ? allowKinds : rejectKinds;
-  const chosen = options.find((option) => wanted.includes(asString(asRecord(option)?.kind))) ?? (allow ? options[0] : options[options.length - 1]);
-  const optionId = asString(asRecord(chosen)?.optionId);
+  const chosen = options.find((option) => wanted.includes(asString(asRecord3(option)?.kind))) ?? (allow ? options[0] : options[options.length - 1]);
+  const optionId = asString(asRecord3(chosen)?.optionId);
   if (!optionId) return { outcome: { outcome: "cancelled" } };
   return { outcome: { outcome: "selected", optionId } };
 }
@@ -19179,9 +19696,9 @@ function createGrokAcpDriver(imageFiles) {
       finalize(state);
       return;
     }
-    const result = asRecord(message.result);
+    const result = asRecord3(message.result);
     if (message.id === initId) {
-      const modelState = asRecord(asRecord(result?._meta)?.modelState);
+      const modelState = asRecord3(asRecord3(result?._meta)?.modelState);
       const model = asString(modelState?.currentModelId);
       if (model) state.activeModel = model;
       beginSession(context, state);
@@ -19195,7 +19712,7 @@ function createGrokAcpDriver(imageFiles) {
       return;
     }
     if (message.id === promptId) {
-      const meta = asRecord(result?._meta);
+      const meta = asRecord3(result?._meta);
       const model = asString(meta?.modelId) || state.activeModel || (typeof context.config.selectedModel === "string" && context.config.selectedModel.trim() ? context.config.selectedModel.trim() : "grok");
       const inputTokens = typeof meta?.inputTokens === "number" ? meta.inputTokens : 0;
       const outputTokens = typeof meta?.outputTokens === "number" ? meta.outputTokens : 0;
@@ -19240,8 +19757,8 @@ function createGrokAcpDriver(imageFiles) {
     }
   }
   function handleNotification(message, context, state) {
-    const params = asRecord(message.params);
-    const update = asRecord(params?.update);
+    const params = asRecord3(message.params);
+    const update = asRecord3(params?.update);
     if (!update || !isPromptActive) return;
     const presenter = context.presenter;
     switch (asString(update.sessionUpdate)) {
@@ -19288,7 +19805,7 @@ function createGrokAcpDriver(imageFiles) {
       if (line.trim().length > 0) void context.presenter.onLog(`[grok_cli] ${line}`);
       return;
     }
-    const message = asRecord(parsed);
+    const message = asRecord3(parsed);
     if (!message) return;
     if (message.id !== void 0 && message.method === void 0) {
       handleResponse(message, context, state);
@@ -19355,9 +19872,9 @@ function buildGrokAgentArgs(config, defaultArgs = []) {
   return args;
 }
 var DEFAULT_SKILL_ROOTS = [
-  (0, import_path6.join)((0, import_os6.homedir)(), ".agents", "skills"),
-  (0, import_path6.join)((0, import_os6.homedir)(), ".claude", "skills"),
-  (0, import_path6.join)((0, import_os6.homedir)(), ".config", "opencode", "skills")
+  (0, import_path7.join)((0, import_os7.homedir)(), ".agents", "skills"),
+  (0, import_path7.join)((0, import_os7.homedir)(), ".claude", "skills"),
+  (0, import_path7.join)((0, import_os7.homedir)(), ".config", "opencode", "skills")
 ];
 function parseFrontmatter(content) {
   if (!content.startsWith("---\n")) return {};
@@ -19373,12 +19890,12 @@ function parseFrontmatter(content) {
   return result;
 }
 function listSkillFiles(root) {
-  if (!(0, import_fs6.existsSync)(root)) return [];
+  if (!(0, import_fs7.existsSync)(root)) return [];
   const files = [];
-  for (const entry of (0, import_fs6.readdirSync)(root, { withFileTypes: true })) {
+  for (const entry of (0, import_fs7.readdirSync)(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const skillPath = (0, import_path6.join)(root, entry.name, "SKILL.md");
-    if ((0, import_fs6.existsSync)(skillPath)) files.push(skillPath);
+    const skillPath = (0, import_path7.join)(root, entry.name, "SKILL.md");
+    if ((0, import_fs7.existsSync)(skillPath)) files.push(skillPath);
   }
   return files;
 }
@@ -19387,7 +19904,7 @@ function loadInstalledSkills(roots = DEFAULT_SKILL_ROOTS) {
   for (const root of roots) {
     for (const skillPath of listSkillFiles(root)) {
       try {
-        const frontmatter = parseFrontmatter((0, import_fs6.readFileSync)(skillPath, "utf8"));
+        const frontmatter = parseFrontmatter((0, import_fs7.readFileSync)(skillPath, "utf8"));
         const name = frontmatter.name;
         const description = frontmatter.description;
         if (!name || !description || skills.has(name)) continue;
@@ -20356,40 +20873,40 @@ function parseSkillInvocation(text) {
 function candidateRoots(cwd) {
   const roots = [];
   if (cwd) {
-    roots.push((0, import_path7.join)(cwd, ".agents", "skills"));
-    roots.push((0, import_path7.join)(cwd, ".claude", "skills"));
-    roots.push((0, import_path7.join)(cwd, ".codex", "skills"));
-    if ((0, import_fs7.existsSync)(cwd)) {
+    roots.push((0, import_path8.join)(cwd, ".agents", "skills"));
+    roots.push((0, import_path8.join)(cwd, ".claude", "skills"));
+    roots.push((0, import_path8.join)(cwd, ".codex", "skills"));
+    if ((0, import_fs8.existsSync)(cwd)) {
       let entries = [];
       try {
-        entries = (0, import_fs7.readdirSync)(cwd, { withFileTypes: true });
+        entries = (0, import_fs8.readdirSync)(cwd, { withFileTypes: true });
       } catch {
       }
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".")) continue;
-        const child = (0, import_path7.join)(cwd, entry.name);
-        roots.push((0, import_path7.join)(child, ".agents", "skills"));
-        roots.push((0, import_path7.join)(child, ".claude", "skills"));
-        roots.push((0, import_path7.join)(child, ".codex", "skills"));
+        const child = (0, import_path8.join)(cwd, entry.name);
+        roots.push((0, import_path8.join)(child, ".agents", "skills"));
+        roots.push((0, import_path8.join)(child, ".claude", "skills"));
+        roots.push((0, import_path8.join)(child, ".codex", "skills"));
       }
     }
   }
-  const home = (0, import_os7.homedir)();
-  roots.push((0, import_path7.join)(home, ".agents", "skills"));
-  roots.push((0, import_path7.join)(home, ".claude", "skills"));
-  roots.push((0, import_path7.join)(home, ".codex", "skills"));
+  const home = (0, import_os8.homedir)();
+  roots.push((0, import_path8.join)(home, ".agents", "skills"));
+  roots.push((0, import_path8.join)(home, ".claude", "skills"));
+  roots.push((0, import_path8.join)(home, ".codex", "skills"));
   return Array.from(new Set(roots));
 }
 function resolveSkillInvocation(text, cwd) {
   const parsed = parseSkillInvocation(text);
   if (!parsed) return null;
   for (const root of candidateRoots(cwd)) {
-    const skillPath = (0, import_path7.join)(root, parsed.command, "SKILL.md");
-    if (!(0, import_fs7.existsSync)(skillPath)) continue;
+    const skillPath = (0, import_path8.join)(root, parsed.command, "SKILL.md");
+    if (!(0, import_fs8.existsSync)(skillPath)) continue;
     let content;
     try {
-      content = (0, import_fs7.readFileSync)(skillPath, "utf-8");
+      content = (0, import_fs8.readFileSync)(skillPath, "utf-8");
     } catch {
       continue;
     }
@@ -20986,14 +21503,14 @@ function normalizePath(candidate, cwd) {
   } catch {
   }
   if (path.startsWith("~/")) return null;
-  if ((0, import_path8.isAbsolute)(path)) return path;
-  return cwd ? (0, import_path8.join)(cwd, path) : null;
+  if ((0, import_path9.isAbsolute)(path)) return path;
+  return cwd ? (0, import_path9.join)(cwd, path) : null;
 }
 function resolveToolCwd(cwd, toolInput) {
   if (!isRecord(toolInput)) return cwd;
   const raw = typeof toolInput.cwd === "string" ? toolInput.cwd : typeof toolInput.workdir === "string" ? toolInput.workdir : typeof toolInput.workingDirectory === "string" ? toolInput.workingDirectory : null;
   if (!raw) return cwd;
-  return (0, import_path8.isAbsolute)(raw) || !cwd ? raw : (0, import_path8.join)(cwd, raw);
+  return (0, import_path9.isAbsolute)(raw) || !cwd ? raw : (0, import_path9.join)(cwd, raw);
 }
 function extractBrowserMediaPathHints(content, cwd, toolName, options = {}, kind = "video") {
   if (!isAgentBrowserMediaInvocation(toolName, content, options.toolInput, kind)) return [];
@@ -21036,19 +21553,19 @@ function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName, op
   const effectiveCwd = resolveToolCwd(cwd, options.toolInput);
   for (const candidate of extractPathCandidates(content, options)) {
     const path = normalizePath(candidate, effectiveCwd);
-    if (!path || seen.has(path) || !(0, import_fs8.existsSync)(path)) continue;
+    if (!path || seen.has(path) || !(0, import_fs9.existsSync)(path)) continue;
     seen.add(path);
-    const ext = (0, import_path8.extname)(path).toLowerCase();
+    const ext = (0, import_path9.extname)(path).toLowerCase();
     const mimeType = IMAGE_MIME_BY_EXT[ext];
     if (!mimeType) continue;
-    const stat = (0, import_fs8.statSync)(path);
+    const stat = (0, import_fs9.statSync)(path);
     if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_GENERATED_IMAGE_BYTES) continue;
-    const buffer = (0, import_fs8.readFileSync)(path);
+    const buffer = (0, import_fs9.readFileSync)(path);
     const { width, height } = readImageDimensions2(buffer, mimeType);
     images.push({
       type: "generated_image",
       id: (0, import_crypto3.randomUUID)(),
-      filename: (0, import_path8.basename)(path),
+      filename: (0, import_path9.basename)(path),
       mimeType,
       size: buffer.length,
       width,
@@ -21075,20 +21592,20 @@ function extractSessionMediaFromToolResult(toolId, content, cwd, toolName, optio
   const mimeByExt = kind === "video" ? VIDEO_MIME_BY_EXT : IMAGE_MIME_BY_EXT;
   for (const candidate of extractPathCandidates(content, options, extensionsPattern)) {
     const path = normalizePath(candidate, effectiveCwd);
-    if (!path || seen.has(path) || !(0, import_fs8.existsSync)(path)) continue;
+    if (!path || seen.has(path) || !(0, import_fs9.existsSync)(path)) continue;
     seen.add(path);
-    const ext = (0, import_path8.extname)(path).toLowerCase();
+    const ext = (0, import_path9.extname)(path).toLowerCase();
     const mimeType = mimeByExt[ext];
     if (!mimeType) continue;
-    const stat = (0, import_fs8.statSync)(path);
+    const stat = (0, import_fs9.statSync)(path);
     if (!stat.isFile() || stat.size <= 0 || stat.size > maxBytes) continue;
-    const buffer = (0, import_fs8.readFileSync)(path);
+    const buffer = (0, import_fs9.readFileSync)(path);
     const dimensions = kind === "image" ? readImageDimensions2(buffer, mimeType) : null;
     media.push({
       type: "session_media",
       kind,
       id: (0, import_crypto3.randomUUID)(),
-      filename: (0, import_path8.basename)(path),
+      filename: (0, import_path9.basename)(path),
       mimeType,
       size: buffer.length,
       width: dimensions?.width,
@@ -23667,7 +24184,7 @@ var RunStartGate = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.45";
+var AGENT_VERSION = "0.1.46";
 
 // src/workspace-relocation.ts
 var import_node_child_process3 = require("child_process");
@@ -25380,11 +25897,21 @@ var RuntimePresenter = class {
   onNotice(kind, message) {
     this.emitEvent({ type: "session_notice", kind, message, ts: Date.now() });
   }
-  onAssistantText(text) {
-    this.emitEvent({ type: "text", text, ts: Date.now() });
+  onAssistantText(text, parentToolUseId) {
+    this.emitEvent({
+      type: "text",
+      text,
+      ts: Date.now(),
+      ...parentToolUseId ? { parentToolUseId } : {}
+    });
   }
-  onThinking(text) {
-    this.emitEvent({ type: "thinking", text, ts: Date.now() });
+  onThinking(text, parentToolUseId) {
+    this.emitEvent({
+      type: "thinking",
+      text,
+      ts: Date.now(),
+      ...parentToolUseId ? { parentToolUseId } : {}
+    });
   }
   onToolUse(tool, input, toolId, parentToolUseId) {
     if (this.verifyWorkspaceLease && !this.verifyWorkspaceLease()) return;
@@ -27488,11 +28015,21 @@ var WebPresenter = class {
   onNotice(kind, message) {
     this.wsClient.emitEvent({ type: "session_notice", kind, message, ts: Date.now() });
   }
-  onAssistantText(text) {
-    this.wsClient.emitEvent({ type: "text", text, ts: Date.now() });
+  onAssistantText(text, parentToolUseId) {
+    this.wsClient.emitEvent({
+      type: "text",
+      text,
+      ts: Date.now(),
+      ...parentToolUseId ? { parentToolUseId } : {}
+    });
   }
-  onThinking(text) {
-    this.wsClient.emitEvent({ type: "thinking", text, ts: Date.now() });
+  onThinking(text, parentToolUseId) {
+    this.wsClient.emitEvent({
+      type: "thinking",
+      text,
+      ts: Date.now(),
+      ...parentToolUseId ? { parentToolUseId } : {}
+    });
   }
   hasKnownToolUse(toolId) {
     return this.toolNamesById.has(toolId);