@qwen-code/qwen-code 0.23.2 → 0.23.3-nightly.20260911.aaa6a32aae

package/chunks/{chunk-PFKGV6PO.js → chunk-465USTVK.js}

@@ -27,12 +27,6 @@ var FIELD_KINDS = /* @__PURE__ */ new Set([
   "object"
 ]);
 var SHARED_ACCESS_FIELDS = [
-  {
-    key: "messagePrefix",
-    label: "Message Prefix",
-    kind: "string",
-    description: "Only dispatch user messages that start with this exact prefix after any leading @mentions. The prefix is removed before the task runs"
-  },
   {
     key: "senderPolicy",
     label: "Sender Policy",
@@ -255,15 +249,15 @@ function ensureBuiltins() {
   if (!builtinsPromise) {
     builtinsPromise = (async () => {
       const labelled = [
-        { name: "telegram", promise: import("./dist-F6JLAJLE.js") },
-        { name: "weixin", promise: import("./dist-NP7QKLVG.js") },
-        { name: "dingtalk", promise: import("./dist-6YDUH3BB.js") },
-        { name: "dws", promise: import("./dist-Y5KC3IHW.js") },
-        { name: "wecom", promise: import("./dist-F34J4FZX.js") },
-        { name: "feishu", promise: import("./dist-ZDNJK74R.js") },
-        { name: "qqbot", promise: import("./dist-BNQVF565.js") },
-        { name: "github", promise: import("./dist-XLV33CLY.js") },
-        { name: "gitlab", promise: import("./dist-UFTFGI6I.js") }
+        { name: "telegram", promise: import("./dist-T6DDPDLQ.js") },
+        { name: "weixin", promise: import("./dist-GUB7QRYA.js") },
+        { name: "dingtalk", promise: import("./dist-GIMQXYLI.js") },
+        { name: "dws", promise: import("./dist-L45UB6DG.js") },
+        { name: "wecom", promise: import("./dist-2QYIVNS6.js") },
+        { name: "feishu", promise: import("./dist-PA7WPFVE.js") },
+        { name: "qqbot", promise: import("./dist-TFGETXFN.js") },
+        { name: "github", promise: import("./dist-MPUZZOG5.js") },
+        { name: "gitlab", promise: import("./dist-VDLSBCLM.js") }
       ];
       const results = await Promise.allSettled(labelled.map((l) => l.promise));
       for (let i = 0; i < results.length; i++) {

package/chunks/{chunk-WG7BL3FY.js → chunk-473RJLIH.js}

@@ -6,7 +6,7 @@ import {
   conversationRuntimeInUseError,
   conversationRuntimeOwnershipCompromisedError,
   conversationRuntimeUnavailableError
-} from "./chunk-2Z3T52OC.js";
+} from "./chunk-Y5TM7SBV.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-J3VZF2AL.js → chunk-4O2AXZXU.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   hasControlCharacter
-} from "./chunk-OWCFKIFQ.js";
+} from "./chunk-5CZMWDJI.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MWIO7MF6.js";
+} from "./chunk-2WSLXP3W.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-N6S3NUYJ.js → chunk-55VOWZ4C.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   isTool
-} from "./chunk-MWIO7MF6.js";
+} from "./chunk-2WSLXP3W.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-OWCFKIFQ.js → chunk-5CZMWDJI.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   isWithinRoot
-} from "./chunk-J6MB5ZHZ.js";
+} from "./chunk-QZW6WRB7.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MWIO7MF6.js";
+} from "./chunk-2WSLXP3W.js";
 import {
   isNodeError
 } from "./chunk-ZAFYHRVY.js";

package/chunks/{chunk-7NDZKE2M.js → chunk-5MUIHID6.js}

@@ -3,19 +3,19 @@
 import {
   mapSkillConfigToStatus
 } from "./chunk-BHTYRHJF.js";
-import {
-  STATUS_SCHEMA_VERSION
-} from "./chunk-FETY36NQ.js";
 import {
   resolveSkillSettings
 } from "./chunk-HWVUSYSN.js";
