@qwen-code/qwen-code 0.23.0 → 0.23.1-preview.1

package/chunks/{chunk-OSSTATJF.js → chunk-GXZHYPHZ.js}

@@ -2,14 +2,17 @@
 "use strict";
 import {
   isGitRepository
-} from "./chunk-ZHO2CW6D.js";
+} from "./chunk-3CZ2BQV6.js";
 import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolDisplayNames,
   ToolNames
-} from "./chunk-7JMGTOH7.js";
+} from "./chunk-RPBMP6BN.js";
 import {
   QWEN_DIR,
   createDebugLogger
-} from "./chunk-EAHOJF6V.js";
+} from "./chunk-ZAFYHRVY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -17,7 +20,7 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
-// packages/core/src/output/types.ts
+// packages/core/src/tools/askUserQuestion.ts
 init_esbuild_shims();
 
 // packages/core/src/core/prompts.ts
@@ -27,6 +30,9 @@ import fs from "node:fs";
 import os from "node:os";
 import process from "node:process";
 
+// packages/core/src/output/types.ts
+init_esbuild_shims();
+
 // packages/core/src/core/output-styles.ts
 init_esbuild_shims();
 var DEFAULT_OUTPUT_STYLE_TURN_REMINDER = "Remember to follow the specific guidelines for this style.";
@@ -119,7 +125,7 @@ function resolveEffectiveOutputStyle(style, interactionMode) {
   if (!style) {
     return void 0;
   }
-  if (interactionMode === "headless" && style.name === "Learning") {
+  if (interactionMode === "headless" && style.source === "built-in" && style.name === "Learning") {
     return void 0;
   }
   return style;
@@ -268,12 +274,14 @@ function getCustomSystemPrompt(customInstruction, userMemory, appendInstruction)
   });
 }
 __name(getCustomSystemPrompt, "getCustomSystemPrompt");
