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

package/chunks/team-create-7R7KA5IP.js

@@ -0,0 +1,314 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  InProcessBackend,
+  TeamManager
+} from "./chunk-TD4OPI4T.js";
+import "./chunk-K5PGHDBN.js";
+import {
+  resetTaskList
+} from "./chunk-XBY7E2FX.js";
+import "./chunk-SKBPNJEW.js";
+import "./chunk-NVFMZBX2.js";
+import "./chunk-O4PICXES.js";
+import "./chunk-TW522KN6.js";
+import {
+  clearAllInboxes
+} from "./chunk-3DHXZ6EV.js";
+import {
+  createTeamFile,
+  formatAgentId,
+  getTasksDir,
+  getTeamDir,
+  sanitizeName,
+  tryReclaimStaleTeam
+} from "./chunk-J5MDQKJL.js";
+import "./chunk-MLZQVCF3.js";
+import {
+  LEADER_NAME,
+  MAX_TEAMMATES
+} from "./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 {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolDisplayNames,
+  ToolNames
+} from "./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 {
+  isNodeError
+} from "./chunk-HR7SV7AY.js";
+import "./chunk-ZERZSAZL.js";
+import "./chunk-QN5NZ3UQ.js";
+import "./chunk-BR4QREVK.js";
+import "./chunk-Z2Z3GUXZ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/tools/team-create.ts
+init_esbuild_shims();
+var TeamCreateInvocation = class extends BaseToolInvocation {
+  constructor(config, params) {
+    super(params);
+    this.config = config;
+  }
+  static {
+    __name(this, "TeamCreateInvocation");
+  }
+  getDescription() {
+    return `Create team "${this.params.team_name}"`;
+  }
+  async execute() {
+    const teamName = sanitizeName(this.params.team_name);
+    if (!teamName) {
+      const msg = "Team name is required.";
+      return {
+        llmContent: msg,
+        returnDisplay: msg,
+        error: { message: msg }
+      };
+    }
+    if (this.config.getArenaManager()) {
+      const msg = "Cannot create a team while an Arena session is active. End the Arena session first.";
+      return {
+        llmContent: msg,
+        returnDisplay: msg,
+        error: { message: msg }
+      };
+    }
+    if (this.config.getTeamManager()) {
+      const msg = "A team is already active. Delete it before creating a new one.";
+      return {
+        llmContent: msg,
+        returnDisplay: msg,
+        error: { message: msg }
+      };
+    }
+    const leadAgentId = formatAgentId(LEADER_NAME, teamName);
+    const teamFile = {
+      name: teamName,
+      description: this.params.description,
+      createdAt: Date.now(),
+      leadAgentId,
+      leadSessionId: this.config.getSessionId(),
+      leadPid: process.pid,
+      members: []
+    };
+    try {
+      await createTeamFile(teamName, teamFile);
+    } catch (err) {
+      if (isNodeError(err) && err.code === "EEXIST") {
+        const reclaimed = await tryReclaimStaleTeam(teamName);
+        if (!reclaimed) {
+          const msg = `Team "${teamName}" already exists and appears to be owned by a live qwen-code session. Pick a different name, or \u2014 if you're sure no other session is using it \u2014 remove the on-disk artifacts manually:
+  rm -rf "${getTeamDir(teamName)}" "${getTasksDir(teamName)}"`;
+          return {
+            llmContent: msg,
+            returnDisplay: msg,
+            error: { message: msg }
+          };
+        }
+        await createTeamFile(teamName, teamFile);
+      } else {
+        throw err;
+      }
+    }
+    await resetTaskList(teamName);
+    await clearAllInboxes(teamName);
+    const backend = new InProcessBackend(this.config);
+    await backend.init();
+    const manager = new TeamManager(
+      backend,
+      teamFile,
+      this.config.getSubagentManager(),
+      {
+        maxTeammates: this.config.getAgentsSettings().team?.maxTeammates
+      }
+    );
+    this.config.setTeamManager(manager);
+    const ctx = {
+      teamName,
+      leadAgentId,
+      teammates: {}
+    };
+    this.config.setTeamContext(ctx);
+    const display = {
+      type: "team_result",
+      teamName,
+      action: "created"
+    };
+    const llmContent = `Team "${teamName}" created.` + (this.params.description ? ` Description: ${this.params.description}` : "");
+    return { llmContent, returnDisplay: display };
+  }
+};
+var TeamCreateTool = class _TeamCreateTool extends BaseDeclarativeTool {
+  constructor(config) {
+    super(
+      _TeamCreateTool.Name,
+      ToolDisplayNames.TEAM_CREATE,
+      `# TeamCreate
+
+## When to Use
+
+Use this tool proactively whenever:
+- The user explicitly asks to use a team, swarm, or group of agents
+- The user mentions wanting agents to work together, coordinate, or collaborate
+- A task is complex enough that it would benefit from parallel work by multiple agents (e.g., building a full-stack feature with frontend and backend work, refactoring a codebase while keeping tests passing, implementing a multi-step project with research, planning, and coding phases)
+
+When in doubt about whether a task warrants a team, prefer spawning a team.
+
+## Choosing Agent Types for Teammates
+
+When spawning teammates via the Agent tool, choose the \`subagent_type\` based on what tools the agent needs for its task. Each agent type has a different set of available tools \u2014 match the agent to the work:
+
+- **Read-only agents** (e.g., Explore, Plan) cannot edit or write files. Only assign them research, search, or planning tasks. Never assign them implementation work.
+- **Full-capability agents** (e.g., general-purpose) have access to all tools including file editing, writing, and bash. Use these for tasks that require making changes.
+- **Custom agents** defined in \`.qwen/agents/\` may have their own tool restrictions. Check their descriptions to understand what they can and cannot do.
+
+Always review the agent type descriptions and their available tools listed in the Agent tool prompt before selecting a \`subagent_type\` for a teammate.
+
+Create a new team to coordinate multiple agents working on a project. Teams have a 1:1 correspondence with task lists (Team = TaskList).
+
+\`\`\`
+{
+  "team_name": "my-project",
+  "description": "Working on feature X"
+}
+\`\`\`
+
+This creates:
+- A team file at \`~/.qwen/teams/{team-name}/config.json\`
+- A corresponding task list directory at \`~/.qwen/tasks/{team-name}/\`
+
+## Team Workflow
+
+1. **Create a team** with TeamCreate - this creates both the team and its task list
+2. **Create tasks** using the Task tools (TaskCreate, TaskList, etc.) - they automatically use the team's task list
+3. **Spawn teammates** using the Agent tool with the \`name\` parameter to create teammates that join the active team (max ${config.getAgentsSettings().team?.maxTeammates ?? MAX_TEAMMATES} teammates per team)
+4. **Assign tasks** using TaskUpdate with \`owner\` to give tasks to idle teammates
+5. **Teammates work on assigned tasks** and mark them completed via TaskUpdate
+6. **Teammates go idle between turns** - after each turn, teammates automatically go idle and send a notification. IMPORTANT: Be patient with idle teammates! Don't comment on their idleness until it actually impacts your work.
+7. **Shutdown your team** - when the task is completed, gracefully shut down your teammates via SendMessage with \`type: "shutdown_request"\` (a top-level parameter alongside \`to\` and \`message\`).
+
+## Task Ownership
+
+Tasks are assigned using TaskUpdate with the \`owner\` parameter. Any agent can set or change task ownership via TaskUpdate.
+
+## Automatic Message Delivery
+
+**IMPORTANT**: Messages from teammates are automatically delivered to you. You do NOT need to manually check your inbox.
+
+When you spawn teammates:
+- They will send you messages when they complete tasks or need help
+- These messages appear automatically as new conversation turns (like user messages)
+- If you're busy (mid-turn), messages are queued and delivered when your turn ends
+- The UI shows a brief notification with the sender's name when messages are waiting
+
+Messages will be delivered automatically.
+
+When reporting on teammate messages, you do NOT need to quote the original message\u2014it's already rendered to the user.
+
+## Teammate Idle State
+
+Teammates go idle after every turn\u2014this is completely normal and expected. A teammate going idle immediately after sending you a message does NOT mean they are done or unavailable. Idle simply means they are waiting for input.
+
+- **Idle teammates can receive messages.** Sending a message to an idle teammate wakes them up and they will process it normally.
+- **Idle notifications are automatic.** The system sends an idle notification whenever a teammate's turn ends. You do not need to react to idle notifications unless you want to assign new work or send a follow-up message.
+- **Do not treat idle as an error.** A teammate sending a message and then going idle is the normal flow\u2014they sent their message and are now waiting for a response.
+- **Peer DM visibility.** When a teammate sends a DM to another teammate, a brief summary is included in their idle notification. This gives you visibility into peer collaboration without the full message content. You do not need to respond to these summaries \u2014 they are informational.
+
+## Discovering Team Members
+
+Teammates can read the team config file to discover other team members:
+- **Team config location**: \`~/.qwen/teams/{team-name}/config.json\`
+
+The config file contains a \`members\` array with each teammate's:
+- \`name\`: Human-readable name (**always use this** for messaging and task assignment)
+- \`agentId\`: Unique identifier (for reference only - do not use for communication)
+- \`agentType\`: Role/type of the agent
+
+**IMPORTANT**: Always refer to teammates by their NAME (e.g., "team-lead", "researcher", "tester"). Names are used for:
+- \`to\` when sending messages
+- Identifying task owners
+
+Example of reading team config:
+\`\`\`
+Use the Read tool to read ~/.qwen/teams/{team-name}/config.json
+\`\`\`
+
+## Task List Coordination
+
+Teams share a task list that all teammates can access at \`~/.qwen/tasks/{team-name}/\`.
+
+Teammates should:
+1. Check TaskList periodically, **especially after completing each task**, to find available work or see newly unblocked tasks
+2. Claim unassigned, unblocked tasks with TaskUpdate (set \`owner\` to your name). **Prefer tasks in ID order** (lowest ID first) when multiple tasks are available, as earlier tasks often set up context for later ones
+3. Create new tasks with \`TaskCreate\` when identifying additional work
+4. Mark tasks as completed with \`TaskUpdate\` when done, then check TaskList for next work
+5. Coordinate with other teammates by reading the task list status
+6. If all available tasks are blocked, notify the team lead or help resolve blocking tasks
+
+**IMPORTANT notes for communication with your team**:
+- Do not use terminal tools to view your team's activity; always send a message to your teammates (and remember, refer to them by name).
+- Your team cannot hear you if you do not use the SendMessage tool. Always send a message to your teammates if you are responding to them.
+- Do NOT send structured JSON status messages like \`{"type":"idle",...}\` or \`{"type":"task_completed",...}\`. Just communicate in plain text when you need to message teammates.
+- Use TaskUpdate to mark tasks completed.
+- If you are an agent in the team, the system will automatically send idle notifications to the team lead when you stop.`,
+      "other" /* Other */,
+      {
+        type: "object",
+        properties: {
+          team_name: {
+            type: "string",
+            description: "Name for the team (alphanumeric and hyphens)."
+          },
+          description: {
+            type: "string",
+            description: "Optional description of the team."
+          }
+        },
+        required: ["team_name"],
+        additionalProperties: false
+      }
+    );
+    this.config = config;
+  }
+  static {
+    __name(this, "TeamCreateTool");
+  }
+  static Name = ToolNames.TEAM_CREATE;
+  createInvocation(params) {
+    return new TeamCreateInvocation(this.config, params);
+  }
+};
+export {
+  TeamCreateTool
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/team-delete-25OIWUPN.js

@@ -0,0 +1,116 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  disposeInboxLocks,
+  unregisterLeader
+} from "./chunk-3DHXZ6EV.js";
+import {
+  deleteTeamDirs
+} from "./chunk-J5MDQKJL.js";
+import {
+  isTeammate
+} from "./chunk-LD2XBG6Z.js";
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolDisplayNames,
+  ToolNames
+} from "./chunk-D3RHSPAS.js";
+import "./chunk-B7HXHOHU.js";
+import {
+  createDebugLogger
+} from "./chunk-HR7SV7AY.js";
+import "./chunk-Z2Z3GUXZ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/tools/team-delete.ts
+init_esbuild_shims();
+var debug = createDebugLogger("TEAM_DELETE");
+var TeamDeleteInvocation = class extends BaseToolInvocation {
+  constructor(config, params) {
+    super(params);
+    this.config = config;
+  }
+  static {
+    __name(this, "TeamDeleteInvocation");
+  }
+  getDescription() {
+    return "Delete current team";
+  }
+  async execute() {
+    if (isTeammate()) {
+      const msg2 = "Only the team leader can delete the team.";
+      return {
+        llmContent: msg2,
+        returnDisplay: msg2,
+        error: { message: msg2 }
+      };
+    }
+    const manager = this.config.getTeamManager();
+    if (!manager) {
+      const msg2 = "No active team to delete.";
+      return {
+        llmContent: msg2,
+        returnDisplay: msg2,
+        error: { message: msg2 }
+      };
+    }
+    const teamFile = manager.getTeamFile();
+    const teamName = teamFile.name;
+    try {
+      await manager.cleanup();
+    } catch (err) {
+      debug.warn("Team cleanup failed; resetting team state anyway:", err);
+    }
+    await deleteTeamDirs(teamName);
+    await new Promise((r) => setTimeout(r, 250));
+    await deleteTeamDirs(teamName);
+    disposeInboxLocks(teamName);
+    this.config.setTeamManager(null);
+    this.config.setTeamContext(null);
+    unregisterLeader();
+    const display = {
+      type: "team_result",
+      teamName,
+      action: "deleted"
+    };
+    const msg = `Team "${teamName}" deleted.`;
+    return { llmContent: msg, returnDisplay: display };
+  }
+};
+var TeamDeleteTool = class _TeamDeleteTool extends BaseDeclarativeTool {
+  constructor(config) {
+    super(
+      _TeamDeleteTool.Name,
+      ToolDisplayNames.TEAM_DELETE,
+      "Delete the current team. Stops all teammates, cleans up team files, tasks, and inboxes. Only the team leader can use this.",
+      "delete" /* Delete */,
+      {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      }
+    );
+    this.config = config;
+  }
+  static {
+    __name(this, "TeamDeleteTool");
+  }
+  static Name = ToolNames.TEAM_DELETE;
+  createInvocation(params) {
+    return new TeamDeleteInvocation(this.config, params);
+  }
+};
+export {
+  TeamDeleteTool
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{todoWrite-VLAUG4CA.js → todoWrite-4YHMIF4X.js}

@@ -2,18 +2,21 @@
 "use strict";
 import {
   detectTodoChanges
-} from "./chunk-4AOCVI6J.js";
+} from "./chunk-SNGELLWX.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-XEGHDASV.js";
+} from "./chunk-D3RHSPAS.js";
+import {
+  atomicWriteFile
+} from "./chunk-B7HXHOHU.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-XP27SJMH.js";
-import "./chunk-QWSRH265.js";
+} from "./chunk-HR7SV7AY.js";
+import "./chunk-Z2Z3GUXZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -206,6 +209,12 @@ The assistant did not use the todo list because this is a single command executi
 </reasoning>
 </example>
 
