@qwen-code/qwen-code 0.21.0 → 0.21.1-simplify-system-prompt.0

package/chunks/{chunk-PHOF65IG.js → chunk-DM4Q4JJH.js}

@@ -71,7 +71,7 @@ import {
   RUNTIME_SNAPSHOT_PREFIX,
   buildModelIdContext,
   resolveModelId
-} from "./chunk-MZAXJAUM.js";
+} from "./chunk-PSWQZHEA.js";
 import {
   LEADER_NAME,
   MAX_TEAMMATES
@@ -188,8 +188,11 @@ import {
 } from "./chunk-DJ2GSRLV.js";
 import {
   DEFAULT_OTLP_ENDPOINT,
-  DEFAULT_TELEMETRY_TARGET
-} from "./chunk-NIBLUX3Y.js";
+  DEFAULT_TELEMETRY_TARGET,
+  addToolArgumentsAttributes,
+  addToolCallResultAttributes,
+  addUserPromptAttributes
+} from "./chunk-BO4XCS7P.js";
 import {
   InvalidStreamError,
   getThoughtSummary
@@ -309,7 +312,7 @@ import {
   updateMCPServerStatus,
   writeLine,
   writeLineSync
-} from "./chunk-CIKQ7KKO.js";
+} from "./chunk-RWS5VYWC.js";
 import {
   E_TIMEOUT,
   Mutex,
@@ -346,7 +349,7 @@ import {
   QWEN_OAUTH_MODELS,
   createContentGenerator,
   resolveContentGeneratorConfigWithSources
-} from "./chunk-IKCX4CCL.js";
+} from "./chunk-U7TXFVUN.js";
 import {
   normalizeMcpToolName,
   sanitizeToolNameForProvider
@@ -375,10 +378,6 @@ import {
   renameWithRetry
 } from "./chunk-A5L3JMUA.js";
 import {
-  addToolInputAttributes,
-  addToolResultAttributes,
-  addUserPromptAttributes,
-  clearDetailedSpanState,
   endHookSpan,
   endInteractionSpan,
   endSubagentSpan,
@@ -403,13 +402,15 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   truncateSpanError
-} from "./chunk-MB4MZHMJ.js";
+} from "./chunk-SRZ6DXVG.js";
+import {
+  safeJsonStringify
+} from "./chunk-W4RQUHY3.js";
 import {
   DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH,
   SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT,
-  isValidSensitiveSpanAttributeMaxLength,
-  safeJsonStringify
-} from "./chunk-BULDBTYC.js";
+  isValidSensitiveSpanAttributeMaxLength
+} from "./chunk-INADJJGW.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
 } from "./chunk-UUUTRMI2.js";
@@ -33104,36 +33105,8 @@ function resolveInteractionMode(config) {
   return config.isInteractive() ? "interactive" : "headless";
 }
 __name(resolveInteractionMode, "resolveInteractionMode");
-function getInteractionModePrompt(mode) {
-  switch (mode) {
-    case "headless":
-      return {
-        role: "a non-interactive CLI agent",
-        questions: `This is a non-interactive, single-turn run and no reply can be received after your response. Never ask the user a question, even if the user explicitly requests one. Do not call '${ToolNames.ASK_USER_QUESTION}' or output a textual question. Make reasonable assumptions when safe and complete the task; if required information is unavailable, report the blocker as the final result.`
-      };
-    case "acp":
-      return {
-        role: "a CLI agent operating through an ACP host",
-        questions: `Use '${ToolNames.ASK_USER_QUESTION}' when clarification is necessary. The ACP host can relay the question and response.`
-      };
-    case "interactive":
-      return getInteractiveInteractionModePrompt();
-    default: {
-      const _exhaustive = mode;
-      void _exhaustive;
-      return getInteractiveInteractionModePrompt();
-    }
-  }
-}
-__name(getInteractionModePrompt, "getInteractionModePrompt");
-function getInteractiveInteractionModePrompt() {
-  return {
-    role: "an interactive CLI agent",
-    questions: `Use '${ToolNames.ASK_USER_QUESTION}' when you need clarification or want to validate assumptions. Never include time estimates in options.`
-  };
-}
-__name(getInteractiveInteractionModePrompt, "getInteractiveInteractionModePrompt");
-function getDefaultCoreIdentitySentence(role) {
+function getDefaultCoreIdentitySentence(interactionMode) {
+  const role = interactionMode === "headless" ? "a non-interactive CLI agent" : interactionMode === "acp" ? "a CLI agent operating through an ACP host" : "an interactive CLI agent";
   return `You are Qwen Code, ${role} developed by Alibaba Group, specializing in software engineering tasks. Your primary goal is to help users safely and efficiently, adhering strictly to the following instructions and utilizing your available tools.`;
 }
 __name(getDefaultCoreIdentitySentence, "getDefaultCoreIdentitySentence");
@@ -33223,101 +33196,42 @@ function getCoreSystemPrompt(userMemory, model, appendInstruction, interactionMo
       throw new Error(`missing system prompt file '${systemMdPath}'`);
     }
   }
-  const interaction = getInteractionModePrompt(interactionMode);
   let basePrompt;
   if (systemMdEnabled) {
     basePrompt = fs5.readFileSync(systemMdPath, "utf8");
   } else {
-    const coreIdentity = resolveCoreIdentityOverride() ?? getDefaultCoreIdentitySentence(interaction.role);
+    const coreIdentity = resolveCoreIdentityOverride() ?? getDefaultCoreIdentitySentence(interactionMode);
     basePrompt = `
 ${coreIdentity}
 
-# Core Mandates
-
-- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
-- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it.
-- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
-- **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
-- **Comments:** Default to none. Only add a comment when the _why_ cannot be conveyed through naming or code structure \u2014 a hidden constraint, a subtle invariant, or a workaround for a specific bug. Do not narrate what the code does. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments.
-- **Proactiveness:** Fulfill the user's request thoroughly. When the task involves code modifications, add tests to verify the change works. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise.
-- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without following the active interaction mode's question guidance. If asked *how* to do something, explain first, don't just do it.
-- **Do Not revert changes:** Do not revert changes to the codebase unless asked to do so by the user. Only revert changes made by you if they have resulted in an error or if the user has explicitly asked you to revert the changes.
-- **Preserve Existing Work:** Treat existing or unexpected changes as user-owned. Do not modify, stage, commit, or revert unrelated changes. If changes overlap files you need to edit, reread them before modifying and stop to clarify if they conflict with the requested work.
-- **Denied Tool Calls:** If a tool call is denied, do not try to complete the denied action through another tool, shell indirection, generated script, alias, symlink, config change, hook, command file, MCP configuration, encoded payload, or equivalent path. If that action is required, stop and request explicit approval only when the current interaction mode can receive it; otherwise report the blocker. You may continue with unrelated safe work or a genuinely safer alternative that does not accomplish the denied action.
-- **Plan before uncertain work:** If the task is not yet clear enough to safely execute, do not make small speculative edits. Continue read-only investigation, make a plan in the current mode, or follow the active interaction mode's question guidance. Do not enter plan mode or call ${ToolNames.ENTER_PLAN_MODE} on your own just because the task involves planning or complexity. Use plan mode only when the user explicitly asks you to switch to plan mode, has already enabled it, or confirms they want it.
-
-
-# Task Management
-You have access to the ${ToolNames.TODO_WRITE} tool to keep user-visible progress for work that benefits from explicit tracking. Use it for complex, ambiguous, or multi-phase tasks or requests with multiple independent outcomes. Do not use it for simple or single-step queries that you can answer or complete immediately unless the user explicitly asks for a plan.
-
-When you create a todo list:
-- Keep it short and outcome-oriented. Use a few meaningful, logically ordered, verifiable steps rather than one item per error, file, command, or minor edit.
-- Keep at most one item in_progress. Keep the list current, mark finished work completed, and revise it when the scope or approach changes. When work completes together, update multiple statuses in one tool call rather than making bookkeeping-only calls.
-- Do not repeat the full todo list in prose after calling the tool; briefly communicate only important context or the next step.
-
-# Primary Workflows
-
-## Software Engineering Tasks
-When requested to perform tasks like fixing bugs, adding features, refactoring, or explaining code, follow this iterative approach:
-- **Plan:** Use '${ToolNames.TODO_WRITE}' for complex, ambiguous, or multi-step work when visible progress tracking adds value. Keep the plan short and outcome-oriented; skip it for simple tasks unless the user explicitly requests a plan.
-- **Implement:** Begin implementing while gathering context as needed. Use available search and editing tools strategically, adhering to project conventions (see 'Core Mandates'). Do not add features, refactor code, or make "improvements" beyond what was asked. Don't add error handling, fallbacks, or validation for scenarios that can't happen\u2014only validate at system boundaries (user input, external APIs). Don't create helpers, utilities, or abstractions for one-time operations. Three similar lines of code is better than a premature abstraction. Prefer editing existing files over creating new ones.
-- **Adapt:** Refine your approach as you discover new information or encounter obstacles. If a todo list exists, keep it current as the scope or approach changes. If an approach fails, diagnose why before switching tactics\u2014read the error, check your assumptions, and try a focused fix. Don't retry blindly, but don't abandon a viable approach after a single failure.
-- **Verify (Tests):** If applicable and feasible, verify the changes using the project's testing procedures. Identify the correct test commands and frameworks by examining 'README' files, build/package configuration (e.g., 'package.json'), or existing test execution patterns. NEVER assume standard test commands. Before reporting a task complete, verify it actually works. If you can't verify (no test exists, can't run the code), say so explicitly rather than claiming success.
-- **Verify (Standards):** When your task involves a code or system change, execute the project-specific build, linting and type-checking commands (e.g., 'tsc', 'npm run lint', 'ruff check .') that you have identified for this project (or obtained from the user). This ensures code quality and adherence to standards. Read-only or explanatory turns do not require verification.
-- **Report outcomes faithfully:** If tests fail, say so with the relevant output. If you did not run a verification step, say that rather than implying it succeeded. Never claim "all tests pass" when output shows failures, never suppress failing checks to manufacture a green result, and never characterize incomplete or broken work as done.
-
-**Key Principle:** Start with a reasonable approach based on available information, then adapt as you learn. Users prefer seeing progress quickly rather than waiting for perfect understanding.
-
-- Tool results and user messages may include <system-reminder> tags. <system-reminder> tags contain useful information and reminders. They are NOT part of the user's provided input or the tool result.
-- When you see a <persisted-output> tag in a tool result, the full output was saved to disk because it was too large. Use the read_file tool to access the complete content if the preview is insufficient.
-
-## New Applications
-
-When a user wants to create a new application, project, website, game, or library from scratch, use the '${ToolNames.SKILL}' tool with skill="new-app" to load the detailed workflow and tech-stack guidance.
-
-# Operational Guidelines
-
-## Communicating With the User
-
-Before your first tool call, briefly state what you're about to do. While working, give short updates at key moments: when you find something load-bearing (a bug, a root cause), when changing direction, or when you've made progress without an update.
-
-Final responses should be concise by default, but their shape and depth must match the request. Lead with the outcome for simple tasks. For code reviews, explanations, investigations, or substantial changes, provide enough structured detail and include code references, verification results, risks, and next steps when relevant so the user can understand and act on the result.
-
-## Tone and Style (CLI Interaction)
-- **Concise & Direct:** Adopt a professional, direct, and concise tone suitable for a CLI environment.
-- **Adaptive Detail:** Use the minimum length and structure needed for clarity. A simple result may be one sentence; complex findings may require several paragraphs or sections.
-- **Clarity over Brevity (When Needed):** While conciseness is key, prioritize clarity for essential explanations or when seeking necessary clarification if a request is ambiguous.
-- **No Chitchat:** Avoid conversational filler and chitchat. Get straight to the action or answer.
-- **Formatting:** Use GitHub-flavored Markdown. Responses will be rendered in monospace.
-- **Tools vs. Text:** Use tools for actions, text output *only* for communication. Do not add explanatory comments within tool calls or code blocks unless specifically part of the required code/command itself.
-- **Handling Inability:** If unable/unwilling to fulfill a request, state so briefly (1-2 sentences) without excessive justification. Offer alternatives if appropriate.
-
-## Security and Safety Rules
-- **Explain Critical Commands:** Before executing commands with '${ToolNames.SHELL}' that modify the file system, codebase, or system state, you *must* provide a brief explanation of the command's purpose and potential impact. Prioritize user understanding and safety. Follow the active permission policy and do not assume an interactive confirmation dialog is available.
-- **Security First:** Always apply security best practices. Never introduce code that exposes, logs, or commits secrets, API keys, or other sensitive information.
-
-## Using Your Tools
-- **Prefer Dedicated Tools:** Do NOT use the '${ToolNames.SHELL}' to run commands when a relevant dedicated tool is provided. Using dedicated tools allows the user to better understand and review your work. This is CRITICAL to assisting the user:
-  - To read files use '${ToolNames.READ_FILE}' instead of cat, head, tail, or sed
-  - To edit files use '${ToolNames.EDIT}' instead of sed or awk
-  - To create files use '${ToolNames.WRITE_FILE}' instead of cat with heredoc or echo redirection
-  - To search for files use '${ToolNames.GLOB}' instead of find or ls
-  - To search the content of files, use '${ToolNames.GREP}' instead of grep or rg
-  - Reserve using the '${ToolNames.SHELL}' exclusively for system commands and terminal operations that require shell execution. If you are unsure and there is a relevant dedicated tool, default to using the dedicated tool and only fallback on using the '${ToolNames.SHELL}' tool for these if it is absolutely necessary.
-- **Tool Fallback:** If a tool returns empty, unhelpful, or unexpected results, try an alternative tool that can accomplish the same goal before telling the user it cannot be done. Never give up after a single tool failure.
-- **Task Management:** Use '${ToolNames.TODO_WRITE}' only when explicit tracking adds value. Keep plans concise, outcome-oriented, and current; do not create a todo list for simple or single-step work unless the user explicitly requests one.
-- **Parallel Tool Calls:** You can call multiple tools in a single response. If you intend to call multiple tools and there are no dependencies between them, make all independent tool calls in parallel. Maximize use of parallel tool calls where possible to increase efficiency. However, if some tool calls depend on previous calls to inform dependent values, do NOT call these tools in parallel and instead call them sequentially. For instance, if one operation must complete before another starts, run these operations sequentially instead.
-- **File Paths:** Always use absolute paths when referring to files with tools like '${ToolNames.READ_FILE}' or '${ToolNames.WRITE_FILE}'. Relative paths are not supported. You must provide an absolute path.
-- **Background Processes:** Use background execution with \`is_background: true\` for commands that are unlikely to stop on their own, e.g. \`node server.js\`. Do not append a trailing \`&\` when using the shell tool's managed background mode. If unsure, follow the active interaction mode's question guidance.
-- **Interactive Commands:** Try to avoid shell commands that are likely to require user interaction (e.g. \`git rebase -i\`). Use non-interactive versions of commands (e.g. \`npm init -y\` instead of \`npm init\`) when available, and otherwise remind the user that interactive shell commands are not supported and may cause hangs until canceled by the user.
-- **Questions:** ${interaction.questions}
-- **Subagent Delegation:** Use the '${ToolNames.AGENT}' tool with specialized agents when the task at hand matches the agent's description. Subagents are valuable for parallelizing independent queries or for protecting the main context window from excessive results, but they should not be used excessively when not needed. Importantly, avoid duplicating work that subagents are already doing - if you delegate research to a subagent, do not also perform the same searches yourself.
-- **Codebase Search:** For simple, directed codebase searches (e.g. for a specific file/class/function) use the '${ToolNames.GREP}' or '${ToolNames.GLOB}' tools directly. For broader codebase exploration and deep research, use the '${ToolNames.AGENT}' tool with subagent_type=Explore. This is slower than using '${ToolNames.GREP}' or '${ToolNames.GLOB}' directly, so use this only when a simple, directed search proves to be insufficient or when your task will clearly require more than 3 queries.
-- **Respect Tool Decisions:** Tool permissions are enforced by the runtime. If a call is denied or canceled, respect that decision and do _not_ try the same action through another path. Retry only if the user subsequently requests that action.
-
-## Interaction Details
-- **Help Command:** The user can use '/help' to display help information.
-- **Feedback:** To report a bug or provide feedback, please use the /bug command.
+You are an agent that helps users with software engineering tasks.
+
+IMPORTANT: Assist with authorized security testing, defensive security, CTF challenges, and educational contexts. Refuse requests for destructive techniques, DoS attacks, mass targeting, supply chain compromise, or detection evasion for malicious purposes. Dual-use security tools (C2 frameworks, credential testing, exploit development) require clear authorization context: pentesting engagements, CTF competitions, security research, or defensive use cases.
+
+# Harness
+
+- Text you output outside of tool use is displayed to the user as GitHub-flavored Markdown in a terminal.
+- Tool permissions are enforced by the runtime. If a call is denied or canceled, adjust your approach and do not retry the same action through another path.
+- \`<system-reminder>\` tags in messages and tool results are injected by the harness, not the user. Treat their contents as runtime guidance.
+- Prefer the dedicated file and search tools over \`${ToolNames.SHELL}\` when one fits: use \`${ToolNames.READ_FILE}\` to read files, \`${ToolNames.WRITE_FILE}\` to create files, \`${ToolNames.EDIT}\` to modify files, \`${ToolNames.GLOB}\` to find files, and \`${ToolNames.GREP}\` to search file contents. Use \`${ToolNames.SHELL}\` for system commands and terminal operations.
+- Independent tool calls can run in parallel in one response.
+- Reference code as \`file_path:line_number\` so locations are clickable.
+
+Write code that reads like the surrounding code: match its comment density, naming, and idiom.
+
+Before modifying code, inspect the current state and preserve the user's existing or unexpected work. Do not overwrite, revert, stage, or otherwise mix unrelated changes into the requested work.
+
+For actions that are hard to reverse or outward-facing, confirm first unless durably authorized or explicitly told to proceed without asking; approval in one context doesn't extend to the next. Sending content to an external service publishes it; it may be cached or indexed even if later deleted. Before deleting or overwriting, look at the target. If what you find contradicts how it was described, or you didn't create it, surface that instead of proceeding. Report outcomes faithfully: if tests fail, say so with the output; if a step was skipped, say that; when something is done and verified, state it plainly without hedging.
+
+# Session-specific guidance
+
+- When the user invokes a listed skill, use the \`${ToolNames.SKILL}\` tool. Only use skills supplied by the runtime; do not guess names or assume a static skill list.
+
+# Context management
+
+When the conversation grows long, some or all of the current context may be summarized. The summary, along with any remaining unsummarized context, is provided in the next context window so work can continue; you don't need to wrap up early or hand off mid-task.
+
+When you have enough information to act, act. Do not re-derive facts already established in the conversation, re-litigate a decision the user has already made, or narrate options you will not pursue. If you are weighing a choice, give a recommendation, not an exhaustive survey.
 
 ${function() {
       const isSandboxExec = process2.env["SANDBOX"] === "sandbox-exec";
@@ -33335,13 +33249,11 @@ You are running in a sandbox container with limited access to files outside the
       } else {
         return `
 # Outside of Sandbox
-You are running outside of a sandbox container, directly on the user's system. For critical commands that are particularly likely to modify the user's system outside of the project directory or system temp directory, as you explain the command to the user (per the Explain Critical Commands rule above), also remind the user to consider enabling sandboxing.
+You are running outside of a sandbox container, directly on the user's system. For critical commands that are particularly likely to modify the user's system outside of the project directory or system temp directory, as you explain the command to the user, also remind the user to consider enabling sandboxing.
 `;
       }
     }()}
 
-${getActionsSection()}
-
 ${function() {
       if (isGitRepository(process2.cwd())) {
         return `
@@ -33369,13 +33281,6 @@ ${function() {
       }
       return "";
     }()}