-function getSoftwareEngineeringTasksSection() {
+function getSoftwareEngineeringTasksSection(todoWriteEnabled) {
+  const planGuidance = todoWriteEnabled ? `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.` : "For complex, ambiguous, or multi-step work, form a concise, outcome-oriented approach and revise it as you learn. Skip formal planning for simple tasks unless the user explicitly requests a plan.";
+  const todoAdaptationGuidance = todoWriteEnabled ? " If a todo list exists, keep it current as the scope or approach changes." : "";
   return `## 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.
+- **Plan:** ${planGuidance}
 - **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.
+- **Adapt:** Refine your approach as you discover new information or encounter obstacles.${todoAdaptationGuidance} 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.
@@ -283,8 +291,20 @@ When requested to perform tasks like fixing bugs, adding features, refactoring,
 `;
 }
 __name(getSoftwareEngineeringTasksSection, "getSoftwareEngineeringTasksSection");
-function buildDefaultBasePrompt(interaction, model, outputStyle) {
-  const softwareEngineeringTasks = outputStyle?.keepCodingInstructions === false ? "" : getSoftwareEngineeringTasksSection();
+function buildDefaultBasePrompt(interaction, model, outputStyle, todoWriteEnabled = 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.
+
+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.
+- When an active Todo plan covers work delegated through top-level Agent calls, pass the matching Todo ID as \`todo_id\` so the execution can be associated with that plan node. Do not create a Todo solely to wrap a delegation that does not otherwise need task tracking.
+- 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));
   return `
 ${coreIdentity}
@@ -305,16 +325,7 @@ ${coreIdentity}
 - **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.
-- When an active Todo plan covers work delegated through top-level Agent calls, pass the matching Todo ID as \`todo_id\` so the execution can be associated with that plan node. Do not create a Todo solely to wrap a delegation that does not otherwise need task tracking.
-- 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
+${taskManagementSection}# Primary Workflows
 
 ${softwareEngineeringTasks}- 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.
@@ -353,8 +364,7 @@ Final responses should be concise by default, but their shape and depth must mat
   - 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.
+${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.
@@ -431,13 +441,14 @@ function resolveMainSessionOutputStyle(config) {
   if (config.getSystemPrompt() || isSystemMdActive()) {
     return void 0;
   }
-  return resolveEffectiveOutputStyle(
-    config.getOutputStyle(),
-    resolveInteractionMode(config)
-  );
+  const style = config.getOutputStyle();
+  if (style?.source === "project" && config.isTrustedFolder?.() === false) {
+    return void 0;
+  }
+  return resolveEffectiveOutputStyle(style, resolveInteractionMode(config));
 }
 __name(resolveMainSessionOutputStyle, "resolveMainSessionOutputStyle");
-function getCoreSystemPrompt(userMemory, model, appendInstruction, interactionMode = "interactive", outputStyle) {
+function getCoreSystemPrompt(userMemory, model, appendInstruction, interactionMode = "interactive", outputStyle, todoWriteEnabled = false) {
   const effectiveOutputStyle = resolveEffectiveOutputStyle(
     outputStyle,
     interactionMode
@@ -456,7 +467,12 @@ function getCoreSystemPrompt(userMemory, model, appendInstruction, interactionMo
     }
   }
   const interaction = getInteractionModePrompt(interactionMode);
-  const basePrompt = systemMdEnabled ? fs.readFileSync(systemMdPath, "utf8") : buildDefaultBasePrompt(interaction, model, effectiveOutputStyle);
+  const basePrompt = systemMdEnabled ? fs.readFileSync(systemMdPath, "utf8") : buildDefaultBasePrompt(
+    interaction,
+    model,
+    effectiveOutputStyle,
+    todoWriteEnabled
+  );
   const writeSystemMdResolution = resolvePathFromEnv(
     process.env["QWEN_WRITE_SYSTEM_MD"]
   );
@@ -465,7 +481,12 @@ function getCoreSystemPrompt(userMemory, model, appendInstruction, interactionMo
     fs.mkdirSync(path.dirname(writePath), { recursive: true });
     fs.writeFileSync(
       writePath,
-      systemMdEnabled ? basePrompt : buildDefaultBasePrompt(interaction, model, void 0)
+      systemMdEnabled ? basePrompt : buildDefaultBasePrompt(
+        interaction,
+        model,
+        void 0,
+        todoWriteEnabled
+      )
     );
   }
   return assembleSystemPrompt({
@@ -1281,9 +1302,374 @@ function getInsightPrompt(type) {
 }
 __name(getInsightPrompt, "getInsightPrompt");
 
+// packages/core/src/permissions/trusted-user-answers.ts
+init_esbuild_shims();
+var MAX_TRUSTED_USER_ANSWER_CALLS = 8;
+var MAX_TRUSTED_USER_ANSWERS_TOTAL_CHARS = 32e3;
+var MAX_TRUSTED_USER_ANSWER_QUESTION_CHARS = 200;
+var MAX_TRUSTED_USER_ANSWER_RECORD_CHARS = 8e3;
+function parseAnswerQuestionIndex(key, questionCount) {
+  const index = Number(key);
+  if (!Number.isSafeInteger(index) || index < 0 || index >= questionCount || String(index) !== key) {
+    return void 0;
+  }
+  return index;
+}
+__name(parseAnswerQuestionIndex, "parseAnswerQuestionIndex");
+function normalizeTrustedUserAnswers(questions, rawAnswers) {
+  if (!rawAnswers || typeof rawAnswers !== "object" || Array.isArray(rawAnswers)) {
+    return [];
+  }
+  const answers = [];
+  for (const [key, value] of Object.entries(rawAnswers)) {
+    if (typeof value !== "string" || value.trim().length === 0) continue;
+    const questionIndex = parseAnswerQuestionIndex(key, questions.length);
+    if (questionIndex === void 0) continue;
+    const question = questions[questionIndex].question;
+    answers.push({
+      question: question.length > MAX_TRUSTED_USER_ANSWER_QUESTION_CHARS ? question.slice(0, MAX_TRUSTED_USER_ANSWER_QUESTION_CHARS) + "\u2026" : question,
+      answer: value
+    });
+  }
+  return answers;
+}
+__name(normalizeTrustedUserAnswers, "normalizeTrustedUserAnswers");
+var TrustedUserAnswers = class {
+  static {
+    __name(this, "TrustedUserAnswers");
+  }
+  records = /* @__PURE__ */ new Map();
+  totalChars = 0;
+  record(callId, questions, rawAnswers) {
+    if (callId.length === 0) return false;
+    if (this.records.has(callId)) return false;
+    const answers = normalizeTrustedUserAnswers(questions, rawAnswers);
+    if (answers.length === 0) return false;
+    let record = { callId, answers, omitted: false };
+    let chars = JSON.stringify(record).length;
+    if (chars > MAX_TRUSTED_USER_ANSWER_RECORD_CHARS) {
+      record = { callId, answers: [], omitted: true };
+      chars = JSON.stringify(record).length;
+      if (chars > MAX_TRUSTED_USER_ANSWER_RECORD_CHARS) return false;
+    }
+    this.records.set(callId, {
+      chars,
+      record: Object.freeze({
+        ...record,
+        answers: Object.freeze(
+          record.answers.map((answer) => Object.freeze(answer))
+        )
+      })
+    });
+    this.totalChars += chars;
+    this.enforceLimits();
+    return this.records.has(callId);
+  }
+  snapshot() {
+    return Object.freeze(
+      [...this.records.values()].map(({ record }) => record)
+    );
+  }
+  clear() {
+    this.records.clear();
+    this.totalChars = 0;
+  }
+  enforceLimits() {
+    while (this.records.size > MAX_TRUSTED_USER_ANSWER_CALLS || this.totalChars > MAX_TRUSTED_USER_ANSWERS_TOTAL_CHARS) {
+      const oldest = this.records.keys().next().value;
+      this.totalChars -= this.records.get(oldest).chars;
+      this.records.delete(oldest);
+    }
+  }
+};
+
+// packages/core/src/tools/askUserQuestion.ts
+var debugLogger2 = createDebugLogger("ASK_USER_QUESTION");
+var askUserQuestionToolDescription = `Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Usage notes:
+- Users will always be able to select "Other" to provide custom text input
+- Use multiSelect: true to allow multiple answers to be selected for a question
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label
+
+Plan mode note: In plan mode, use this tool to clarify requirements or choose between approaches BEFORE finalizing your plan. Do NOT use this tool to ask "Is this plan ready?" or "Should I proceed?" - use ExitPlanMode for plan approval.
+`;
+var askUserQuestionToolSchemaData = {
+  name: "ask_user_question",
+  description: askUserQuestionToolDescription,
+  parametersJsonSchema: {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties: {
+      questions: {
+        description: "Questions to ask the user (1-4 questions)",
+        minItems: 1,
+        maxItems: 4,
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            question: {
+              description: 'The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?"',
+              type: "string"
+            },
+            header: {
+              description: 'Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach".',
+              type: "string"
+            },
+            options: {
+              description: "The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no 'Other' option, that will be provided automatically.",
+              minItems: 2,
+              maxItems: 4,
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  label: {
+                    description: "The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice.",
+                    type: "string"
+                  },
+                  description: {
+                    description: "Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications.",
+                    type: "string"
+                  }
+                },
+                required: ["label", "description"],
+                additionalProperties: false
+              }
+            },
+            multiSelect: {
+              description: "Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive.",
+              default: false,
+              type: "boolean"
+            }
+          },
+          required: ["question", "header", "options"],
+          additionalProperties: false
+        }
+      },
+      metadata: {
+        description: "Optional metadata for tracking and analytics purposes. Not displayed to user.",
+        type: "object",
+        properties: {
+          source: {
+            description: 'Optional identifier for the source of this question (e.g., "remember" for /remember command). Used for analytics tracking.',
+            type: "string"
+          }
+        },
+        additionalProperties: false
+      }
+    },
+    required: ["questions"],
+    additionalProperties: false
+  }
+};
+var AskUserQuestionToolInvocation = class extends BaseToolInvocation {
+  constructor(_config, params) {
+    super(params);
+    this._config = _config;
+  }
+  static {
+    __name(this, "AskUserQuestionToolInvocation");
+  }
+  userAnswers = {};
+  wasAnswered = false;
+  getDescription() {
+    const questionCount = this.params.questions.length;
+    return `Ask user ${questionCount} question${questionCount > 1 ? "s" : ""}`;
+  }
+  /**
+   * Whether a host is present that can put the questions in front of the
+   * user *and* answer them. ACP hosts (VSCode extension, Zed, stream-json
+   * clients) run in non-interactive mode but still collect answers through
+   * the confirmation channel.
+   *
+   * The modality half is `resolveInteractionMode()`. The responder half is
+   * what that helper cannot know: a stream-json session only has something
+   * to answer a confirmation round once the SDK control system is up. In
+   * stream-json *direct* mode the first stdin frame is a plain user message,
+   * so `Session.handleFirstMessage()` leaves the control system off, no
+   * `PermissionController` is built and `onToolCallsUpdate` is never wired
+   * (`nonInteractiveCli.ts`, gated on `options.controlService`). Claiming a
+   * host there parks the call in `awaiting_approval` forever: the scheduler's
+   * non-interactive auto-deny carries `getInputFormat() !== STREAM_JSON` as a
+   * required conjunct, so it does not fire either.
+   */
+  canCollectAnswers() {
+    if (resolveInteractionMode(this._config) === "headless") {
+      return false;
+    }
+    return this._config.isInteractive() || this._config.getExperimentalZedIntegration() || this._config.getInputFormat() !== "stream-json" /* STREAM_JSON */ || this._config.getSdkMode();
+  }
+  /**
+   * ask_user_question always requires user confirmation so the user can
+   * provide answers. In non-interactive mode without ACP support, we skip
+   * confirmation (and subsequently skip execution).
+   */
+  async getDefaultPermission() {
+    if (!this.canCollectAnswers()) {
+      return "allow";
+    }
+    return "ask";
+  }
+  /**
+   * The confirmation dialog IS this tool: the answers are collected through
+   * `onConfirm`, so an approval that skips the dialog does not "allow" the
+   * tool, it silently answers "declined" on the user's behalf. Permission
+   * rules and automatic approval modes must therefore never satisfy it —
+   * a bare `ask_user_question` allow rule (a skill's `allowedTools` grant,
+   * `permissions.allow`, an "always allow" answer) would otherwise override
+   * the 'ask' default at L4 and the scheduler would run the tool with no
+   * dialog ever shown. Headless runs stay as they were: nothing can prompt
+   * there, and `execute()` reports that instead.
+   */
+  requiresUserInteraction() {
+    return this.canCollectAnswers();
+  }
+  async getConfirmationDetails(_abortSignal) {
+    const details = {
+      type: "ask_user_question",
+      title: "Please answer the following question(s):",
+      questions: this.params.questions,
+      metadata: this.params.metadata,
+      onConfirm: /* @__PURE__ */ __name(async (outcome, payload) => {
+        switch (outcome) {
+          case "proceed_once" /* ProceedOnce */:
+          case "proceed_always" /* ProceedAlways */:
+            this.wasAnswered = true;
+            this.userAnswers = payload?.answers ?? {};
+            break;
+          case "cancel" /* Cancel */:
+            this.wasAnswered = false;
+            break;
+          default:
+            this.wasAnswered = true;
+            this.userAnswers = payload?.answers ?? {};
+            break;
+        }
+      }, "onConfirm")
+    };
+    return details;
+  }
+  async execute(_signal) {
+    try {
+      if (!this.canCollectAnswers()) {
+        const errorMessage = "Cannot ask user questions in non-interactive mode without ACP support. Please run in interactive mode or enable ACP mode to use this tool.";
+        return {
+          llmContent: errorMessage,
+          returnDisplay: errorMessage
+        };
+      }
+      if (!this.wasAnswered) {
+        const cancellationMessage = "User declined to answer the questions.";
+        return {
+          llmContent: cancellationMessage,
+          returnDisplay: cancellationMessage
+        };
+      }
+      const answersContent = Object.entries(this.userAnswers).flatMap(([key, value]) => {
+        const questionIndex = parseAnswerQuestionIndex(
+          key,
+          this.params.questions.length
+        );
+        if (questionIndex === void 0) return [];
+        const question = this.params.questions[questionIndex];
+        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:
+
+${messageBody}`;
+      return {
+        llmContent: llmMessage,
+        returnDisplay: displayMessage
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      debugLogger2.error(
+        `[AskUserQuestionTool] Error executing ask_user_question: ${errorMessage}`
+      );
+      const errorLlmContent = `Failed to process user answers: ${errorMessage}`;
+      return {
+        llmContent: errorLlmContent,
+        returnDisplay: `Error processing answers: ${errorMessage}`
+      };
+    }
+  }
+};
+var AskUserQuestionTool = class _AskUserQuestionTool extends BaseDeclarativeTool {
+  constructor(config) {
+    super(
+      _AskUserQuestionTool.Name,
+      ToolDisplayNames.ASK_USER_QUESTION,
+      askUserQuestionToolDescription,
+      "think" /* Think */,
+      askUserQuestionToolSchemaData.parametersJsonSchema,
+      true,
+      // isOutputMarkdown
+      false,
+      // canUpdateOutput
+      false
+      // shouldDefer — kept always-visible so the model reaches for the structured clarification UX instead of asking in plain prose
+    );
+    this.config = config;
+  }
+  static {
+    __name(this, "AskUserQuestionTool");
+  }
+  static Name = ToolNames.ASK_USER_QUESTION;
+  validateToolParams(params) {
+    if (!Array.isArray(params.questions)) {
+      return 'Parameter "questions" must be an array.';
+    }
+    if (params.questions.length < 1 || params.questions.length > 4) {
+      return 'Parameter "questions" must contain between 1 and 4 questions.';
+    }
+    for (let i = 0; i < params.questions.length; i++) {
+      const question = params.questions[i];
+      if (!question.question || typeof question.question !== "string" || question.question.trim() === "") {
+        return `Question ${i + 1}: "question" must be a non-empty string.`;
+      }
+      if (!question.header || typeof question.header !== "string" || question.header.trim() === "") {
+        return `Question ${i + 1}: "header" must be a non-empty string.`;
+      }
+      if (!Array.isArray(question.options)) {
+        return `Question ${i + 1}: "options" must be an array.`;
+      }
+      if (question.options.length < 2 || question.options.length > 4) {
+        return `Question ${i + 1}: "options" must contain between 2 and 4 options.`;
+      }
+      for (let j = 0; j < question.options.length; j++) {
+        const option = question.options[j];
+        if (!option.label || typeof option.label !== "string" || option.label.trim() === "") {
+          return `Question ${i + 1}, Option ${j + 1}: "label" must be a non-empty string.`;
+        }
+        if (!option.description || typeof option.description !== "string" || option.description.trim() === "") {
+          return `Question ${i + 1}, Option ${j + 1}: "description" must be a non-empty string.`;
+        }
+      }
+      if (question.multiSelect !== void 0 && typeof question.multiSelect !== "boolean") {
+        return `Question ${i + 1}: "multiSelect" must be a boolean.`;
+      }
+    }
+    return null;
+  }
+  createInvocation(params) {
+    return new AskUserQuestionToolInvocation(this.config, params);
+  }
+};
+
 export {
   BUILT_IN_OUTPUT_STYLES,
   getBuiltInOutputStyle,
+  resolveEffectiveOutputStyle,
   getOutputStyleTurnReminder,
   resolveInteractionMode,
   isSystemMdActive,
@@ -1296,7 +1682,9 @@ export {
   getPlanModeSystemReminder,
   getManualPlanExitSystemReminder,
   getArenaSystemReminder,
-  getInsightPrompt
+  getInsightPrompt,
+  TrustedUserAnswers,
+  AskUserQuestionTool
 };
 /**
  * @license
@@ -1308,3 +1696,13 @@ export {
  * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-IPATA3T2.js → chunk-GZWW2QWR.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   useKeypress
-} from "./chunk-FRICLXCZ.js";
+} from "./chunk-Z6WZPXQH.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   t
-} from "./chunk-I4NRYS6A.js";
+} from "./chunk-MUZCSTOO.js";
 import {
   APPROVAL_MODES
 } from "./chunk-JX6XHPTX.js";

package/chunks/{chunk-C4TIXFDZ.js → chunk-H3UDNQLO.js}

@@ -6,21 +6,22 @@ import {
   PROJECT_ENV_HARDCODED_EXCLUSIONS,
   isHardcodedProjectEnvExclusion,
   isLoaderEnvKey,
+  isPrivateProvenanceEnvKey,
   publishPendingCompileCache,
   reportRejectedLoaderKeys,
   resetLoaderKeyRejectionReportingForTesting
-} from "./chunk-2M3EWQNG.js";
+} from "./chunk-NUQFUXOG.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-65HWLGA7.js";
+} from "./chunk-XY3USGFE.js";
 import {
   require_main
-} from "./chunk-5M6IDOMF.js";
+} from "./chunk-3K65MUKD.js";
 import {
   QWEN_DIR,
   Storage,
   getErrorMessage
-} from "./chunk-EAHOJF6V.js";
+} from "./chunk-ZAFYHRVY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -303,6 +304,7 @@ __name(parseEnvFiles, "parseEnvFiles");
 function canApplyParsedEnvKey(envFile, key, excludedVars, options = {}) {
   if (!Object.hasOwn(envFile.parsedEnv, key)) return false;
   if (isLoaderEnvKey(key)) return false;
+  if (isPrivateProvenanceEnvKey(key)) return false;
   if (options.reload && isReloadExcludedKey(key)) return false;
   if (!envFile.isHomeScopedEnvFile && isHardcodedProjectEnvExclusion(key)) {
     return false;

package/chunks/chunk-HD7O6WLV.js

@@ -0,0 +1,18 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+
+// packages/core/src/memory/scopes.ts
+init_esbuild_shims();
+var MEMORY_PROJECT_SCOPES = ["git-root", "workspace"];
+
+export {
+  MEMORY_PROJECT_SCOPES
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */