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

package/chunks/{chunk-JKMBWLFB.js → chunk-YILFYI5W.js}

@@ -2,23 +2,24 @@
 "use strict";
 import {
   t
-} from "./chunk-DQ4QTG7E.js";
+} from "./chunk-VV4F63BD.js";
 import {
+  computeThresholds,
   getCoreSystemPrompt
-} from "./chunk-3OCRHZA3.js";
+} from "./chunk-TD4OPI4T.js";
 import {
   buildSkillLlmContent
-} from "./chunk-G7YTSRES.js";
+} from "./chunk-OHEGWO4L.js";
 import {
   DiscoveredMCPTool,
   uiTelemetryService
-} from "./chunk-K6O2NBMF.js";
-import {
-  DEFAULT_TOKEN_LIMIT
-} from "./chunk-MAY32HXD.js";
+} from "./chunk-OQ7NJIY7.js";
 import {
   ToolNames
-} from "./chunk-XEGHDASV.js";
+} from "./chunk-D3RHSPAS.js";
+import {
+  DEFAULT_TOKEN_LIMIT
+} from "./chunk-M6VTDSVR.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -519,7 +520,13 @@ function isTerminalGoalStatusKind(kind) {
 __name(isTerminalGoalStatusKind, "isTerminalGoalStatusKind");
 
 // packages/cli/src/ui/commands/contextCommand.ts
-var DEFAULT_COMPRESSION_THRESHOLD = 0.7;
+function currentTier(tokens, thresholds) {
+  if (tokens >= thresholds.hard) return "hard";
+  if (tokens >= thresholds.auto) return "auto";
+  if (tokens >= thresholds.warn) return "warn";
+  return "safe";
+}
+__name(currentTier, "currentTier");
 function estimateTokens(text) {
   if (!text || text.length === 0) return 0;
   let asciiChars = 0;
@@ -567,12 +574,15 @@ async function collectContextData(config, showDetails) {
   const systemPromptTokens = estimateTokens(systemPromptText);
   const toolRegistry = config.getToolRegistry();
   const allTools = toolRegistry ? toolRegistry.getAllTools() : [];
-  const toolDeclarations = toolRegistry ? toolRegistry.getFunctionDeclarations({ includeDeferred: true }) : [];
+  const toolDeclarations = toolRegistry ? toolRegistry.getFunctionDeclarations() : [];
   const toolsJsonStr = JSON.stringify(toolDeclarations);
   const allToolsTokens = estimateTokens(toolsJsonStr);
   const builtinTools = [];
   const mcpTools = [];
   for (const tool of allTools) {
+    if (tool.shouldDefer && !tool.alwaysLoad && !toolRegistry?.isDeferredToolRevealed(tool.name)) {
+      continue;
+    }
     const toolJsonStr = JSON.stringify(tool.schema);
     const tokens = estimateTokens(toolJsonStr);
     if (tool instanceof DiscoveredMCPTool) {
@@ -625,8 +635,11 @@ ${skill.level}
     };
   });
   const skillsTokens = skillToolDefinitionTokens + loadedBodiesTokens;
-  const compressionThreshold = config.getChatCompression()?.contextPercentageThreshold ?? DEFAULT_COMPRESSION_THRESHOLD;
-  const autocompactBuffer = compressionThreshold > 0 ? Math.round((1 - compressionThreshold) * contextWindowSize) : 0;
+  const thresholds = computeThresholds(contextWindowSize);
+  const autocompactBuffer = Math.max(
+    0,
+    Math.round(contextWindowSize - thresholds.auto)
+  );
   const rawOverhead = systemPromptTokens + allToolsTokens + memoryFilesTokens + loadedBodiesTokens;
   const isEstimated = apiTotalTokens === 0;
   const mcpToolsTotalTokens = mcpTools.reduce(
@@ -703,6 +716,7 @@ ${skill.level}
       bodyTokens: item.bodyTokens ? Math.round(item.bodyTokens * overheadScale) : void 0
     })) : skills;
   }