-
-${getToolCallExamples(model || "")}
-
-# Final Reminder
-Your core function is efficient and safe assistance. Balance conciseness with the crucial need for clarity, especially regarding safety and potential system modifications. Always prioritize user control and project conventions. Never make assumptions about the contents of files; instead use '${ToolNames.READ_FILE}' to ensure you aren't making broad assumptions. Finally, you are an agent - please keep going until the user's query is completely resolved.
-
-Interaction mode reminder: ${interaction.questions}
 `.trim();
   }
   const writeSystemMdResolution = resolvePathFromEnv(
@@ -33400,21 +33305,6 @@ function buildSystemPromptSuffix(text) {
 ${trimmed2}` : "";
 }
 __name(buildSystemPromptSuffix, "buildSystemPromptSuffix");
-function getActionsSection() {
-  return `
-# Executing actions with care
-
-Carefully consider the reversibility and blast radius of actions. Generally you can freely take local, reversible actions like editing files or running tests. But for actions that are hard to reverse, affect shared systems beyond your local environment, or could otherwise be risky or destructive, obtain confirmation when the current interaction mode can receive it; otherwise stop and report the blocker. The cost of pausing to confirm is low, while the cost of an unwanted action (lost work, unintended messages sent, deleted branches) can be very high. For actions like these, consider the context, the action, and user instructions, and by default transparently communicate the action and follow the active interaction mode's question guidance before proceeding. This default can be changed by user instructions - if explicitly asked to operate more autonomously, then you may proceed without confirmation, but still attend to the risks and consequences when taking actions. A user approving an action (like a git push) once does NOT mean that they approve it in all contexts, so unless actions are authorized in advance in durable instructions like QWEN.md files, obtain confirmation only when the current interaction mode can receive it; otherwise report the blocker. Authorization stands for the scope specified, not beyond. Match the scope of your actions to what was actually requested.
-
-Examples of the kind of risky actions that warrant user confirmation:
-- Destructive operations: deleting files/branches, dropping database tables, killing processes, rm -rf, overwriting uncommitted changes
-- Hard-to-reverse operations: force-pushing (can also overwrite upstream), git reset --hard, amending published commits, removing or downgrading packages/dependencies, modifying CI/CD pipelines
-- Actions visible to others or that affect shared state: pushing code, creating/closing/commenting on PRs or issues, sending messages (Slack, email, GitHub), posting to external services, modifying shared infrastructure or permissions
-- Uploading content to third-party web tools (diagram renderers, pastebins, gists) publishes it - consider whether it could be sensitive before sending, since it may be cached or indexed even if later deleted.
-
-When you encounter an obstacle, do not use destructive actions as a shortcut to simply make it go away. For instance, try to identify root causes and fix underlying issues rather than bypassing safety checks (e.g. --no-verify). If you discover unexpected state like unfamiliar files, branches, or configuration, investigate before deleting or overwriting, as it may represent the user's in-progress work. For example, typically resolve merge conflicts rather than discarding changes; similarly, if a lock file exists, investigate what process holds it rather than deleting it. In short: only take risky actions carefully, and when in doubt, follow the active interaction mode's question guidance before acting. Follow both the spirit and letter of these instructions - measure twice, cut once.`;
-}
-__name(getActionsSection, "getActionsSection");
 function getCompressionPrompt() {
   return `
 You are the component that summarizes a conversation when its context window is about to overflow. The summary you produce will become the agent's ONLY memory of everything that happened before this point. The agent will resume its work based solely on this summary plus a small number of restored file / image attachments that follow.
@@ -33488,450 +33378,6 @@ You are a specialized context summarizer that creates a comprehensive markdown s
 `.trim();
 }
 __name(getProjectSummaryPrompt, "getProjectSummaryPrompt");