+## Planning with Todos
+
+Before breaking work into low-level edits, use the todo list to reflect the overall approach at a meaningful level (for example: investigate, design, implement, verify). This helps maintain a global view of the task instead of jumping between isolated local changes.
+
+When new information changes your understanding of the task, update the todo structure to reflect the revised plan rather than only appending isolated follow-up items. The todo list should continue to represent the current overall strategy.
+
 ## Task States and Management
 
 1. **Task States**: Use these states to track progress:
@@ -267,7 +276,9 @@ async function writeTodosToFile(todos, sessionId) {
     todos,
     sessionId: sessionId || "default"
   };
-  await fs.writeFile(todoFilePath, JSON.stringify(data, null, 2), "utf-8");
+  await atomicWriteFile(todoFilePath, JSON.stringify(data, null, 2), {
+    encoding: "utf-8"
+  });
 }
 __name(writeTodosToFile, "writeTodosToFile");
 function createBlockedTodoResult(message, systemMessage) {

package/chunks/{tool-search-MZGHUUKD.js → tool-search-YBRVZCLI.js}

@@ -2,28 +2,31 @@
 "use strict";
 import {
   DiscoveredMCPTool
-} 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";
@@ -44,7 +47,7 @@ var SCORE_NAME_EXACT_MCP = 12;
 var SCORE_NAME_SUBSTR_MCP = 6;
 var toolSearchDescription = `Fetches function declarations for deferred tools and registers them with the active session so subsequent turns can call them.
 
-Deferred tools appear by name in the "Deferred Tools" section of the system prompt. Until fetched, only the name is known \u2014 there is no parameter schema, so the tool cannot be invoked. This tool takes a query, matches it against the deferred tool list, and returns the matched tools' function declarations (name + description + parameter schema) inside a <functions> block.
+Deferred tools appear by name in the deferred-tools startup reminder. Until fetched, only the name is known \u2014 there is no parameter schema, so the tool cannot be invoked. This tool takes a query, matches it against the deferred tool list, and returns the matched tools' function declarations (name + description + parameter schema) inside a <functions> block.
 
 The returned <functions> block is informational \u2014 it shows what the schema looks like. Calling the tool itself happens via the model's normal function-call mechanism on the NEXT turn, after the active session's declaration list has been updated. Tools fetched here remain available for the rest of the session.
 
@@ -210,6 +213,21 @@ var ToolSearchInvocation = class extends BaseToolInvocation {
 `
           );
         }