+import {
+  STATUS_SCHEMA_VERSION
+} from "./chunk-HGEUHUEV.js";
 import {
   loadSettings
-} from "./chunk-WBU2PIZ5.js";
+} from "./chunk-CSDKDHWV.js";
 import {
   SkillManager,
   isSafeModeEnv
-} from "./chunk-HJ5UJQQL.js";
+} from "./chunk-2UKKQGRA.js";
 import {
   writeStderrLine
 } from "./chunk-7FA2II6K.js";

package/chunks/{chunk-RM244SCQ.js → chunk-5Z74GE4N.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runExitCleanup
-} from "./chunk-DAI65CMX.js";
+} from "./chunk-FJZWRNEW.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-G5VOXCRX.js → chunk-6375QMAO.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   useKeypress
-} from "./chunk-A7EFXK7P.js";
+} from "./chunk-SAOJHRWY.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   t
-} from "./chunk-CRZBDVP2.js";
+} from "./chunk-432JQKIO.js";
 import {
   APPROVAL_MODES
 } from "./chunk-JX6XHPTX.js";

package/chunks/{chunk-3LPJ776W.js → chunk-63GQZKXL.js}

@@ -8,7 +8,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MWIO7MF6.js";
+} from "./chunk-2WSLXP3W.js";
 import {
   QWEN_DIR,
   createDebugLogger
@@ -291,7 +291,54 @@ When requested to perform tasks like fixing bugs, adding features, refactoring,
 `;
 }
 __name(getSoftwareEngineeringTasksSection, "getSoftwareEngineeringTasksSection");
-function buildDefaultBasePrompt(interaction, model, outputStyle, todoWriteEnabled = false) {
+function getToolGuidanceSection(questions, codeModeOnly, todoWriteEnabled) {
+  const taskManagementToolGuidance = todoWriteEnabled ? `- **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.
+` : "";
+  const directControls = todoWriteEnabled ? `'${ToolNames.TODO_WRITE}', '${ToolNames.AGENT}' and the other direct controls` : `'${ToolNames.AGENT}' and the other direct controls`;
+  if (codeModeOnly) {
+    return `
+## Using Your Tools
+- **Calling Convention:** Ordinary tools exist only inside '${ToolNames.EXEC}', as \`tools.<name>(args)\`. Every other tool declared to you \u2014 ${directControls} \u2014 is called directly and is not reachable through \`tools\`.
+- **Prefer Dedicated Tools:** Do NOT use \`tools.${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 \`tools.${ToolNames.READ_FILE}\` instead of cat, head, tail, or sed
+  - To edit files use \`tools.${ToolNames.EDIT}\` instead of sed or awk
+  - To create files use \`tools.${ToolNames.WRITE_FILE}\` instead of cat with heredoc or echo redirection
+  - To search for files use \`tools.${ToolNames.GLOB}\` instead of find or ls
+  - To search the content of files, use \`tools.${ToolNames.GREP}\` instead of grep or rg
+  - Reserve \`tools.${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 \`tools.${ToolNames.SHELL}\` for these if it is absolutely necessary.
+- **Batch Into One Program:** Put independent calls in a single '${ToolNames.EXEC}' program and await them together with \`Promise.all\`. Sequence calls only when a later one needs a value an earlier one produced. Whatever you need to see must be passed to \`text()\` \u2014 a result you only assign is never reported back to you. A denied or failed call aborts the whole program, so keep a call that may be refused out of a batch you would then have to repeat.
+- **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.
+${taskManagementToolGuidance}- **File Paths:** Always use absolute paths when referring to files with tools like \`tools.${ToolNames.READ_FILE}\` or \`tools.${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:** ${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. A background subagent's result arrives as a task notification in a later turn; while waiting, do not read its transcript, predict its findings, or launch a replacement for the same task.
+- **Codebase Search:** For simple, directed codebase searches (e.g. for a specific file/class/function) call \`tools.${ToolNames.GREP}\` or \`tools.${ToolNames.GLOB}\` yourself. For broader codebase exploration and deep research, use the '${ToolNames.AGENT}' tool with subagent_type=Explore. This is slower than calling them yourself, 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.
+`.trim();
+  }
+  return `
+## 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.
+${taskManagementToolGuidance}- **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:** ${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. A background subagent's result arrives as a task notification in a later turn; while waiting, do not read its transcript, predict its findings, or launch a replacement for the same task.
+- **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.
+`.trim();
+}
+__name(getToolGuidanceSection, "getToolGuidanceSection");
+function buildDefaultBasePrompt(interaction, model, outputStyle, todoWriteEnabled = false, codeModeOnly = false) {
   const softwareEngineeringTasks = outputStyle?.keepCodingInstructions === false ? "" : getSoftwareEngineeringTasksSection(todoWriteEnabled);
   const taskManagementSection = todoWriteEnabled ? `# 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.
@@ -302,10 +349,13 @@ When you create a todo list:
 - 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.
 
-` : "";
-  const taskManagementToolGuidance = todoWriteEnabled ? `- **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.
 ` : "";
   const coreIdentity = resolveCoreIdentityOverride() ?? getDefaultCoreIdentitySentence(interaction.role, Boolean(outputStyle));
+  const toolGuidance = getToolGuidanceSection(
+    interaction.questions,
+    codeModeOnly,
+    todoWriteEnabled
+  );
   return `
 ${coreIdentity}
 
@@ -355,23 +405,7 @@ Final responses should be concise by default, but their shape and depth must mat
 - **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.
-${taskManagementToolGuidance}- **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. A background subagent's result arrives as a task notification in a later turn; while waiting, do not read its transcript, predict its findings, or launch a replacement for the same task.
-- **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.
+${toolGuidance}
 
 ## Interaction Details
 - **Help Command:** The user can use '/help' to display help information.
@@ -428,7 +462,7 @@ ${function() {
     return "";
   }()}
 
-${getToolCallExamples(model || "")}
+${codeModeOnly ? codeModeToolCallExamples : 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.
@@ -448,7 +482,7 @@ function resolveMainSessionOutputStyle(config) {
   return resolveEffectiveOutputStyle(style, resolveInteractionMode(config));
 }
 __name(resolveMainSessionOutputStyle, "resolveMainSessionOutputStyle");
-function getCoreSystemPrompt(userMemory, model, appendInstruction, interactionMode = "interactive", outputStyle, todoWriteEnabled = false) {
+function getCoreSystemPrompt(userMemory, model, appendInstruction, interactionMode = "interactive", outputStyle, todoWriteEnabled = false, codeModeOnly = false) {
   const effectiveOutputStyle = resolveEffectiveOutputStyle(
     outputStyle,
     interactionMode
@@ -471,7 +505,8 @@ function getCoreSystemPrompt(userMemory, model, appendInstruction, interactionMo
     interaction,
     model,
     effectiveOutputStyle,
-    todoWriteEnabled
+    todoWriteEnabled,
+    codeModeOnly
   );
   const writeSystemMdResolution = resolvePathFromEnv(
     process.env["QWEN_WRITE_SYSTEM_MD"]
@@ -485,7 +520,8 @@ function getCoreSystemPrompt(userMemory, model, appendInstruction, interactionMo
         interaction,
         model,
         void 0,
-        todoWriteEnabled
+        todoWriteEnabled,
+        codeModeOnly
       )
     );
   }
@@ -677,6 +713,100 @@ I found the following 'app.config' files:
 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 codeModeToolCallExamples = `
+# 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.EXEC} with source: await tools.${ToolNames.SHELL}({ command: 'node server.js', is_background: true });]
+</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 check for a test safety net and confirm 'requests' is a dependency. Those two lookups are independent, so they go in one program.
+[tool_call: ${ToolNames.EXEC} with source:
+const [tests, requirements] = await Promise.all([
+  tools.${ToolNames.GLOB}({ pattern: 'tests/test_auth.py' }),
+  tools.${ToolNames.READ_FILE}({ file_path: '/path/to/requirements.txt' }),
+]);
+text(tests.output);
+text(requirements.output);
+]
+(After analysis)
+Great, 'tests/test_auth.py' covers the core authentication logic and 'requests' is available. With this safety net in place, I can safely plan the refactoring.
+
+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.EXEC} with source: await tools.${ToolNames.EDIT}({ file_path: '/path/to/src/auth.py', old_string: '(exact old code)', new_string: '(new code)' });]
+Refactoring complete. Running verification...
+[tool_call: ${ToolNames.EXEC} with source:
+const checks = await tools.${ToolNames.SHELL}({ command: 'ruff check src/auth.py && pytest' });
+text(checks.output);
+]
+(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 the source together with an existing test to pick up the local conventions.
+[tool_call: ${ToolNames.EXEC} with source:
+const [source, existing] = await Promise.all([
+  tools.${ToolNames.READ_FILE}({ file_path: '/path/to/someFile.ts' }),
+  tools.${ToolNames.READ_FILE}({ file_path: '/path/to/existingTest.test.ts' }),
+]);
+text(source.output);
+text(existing.output);
+]
+(After reviewing both)
+Now I'll check whether the intended test file already exists. A failed call aborts the whole program, so this probe stays on its own.
+[tool_call: ${ToolNames.EXEC} with source: text((await tools.${ToolNames.READ_FILE}({ file_path: '/path/to/someFile.test.ts' })).output);]
+(After ${ToolNames.READ_FILE} reports that /path/to/someFile.test.ts does not exist)
+[tool_call: ${ToolNames.EXEC} with source: await tools.${ToolNames.WRITE_FILE}({ file_path: '/path/to/someFile.test.ts', content: '(test code content)' });]
+I've written the tests. Now I'll run the project's test command to verify them.
+[tool_call: ${ToolNames.EXEC} with source:
+const result = await tools.${ToolNames.SHELL}({ command: 'npm run test' });
+text(result.output);
+]
+(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.EXEC} with source:
+const found = await tools.${ToolNames.GLOB}({ pattern: './**/app.config' });
+text(found.output);
+]
+(Assuming the glob call returns 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>
@@ -1574,6 +1704,7 @@ var AskUserQuestionToolInvocation = class extends BaseToolInvocation {
           returnDisplay: cancellationMessage
         };
       }