-var generalToolCallExamples = `
-# Examples (Illustrating Tone and Workflow)
-<example>
-user: 1 + 2
-model: 3
-</example>
-
-<example>
-user: is 13 a prime number?
-model: true
-</example>
-
-<example>
-user: start the server implemented in server.js
-model: [tool_call: ${ToolNames.SHELL} for 'node server.js' with is_background: true because it must run in the background]
-</example>
-
-<example>
-user: Refactor the auth logic in src/auth.py to use the requests library instead of urllib.
-model: Okay, I can refactor 'src/auth.py'.
-First, I'll analyze the code and check for a test safety net before planning any changes.
-[tool_call: ${ToolNames.GLOB} for pattern 'tests/test_auth.py']
-[tool_call: ${ToolNames.READ_FILE} for file_path '/path/to/tests/test_auth.py' with offset 0 and limit 10]
-(After analysis)
-Great, 'tests/test_auth.py' exists and covers the core authentication logic. With this safety net in place, I can safely plan the refactoring.
-I'll also confirm 'requests' is a dependency.
-[tool_call: ${ToolNames.READ_FILE} for file_path '/path/to/requirements.txt']
-(After analysis)
-Looks good, 'requests' is available.
-
-Here's the plan:
-1.  Replace the 'urllib' calls with 'requests'.
-2.  Add proper 'try...except' error handling for the new network calls.
-3.  Remove the old 'urllib' import.
-4.  Run the project's linter and tests to verify the changes.
-
-[tool_call: ${ToolNames.EDIT} for file_path '/path/to/src/auth.py' replacing old_string with new_string]
-Refactoring complete. Running verification...
-[tool_call: ${ToolNames.SHELL} for 'ruff check src/auth.py && pytest']
-(After verification passes)
-All checks passed. This is a stable checkpoint.
-Would you like me to write a commit message and commit these changes?
-</example>
-
-<example>
-user: Delete the temp directory.
-model: I can run \`rm -rf /path/to/project/temp\`. This will permanently delete the directory and all its contents.
-</example>
-
-<example>
-user: Write tests for someFile.ts
-model:
-Okay, I can write those tests. First, I'll read someFile.ts to understand its functionality.
-[tool_call: ${ToolNames.READ_FILE} for file_path '/path/to/someFile.ts']
-Now I'll look for existing or related test files to understand current testing conventions and dependencies.
-[tool_call: ${ToolNames.READ_FILE} for file_path '/path/to/existingTest.test.ts']
-(After reviewing existing tests and the file content)
-[tool_call: ${ToolNames.WRITE_FILE} for file_path '/path/to/someFile.test.ts' with content '(test code content)']
-I've written the tests. Now I'll run the project's test command to verify them.
-[tool_call: ${ToolNames.SHELL} for 'npm run test']
-(After verification passes)
-All checks passed. This is a stable checkpoint.
-</example>
-
-<example>
-user: Where are all the 'app.config' files in this project? I need to check their settings.
-model:
-[tool_call: ${ToolNames.GLOB} for pattern './**/app.config']
-(Assuming GlobTool returns a list of paths like ['/path/to/moduleA/app.config', '/path/to/moduleB/app.config'])
-I found the following 'app.config' files:
-- /path/to/moduleA/app.config
-- /path/to/moduleB/app.config
-To help you check their settings, I can read their contents. Which one would you like to start with, or should I read all of them?
-</example>
-`.trim();
-var qwenCoderToolCallExamples = `
-# Examples (Illustrating Tone and Workflow)
-<example>
-user: 1 + 2
-model: 3
-</example>
-
-<example>
-user: is 13 a prime number?
-model: true
-</example>
-
-<example>
-user: start the server implemented in server.js
-model:
-<tool_call>
-<function=${ToolNames.SHELL}>
-<parameter=command>
-node server.js
-</parameter>
-<parameter=is_background>
-true
-</parameter>
-</function>
-</tool_call>
-</example>
-
-<example>
-user: Refactor the auth logic in src/auth.py to use the requests library instead of urllib.
-model: Okay, I can refactor 'src/auth.py'.
-First, I'll analyze the code and check for a test safety net before planning any changes.
-<tool_call>
-<function=${ToolNames.GLOB}>
-<parameter=pattern>
-tests/test_auth.py
-</parameter>
-</function>
-</tool_call>
-<tool_call>
-<function=${ToolNames.READ_FILE}>
-<parameter=file_path>
-/path/to/tests/test_auth.py
-</parameter>
-<parameter=offset>
-0
-</parameter>
-<parameter=limit>
-10
-</parameter>
-</function>
-</tool_call>
-(After analysis)
-Great, 'tests/test_auth.py' exists and covers the core authentication logic. With this safety net in place, I can safely plan the refactoring.
-I'll also confirm 'requests' is a dependency.
-<tool_call>
-<function=${ToolNames.READ_FILE}>
-<parameter=file_path>
-/path/to/requirements.txt
-</parameter>
-</function>
-</tool_call>
-(After analysis)
-Looks good, 'requests' is available.
-
-Here's the plan:
-1.  Replace the 'urllib' calls with 'requests'.
-2.  Add proper 'try...except' error handling for the new network calls.
-3.  Remove the old 'urllib' import.
-4.  Run the project's linter and tests to verify the changes.
-
-<tool_call>
-<function=${ToolNames.EDIT}>
-<parameter=file_path>
-/path/to/src/auth.py
-</parameter>
-<parameter=old_string>
-(old code content)
-</parameter>
-<parameter=new_string>
-(new code content)
-</parameter>
-</function>
-</tool_call>
-Refactoring complete. Running verification...
-<tool_call>
-<function=${ToolNames.SHELL}>
-<parameter=command>
-ruff check src/auth.py && pytest
-</parameter>
-</function>
-</tool_call>
-(After verification passes)
-All checks passed. This is a stable checkpoint.
-Would you like me to write a commit message and commit these changes?
-</example>
-
-<example>
-user: Delete the temp directory.
-model: I can run \`rm -rf /path/to/project/temp\`. This will permanently delete the directory and all its contents.
-</example>
-
-<example>
-user: Write tests for someFile.ts
-model:
-Okay, I can write those tests. First, I'll read someFile.ts to understand its functionality.
-<tool_call>
-<function=${ToolNames.READ_FILE}>
-<parameter=file_path>
-/path/to/someFile.ts
-</parameter>
-</function>
-</tool_call>
-Now I'll look for existing or related test files to understand current testing conventions and dependencies.
-<tool_call>
-<function=${ToolNames.READ_FILE}>
-<parameter=file_path>
-/path/to/existingTest.test.ts
-</parameter>
-</function>
-</tool_call>
-(After reviewing existing tests and the file content)
-<tool_call>
-<function=${ToolNames.WRITE_FILE}>
-<parameter=file_path>
-/path/to/someFile.test.ts
-</parameter>
-<parameter=content>
-(test code content)
-</parameter>
-</function>
-</tool_call>
-I've written the tests. Now I'll run the project's test command to verify them.
-<tool_call>
-<function=${ToolNames.SHELL}>
-<parameter=command>
-npm run test
-</parameter>
-</function>
-</tool_call>
-(After verification passes)
-All checks passed. This is a stable checkpoint.
-</example>
-
-<example>
-user: Where are all the 'app.config' files in this project? I need to check their settings.
-model:
-<tool_call>
-<function=${ToolNames.GLOB}>
-<parameter=pattern>
-./**/app.config
-</parameter>
-</function>
-</tool_call>
-(Assuming GlobTool returns a list of paths like ['/path/to/moduleA/app.config', '/path/to/moduleB/app.config'])
-I found the following 'app.config' files:
-- /path/to/moduleA/app.config
-- /path/to/moduleB/app.config
-To help you check their settings, I can read their contents. Which one would you like to start with, or should I read all of them?
-</example>
-`.trim();
-var qwenVlToolCallExamples = `
-# Examples (Illustrating Tone and Workflow)
-<example>
-user: 1 + 2
-model: 3
-</example>
-
-<example>
-user: is 13 a prime number?
-model: true
-</example>
-
-<example>
-user: start the server implemented in server.js
-model: 
-<tool_call>
-{"name": "${ToolNames.SHELL}", "arguments": {"command": "node server.js", "is_background": true}}
-</tool_call>
-</example>
-
-<example>
-user: Refactor the auth logic in src/auth.py to use the requests library instead of urllib.
-model: Okay, I can refactor 'src/auth.py'.
-First, I'll analyze the code and check for a test safety net before planning any changes.
-<tool_call>
-{"name": "${ToolNames.GLOB}", "arguments": {"pattern": "tests/test_auth.py"}}
-</tool_call>
-<tool_call>
-{"name": "${ToolNames.READ_FILE}", "arguments": {"file_path": "/path/to/tests/test_auth.py", "offset": 0, "limit": 10}}
-</tool_call>
-(After analysis)
-Great, 'tests/test_auth.py' exists and covers the core authentication logic. With this safety net in place, I can safely plan the refactoring.
-I'll also confirm 'requests' is a dependency.
-<tool_call>
-{"name": "${ToolNames.READ_FILE}", "arguments": {"file_path": "/path/to/requirements.txt"}}
-</tool_call>
-(After analysis)
-Looks good, 'requests' is available.
-
-Here's the plan:
-1.  Replace the 'urllib' calls with 'requests'.
-2.  Add proper 'try...except' error handling for the new network calls.
-3.  Remove the old 'urllib' import.
-4.  Run the project's linter and tests to verify the changes.
-
-<tool_call>
-{"name": "${ToolNames.EDIT}", "arguments": {"file_path": "/path/to/src/auth.py", "old_string": "(old code content)", "new_string": "(new code content)"}}
-</tool_call>
-Refactoring complete. Running verification...
-<tool_call>
-{"name": "${ToolNames.SHELL}", "arguments": {"command": "ruff check src/auth.py && pytest"}}
-</tool_call>
-(After verification passes)
-All checks passed. This is a stable checkpoint.
-Would you like me to write a commit message and commit these changes?
-</example>
-
-<example>
-user: Delete the temp directory.
-model: I can run \`rm -rf /path/to/project/temp\`. This will permanently delete the directory and all its contents.
-</example>
-
-<example>
-user: Write tests for someFile.ts
-model:
-Okay, I can write those tests. First, I'll read someFile.ts to understand its functionality.
-<tool_call>
-{"name": "${ToolNames.READ_FILE}", "arguments": {"file_path": "/path/to/someFile.ts"}}
-</tool_call>
-Now I'll look for existing or related test files to understand current testing conventions and dependencies.
-<tool_call>
-{"name": "${ToolNames.READ_FILE}", "arguments": {"file_path": "/path/to/existingTest.test.ts"}}
-</tool_call>
-(After reviewing existing tests and the file content)
-<tool_call>
-{"name": "${ToolNames.WRITE_FILE}", "arguments": {"file_path": "/path/to/someFile.test.ts", "content": "(test code content)"}}
-</tool_call>
-I've written the tests. Now I'll run the project's test command to verify them.
-<tool_call>
-{"name": "${ToolNames.SHELL}", "arguments": {"command": "npm run test"}}
-</tool_call>
-(After verification passes)
-All checks passed. This is a stable checkpoint.
-</example>
-
-<example>
-user: Where are all the 'app.config' files in this project? I need to check their settings.
-model:
-<tool_call>
-{"name": "${ToolNames.GLOB}", "arguments": {"pattern": "./**/app.config"}}
-</tool_call>
-(Assuming GlobTool returns a list of paths like ['/path/to/moduleA/app.config', '/path/to/moduleB/app.config'])
-I found the following 'app.config' files:
-- /path/to/moduleA/app.config
-- /path/to/moduleB/app.config
-To help you check their settings, I can read their contents. Which one would you like to start with, or should I read all of them?
-</example>
-`.trim();
-var gemma4ToolCallExamples = `
-# Examples (Illustrating Tone and Workflow)
-<example>
-user: 1 + 2
-model: 3
-</example>
-
-<example>
-user: is 13 a prime number?
-model: true
-</example>
-
-<example>
-user: start the server implemented in server.js
-model: <|tool_call>call:${ToolNames.SHELL}{command:<|"|>node server.js<|"|>,is_background:true}<tool_call|>
-</example>
-
-<example>
-user: Refactor the auth logic in src/auth.py to use the requests library instead of urllib.
-model: Okay, I can refactor 'src/auth.py'.
-First, I'll analyze the code and check for a test safety net before planning any changes.
-<|tool_call>call:${ToolNames.GLOB}{pattern:<|"|>tests/test_auth.py<|"|>}<tool_call|>
-<|tool_call>call:${ToolNames.READ_FILE}{file_path:<|"|>/path/to/tests/test_auth.py<|"|>,offset:0,limit:10}<tool_call|>
-(After analysis)
-Great, 'tests/test_auth.py' exists and covers the core authentication logic. With this safety net in place, I can safely plan the refactoring.
-I'll also confirm 'requests' is a dependency.
-<|tool_call>call:${ToolNames.READ_FILE}{file_path:<|"|>/path/to/requirements.txt<|"|>}<tool_call|>
-(After analysis)
-Looks good, 'requests' is available.
-
-Here's the plan:
-1.  Replace the 'urllib' calls with 'requests'.
-2.  Add proper 'try...except' error handling for the new network calls.
-3.  Remove the old 'urllib' import.
-4.  Run the project's linter and tests to verify the changes.
-
-<|tool_call>call:${ToolNames.EDIT}{file_path:<|"|>/path/to/src/auth.py<|"|>,old_string:<|"|>(old code content)<|"|>,new_string:<|"|>(new code content)<|"|>}<tool_call|>
-Refactoring complete. Running verification...
-<|tool_call>call:${ToolNames.SHELL}{command:<|"|>ruff check src/auth.py && pytest<|"|>}<tool_call|>
-(After verification passes)
-All checks passed. This is a stable checkpoint.
-Would you like me to write a commit message and commit these changes?
-</example>
-
-<example>
-user: Delete the temp directory.
-model: I can run \`rm -rf /path/to/project/temp\`. This will permanently delete the directory and all its contents.
-</example>
-
-<example>
-user: Write tests for someFile.ts
-model:
-Okay, I can write those tests. First, I'll read someFile.ts to understand its functionality.
-<|tool_call>call:${ToolNames.READ_FILE}{file_path:<|"|>/path/to/someFile.ts<|"|>}<tool_call|>
-Now I'll look for existing or related test files to understand current testing conventions and dependencies.
-<|tool_call>call:${ToolNames.READ_FILE}{file_path:<|"|>/path/to/existingTest.test.ts<|"|>}<tool_call|>
-(After reviewing existing tests and the file content)
-<|tool_call>call:${ToolNames.WRITE_FILE}{file_path:<|"|>/path/to/someFile.test.ts<|"|>,content:<|"|>(test code content)<|"|>}<tool_call|>
-I've written the tests. Now I'll run the project's test command to verify them.
-<|tool_call>call:${ToolNames.SHELL}{command:<|"|>npm run test<|"|>}<tool_call|>
-(After verification passes)
-All checks passed. This is a stable checkpoint.
-</example>
-
-<example>
-user: Where are all the 'app.config' files in this project? I need to check their settings.
-model:
-<|tool_call>call:${ToolNames.GLOB}{pattern:<|"|>./**/app.config<|"|>}<tool_call|>
-(Assuming GlobTool returns a list of paths like ['/path/to/moduleA/app.config', '/path/to/moduleB/app.config'])
-I found the following 'app.config' files:
-- /path/to/moduleA/app.config
-- /path/to/moduleB/app.config
-To help you check their settings, I can read their contents. Which one would you like to start with, or should I read all of them?
-</example>
-`.trim();
-function getToolCallExamples(model) {
-  const toolCallStyle = process2.env["QWEN_CODE_TOOL_CALL_STYLE"];
-  if (toolCallStyle) {
-    switch (toolCallStyle.toLowerCase()) {
-      case "qwen-coder":
-        return qwenCoderToolCallExamples;
-      case "qwen-vl":
-        return qwenVlToolCallExamples;
-      case "gemma4":
-        return gemma4ToolCallExamples;
-      case "general":
-        return generalToolCallExamples;
-      default:
-        debugLogger10.warn(
-          `Unknown QWEN_CODE_TOOL_CALL_STYLE value: ${toolCallStyle}. Using model-based detection.`
-        );
-        break;
-    }
-  }
-  if (model && model.length < 100) {
-    if (/qwen[^-]*-coder/i.test(model)) {
-      return qwenCoderToolCallExamples;
-    }
-    if (/qwen[^-]*-vl/i.test(model)) {
-      return qwenVlToolCallExamples;
-    }
-    if (/coder-model/i.test(model)) {
-      return qwenCoderToolCallExamples;
-    }
-    if (/gemma[-_]?4/i.test(model)) {
-      return gemma4ToolCallExamples;
-    }
-  }
-  return generalToolCallExamples;
-}
-__name(getToolCallExamples, "getToolCallExamples");
 function getPlanModeSystemReminder(planOnly = false) {
   return `<system-reminder>
 Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run tools classified as state-modifying (including changing configs or making commits), or otherwise make changes to the system. A shell command whose safety cannot be determined may run only after the user explicitly approves that exact invocation once, and only when it is necessary for the investigation. This supersedes any other instructions you have received (for example, to make edits).
@@ -33983,6 +33429,12 @@ Your plan is ready when you have addressed all ambiguities and it covers: what t
 </system-reminder>`;
 }
 __name(getPlanModeSystemReminder, "getPlanModeSystemReminder");