+  const tierTokens = isEstimated ? rawOverhead : apiTotalTokens;
   const breakdown = {
     systemPrompt: displaySystemPrompt,
     builtinTools: displayBuiltinTools,
@@ -711,7 +725,9 @@ ${skill.level}
     skills: displaySkills,
     messages: messagesTokens,
     freeSpace,
-    autocompactBuffer
+    autocompactBuffer,
+    thresholds,
+    currentTier: currentTier(tierTokens, thresholds)
   };
   return {
     type: "context_usage" /* CONTEXT_USAGE */,
@@ -736,7 +752,7 @@ function fmtTokens(tokens) {
 }
 __name(fmtTokens, "fmtTokens");
 function fmtCategoryRow(label, tokens, contextWindowSize, indent = "  ") {
-  const percentage = (tokens / contextWindowSize * 100).toFixed(1);
+  const percentage = contextWindowSize > 0 ? (tokens / contextWindowSize * 100).toFixed(1) : "0.0";
   const right = `${fmtTokens(tokens)} tokens (${percentage}%)`;
   const leftPart = `${indent}${label}`;
   const totalWidth = 56;
@@ -744,6 +760,10 @@ function fmtCategoryRow(label, tokens, contextWindowSize, indent = "  ") {
   return `${leftPart}${" ".repeat(dots)}${right}`;
 }
 __name(fmtCategoryRow, "fmtCategoryRow");
+function formatNum(n) {
+  return Math.round(n).toLocaleString("en-US");
+}
+__name(formatNum, "formatNum");
 function formatContextUsageText(data) {
   const {
     modelName,
@@ -775,13 +795,15 @@ function formatContextUsageText(data) {
     lines.push("");
     lines.push(fmtCategoryRow("Used", totalTokens, contextWindowSize));
     lines.push(fmtCategoryRow("Free", breakdown.freeSpace, contextWindowSize));
+    lines.push("");
+    lines.push("**Compaction thresholds**");
     lines.push(
-      fmtCategoryRow(
-        "Autocompact buffer",
-        breakdown.autocompactBuffer,
-        contextWindowSize
-      )
+      `  Effective window:   ${formatNum(breakdown.thresholds.effectiveWindow)}  (window \u2212 ${formatNum(contextWindowSize - breakdown.thresholds.effectiveWindow)} reserve)`
     );
+    lines.push(`  Warn threshold:     ${formatNum(breakdown.thresholds.warn)}`);
+    lines.push(`  Auto threshold:     ${formatNum(breakdown.thresholds.auto)}`);
+    lines.push(`  Hard threshold:     ${formatNum(breakdown.thresholds.hard)}`);
+    lines.push(`  Current tier:       ${breakdown.currentTier}`);
     lines.push("");
     lines.push("**Usage by category**");
   }
@@ -877,7 +899,8 @@ var contextCommand = {
   kind: "built-in" /* BUILT_IN */,
   supportedModes: ["interactive", "non_interactive", "acp"],
   action: /* @__PURE__ */ __name(async (context, args) => {
-    const showDetails = args?.trim().toLowerCase() === "detail" || args?.trim().toLowerCase() === "-d";
+    const normalizedArgs = args?.trim().toLowerCase();
+    const showDetails = normalizedArgs === "detail" || normalizedArgs === "-d";
     const executionMode = context.executionMode ?? "interactive";
     const { config } = context.services;
     if (!config) {
@@ -901,13 +924,12 @@ var contextCommand = {
     if (executionMode === "interactive") {
       context.ui.addItem(contextUsageItem, Date.now());
       return;
-    } else {
-      return {
-        type: "message",
-        messageType: "info",
-        content: formatContextUsageText(contextUsageItem)
-      };
     }
+    return {
+      type: "message",
+      messageType: "info",
+      content: formatContextUsageText(contextUsageItem)
+    };
   }, "action"),
   subCommands: [
     {

package/chunks/chunk-YOGAOMYB.js

@@ -0,0 +1,159 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  createTask
+} from "./chunk-XBY7E2FX.js";
+import {
+  resolveActiveTeamName
+} from "./chunk-LD2XBG6Z.js";
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolDisplayNames,
+  ToolNames
+} from "./chunk-D3RHSPAS.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/tools/task-create.ts
+init_esbuild_shims();
+var CONFIRMATION_DESCRIPTION_LIMIT = 2e3;
+function truncateForConfirmation(text) {
+  if (text.length <= CONFIRMATION_DESCRIPTION_LIMIT) return text;
+  return `${text.slice(0, CONFIRMATION_DESCRIPTION_LIMIT)}
+\u2026 (${text.length - CONFIRMATION_DESCRIPTION_LIMIT} more characters)`;
+}
+__name(truncateForConfirmation, "truncateForConfirmation");
+var TaskCreateInvocation = class extends BaseToolInvocation {
+  constructor(config, params) {
+    super(params);
+    this.config = config;
+  }
+  static {
+    __name(this, "TaskCreateInvocation");
+  }
+  getDescription() {
+    return `Create task: ${this.params.subject}`;
+  }
+  /**
+   * A task's `description` becomes the prompt an idle teammate auto-claims
+   * and executes with full tool access — the same privileged-sink shape as
+   * `send_message`, where free-form text turns into a new instruction for
+   * another agent. The base default `'allow'` short-circuits the classifier
+   * in AUTO mode, so override to `'ask'` to keep that injection path under
+   * the classifier / human-in-the-loop.
+   */
+  async getDefaultPermission() {
+    return "ask";
+  }
+  /**
+   * Unlike the one-line getDescription() used for transcript rendering,
+   * the confirmation prompt must show the instruction text itself: the
+   * `description` is what an idle teammate will auto-claim and execute
+   * with full tool access, so it is exactly what the human is approving.
+   */
+  getConfirmationDetails(_abortSignal) {
+    const details = {
+      type: "info",
+      title: "Confirm TaskCreate",
+      prompt: `Create task: ${this.params.subject}
+
+` + truncateForConfirmation(this.params.description),
+      onConfirm: /* @__PURE__ */ __name(async () => {
+      }, "onConfirm")
+    };
+    return Promise.resolve(details);
+  }
+  async execute() {
+    const teamName = resolveActiveTeamName(
+      this.config.getTeamContext()?.teamName
+    );
+    if (!teamName) {
+      const msg = "No active team. Create a team first.";
+      return {
+        llmContent: msg,
+        returnDisplay: msg,
+        error: { message: msg }
+      };
+    }
+    const task = await createTask(teamName, {
+      subject: this.params.subject,
+      description: this.params.description,
+      activeForm: this.params.activeForm,
+      metadata: this.params.metadata
+    });
+    const llmContent = `Task #${task.id} created: "${task.subject}"`;
+    return { llmContent, returnDisplay: llmContent };
+  }
+};
+var TaskCreateTool = class _TaskCreateTool extends BaseDeclarativeTool {
+  constructor(config) {
+    super(
+      _TaskCreateTool.Name,
+      ToolDisplayNames.TASK_CREATE,
+      "Create a new task in the team task list. Tasks are automatically assigned to idle teammates.",
+      "other" /* Other */,
+      {
+        type: "object",
+        properties: {
+          subject: {
+            type: "string",
+            description: "Short title for the task.",
+            maxLength: 200
+          },
+          description: {
+            type: "string",
+            description: "Detailed description of the task.",
+            maxLength: 1e4
+          },
+          activeForm: {
+            type: "string",
+            maxLength: 200,
+            description: 'Present tense label for UI (e.g., "Running tests").'
+          },
+          metadata: {
+            type: "object",
+            description: "Optional arbitrary metadata."
+          }
+        },
+        required: ["subject", "description"],
+        additionalProperties: false
+      }
+    );
+    this.config = config;
+  }
+  static {
+    __name(this, "TaskCreateTool");
+  }
+  static Name = ToolNames.TASK_CREATE;
+  createInvocation(params) {
+    return new TaskCreateInvocation(this.config, params);
+  }
+  /**
+   * Forward the task content to the classifier. The base sentinel `''`
+   * projects to an empty args object, so without this override the AUTO
+   * classifier rules on `task_create({})` — the injected payload that
+   * `getDefaultPermission() === 'ask'` exists to inspect would be
+   * invisible to it. Mirrors `send_message`'s projection.
+   */
+  toAutoClassifierInput(params) {
+    return {
+      subject: params.subject,
+      description: params.description
+    };
+  }
+};
+
+export {
+  truncateForConfirmation,
+  TaskCreateTool
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */