@mmmbuto/qwen-code-termux 0.16.1-termux → 0.18.0-termux

package/chunks/shell-NQZQGFM2.js

@@ -0,0 +1,56 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  OUTPUT_UPDATE_INTERVAL_MS,
+  ShellTool,
+  ShellToolInvocation,
+  buildLongRunningForegroundHint,
+  detectBlockedSleepPattern,
+  parseNumstat
+} from "./chunk-TD4OPI4T.js";
+import "./chunk-K5PGHDBN.js";
+import "./chunk-XBY7E2FX.js";
+import "./chunk-SKBPNJEW.js";
+import "./chunk-NVFMZBX2.js";
+import "./chunk-O4PICXES.js";
+import "./chunk-TW522KN6.js";
+import "./chunk-3DHXZ6EV.js";
+import "./chunk-J5MDQKJL.js";
+import "./chunk-MLZQVCF3.js";
+import "./chunk-LD2XBG6Z.js";
+import "./chunk-OHEGWO4L.js";
+import "./chunk-SNGELLWX.js";
+import "./chunk-77WXWU44.js";
+import "./chunk-A7B4ISQP.js";
+import "./chunk-OQ7NJIY7.js";
+import "./chunk-3PJXIDKI.js";
+import "./chunk-UWCTAVOD.js";
+import "./chunk-OFEVLU4C.js";
+import "./chunk-3HTIVKZE.js";
+import "./chunk-IDX6COTE.js";
+import "./chunk-KQJMQJPI.js";
+import "./chunk-D3RHSPAS.js";
+import "./chunk-2Y5SYSD3.js";
+import "./chunk-SEGYWKIH.js";
+import "./chunk-64WXLC72.js";
+import "./chunk-B7HXHOHU.js";
+import "./chunk-EYENRK4D.js";
+import "./chunk-M6VTDSVR.js";
+import "./chunk-55ZMG67I.js";
+import "./chunk-H6BD2ELD.js";
+import "./chunk-5IFG2VC4.js";
+import "./chunk-HR7SV7AY.js";
+import "./chunk-ZERZSAZL.js";
+import "./chunk-QN5NZ3UQ.js";
+import "./chunk-BR4QREVK.js";
+import "./chunk-Z2Z3GUXZ.js";
+import "./chunk-A4BMJM77.js";
+import "./chunk-J2S4EL5Y.js";
+export {
+  OUTPUT_UPDATE_INTERVAL_MS,
+  ShellTool,
+  ShellToolInvocation,
+  buildLongRunningForegroundHint,
+  detectBlockedSleepPattern,
+  parseNumstat
+};

package/chunks/{skill-D6YRHTTI.js → skill-WCFW4644.js}

@@ -1,36 +1,40 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
+  applySkillAllowedTools,
   buildSkillLlmContent,
-  escapeXml,
+  collectAvailableSkillEntries,
   registerSkillHooks
-} from "./chunk-G7YTSRES.js";
-import "./chunk-4AOCVI6J.js";
+} from "./chunk-OHEGWO4L.js";
+import "./chunk-SNGELLWX.js";
 import {
   SkillLaunchEvent,
   logSkillLaunch
-} from "./chunk-K6O2NBMF.js";
+} from "./chunk-OQ7NJIY7.js";
+import "./chunk-3PJXIDKI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
-import "./chunk-PR4T27R7.js";
-import "./chunk-MAY32HXD.js";
-import "./chunk-D5NTAHYL.js";
-import "./chunk-MYAKAFEC.js";
-import "./chunk-66CXYE4B.js";
-import "./chunk-NCTLV2NB.js";
+import "./chunk-3HTIVKZE.js";
+import "./chunk-IDX6COTE.js";
+import "./chunk-KQJMQJPI.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-XEGHDASV.js";
+} from "./chunk-D3RHSPAS.js";
+import "./chunk-B7HXHOHU.js";
+import "./chunk-M6VTDSVR.js";
+import "./chunk-55ZMG67I.js";
+import "./chunk-H6BD2ELD.js";
+import "./chunk-5IFG2VC4.js";
 import {
   createDebugLogger
-} from "./chunk-XP27SJMH.js";
+} from "./chunk-HR7SV7AY.js";
 import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";
 import "./chunk-BR4QREVK.js";