+function getManualPlanExitSystemReminder(currentMode) {
+  return `<system-reminder>
+The user has manually switched out of plan mode (current approval mode: ${currentMode}). You are no longer in plan mode. Do NOT call ${ToolNames.EXIT_PLAN_MODE} \u2014 there is no plan approval pending. Continue working in the current mode; previous plan-mode restrictions on edits and state-modifying tools no longer apply.
+</system-reminder>`;
+}
+__name(getManualPlanExitSystemReminder, "getManualPlanExitSystemReminder");
 function getArenaSystemReminder(configFilePath2) {
   return `<system-reminder>An Arena session is active. For details, read: ${configFilePath2}. This message is for internal use only. Do not mention this to user in your response.</system-reminder>`;
 }
@@ -47204,7 +46656,6 @@ var GeminiChat = class {
       this.setHistory(newHistory);
       debugLogger22.debug("[FILE_READ_CACHE] clear after auto tryCompress");
       this.config.getFileReadCache().clear();
-      clearDetailedSpanState();
       this.lastPromptTokenCount = info.newTokenCount;
       this.lastOutputTokenCount = 0;
       this.telemetryService?.setLastPromptTokenCount(info.newTokenCount);
@@ -47275,7 +46726,6 @@ var GeminiChat = class {
       })
     );
     this.setHistory(newHistory);
-    clearDetailedSpanState();
     this.lastPromptTokenCount = adjustedTokenCount;
     this.telemetryService?.setLastPromptTokenCount(adjustedTokenCount);
     this.consecutiveFailures = 0;
@@ -49989,7 +49439,7 @@ __name(computeCharContribution, "computeCharContribution");
 init_esbuild_shims();
 import * as fs89 from "node:fs/promises";
 import * as path93 from "node:path";
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 
 // packages/core/src/memory/store.ts
 init_esbuild_shims();
@@ -50123,13 +49573,13 @@ init_esbuild_shims();
 
 // packages/core/src/tools/agent/agent.ts
 init_esbuild_shims();
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 import * as path90 from "node:path";
 import * as fs84 from "node:fs/promises";
 
 // packages/core/src/agents/runtime/agent-core.ts
 init_esbuild_shims();
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 
 // packages/core/src/core/coreToolScheduler.ts
 init_esbuild_shims();
@@ -55797,12 +55247,12 @@ async function initParser() {
   initPromise = (async () => {
     const { default: ParserClass } = await import("./tree-sitter-YJVE2ZUK.js");
     const treeSitterWasm = await loadWasmBinary(
-      () => import("./tree-sitter-4D7QS7F6.js"),
+      () => import("./tree-sitter-FS4VPMZA.js"),
       "web-tree-sitter/tree-sitter.wasm"
     );
     await ParserClass.init({ wasmBinary: treeSitterWasm });
     const bashWasm = await loadWasmBinary(
-      () => import("./tree-sitter-bash-VEJGF5XF.js"),
+      () => import("./tree-sitter-bash-6B46JJCV.js"),
       "tree-sitter-wasms/out/tree-sitter-bash.wasm"
     );
     bashLanguage = await ParserClass.Language.load(bashWasm);
@@ -96399,6 +95849,10 @@ function truncateCommandForModel(command) {
 }
 __name(truncateCommandForModel, "truncateCommandForModel");
 var MAX_RETAINED_TERMINAL_SHELLS = 32;
+function statusFilePathFor(outputFile) {
+  return outputFile.endsWith(".output") ? `${outputFile.slice(0, -".output".length)}.status` : `${outputFile}.status`;
+}
+__name(statusFilePathFor, "statusFilePathFor");
 var BackgroundShellRegistry = class {
   static {
     __name(this, "BackgroundShellRegistry");
@@ -96437,6 +95891,7 @@ var BackgroundShellRegistry = class {
     entry.outputOffset = 0;
     entry.notified = false;
     this.entries.set(entry.shellId, entry);
+    this.writeStatusFile(entry);
     this.fireRegister(entry);
     this.fireStatusChange(entry);
     return entry;
@@ -96459,6 +95914,7 @@ var BackgroundShellRegistry = class {
     entry.status = "completed";
     entry.exitCode = exitCode;
     entry.endTime = endTime;
+    this.writeStatusFile(entry);
     this.emitNotification(entry);
     this.pruneTerminalEntries();
     this.fireStatusChange(entry);
@@ -96469,6 +95925,7 @@ var BackgroundShellRegistry = class {
     entry.status = "failed";
     entry.error = error;
     entry.endTime = endTime;
+    this.writeStatusFile(entry);
     this.emitNotification(entry);
     this.pruneTerminalEntries();
     this.fireStatusChange(entry);
@@ -96495,6 +95952,7 @@ var BackgroundShellRegistry = class {
   settleAsCancelled(entry, endTime) {
     entry.status = "cancelled";
     entry.endTime = endTime;
+    this.writeStatusFile(entry);
     entry.abortController.abort();
   }
   /**
@@ -96516,6 +95974,49 @@ var BackgroundShellRegistry = class {
       }
     }
   }
+  /**
+   * Mirrors the entry into a machine-readable JSON sidecar next to the
+   * output file (see {@link statusFilePathFor}) so the model can check
+   * whether a background shell is still alive instead of inferring
+   * liveness from the output file — which block-buffering children keep
+   * empty for their whole run (#7626). Timestamps are ISO strings for
+   * model readability; `pid` is included so a `running` sidecar left
+   * behind by a hard-killed CLI can still be cross-checked.
+   *
+   * Fire-and-forget: a write failure (disk full, permission change)
+   * must not poison the registry or the spawn path — mirror of the
+   * output-stream error handling in shell.ts. Temp-file + rename keeps
+   * readers from ever seeing a half-written JSON document.
+   */
+  writeStatusFile(entry) {
+    const statusPath = statusFilePathFor(entry.outputFile);
+    const payload = {
+      id: entry.id,
+      status: entry.status,
+      command: entry.command,
+      cwd: entry.cwd,
+      startTime: new Date(entry.startTime).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (entry.pid !== void 0) payload["pid"] = entry.pid;
+    if (entry.endTime !== void 0) {
+      payload["endTime"] = new Date(entry.endTime).toISOString();
+    }
+    if (entry.exitCode !== void 0) payload["exitCode"] = entry.exitCode;
+    if (entry.error !== void 0) payload["error"] = entry.error;
+    try {
+      atomicWriteFileSync(statusPath, JSON.stringify(payload, null, 2), {
+        flush: false,
+        mode: 384,
+        forceMode: true,
+        noFollow: true
+      });
+    } catch (error) {
+      debugLogger58.warn(
+        `status sidecar write failed for shell ${entry.shellId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   fireRegister(entry) {
     if (!this.registerCallback) return;
     try {
@@ -115775,6 +115276,21 @@ var ExtensionStore = class {
     const legacy = await this.readLegacyProjection();
     if (existing) {
       let changed = false;
+      const loadedIds = new Set(extensions.map((identity) => identity.id));
+      for (const identity of extensions) {
+        assertIdentity(identity);
+        if (existing.extensions[identity.id]) continue;
+        const staleEntry = Object.entries(existing.extensions).find(
+          ([id, policy]) => !loadedIds.has(id) && policy.name.toLowerCase() === identity.name.toLowerCase()
+        );
+        if (staleEntry) {
+          const [staleId, policy] = staleEntry;
+          delete existing.extensions[staleId];
+          policy.name = identity.name;
+          existing.extensions[identity.id] = policy;
+          changed = true;
+        }
+      }
       if (existing.legacyProjectionHash !== projectionHash(legacy)) {
         if (!await this.legacyProjectionIsNewerThanState()) {
           try {
@@ -118437,6 +117953,9 @@ function getExtensionId(config, installMetadata) {
   } else {
     idValue = installMetadata?.source ?? config.name;
   }
+  if (installMetadata?.pluginName) {
+    idValue += `:${installMetadata.pluginName}`;
+  }
   return hashValue(idValue);
 }
 __name(getExtensionId, "getExtensionId");
@@ -133068,10 +132587,147 @@ async function watchRepoBranch(cwd, onChange) {
 }
 __name(watchRepoBranch, "watchRepoBranch");
 
+// packages/core/src/utils/github-prs.ts
+init_esbuild_shims();
+import { execFile as execFile8 } from "node:child_process";
+var GH_TIMEOUT_MS = 1e4;
+var GH_MAX_BUFFER = 16 * 1024 * 1024;
+var GH_ERROR_RAW_MAX = 4096;
+var GITHUB_PR_ERROR_MESSAGE_MAX = 512;
+var GITHUB_PR_LIST_LIMIT = 30;
+var GH_PR_LIST_FIELDS = "number,title,url,author,headRefName,isDraft,reviewDecision,statusCheckRollup,updatedAt";
+var FAILING_CHECK_RUN_CONCLUSIONS = /* @__PURE__ */ new Set([
+  "FAILURE",
+  "CANCELLED",
+  "TIMED_OUT",
+  "ACTION_REQUIRED",
+  "STARTUP_FAILURE",
+  "STALE"
+]);
+var FAILING_STATUS_CONTEXT_STATES = /* @__PURE__ */ new Set(["ERROR", "FAILURE"]);
+function aggregateChecks(rollup) {
+  if (!Array.isArray(rollup) || rollup.length === 0) return "none";
+  let sawPassing = false;
+  let sawPending = false;
+  for (const entry of rollup) {
+    if (entry.__typename === "StatusContext") {
+      const state = entry.state?.toUpperCase();
+      if (state && FAILING_STATUS_CONTEXT_STATES.has(state)) return "failing";
+      if (state === "SUCCESS") sawPassing = true;
+      else sawPending = true;
+    } else {
+      const conclusion = entry.conclusion?.toUpperCase();
+      if (conclusion) {
+        if (FAILING_CHECK_RUN_CONCLUSIONS.has(conclusion)) return "failing";
+        sawPassing = true;
+      } else {
+        sawPending = true;
+      }
+    }
+  }
+  if (sawPending) return "pending";
+  return sawPassing ? "passing" : "none";
+}
+__name(aggregateChecks, "aggregateChecks");
+function mapReviewDecision(value) {
+  switch (value) {
+    case "APPROVED":
+      return "approved";
+    case "CHANGES_REQUESTED":
+      return "changes_requested";
+    case "REVIEW_REQUIRED":
+      return "review_required";
+    default:
+      return null;
+  }
+}
+__name(mapReviewDecision, "mapReviewDecision");
+function mapEntry(entry) {
+  if (typeof entry.number !== "number") return null;
+  const parsed = Date.parse(entry.updatedAt ?? "");
+  return {
+    number: entry.number,
+    title: entry.title ?? "",
+    url: entry.url ?? "",
+    author: entry.author?.login ?? "",
+    headRefName: entry.headRefName ?? "",
+    state: entry.isDraft ? "draft" : "open",
+    reviewDecision: mapReviewDecision(entry.reviewDecision),
+    checks: aggregateChecks(entry.statusCheckRollup),
+    updatedAt: Number.isNaN(parsed) ? 0 : Math.floor(parsed / 1e3)
+  };
+}
+__name(mapEntry, "mapEntry");
+function parseGhPrList(stdout) {
+  const parsed = JSON.parse(stdout);
+  if (!Array.isArray(parsed)) {
+    throw new Error("unexpected gh output: expected a JSON array");
+  }
+  return parsed.map((entry) => mapEntry(entry)).filter((entry) => entry !== null).sort((a, b3) => b3.updatedAt - a.updatedAt);
+}
+__name(parseGhPrList, "parseGhPrList");
+function runGhPrList(gitRoot) {
+  return new Promise((resolve39, reject) => {
+    execFile8(
+      "gh",
+      [
+        "pr",
+        "list",
+        "--state",
+        "open",
+        "--limit",
+        String(GITHUB_PR_LIST_LIMIT),
+        "--json",
+        GH_PR_LIST_FIELDS
+      ],
+      {
+        cwd: gitRoot,
+        timeout: GH_TIMEOUT_MS,
+        maxBuffer: GH_MAX_BUFFER,
+        windowsHide: true,
+        encoding: "utf8"
+      },
+      (error, stdout) => {
+        if (error) reject(error);
+        else resolve39(stdout);
+      }
+    );
+  });
+}
+__name(runGhPrList, "runGhPrList");
+function ghErrorMessage(error) {
+  if (error?.killed === true) {
+    return `gh pr list timed out after ${GH_TIMEOUT_MS / 1e3}s`;
+  }
+  const stderr = error?.stderr;
+  const raw = typeof stderr === "string" && stderr.trim() ? stderr : error instanceof Error ? error.message : String(error);
+  return raw.replace(/\s+/g, " ").trim().slice(0, GH_ERROR_RAW_MAX);
+}
+__name(ghErrorMessage, "ghErrorMessage");
+async function fetchGitHubPullRequests(cwd) {
+  const gitRoot = findGitRoot(cwd);
+  if (!gitRoot) return { kind: "not_a_repo" };
+  let stdout;
+  try {
+    stdout = await runGhPrList(gitRoot);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { kind: "cli_unavailable" };
+    }
+    return { kind: "failed", message: ghErrorMessage(error), gitRoot };
+  }
+  try {
+    return { kind: "ok", pullRequests: parseGhPrList(stdout) };
+  } catch (error) {
+    return { kind: "failed", message: ghErrorMessage(error), gitRoot };
+  }
+}
+__name(fetchGitHubPullRequests, "fetchGitHubPullRequests");
+
 // packages/core/src/utils/memoryDiagnostics.ts
 init_esbuild_shims();
 import { readdir as readdir13, readFile as readFile22 } from "node:fs/promises";
-import { execFile as execFile8 } from "node:child_process";
+import { execFile as execFile9 } from "node:child_process";
 import process6 from "node:process";
 import { promisify as promisify5 } from "node:util";
 import v8 from "node:v8";
@@ -133082,7 +132738,7 @@ var ACTIVE_HANDLES_THRESHOLD = 256;
 var ACTIVE_REQUESTS_THRESHOLD = 100;
 var OPEN_FD_THRESHOLD = 500;
 var debugLogger105 = createDebugLogger("MEMORY_DIAGNOSTICS");
-var execFileAsync5 = promisify5(execFile8);
+var execFileAsync5 = promisify5(execFile9);
 async function collectMemoryDiagnostics(options2 = {}) {
   const now = options2.now ?? (() => /* @__PURE__ */ new Date());
   const platform3 = options2.platform ?? process6.platform;
@@ -142593,6 +142249,687 @@ function createGoalVerifier(config, options2 = {}) {
 }
 __name(createGoalVerifier, "createGoalVerifier");
 
+// packages/core/src/goals/goal-runtime.ts
+init_esbuild_shims();
+import { randomUUID as randomUUID13 } from "node:crypto";
+function createGoalRuntime(options2) {
+  if (Boolean(options2.evidenceSource) !== Boolean(options2.verifier)) {
+    throw new Error(
+      "Goal evidence source and verifier must be configured together"
+    );
+  }
+  let snapshot = {
+    v: GOAL_STATE_VERSION,
+    goal: null,
+    activity: "idle"
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  let dispatchTail = Promise.resolve();
+  let host;
+  let currentPermit;
+  let currentPermitHost;
+  let currentTurnKey;
+  let queuedTurnKey;
+  let continuationQueued = false;
+  let currentProposal;
+  let pendingProposal;
+  let verificationAttempt;
+  let blockedAudit;
+  let nextVerifierFeedback;
+  let currentTurnFeedback;
+  let restored = false;
+  let disposed = false;
+  let recoveryError;
+  const assertAvailable = /* @__PURE__ */ __name(() => {
+    if (disposed) throw new Error("Goal runtime has been disposed");
+  }, "assertAvailable");
+  const assertOperational = /* @__PURE__ */ __name(() => {
+    assertAvailable();
+    if (recoveryError) throw recoveryError;
+  }, "assertOperational");
+  const getSnapshot = /* @__PURE__ */ __name(() => structuredClone(snapshot), "getSnapshot");
+  const broadcast = /* @__PURE__ */ __name((cause) => {
+    for (const listener of listeners) {
+      try {
+        listener(getSnapshot(), cause);
+      } catch {
+      }
+    }
+  }, "broadcast");
+  const preemptHost = /* @__PURE__ */ __name((reason, target = host) => {
+    try {
+      target?.preemptGoalTurn(reason);
+    } catch {
+    }
+  }, "preemptHost");
+  const flushContinuation = /* @__PURE__ */ __name((cause) => {
+    if (!continuationQueued || !host || currentPermit || pendingProposal || verificationAttempt || snapshot.activity !== "idle" || snapshot.goal?.status !== "active") {
+      return;
+    }
+    continuationQueued = false;
+    const scheduledHost = host;
+    const continuationContext = snapshot.goal.objective;
+    const verifierFeedback = nextVerifierFeedback;
+    nextVerifierFeedback = void 0;
+    currentTurnFeedback = verifierFeedback;
+    currentPermit = {
+      goalId: snapshot.goal.goalId,
+      revision: snapshot.goal.revision,
+      turnId: randomUUID13()
+    };
+    currentPermitHost = scheduledHost;
+    currentTurnKey = `goal-runtime:${currentPermit.turnId}`;
+    const startedPermit = structuredClone(currentPermit);
+    snapshot = { ...snapshot, activity: "running" };
+    broadcast(cause);
+    const handleStartFailure = /* @__PURE__ */ __name(() => {
+      void enqueue(async () => {
+        if (isCurrentPermit(startedPermit)) {
+          const nextTurnKey = queuedTurnKey;
+          currentPermit = void 0;
+          currentPermitHost = void 0;
+          currentTurnKey = void 0;
+          currentProposal = void 0;
+          if (currentTurnFeedback !== void 0) {
+            nextVerifierFeedback ??= currentTurnFeedback;
+          }
+          currentTurnFeedback = void 0;
+          if (host === scheduledHost) host = void 0;
+          if (nextTurnKey && snapshot.goal?.status === "active") {
+            currentPermit = {
+              goalId: snapshot.goal.goalId,
+              revision: snapshot.goal.revision,
+              turnId: randomUUID13()
+            };
+            currentPermitHost = host;
+            currentTurnKey = nextTurnKey;
+            currentTurnFeedback = nextVerifierFeedback;
+            nextVerifierFeedback = void 0;
+            queuedTurnKey = void 0;
+            continuationQueued = false;
+            snapshot = { ...snapshot, activity: "running" };
+          } else {
+            snapshot = { ...snapshot, activity: "idle" };
+          }
+          broadcast();
+          if (!currentPermit) queueContinuation();
+        }
+      }).catch(() => void 0);
+    }, "handleStartFailure");
+    let started;
+    try {
+      started = scheduledHost.startGoalTurn({
+        permit: startedPermit,
+        continuationContext,
+        ...verifierFeedback ? { verifierFeedback } : {}
+      });
+    } catch {
+      handleStartFailure();
+      return;
+    }
+    void started.catch(handleStartFailure);
+  }, "flushContinuation");
+  const queueContinuation = /* @__PURE__ */ __name((cause) => {
+    if (snapshot.goal?.status !== "active" || currentPermit || pendingProposal || verificationAttempt) {
+      return;
+    }
+    continuationQueued = true;
+    flushContinuation(cause);
+  }, "queueContinuation");
+  const enqueue = /* @__PURE__ */ __name((operation) => {
+    const result = dispatchTail.then(operation, operation);
+    dispatchTail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }, "enqueue");
+  const isCurrentPermit = /* @__PURE__ */ __name((permit) => snapshot.goal?.goalId === permit.goalId && snapshot.goal.revision === permit.revision && currentPermit?.goalId === permit.goalId && currentPermit.revision === permit.revision && currentPermit.turnId === permit.turnId, "isCurrentPermit");
+  const isCurrentVerificationAttempt = /* @__PURE__ */ __name((attempt) => verificationAttempt === attempt && snapshot.goal?.goalId === attempt.permit.goalId && snapshot.goal.revision === attempt.permit.revision && snapshot.goal.status === "active" && snapshot.activity === "verifying", "isCurrentVerificationAttempt");
+  const invalidateVerification = /* @__PURE__ */ __name((reason) => {
+    const attempt = verificationAttempt;
+    verificationAttempt = void 0;
+    pendingProposal = void 0;
+    if (attempt && !attempt.controller.signal.aborted) {
+      attempt.controller.abort(new Error(reason));
+    }
+  }, "invalidateVerification");
+  const verifierInput = /* @__PURE__ */ __name((attempt, evidence) => {
+    const currentDeliveredOutput = evidence.citedRecords.filter(
+      (record2) => record2.proofKind === "delivered_output" && record2.turnId === attempt.permit.turnId
+    ).map((record2) => record2.content);
+    const base = {
+      goal: {
+        goalId: attempt.goal.goalId,
+        revision: attempt.goal.revision,
+        objective: attempt.goal.objective
+      },
+      evidence: evidence.citedRecords,
+      ...currentDeliveredOutput.length > 0 ? { currentDeliveredOutput } : {}
+    };
+    if (attempt.proposal.status === "complete") {
+      return {
+        ...base,
+        proposal: { ...attempt.proposal, status: "complete" }
+      };
+    }
+    return {
+      ...base,
+      proposal: { ...attempt.proposal, status: "blocked" },
+      blockedPolicy: "A blocked Goal is resumable. It may be accepted immediately only when the evidence shows that new user authority or a material user choice is required, or that an external state change is required, and no meaningful in-scope work remains. An ordinary technical blocker requires evidence of the same cause from the current and two immediately preceding Goal turns. Difficulty, uncertainty, incomplete work, or a preference for clarification do not by themselves justify blocked."
+    };
+  }, "verifierInput");
+  const promoteQueuedUserTurn = /* @__PURE__ */ __name(() => {
+    const nextTurnKey = queuedTurnKey;
+    if (!nextTurnKey || currentPermit || snapshot.goal?.status !== "active") {
+      return false;
+    }
+    queuedTurnKey = void 0;
+    continuationQueued = false;
+    currentPermit = {
+      goalId: snapshot.goal.goalId,
+      revision: snapshot.goal.revision,
+      turnId: randomUUID13()
+    };
+    currentPermitHost = host;
+    currentTurnKey = nextTurnKey;
+    currentTurnFeedback = nextVerifierFeedback;
+    nextVerifierFeedback = void 0;
+    snapshot = { ...snapshot, activity: "running" };
+    return true;
+  }, "promoteQueuedUserTurn");
+  const admitAfterRejection = /* @__PURE__ */ __name(() => {
+    continuationQueued = false;
+    if (promoteQueuedUserTurn()) return false;
+    const activityBefore = snapshot.activity;
+    queueContinuation("verifier_reject");
+    return activityBefore !== snapshot.activity;
+  }, "admitAfterRejection");
+  const recordVerificationOutcome = /* @__PURE__ */ __name(async (attempt, outcome) => {
+    await enqueue(async () => {
+      if (!isCurrentVerificationAttempt(attempt) || !snapshot.goal) return;
+      const now = Date.now();
+      if (outcome.kind === "decision" && outcome.result.decision === "accept") {
+        const acceptedGoal = {
+          ...snapshot.goal,
+          activeTimeMs: elapsedActiveTime(snapshot.goal, now),
+          updatedAt: now,
+          lastReason: outcome.result.reason
+        };
+        const acceptedSnapshot = {
+          v: GOAL_STATE_VERSION,
+          goal: acceptedGoal,
+          activity: "idle"
+        };
+        const terminalSnapshot = {
+          v: GOAL_STATE_VERSION,
+          goal: {
+            ...acceptedGoal,
+            status: attempt.proposal.status
+          },
+          activity: "idle"
+        };
+        await options2.journal.recordGoalState(randomUUID13(), {
+          v: GOAL_STATE_VERSION,
+          cause: "verifier_accept",
+          snapshot: acceptedSnapshot
+        });
+        if (!isCurrentVerificationAttempt(attempt) || !snapshot.goal) return;
+        await options2.journal.recordGoalState(randomUUID13(), {
+          v: GOAL_STATE_VERSION,
+          cause: attempt.proposal.status,
+          snapshot: terminalSnapshot
+        });
+        if (!isCurrentVerificationAttempt(attempt) || !snapshot.goal) return;
+        verificationAttempt = void 0;
+        pendingProposal = void 0;
+        if (attempt.proposal.status === "complete") queuedTurnKey = void 0;
+        continuationQueued = false;
+        nextVerifierFeedback = void 0;
+        currentTurnFeedback = void 0;
+        snapshot = structuredClone(terminalSnapshot);
+        broadcast(attempt.proposal.status);
+        return;
+      }
+      if (outcome.kind === "usage_limited") {
+        const limitedSnapshot = {
+          v: GOAL_STATE_VERSION,
+          goal: {
+            ...snapshot.goal,
+            status: "usage_limited",
+            activeTimeMs: elapsedActiveTime(snapshot.goal, now),
+            updatedAt: now,
+            lastReason: outcome.reason
+          },
+          activity: "idle"
+        };
+        await options2.journal.recordGoalState(randomUUID13(), {
+          v: GOAL_STATE_VERSION,
+          cause: "usage_limited",
+          snapshot: limitedSnapshot
+        });
+        if (!isCurrentVerificationAttempt(attempt) || !snapshot.goal) return;
+        verificationAttempt = void 0;
+        pendingProposal = void 0;
+        continuationQueued = false;
+        nextVerifierFeedback = void 0;
+        currentTurnFeedback = void 0;
+        snapshot = structuredClone(limitedSnapshot);
+        broadcast("usage_limited");
+        return;
+      }
+      const rejectedSnapshot = {
+        v: GOAL_STATE_VERSION,
+        goal: {
+          ...snapshot.goal,
+          activeTimeMs: elapsedActiveTime(snapshot.goal, now),
+          updatedAt: now,
+          lastReason: outcome.result.reason
+        },
+        activity: "idle"
+      };
+      await options2.journal.recordGoalState(randomUUID13(), {
+        v: GOAL_STATE_VERSION,
+        cause: "verifier_reject",
+        snapshot: rejectedSnapshot,
+        ...blockedAudit ? { blockedAudit: structuredClone(blockedAudit) } : {}
+      });
+      if (!isCurrentVerificationAttempt(attempt) || !snapshot.goal) return;
+      verificationAttempt = void 0;
+      pendingProposal = void 0;
+      snapshot = structuredClone(rejectedSnapshot);
+      nextVerifierFeedback = outcome.result.reason;
+      const continuationBroadcast = admitAfterRejection();
+      if (!continuationBroadcast) broadcast("verifier_reject");
+    });
+  }, "recordVerificationOutcome");
+  const runVerification = /* @__PURE__ */ __name(async (attempt) => {
+    const evidenceSource = options2.evidenceSource;
+    const verifier = options2.verifier;
+    if (!evidenceSource || !verifier) return;
+    let outcome;
+    try {
+      await evidenceSource.flush();
+      if (attempt.controller.signal.aborted) return;
+      const records = await evidenceSource.readActiveTranscriptChain();
+      if (attempt.controller.signal.aborted) return;
+      const evidence = validateGoalEvidenceReferences({
+        records,
+        goal: attempt.goal,
+        permit: attempt.permit,
+        proposal: attempt.proposal
+      });
+      const result = await verifier(
+        verifierInput(attempt, evidence),
+        attempt.controller.signal
+      );
+      if (attempt.controller.signal.aborted) return;
+      outcome = { kind: "decision", result };
+    } catch (error) {
+      if (attempt.controller.signal.aborted) return;
+      if (error instanceof InvalidGoalEvidenceReferenceError) {
+        outcome = {
+          kind: "decision",
+          result: { decision: "reject", reason: error.message }
+        };
+      } else {
+        const reason = error instanceof EvidenceSourceUnavailableError ? error.message : error instanceof Error ? error.message : String(error);
+        outcome = { kind: "usage_limited", reason };
+      }
+    }
+    await recordVerificationOutcome(attempt, outcome);
+  }, "runVerification");
+  return {
+    getSnapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    restore(records) {
+      return enqueue(async () => {
+        assertAvailable();
+        if (restored) return;
+        const recovery = recoverGoalFromRecords(records);
+        if (recovery.kind === "unsupported") {
+          recoveryError = new Error(recovery.reason);
+          throw recoveryError;
+        }
+        try {
+          let recoveredSnapshot;
+          let recoveredCause;
+          if (recovery.kind === "v2") {
+            recoveredSnapshot = {
+              ...structuredClone(recovery.payload.snapshot),
+              activity: "idle"
+            };
+            blockedAudit = recovery.payload.blockedAudit ? structuredClone(recovery.payload.blockedAudit) : void 0;
+            recoveredCause = recovery.payload.cause;
+          } else if (recovery.kind === "legacy") {
+            const recordUuid = randomUUID13();
+            const payload = createMigratedGoalState({
+              objective: recovery.objective,
+              goalId: randomUUID13(),
+              recordUuid,
+              now: Date.now()
+            });
+            await options2.journal.recordGoalState(recordUuid, payload);
+            assertAvailable();
+            recoveredSnapshot = structuredClone(payload.snapshot);
+            recoveredCause = payload.cause;
+          }
+          if (recoveredSnapshot) snapshot = recoveredSnapshot;
+          recoveryError = void 0;
+          restored = true;
+          if (recoveredSnapshot) broadcast(recoveredCause);
+          queueContinuation();
+        } catch (error) {
+          if (!disposed) {
+            recoveryError = error instanceof Error ? error : new Error(String(error));
+          }
+          throw error;
+        }
+      });
+    },
+    bindHost(nextHost) {
+      assertOperational();
+      host = nextHost;
+      queueContinuation();
+      return () => {
+        if (host === nextHost) host = void 0;
+      };
+    },
+    beginTurn(turnKey) {
+      assertOperational();
+      if (snapshot.goal?.status !== "active") return void 0;
+      if (snapshot.activity === "verifying" || pendingProposal || verificationAttempt) {
+        queuedTurnKey ??= turnKey;
+        continuationQueued = false;
+        return void 0;
+      }
+      if (currentPermit) {
+        if (currentTurnKey === turnKey) return structuredClone(currentPermit);
+        queuedTurnKey ??= turnKey;
+        continuationQueued = false;
+        return void 0;
+      }
+      continuationQueued = false;
+      currentPermit = {
+        goalId: snapshot.goal.goalId,
+        revision: snapshot.goal.revision,
+        turnId: randomUUID13()
+      };
+      currentPermitHost = host;
+      currentTurnKey = turnKey;
+      currentTurnFeedback = nextVerifierFeedback;
+      nextVerifierFeedback = void 0;
+      snapshot = { ...snapshot, activity: "running" };
+      broadcast();
+      return structuredClone(currentPermit);
+    },
+    releaseTurn(turnKey) {
+      return enqueue(async () => {
+        assertOperational();
+        let released = false;
+        if (queuedTurnKey === turnKey) {
+          queuedTurnKey = void 0;
+          released = true;
+        }
+        if (currentPermit && currentTurnKey === turnKey) {
+          if (currentTurnFeedback !== void 0) {
+            nextVerifierFeedback ??= currentTurnFeedback;
+          }
+          currentPermit = void 0;
+          currentPermitHost = void 0;
+          currentTurnKey = void 0;
+          currentTurnFeedback = void 0;
+          currentProposal = void 0;
+          snapshot = { ...snapshot, activity: "idle" };
+          broadcast();
+          released = true;
+        }
+        if (released) queueContinuation();
+        return released;
+      });
+    },
+    permitForTurn(turnKey) {
+      assertOperational();
+      return currentPermit && currentTurnKey === turnKey ? structuredClone(currentPermit) : void 0;
+    },
+    getVerifierFeedback(permit) {
+      assertOperational();
+      if (!isCurrentPermit(permit)) {
+        throw new Error("Goal turn permit is no longer valid");
+      }
+      return currentTurnFeedback;
+    },
+    finishTurn(permit) {
+      const finish = enqueue(
+        async () => {
+          assertOperational();
+          if (!isCurrentPermit(permit) || !snapshot.goal) {
+            throw new Error("Goal turn permit is no longer valid");
+          }
+          const recordUuid = randomUUID13();
+          const nextGoal = reduceGoalTurnFinished(snapshot.goal, {
+            now: Date.now()
+          });
+          const persistedSnapshot = {
+            v: GOAL_STATE_VERSION,
+            goal: nextGoal,
+            activity: "idle"
+          };
+          const persistedBlockedAudit = currentProposal?.blockedAuditCandidate;
+          await options2.journal.recordGoalState(recordUuid, {
+            v: GOAL_STATE_VERSION,
+            cause: "turn_finished",
+            snapshot: persistedSnapshot,
+            ...persistedBlockedAudit ? { blockedAudit: structuredClone(persistedBlockedAudit) } : {}
+          });
+          assertAvailable();
+          const nextTurnKey = queuedTurnKey;
+          const proposal = currentProposal;
+          const activeProposal = proposal && persistedSnapshot.goal?.status === "active" ? proposal : void 0;
+          if (activeProposal?.blockedAuditCandidate) {
+            blockedAudit = activeProposal.blockedAuditCandidate;
+          } else if (persistedSnapshot.goal?.status === "active") {
+            blockedAudit = void 0;
+          }
+          pendingProposal = activeProposal?.readyForVerification && !options2.verifier ? {
+            permit: structuredClone(permit),
+            proposal: structuredClone(activeProposal.proposal)
+          } : void 0;
+          verificationAttempt = activeProposal?.readyForVerification && options2.verifier ? {
+            permit: structuredClone(permit),
+            proposal: structuredClone(activeProposal.proposal),
+            goal: structuredClone(nextGoal),
+            controller: new AbortController()
+          } : void 0;
+          const verifying = Boolean(pendingProposal || verificationAttempt);
+          snapshot = {
+            ...structuredClone(persistedSnapshot),
+            activity: verifying ? "verifying" : "idle"
+          };
+          currentPermit = void 0;
+          currentPermitHost = void 0;
+          currentTurnKey = void 0;
+          currentTurnFeedback = void 0;
+          queuedTurnKey = verifying ? nextTurnKey : void 0;
+          continuationQueued = false;
+          currentProposal = void 0;
+          if (!verifying && nextTurnKey && snapshot.goal?.status === "active") {
+            currentPermit = {
+              goalId: snapshot.goal.goalId,
+              revision: snapshot.goal.revision,
+              turnId: randomUUID13()
+            };
+            currentPermitHost = host;
+            currentTurnKey = nextTurnKey;
+            currentTurnFeedback = nextVerifierFeedback;
+            nextVerifierFeedback = void 0;
+            snapshot = { ...snapshot, activity: "running" };
+          }
+          broadcast("turn_finished");
+          if (!verifying && !currentPermit) {
+            queueContinuation();
+          }
+          return verificationAttempt;
+        }
+      );
+      return finish.then(async (attempt) => {
+        if (attempt) await runVerification(attempt);
+      });
+    },
+    async getGoalForWorker(permit) {
+      assertOperational();
+      if (!isCurrentPermit(permit) || !snapshot.goal) {
+        throw new Error("Goal turn permit is no longer valid");
+      }
+      const goal = structuredClone(snapshot.goal);
+      const verifierFeedback = currentTurnFeedback;
+      const evidenceSource = options2.evidenceSource;
+      if (!evidenceSource) {
+        return {
+          goalId: goal.goalId,
+          revision: goal.revision,
+          objective: goal.objective,
+          evidenceCursor: structuredClone(goal.evidenceCursor),
+          ...verifierFeedback ? { verifierFeedback } : {}
+        };
+      }
+      await evidenceSource.flush();
+      const records = await evidenceSource.readActiveTranscriptChain();
+      const evidenceCatalog = buildGoalEvidenceCatalog({
+        records,
+        goal,
+        permit
+      });
+      if (!isCurrentPermit(permit) || !snapshot.goal) {
+        throw new Error("Goal turn permit is no longer valid");
+      }
+      return {
+        goalId: goal.goalId,
+        revision: goal.revision,
+        objective: goal.objective,
+        evidenceCursor: structuredClone(goal.evidenceCursor),
+        evidenceCatalog,
+        ...verifierFeedback ? { verifierFeedback } : {}
+      };
+    },
+    recordTerminalProposal(permit, proposal) {
+      assertOperational();
+      if (!isCurrentPermit(permit)) {
+        throw new Error("Goal turn permit is no longer valid");
+      }
+      if (currentProposal) {
+        return {
+          recorded: false,
+          readyForVerification: currentProposal.readyForVerification
+        };
+      }
+      let readyForVerification = true;
+      let blockedAuditCandidate;
+      if (proposal.status === "blocked" && proposal.blockerKind !== "authority" && proposal.blockerKind !== "external") {
+        const fingerprint2 = `${proposal.blockerKind ?? ""}
+${proposal.reason}`;
+        blockedAuditCandidate = {
+          fingerprint: fingerprint2,
+          count: blockedAudit?.fingerprint === fingerprint2 ? Math.min(blockedAudit.count + 1, 3) : 1,
+          turnIds: blockedAudit?.fingerprint === fingerprint2 ? [...blockedAudit.turnIds, permit.turnId].slice(-3) : [permit.turnId]
+        };
+        readyForVerification = blockedAuditCandidate.count >= 3;
+      }
+      currentProposal = {
+        proposal: structuredClone(proposal),
+        readyForVerification,
+        ...blockedAuditCandidate ? { blockedAuditCandidate } : {}
+      };
+      return { recorded: true, readyForVerification };
+    },
+    takePendingTerminalProposal() {
+      assertOperational();
+      const proposal = pendingProposal;
+      pendingProposal = void 0;
+      return proposal ? structuredClone(proposal) : void 0;
+    },
+    dispatch(request) {
+      const execute = /* @__PURE__ */ __name(async () => {
+        assertOperational();
+        const recordUuid = randomUUID13();
+        const nextGoal = reduceGoalControl(snapshot.goal, {
+          request,
+          now: Date.now(),
+          nextGoalId: randomUUID13(),
+          cursor: request.action === "create" || request.action === "replace" || request.action === "edit" ? { recordId: recordUuid } : options2.journal.getTranscriptCursor()
+        });
+        const nextSnapshot = {
+          v: GOAL_STATE_VERSION,
+          goal: nextGoal,
+          activity: "idle"
+        };
+        await options2.journal.recordGoalState(recordUuid, {
+          v: GOAL_STATE_VERSION,
+          cause: request.action,
+          snapshot: nextSnapshot
+        });
+        assertAvailable();
+        const invalidatesPermit = request.action === "create" || request.action === "replace" || request.action === "edit" || request.action === "pause" || request.action === "clear";
+        const invalidatedHost = currentPermitHost ?? host;
+        if (invalidatesPermit) {
+          invalidateVerification(`Goal ${request.action}`);
+        }
+        if (invalidatesPermit) {
+          currentPermit = void 0;
+          currentPermitHost = void 0;
+          currentTurnKey = void 0;
+          queuedTurnKey = void 0;
+          currentProposal = void 0;
+          pendingProposal = void 0;
+          blockedAudit = void 0;
+          nextVerifierFeedback = void 0;
+          currentTurnFeedback = void 0;
+          continuationQueued = false;
+        } else if (request.action === "resume") {
+          blockedAudit = void 0;
+        }
+        snapshot = {
+          ...structuredClone(nextSnapshot),
+          activity: currentPermit && request.action === "resume" ? "running" : "idle"
+        };
+        if (request.action === "resume") promoteQueuedUserTurn();
+        broadcast(request.action);
+        if (invalidatesPermit) {
+          preemptHost(`Goal ${request.action}`, invalidatedHost);
+        }
+        if (request.action === "resume" || request.action !== "clear" && snapshot.goal?.status === "active") {
+          queueContinuation();
+        }
+        return { snapshot: getSnapshot() };
+      }, "execute");
+      return enqueue(execute);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      const invalidatedHost = currentPermitHost ?? host;
+      currentPermit = void 0;
+      currentPermitHost = void 0;
+      currentTurnKey = void 0;
+      queuedTurnKey = void 0;
+      continuationQueued = false;
+      currentProposal = void 0;
+      pendingProposal = void 0;
+      invalidateVerification("Goal runtime disposed");
+      blockedAudit = void 0;
+      nextVerifierFeedback = void 0;
+      currentTurnFeedback = void 0;
+      preemptHost("Goal runtime disposed", invalidatedHost);
+      host = void 0;
+      listeners.clear();
+    }
+  };
+}
+__name(createGoalRuntime, "createGoalRuntime");
+
 // packages/core/src/core/coreToolScheduler.ts
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 var import_fast_levenshtein = __toESM(require_levenshtein(), 1);
@@ -143967,12 +144304,16 @@ var CoreToolScheduler = class {
         }
         const { request: reqInfo, invocation } = toolCall;
         const canonicalName = canonicalToolName2(reqInfo.name);
-        const toolSpan = startToolSpan(canonicalName, {
-          "tool.call_id": reqInfo.callId,
-          "gen_ai.tool.call.id": reqInfo.providerCallId ?? reqInfo.callId,
-          call_id: reqInfo.callId,
-          tool_name: canonicalName
-        });
+        const toolSpan = startToolSpan(
+          canonicalName,
+          {
+            "tool.call_id": reqInfo.callId,
+            "gen_ai.tool.call.id": reqInfo.providerCallId ?? reqInfo.callId,
+            call_id: reqInfo.callId,
+            tool_name: canonicalName
+          },
+          toolCall.tool.description
+        );
         this.toolSpans.set(reqInfo.callId, toolSpan);
         batchState.callIds.add(reqInfo.callId);
         this.callIdToBatch.set(reqInfo.callId, batchState);
@@ -144892,14 +145233,18 @@ var CoreToolScheduler = class {
     let toolSpan = this.toolSpans.get(callId);
     if (!toolSpan) {
       const canonical = canonicalToolName2(toolName);
-      toolSpan = startToolSpan(canonical, {
-        "tool.call_id": callId,
-        "gen_ai.tool.call.id": scheduledCall.request.providerCallId ?? callId,
-        call_id: callId,
-        // legacy alias — see _schedule for context
-        tool_name: canonical
-        // legacy alias — see _schedule for context
-      });
+      toolSpan = startToolSpan(
+        canonical,
+        {
+          "tool.call_id": callId,
+          "gen_ai.tool.call.id": scheduledCall.request.providerCallId ?? callId,
+          call_id: callId,
+          // legacy alias — see _schedule for context
+          tool_name: canonical
+          // legacy alias — see _schedule for context
+        },
+        scheduledCall.tool.description
+      );
       this.toolSpans.set(callId, toolSpan);
     }
     try {
@@ -145002,18 +145347,18 @@ var CoreToolScheduler = class {
       });
     }
   }
-  safelyAddToolInputAttributes(span, toolName, toolInput) {
+  safelyAddToolArgumentsAttributes(span, argumentsValue) {
     try {
-      addToolInputAttributes(this.config, span, toolName, toolInput);
+      addToolArgumentsAttributes(this.config, span, argumentsValue);
     } catch (error) {
-      debugLogger119.warn("Failed to add tool input span attributes:", error);
+      debugLogger119.warn("Failed to add tool arguments span attribute:", error);
     }
   }
-  safelyAddToolResultAttributes(span, toolName, toolResult) {
+  safelyAddToolCallResultAttributes(span, result) {
     try {
-      addToolResultAttributes(this.config, span, toolName, toolResult);
+      addToolCallResultAttributes(this.config, span, result);
     } catch (error) {
-      debugLogger119.warn("Failed to add tool result span attributes:", error);
+      debugLogger119.warn("Failed to add tool result span attribute:", error);
     }
   }
   async _executeToolCallBody(scheduledCall, signal, span) {
@@ -145029,13 +145374,6 @@ var CoreToolScheduler = class {
         }
       }
     }
-    if (this.config.getTelemetryIncludeSensitiveSpanAttributes?.()) {
-      this.safelyAddToolInputAttributes(
-        span,
-        toolName,
-        safeJsonStringify(toolInput) ?? "{}"
-      );
-    }
     const toolUseId = isPostAskReexecution ? this.bouncedToolUseId.get(callId) ?? generateToolUseId() : generateToolUseId();
     const messageBus = this.config.getMessageBus();
     const hooksEnabled = !this.config.getDisableAllHooks();
@@ -145089,11 +145427,6 @@ var CoreToolScheduler = class {
           new Error(blockMessage),
           "execution_denied" /* EXECUTION_DENIED */
         );
-        this.safelyAddToolResultAttributes(
-          span,
-          toolName,
-          `BLOCKED: ${blockMessage}`
-        );
         this.setStatusInternal(callId, "error", errorResponse);
         setToolSpanFailure(
           span,
@@ -145169,6 +145502,7 @@ var CoreToolScheduler = class {
           );
           return promotableShells.length === 1 && promotableShells[0]?.request.callId === callId;
         }, "canPromoteForegroundShell");
+        this.safelyAddToolArgumentsAttributes(span, invocation.params);
         promise = invocation.execute(
           execSignal,
           liveOutputCallback,
@@ -145178,6 +145512,7 @@ var CoreToolScheduler = class {
           canPromoteForegroundShell
         );
       } else {
+        this.safelyAddToolArgumentsAttributes(span, invocation.params);
         promise = invocation.execute(
           execSignal,
           liveOutputCallback,
@@ -145252,11 +145587,6 @@ ${failureHookResult.additionalContext}`;
           }
           failureHookArtifacts = failureHookResult.artifacts;
         }
-        this.safelyAddToolResultAttributes(
-          span,
-          toolName,
-          `CANCELLED: ${cancelMessage}`
-        );
         this.setStatusInternal(
           callId,
           "cancelled",
@@ -145331,11 +145661,6 @@ ${failureHookResult.additionalContext}`;
               new Error(stopMessage),
               "execution_denied" /* EXECUTION_DENIED */
             );
-            this.safelyAddToolResultAttributes(
-              span,
-              toolName,
-              `STOPPED: ${stopMessage}`
-            );
             this.setStatusInternal(callId, "error", errorResponse);
             setToolSpanFailure(
               span,
@@ -145472,13 +145797,6 @@ ${body}
             }
           }
         }
-        if (this.config.getTelemetryIncludeSensitiveSpanAttributes?.()) {
-          this.safelyAddToolResultAttributes(
-            span,
-            toolName,
-            typeof content === "string" ? content : safeJsonStringify(content) ?? ""
-          );
-        }
         contentLength = typeof content === "string" ? content.length : void 0;
         const response = convertToFunctionResponse(toolName, callId, content);
         const artifacts = [
@@ -145506,6 +145824,12 @@ ${body}
           span.setAttribute("success", true);
         } catch {
         }
+        const result = response.find(
+          (part) => part.functionResponse !== void 0
+        )?.functionResponse?.response;
+        if (result !== void 0) {
+          this.safelyAddToolCallResultAttributes(span, result);
+        }
       } else {
         const operationalErrorMessage = toolResult.error.message;
         let errorMessage = operationalErrorMessage;
@@ -145567,11 +145891,6 @@ ${failureHookResult.additionalContext}`;
             const error2 = part.functionResponse?.response?.["error"];
             return total + (typeof error2 === "string" ? error2.length : 0);
           }, 0);
-          this.safelyAddToolResultAttributes(
-            span,
-            toolName,
-            `ERROR: ${operationalErrorMessage}`
-          );
           const artifacts = [
             ...toolResult.artifacts ?? [],
             ...failureHookArtifacts ?? []
@@ -145617,11 +145936,6 @@ ${failureHookResult.additionalContext}`;
             ])
           );
         }
-        this.safelyAddToolResultAttributes(
-          span,
-          toolName,
-          `ERROR: ${errorMessage}`
-        );
         const error = new Error(errorMessage);
         const errorResponse = createErrorResponse(
           scheduledCall.request,
@@ -145682,11 +145996,6 @@ ${failureHookResult.additionalContext}`;
           }
           failureHookArtifacts = failureHookResult.artifacts;
         }
-        this.safelyAddToolResultAttributes(
-          span,
-          toolName,
-          `CANCELLED: ${cancelMessage}`
-        );
         this.setStatusInternal(
           callId,
           "cancelled",
@@ -145728,11 +146037,6 @@ ${failureHookResult.additionalContext}`;
           }
           failureHookArtifacts = failureHookResult.artifacts;
         }
-        this.safelyAddToolResultAttributes(
-          span,
-          toolName,
-          `EXCEPTION: ${exceptionErrorMessage}`
-        );
         this.setStatusInternal(
           callId,
           "error",
@@ -146197,7 +146501,7 @@ var AgentCore = class {
   lastPromptTokenCount = 0;
   toolUsage = /* @__PURE__ */ new Map();
   constructor(name, runtimeContext, promptConfig, modelConfig, runConfig, toolConfig, eventEmitter, hooks, runtimeView) {
-    const randomPart = randomUUID13().replace(/-/g, "").slice(0, 8);
+    const randomPart = randomUUID14().replace(/-/g, "").slice(0, 8);
     this.subagentId = `${name}-${randomPart}`;
     this.name = name;
     this.runtimeContext = runtimeContext;
@@ -146458,7 +146762,7 @@ var AgentCore = class {
   }
   async _runReasoningLoopInner(chat, initialMessages, toolsList, abortController, options2) {
     const startTime = options2?.startTimeMs ?? Date.now();
-    const runId = randomUUID13();
+    const runId = randomUUID14();
     let currentMessages = initialMessages;
     let turnCounter = 0;
     let finalText = "";
@@ -146915,7 +147219,7 @@ ${text}` : text;
   async processFunctionCalls(functionCalls, abortController, promptId, currentRound, toolsList, responseId, wasOutputTruncated = false, handledProviderToolCallIds = /* @__PURE__ */ new Set(), duplicateProviderToolCallResponseIds = /* @__PURE__ */ new Set()) {
     const responseByCallId = /* @__PURE__ */ new Map();
     const uniqueFunctionCalls = dedupeToolCallsById(functionCalls);
-    const generatedCallIdBase = randomUUID13();
+    const generatedCallIdBase = randomUUID14();
     const callIdByFunctionCall = new Map(
       uniqueFunctionCalls.map((functionCall, index) => [
         functionCall,
@@ -149170,7 +149474,7 @@ var AgentToolInvocation = class extends BaseToolInvocation {
         ov.workspaceContext = wtWorkspace;
         ov.getWorkspaceContext = () => wtWorkspace;
       }
-      const agentIdSuffix = this.callId ?? randomUUID14().slice(0, 8);
+      const agentIdSuffix = this.callId ?? randomUUID15().slice(0, 8);
       const launchDepth = childLaunchDepth();
       const hookOpts = {
         agentId: `${subagentConfig.name}-${agentIdSuffix}`,
@@ -151767,7 +152071,7 @@ var WRITE_TOOL_NAMES2 = /* @__PURE__ */ new Set([
 function makeTaskRecord(type, projectRoot, sessionId) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
-    id: randomUUID15(),
+    id: randomUUID16(),
     taskType: type,
     projectRoot,
     sessionId,
@@ -154409,6 +154713,10 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
               shouldUsePlanOnlyReminderInSubagentContext() || this.config.getSdkMode()
             )
           );
+        } else if (this.config.consumePendingManualPlanExitNotice()) {
+          systemReminders.push(
+            getManualPlanExitSystemReminder(this.config.getApprovalMode())
+          );
         }
         const arenaManager = this.config.getArenaManager();
         if (arenaManager) {
@@ -156051,14 +156359,14 @@ var ResourceRegistry = class {
 };
 
 // packages/core/src/config/config.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 
 // packages/core/src/memory/team-memory-sync.ts
 init_esbuild_shims();
-import { execFile as execFile9 } from "node:child_process";
+import { execFile as execFile10 } from "node:child_process";
 import * as path96 from "node:path";
 import { promisify as promisify6 } from "node:util";
-var execFileAsync6 = promisify6(execFile9);
+var execFileAsync6 = promisify6(execFile10);
 var debugLogger135 = createDebugLogger("TEAM_MEMORY_SYNC");
 var GIT_TIMEOUT_MS2 = 15e3;
 async function tryGit(cwd, args, killSignal = "SIGTERM") {
@@ -156674,6 +156982,7 @@ var Config = class {
   approvalMode;
   prePlanMode;
   approvalModeRevision = 0;
+  pendingManualPlanExitNotice = false;
   autoModeDenialState = createDenialState();
   accessibility;
   showResponseTokensPerSecond;
@@ -156815,7 +157124,7 @@ var Config = class {
   settingsWatcher;
   constructor(params) {
     this.sessionRuntimeBaseDir = Storage.getRuntimeBaseDir();
-    this.sessionId = params.sessionId ?? randomUUID16();
+    this.sessionId = params.sessionId ?? randomUUID17();
     if (!sessionEnvClaimed && process8.env) {
       process8.env["QWEN_CODE_SESSION_ID"] = this.sessionId;
       sessionEnvClaimed = true;
@@ -157926,7 +158235,7 @@ var Config = class {
     void outgoingChatRecordingService?.flush().catch(() => {
     });
     const previousSessionId = this.sessionId;
-    this.sessionId = sessionId ?? randomUUID16();
+    this.sessionId = sessionId ?? randomUUID17();
     if (process8.env) {
       process8.env["QWEN_CODE_SESSION_ID"] = this.sessionId;
     }
@@ -159422,7 +159731,6 @@ var Config = class {
     return this.approvalModeRevision;
   }
   setApprovalMode(mode, options2) {
-    void options2;
     if (!this.isTrustedFolder() && mode !== "default" /* DEFAULT */ && mode !== "plan" /* PLAN */) {
       throw new TrustGateError(
         "Cannot enable privileged approval modes in an untrusted folder."
@@ -159438,8 +159746,12 @@ var Config = class {
     }
     if (mode === "plan" /* PLAN */ && fromMode !== "plan" /* PLAN */) {
       this.prePlanMode = fromMode;
+      this.pendingManualPlanExitNotice = false;
     } else if (mode !== "plan" /* PLAN */ && fromMode === "plan" /* PLAN */) {
       this.prePlanMode = void 0;
+      if (!options2?.fromApprovedPlanExit) {
+        this.pendingManualPlanExitNotice = true;
+      }
     }
     if (fromMode !== mode) {
       this.autoModeDenialState = resetDenialState();
@@ -159449,6 +159761,16 @@ var Config = class {
       this.approvalModeRevision++;
     }
   }
+  /**
+   * One-shot: returns whether a manual (non-approved) plan-mode exit is
+   * pending model notification, and clears the flag. Consumed by the
+   * system-reminder assembly in `GeminiClient` on the next model-bound turn.
+   */
+  consumePendingManualPlanExitNotice() {
+    const pending = this.pendingManualPlanExitNotice;
+    this.pendingManualPlanExitNotice = false;
+    return pending;
+  }
   /**
    * Returns the directory where this session's plan file is stored.
    */
@@ -160589,7 +160911,7 @@ var Config = class {
     }
     if (!enabled) return;
     registry.registerFactory(ToolNames.IMAGE_GEN, async () => {
-      const { ImageGenTool } = await import("./image-gen-Z3VPGKRC.js");
+      const { ImageGenTool } = await import("./image-gen-WIEM7KZA.js");
       return new ImageGenTool(this);
     });
   }
@@ -160625,19 +160947,19 @@ var Config = class {
     }, "registerStructuredOutputIfRequested");
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-APMO3PSX.js");
+        const { ReadFileTool } = await import("./read-file-LZXUR4TO.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-OBDSQURM.js");
+        const { EditTool } = await import("./edit-RIEOJWKB.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-BNOK452R.js");
+        const { NotebookEditTool } = await import("./notebook-edit-JGJV2K6J.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-HH3PF3A2.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-45IPBDP5.js");
         return new ShellTool2(this);
       });
       await registerStructuredOutputIfRequested();
@@ -160647,7 +160969,7 @@ var Config = class {
       return registry;
     }
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-NF7GB6LE.js");
+      const { ToolSearchTool } = await import("./tool-search-APECNQ3Z.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.READ_MCP_RESOURCE, async () => {
@@ -160655,7 +160977,7 @@ var Config = class {
       return new ReadMcpResourceTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-6ODUANDO.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-VXDAN5JK.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.LIST_AGENTS, async () => {
@@ -160671,7 +160993,7 @@ var Config = class {
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-I3SDA4MB.js");
+      const { SkillTool } = await import("./skill-LIWXNLDW.js");
       return new SkillTool(this);
     });
     await registerLazy(ToolNames.LS, async () => {
@@ -160679,7 +161001,7 @@ var Config = class {
       return new LSTool(this);
     });
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-APMO3PSX.js");
+      const { ReadFileTool } = await import("./read-file-LZXUR4TO.js");
       return new ReadFileTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -160694,7 +161016,7 @@ var Config = class {
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-BEJDEDXW.js");
+          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-2U2FRGMV.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -160707,7 +161029,7 @@ var Config = class {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-QYPSK7OP.js");
+          const { GrepTool } = await import("./grep-RKWVROCW.js");
           return new GrepTool(this);
         });
       }
@@ -160715,28 +161037,28 @@ var Config = class {
       recordStartupEvent("config_initialize_ripgrep_probe_start");
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       await registerLazy(ToolNames.GREP, async () => {
-        const { GrepTool } = await import("./grep-QYPSK7OP.js");
+        const { GrepTool } = await import("./grep-RKWVROCW.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-V7R3PSK3.js");
+      const { GlobTool } = await import("./glob-FRTM3X2E.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-OBDSQURM.js");
+      const { EditTool } = await import("./edit-RIEOJWKB.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-BNOK452R.js");
+      const { NotebookEditTool } = await import("./notebook-edit-JGJV2K6J.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-VHIXW5M7.js");
+      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-HUUCEG4P.js");
       return new WriteFileTool2(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-HH3PF3A2.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-45IPBDP5.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
@@ -160752,34 +161074,34 @@ var Config = class {
     }
     if (!this.sdkMode && (supportsUserInteraction || options2?.forSubAgent)) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool } = await import("./exitPlanMode-GXTBWQAR.js");
+        const { ExitPlanModeTool } = await import("./exitPlanMode-GHPUHBZJ.js");
         return new ExitPlanModeTool(this);
       });
     }
     if (!this.sdkMode && supportsUserInteraction) {
       await registerLazy(ToolNames.ENTER_PLAN_MODE, async () => {
-        const { EnterPlanModeTool } = await import("./enterPlanMode-BC5QUZZ2.js");
+        const { EnterPlanModeTool } = await import("./enterPlanMode-IWZYALIB.js");
         return new EnterPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-U6MRPQ2P.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-OGK5FQ3R.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-DGNYMECB.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-4TEYVIVP.js");
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
-      const { WebFetchTool } = await import("./web-fetch-NKCSG7ZE.js");
+      const { WebFetchTool } = await import("./web-fetch-L5UTI53V.js");
       return new WebFetchTool(this);
     });
     if (this.webSearchSettings?.enabled) {
-      const { evaluateWebSearchGate } = await import("./web-search-S62WAP4S.js");
+      const { evaluateWebSearchGate } = await import("./web-search-KM33JOS3.js");
       const gate = evaluateWebSearchGate(this);
       if (gate.ok) {
         await registerLazy(ToolNames.WEB_SEARCH, async () => {
-          const { WebSearchTool } = await import("./web-search-S62WAP4S.js");
+          const { WebSearchTool } = await import("./web-search-KM33JOS3.js");
           return new WebSearchTool(this);
         });
       } else if (!this.webSearchNoticeEmitted && !options2?.forSubAgent) {
@@ -160831,7 +161153,7 @@ var Config = class {
     });
     if (this.isAgentTeamEnabled()) {
       await registerLazy(ToolNames.TEAM_CREATE, async () => {
-        const { TeamCreateTool } = await import("./team-create-YJALH5D2.js");
+        const { TeamCreateTool } = await import("./team-create-O2FROQ4R.js");
         return new TeamCreateTool(this);
       });
       await registerLazy(ToolNames.TEAM_DELETE, async () => {
@@ -160839,7 +161161,7 @@ var Config = class {
         return new TeamDeleteTool(this);
       });
       await registerLazy(ToolNames.TEAM_PLAN_APPROVAL, async () => {
-        const { TeamPlanApprovalTool } = await import("./team-plan-approval-34QFYKGN.js");
+        const { TeamPlanApprovalTool } = await import("./team-plan-approval-Q6WDBXTQ.js");
         return new TeamPlanApprovalTool(this);
       });
       await registerLazy(ToolNames.TASK_CREATE, async () => {
@@ -160857,16 +161179,16 @@ var Config = class {
     }
     if (this.isWorkflowsEnabled()) {
       await registerLazy(ToolNames.WORKFLOW, async () => {
-        const { WorkflowTool } = await import("./workflow-QAGU5RU4.js");
+        const { WorkflowTool } = await import("./workflow-K7FAWV77.js");
         return new WorkflowTool(this);
       });
     }
     if (this.isComputerUseEnabled()) {
-      const { registerComputerUseTools } = await import("./computer-use-SOQ4E3VX.js");
+      const { registerComputerUseTools } = await import("./computer-use-DOFAHZAB.js");
       await registerComputerUseTools(registerLazy, this);
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-R3ODH5U6.js");
+      const { MonitorTool } = await import("./monitor-7FEWXX5F.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {
@@ -161480,6 +161802,11 @@ __name(buildReplacement, "buildReplacement");
 
 // packages/core/src/tools/shell.ts
 var debugLogger137 = createDebugLogger("SHELL");
+function statusFileGuidance(outputPath) {
+  return `status file: ${statusFilePathFor(outputPath)}
+To check whether this process is still running, Read the status file (status: running|completed|failed|cancelled). Do NOT infer liveness from the output file: programs often block-buffer stdout when not attached to a TTY, so an empty output file is normal while the process is alive (for live output, re-run with e.g. \`python -u\` or \`stdbuf -oL\`).`;
+}
+__name(statusFileGuidance, "statusFileGuidance");
 function stripTrailingBackgroundAmp2(command) {
   const trimmed2 = command.trimEnd();
   if (!trimmed2.endsWith("&")) return command;
@@ -163437,12 +163764,14 @@ ${longRunHint}` : ""),
       promoteArtifacts.onSettleWired(queued);
     }
     const statusLine = postPromoteSettleObserved ? `Status: ${postPromoteFinalStatus ?? "settled"}. PID: ${result.pid ?? "(unknown)"}.` : `Status: running. PID: ${result.pid ?? "(unknown)"}.`;
+    const statusFileLine = statusFileGuidance(outputPath);
     const inspectLine = `To inspect: \`/tasks\` (text), the Background tasks dialog (\u2193 + Enter on the footer pill), or \`Read\` the output file directly.`;
     const stopLine = postPromoteSettleObserved ? `Process has already exited; no \`task_stop\` needed (the entry is observable in \`/tasks\` for inspection).` : `To stop the now-background process: \`task_stop({ task_id: '${shellId}' })\`.`;
     const llmContent = [
       `Foreground command "${commandToExecute}" promoted to background as ${shellId}.`,
       statusLine,
       `Output snapshot at promote time saved to: ${outputPath}`,
+      statusFileLine,
       inspectLine,
       stopLine
     ].join("\n");
@@ -163568,6 +163897,7 @@ ${longRunHint}` : ""),
       llmContent: `Background shell started.
 id: ${shellId}
 ` + pidLine + `output file: ${outputPath}
+${statusFileGuidance(outputPath)}
 To inspect: /tasks (text) or the interactive Background tasks dialog (focus the footer Background tasks pill, then Enter \u2014 detail view + live updates). Read the output file directly to view the captured output.`,
       returnDisplay: `Background shell ${shellId} started${pid !== void 0 ? ` (pid ${pid})` : ""}.`
     };
@@ -164441,6 +164771,7 @@ export {
   getCompressionPrompt,
   getProjectSummaryPrompt,
   getPlanModeSystemReminder,
+  getManualPlanExitSystemReminder,
   getArenaSystemReminder,
   getInsightPrompt,
   PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE,
@@ -164735,6 +165066,10 @@ export {
   getShellPagerEnv,
   getShellAbortReasonKind,
   ShellExecutionService,
+  MAX_NOTIFICATION_OUTPUT_TAIL_BYTES,
+  MAX_RETAINED_TERMINAL_SHELLS,
+  statusFilePathFor,
+  BackgroundShellRegistry,
   StructuredToolError,
   checkPriorRead,
   escape,
@@ -164936,9 +165271,6 @@ export {
   MAX_RETAINED_TERMINAL_MONITORS,
   getMonitorOutputPath,
   MonitorRegistry,
-  MAX_NOTIFICATION_OUTPUT_TAIL_BYTES,
-  MAX_RETAINED_TERMINAL_SHELLS,
-  BackgroundShellRegistry,
   MAX_RETAINED_TERMINAL_WORKFLOWS,
   WorkflowRunRegistry,
   FileReadCache,
@@ -165253,6 +165585,10 @@ export {
   readGitHead,
   resolveBranchName,
   watchRepoBranch,
+  GITHUB_PR_ERROR_MESSAGE_MAX,
+  GITHUB_PR_LIST_LIMIT,
+  parseGhPrList,
+  fetchGitHubPullRequests,
   readPathFromWorkspace,
   getWelcomeBackState,
   saveWelcomeBackRestartChoice,
@@ -165292,7 +165628,8 @@ export {
   GoalVerifierInputTooLargeError,
   parseGoalVerifierText,
   validateGoalVerifierText,
-  createGoalVerifier
+  createGoalVerifier,
+  createGoalRuntime
 };
 /**
  * @license