+        if (!setToolsError) {
+          try {
+            await geminiClient.refreshStartupContextReminder();
+          } catch (err) {
+            const refreshError = err instanceof Error ? err.message : String(err);
+            debugLogger.warn(
+              "refreshStartupContextReminder() failed after revealing deferred tools:",
+              err
+            );
+            process.stderr.write(
+              `[ToolSearch] refreshStartupContextReminder() failed after revealing deferred tools: ${refreshError}
+`
+            );
+          }
+        }
       }
       if (setToolsError) {
         for (const name of newlyRevealed) {

package/chunks/{tts-notification-K3X7X7MN.js → tts-notification-7SOEMQK4.js}

@@ -5,11 +5,11 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-XEGHDASV.js";
+} from "./chunk-D3RHSPAS.js";
 import {
   createDebugLogger
-} from "./chunk-XP27SJMH.js";
-import "./chunk-QWSRH265.js";
+} from "./chunk-HR7SV7AY.js";
+import "./chunk-Z2Z3GUXZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -110,6 +110,7 @@ export {
 };
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2026 Qwen
+ * Copyright 2026 Davide A. Guglielmi (Termux porting patches)
  * SPDX-License-Identifier: Apache-2.0
  */

package/chunks/{web-fetch-OILB464A.js → web-fetch-MFIRHIHI.js}

@@ -2,22 +2,22 @@
 "use strict";
 import {
   runSideQuery
-} from "./chunk-N4WOREMD.js";
+} from "./chunk-NVFMZBX2.js";
 import "./chunk-OFEVLU4C.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-XEGHDASV.js";
+} from "./chunk-D3RHSPAS.js";
 import {
   fetchWithTimeout,
   isPrivateIp
-} from "./chunk-KXZ4TJB4.js";
+} from "./chunk-SEGYWKIH.js";
 import {
   createDebugLogger
-} from "./chunk-XP27SJMH.js";
-import "./chunk-QWSRH265.js";
+} from "./chunk-HR7SV7AY.js";
+import "./chunk-Z2Z3GUXZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";