-import "./chunk-QWSRH265.js";
+import "./chunk-Z2Z3GUXZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -42,6 +46,31 @@ import {
 init_esbuild_shims();
 import path from "path";
 var debugLogger = createDebugLogger("SKILL");
+var SKILL_TOOL_DESCRIPTION = `Execute a skill within the main conversation
+
+<skills_instructions>
+When users ask you to perform tasks, check if any of the available skills can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to invoke:
+- Use this tool with the skill name only (no arguments)
+- Examples:
+  - \`skill: "pdf"\` - invoke the pdf skill
+  - \`skill: "xlsx"\` - invoke the xlsx skill
+  - \`skill: "ms-office-suite:pdf"\` - invoke using fully qualified name
+  - \`skill: "mcp-prompt", args: "topic"\` - invoke a model-invocable command with arguments
+
+Important:
+- Available skills are listed in <system-reminder> messages in the conversation; only use skills listed there.
+- When a skill is relevant, you must invoke this tool IMMEDIATELY as your first action
+- NEVER just announce or mention a skill in your text response without actually calling this tool
+- This is a BLOCKING REQUIREMENT: invoke the relevant Skill tool BEFORE generating any other response about the task
+- Do not invoke a skill that is already running
+- Do not use this tool for built-in CLI commands (like /help, /clear, etc.)
+- When executing scripts or loading referenced files, ALWAYS resolve absolute paths from skill's base directory. Examples:
+  - \`bash scripts/init.sh\` -> \`bash /path/to/skill/scripts/init.sh\`
+  - \`python scripts/helper.py\` -> \`python /path/to/skill/scripts/helper.py\`
+  - \`reference.md\` -> \`/path/to/skill/reference.md\`
+</skills_instructions>`;
 var SkillTool = class _SkillTool extends BaseDeclarativeTool {
   constructor(config) {
     const initialSchema = {
@@ -49,7 +78,11 @@ var SkillTool = class _SkillTool extends BaseDeclarativeTool {
       properties: {
         skill: {
           type: "string",
-          description: 'The skill name (no arguments). E.g., "pdf" or "xlsx"'
+          description: 'The skill or command name. E.g., "pdf" or "xlsx"'
+        },
+        args: {
+          type: "string",
+          description: "Optional arguments for model-invocable slash commands."
         }
       },
       required: ["skill"],
@@ -59,8 +92,8 @@ var SkillTool = class _SkillTool extends BaseDeclarativeTool {
     super(
       _SkillTool.Name,
       ToolDisplayNames.SKILL,
-      "Execute a skill within the main conversation. Loading available skills...",
-      // Initial description
+      SKILL_TOOL_DESCRIPTION,
+      // Static; live skill list is injected via system-reminders.
       "read" /* Read */,
       initialSchema,
       false,
@@ -97,116 +130,48 @@ var SkillTool = class _SkillTool extends BaseDeclarativeTool {
   // SkillTool instances (subagents share the parent's SkillManager) can
   // detach their listener at teardown — without this the SkillManager
   // accumulates listeners across subagent lifetimes, and each path
-  // activation would serialize through every stale listener's
-  // refreshSkills / setTools round-trip.
+  // activation would serialize through every stale listener's refreshSkills run.
   removeChangeListener;
   /**
-   * Asynchronously initializes the tool by loading available skills
-   * and updating the description and schema.
+   * Refreshes the in-memory runtime sets — `availableSkills`,
+   * `pendingConditionalSkillNames`, `modelInvocableCommands` — that back
+   * `validateToolParams` / `execute`. Invoked on construction and whenever the
+   * SkillManager fires a change (skill-file edit, conditional activation, config
+   * toggle, or MCP-prompt provider change).
+   *
+   * It deliberately does NOT mutate the tool declaration or call
+   * `geminiClient.setTools()`. The Skill tool's description is static
+   * (`SKILL_TOOL_DESCRIPTION`), so the skill set no longer affects the tools
+   * block — and the tools block is the front of the tools → system → messages
+   * prompt-cache prefix, where any byte change invalidates the whole cached
+   * prefix. These runtime sets are in-memory only and never serialized into a
+   * request, so refreshing them is prompt-cache-neutral. The model's view of the
+   * available skills comes from the `<available_skills>` snapshot in the startup
+   * prelude plus per-turn `<system-reminder>` deltas.
    */
   async refreshSkills() {
     try {
-      const allSkills = await this.skillManager.listSkills();
-      this.availableSkills = allSkills.filter(
-        (s) => !s.disableModelInvocation && this.skillManager.isSkillActive(s)
-      );
-      this.pendingConditionalSkillNames = new Set(
-        allSkills.filter(
-          (s) => !s.disableModelInvocation && s.paths && s.paths.length > 0 && !this.skillManager.isSkillActive(s)
-        ).map((s) => s.name)
-      );
-      const provider = this.config.getModelInvocableCommandsProvider();
-      const allCommands = provider ? provider() : [];
-      const fileBasedSkillNames = new Set(
-        allSkills.filter((s) => !s.disableModelInvocation).map((s) => s.name)
+      const collected = await collectAvailableSkillEntries(
+        this.skillManager,
+        this.config
       );
-      this.modelInvocableCommands = allCommands.filter(
-        (cmd) => !fileBasedSkillNames.has(cmd.name)
-      );
-      this.updateDescriptionAndSchema();
+      this.availableSkills = collected.availableSkills;
+      this.pendingConditionalSkillNames = collected.pendingConditionalSkillNames;
+      this.modelInvocableCommands = collected.modelInvocableCommands;
     } catch (error) {
       debugLogger.warn("Failed to load skills for Skills tool:", error);
       this.availableSkills = [];
       this.pendingConditionalSkillNames = /* @__PURE__ */ new Set();
       this.modelInvocableCommands = [];
-      this.updateDescriptionAndSchema();
-    } finally {
-      const geminiClient = this.config.getGeminiClient();
-      if (geminiClient) {
-        await geminiClient.setTools();
-      }
-    }
-  }
-  /**
-   * Updates the tool's description and schema based on available skills and
-   * model-invocable commands (e.g. bundled skills, file commands, MCP prompts).
-   */
-  updateDescriptionAndSchema() {
-    const allSkillEntries = [];
-    for (const skill of this.availableSkills) {
-      const descText = `${escapeXml(skill.description)}${skill.whenToUse ? ` \u2014 ${escapeXml(skill.whenToUse)}` : ""} (${skill.level})`;
-      allSkillEntries.push(`<skill>
-<name>
-${escapeXml(skill.name)}
-</name>
-<description>
-${descText}
-</description>
-<location>
-${skill.level}
-</location>
-</skill>`);
-    }
-    for (const cmd of this.modelInvocableCommands) {
-      allSkillEntries.push(`<skill>
-<name>
-${escapeXml(cmd.name)}
-</name>
-<description>
-${escapeXml(cmd.description)}
-</description>
-</skill>`);
     }
-    let skillDescriptions = "";
-    if (allSkillEntries.length === 0) {
-      skillDescriptions = "No skills are currently configured. Skills can be created by adding directories with SKILL.md files to .qwen/skills/ or ~/.qwen/skills/.";
-    } else {
-      skillDescriptions = allSkillEntries.join("\n");
-    }
-    const baseDescription = `Execute a skill within the main conversation
-
-<skills_instructions>
-When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
-
-How to invoke:
-- Use this tool with the skill name only (no arguments)
-- Examples:
-  - \`skill: "pdf"\` - invoke the pdf skill
-  - \`skill: "xlsx"\` - invoke the xlsx skill
-  - \`skill: "ms-office-suite:pdf"\` - invoke using fully qualified name
-
-Important:
-- When a skill is relevant, you must invoke this tool IMMEDIATELY as your first action
-- NEVER just announce or mention a skill in your text response without actually calling this tool
-- This is a BLOCKING REQUIREMENT: invoke the relevant Skill tool BEFORE generating any other response about the task
-- Only use skills listed in <available_skills> below
-- Do not invoke a skill that is already running
-- Do not use this tool for built-in CLI commands (like /help, /clear, etc.)
-- When executing scripts or loading referenced files, ALWAYS resolve absolute paths from skill's base directory. Examples:
-  - \`bash scripts/init.sh\` -> \`bash /path/to/skill/scripts/init.sh\`
-  - \`python scripts/helper.py\` -> \`python /path/to/skill/scripts/helper.py\`
-  - \`reference.md\` -> \`/path/to/skill/reference.md\`
-</skills_instructions>
-
-<available_skills>
-${skillDescriptions}
-</available_skills>`;
-    this.description = baseDescription;
   }
   validateToolParams(params) {
     if (!params.skill || typeof params.skill !== "string" || params.skill.trim() === "") {
       return 'Parameter "skill" must be a non-empty string.';
     }
+    if (params.args !== void 0 && typeof params.args !== "string") {
+      return 'Parameter "args" must be a string when provided.';
+    }
     const skillExists = this.availableSkills.some(
       (skill) => skill.name === params.skill
     );
@@ -215,6 +180,9 @@ ${skillDescriptions}
       (cmd) => cmd.name === params.skill
     );
     if (commandExists) return null;
+    if (this.config.getDisabledSkillNames().has(params.skill.toLowerCase())) {
+      return `Skill "${params.skill}" is disabled. Re-enable it via /skills or remove it from skills.disabled.`;
+    }
     if (this.pendingConditionalSkillNames.has(params.skill)) {
       return `Skill "${params.skill}" is gated by path-based activation (paths: frontmatter) and is not yet available. Access a file matching its paths patterns first to activate it.`;
     }
@@ -237,7 +205,7 @@ ${skillDescriptions}
     );
   }
   toAutoClassifierInput(params) {
-    return { skill: params.skill };
+    return params.args === void 0 ? { skill: params.skill } : { skill: params.skill, args: params.args };
   }
   getAvailableSkillNames() {
     return this.availableSkills.map((skill) => skill.name);
@@ -265,7 +233,7 @@ ${skillDescriptions}
    * SkillManager would accumulate one stale listener per subagent
    * lifetime — and `notifyChangeListeners` is now `await`-ed
    * sequentially, so each path activation would serialize through every
-   * accumulated listener's refreshSkills + setTools round-trip.
+   * accumulated listener's refreshSkills run.
    */
   dispose() {
     this.removeChangeListener();
@@ -282,8 +250,14 @@ var SkillToolInvocation = class extends BaseToolInvocation {
   static {
     __name(this, "SkillToolInvocation");
   }
+  // Populated by scheduler via setPromptId; empty = direct/non-scheduled
+  // call, filter `prompt_id != ''` downstream. See design doc §4.1.1.
+  promptId = "";
+  setPromptId(promptId) {
+    this.promptId = promptId;
+  }
   getDescription() {
-    return `Use skill: "${this.params.skill}"`;
+    return this.params.args === void 0 ? `Use skill: "${this.params.skill}"` : `Use skill: "${this.params.skill}" with args: "${formatArgsForDescription(this.params.args)}"`;
   }
   /**
    * Skills load user-defined code that runs with the agent's tool
@@ -297,28 +271,71 @@ var SkillToolInvocation = class extends BaseToolInvocation {
     return "ask";
   }
   async execute(_signal, _updateOutput) {
+    const disabled = this.config.getDisabledSkillNames().has(this.params.skill.toLowerCase());
+    if (disabled) {
+      if (this.commandExecutor) {
+        try {
+          const content = await this.commandExecutor(
+            this.params.skill,
+            this.params.args ?? ""
+          );
+          if (content && typeof content === "object" && "error" in content) {
+            return {
+              llmContent: content.error,
+              returnDisplay: content.error
+            };
+          }
+          if (typeof content === "string") {
+            return {
+              llmContent: [{ text: content }],
+              returnDisplay: `Delegated to command: ${this.params.skill}`
+            };
+          }
+        } catch {
+        }
+      }
+      logSkillLaunch(
+        this.config,
+        new SkillLaunchEvent(this.params.skill, false, this.promptId)
+      );
+      const msg = `Skill "${this.params.skill}" is disabled. Re-enable it via /skills or remove it from skills.disabled.`;
+      return { llmContent: msg, returnDisplay: msg };
+    }
     try {
       const skill = await this.skillManager.loadSkillForRuntime(
         this.params.skill
       );
       if (!skill) {
         if (this.commandExecutor) {
-          const content = await this.commandExecutor(this.params.skill);
-          if (content !== null) {
+          const commandResult = await this.commandExecutor(
+            this.params.skill,
+            this.params.args ?? ""
+          );
+          if (commandResult && typeof commandResult === "object" && "error" in commandResult) {
             logSkillLaunch(
               this.config,
-              new SkillLaunchEvent(this.params.skill, true)
+              new SkillLaunchEvent(this.params.skill, false, this.promptId)
+            );
+            return {
+              llmContent: commandResult.error,
+              returnDisplay: commandResult.error
+            };
+          }
+          if (typeof commandResult === "string") {
+            logSkillLaunch(
+              this.config,
+              new SkillLaunchEvent(this.params.skill, true, this.promptId)
             );
             this.onSkillLoaded(this.params.skill);
             return {
-              llmContent: [{ text: content }],
+              llmContent: [{ text: commandResult }],
               returnDisplay: `Executed command: ${this.params.skill}`
             };
           }
         }
         logSkillLaunch(
           this.config,
-          new SkillLaunchEvent(this.params.skill, false)
+          new SkillLaunchEvent(this.params.skill, false, this.promptId)
         );
         const parseErrors = this.skillManager.getParseErrors();
         const errorMessages = [];
@@ -337,9 +354,13 @@ ${errorMessages.join("\n")}` : "";
       }
       logSkillLaunch(
         this.config,
-        new SkillLaunchEvent(this.params.skill, true)
+        new SkillLaunchEvent(this.params.skill, true, this.promptId)
       );
       this.onSkillLoaded(this.params.skill);
+      applySkillAllowedTools(
+        this.config.getPermissionManager(),
+        skill.allowedTools
+      );
       debugLogger.debug("Skill hooks check:", {
         hasHooks: !!skill.hooks,
         hooksKeys: skill.hooks ? Object.keys(skill.hooks) : [],
@@ -386,7 +407,7 @@ ${errorMessages.join("\n")}` : "";
       debugLogger.error(`[SkillsTool] Error using skill: ${errorMessage}`);
       logSkillLaunch(
         this.config,
-        new SkillLaunchEvent(this.params.skill, false)
+        new SkillLaunchEvent(this.params.skill, false, this.promptId)
       );
       return {
         llmContent: `Failed to load skill "${this.params.skill}": ${errorMessage}`,
@@ -395,6 +416,11 @@ ${errorMessages.join("\n")}` : "";
     }
   }
 };
+function formatArgsForDescription(args) {
+  const escapeMarkdown = /* @__PURE__ */ __name((value) => value.replace(/([\\`*_{}[\]()#+\-.!|>])/g, "\\$1"), "escapeMarkdown");
+  return args.length > 120 ? `${escapeMarkdown(args.slice(0, 117))}...` : escapeMarkdown(args);
+}
+__name(formatArgsForDescription, "formatArgsForDescription");
 export {
   SkillTool,
   buildSkillLlmContent