+      const answers = [];
       const answersContent = Object.entries(this.userAnswers).flatMap(([key, value]) => {
         const questionIndex = parseAnswerQuestionIndex(
           key,
@@ -1581,18 +1712,20 @@ var AskUserQuestionToolInvocation = class extends BaseToolInvocation {
         );
         if (questionIndex === void 0) return [];
         const question = this.params.questions[questionIndex];
+        answers.push({ question: question.question, answer: value });
         return `**${question.header || `Question ${questionIndex + 1}`}**: ${value}`;
       }).join("\n");
       const messageBody = answersContent.length > 0 ? answersContent : "No valid answers were provided.";
-      const llmMessage = `User has provided the following answers:
-
-${messageBody}`;
-      const displayMessage = `User has provided the following answers:
+      const message = `User has provided the following answers:
 
 ${messageBody}`;
       return {
-        llmContent: llmMessage,
-        returnDisplay: displayMessage
+        llmContent: message,
+        returnDisplay: {
+          type: "ask_user_question_answers",
+          text: message,
+          answers
+        }
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);

package/chunks/{chunk-O2FEO2CB.js → chunk-6GDELAVL.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-G6UUOCUT.js";
 import {
   ToolNames
-} from "./chunk-MWIO7MF6.js";
+} from "./chunk-2WSLXP3W.js";
 import {
   createDebugLogger
 } from "./chunk-ZAFYHRVY.js";
@@ -248,7 +248,15 @@ function applySkillHooks(config, skill) {
   }
 }
 __name(applySkillHooks, "applySkillHooks");
-function applySkillSideEffects(config, skill) {
+var ReviewWorkflowActivationError = class extends Error {
+  static {
+    __name(this, "ReviewWorkflowActivationError");
+  }
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+  }
+};
+async function applySkillSideEffects(config, skill) {
   if (!config) {
     return;
   }
@@ -264,6 +272,13 @@ function applySkillSideEffects(config, skill) {
     trustGated: skill.level === "project"
   });
   applySkillHooks(config, skill);
+  if (skill.level === "bundled" && skill.name === "review") {
+    try {
+      await config.enableReviewWorkflow();
+    } catch (error) {
+      throw new ReviewWorkflowActivationError(error);
+    }
+  }
 }
 __name(applySkillSideEffects, "applySkillSideEffects");
 function clearLoadedSkillTracking(toolRegistry, logTag) {
@@ -282,6 +297,7 @@ export {
   clearCollectedSkillEntriesCache,
   collectAvailableSkillEntries,
   renderAvailableSkillsBlock,
+  ReviewWorkflowActivationError,
   applySkillSideEffects,
   clearLoadedSkillTracking
 };