muonroi-cli 1.7.2 → 1.8.0

package/dist/src/orchestrator/stream-runner.js

@@ -34,8 +34,10 @@ import { normalizeModelId } from "../models/registry.js";
 import { cheapModelShellLine, injectCheapModelPlaybook, injectCheapModelShellDirective, shouldInjectCheapModelPlaybook, } from "../pil/cheap-model-playbook.js";
 import { injectCheapModelWorkbook, shouldInjectCheapModelWorkbook, subagentTaskType, } from "../pil/cheap-model-workbooks.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
+import { getVisionGuidanceForTextOnly } from "../providers/mcp-vision-bridge.js";
 import { captureToolSchemas } from "../providers/patch-zod-schema.js";
 import { buildTurnProviderOptions, requireRuntimeProvider, resolveModelRuntime, shouldDropParam, } from "../providers/runtime.js";
+import { needsVisionProxy } from "../providers/vision-proxy.js";
 import { wireDebug } from "../providers/wire-debug.js";
 import { BashTool } from "../tools/bash.js";
 import { createBuiltinTools } from "../tools/registry.js";
@@ -56,7 +58,7 @@ import { attachReminderToMessages, buildScopeReminder, cadenceForSize, shouldInj
 import { recordCompaction, recordElision } from "./session-experience.js";
 import { createStallWatchdog, STALL_ERROR_MESSAGE } from "./stall-watchdog.js";
 import { wrapToolSetWithCap } from "./sub-agent-cap.js";
-import { compactSubAgentMessages } from "./subagent-compactor.js";
+import { compactSubAgentMessages, applyAnthropicPromptCaching } from "./subagent-compactor.js";
 import { combineAbortSignals, firstLine, formatSubagentActivity } from "./tool-utils.js";
 /**
  * StreamRunner — extracted sub-agent stream lifecycle.
@@ -133,10 +135,19 @@ export class StreamRunner {
                 : topBash.getSandboxSettings(),
             shellSettings: getCurrentShellSettings(),
         });
+        // Resolve child model early so we can pass modelId to createBuiltinTools
+        // (needed for vision-proxy tools: analyze_image / ask_vision_proxy).
+        const childModelId = normalizeModelId(isVision
+            ? VISION_MODEL
+            : isComputer
+                ? COMPUTER_MODEL
+                : custom
+                    ? custom.model
+                    : this.deps.resolveModelForTask(isExplore ? "explore" : isVerify || isVerifyDetect || isVerifyManifest ? "verify" : "general"));
         // Mirror the file-local `createTools` wrapper from orchestrator.ts —
-        // it calls createBuiltinTools(bash, mode) without provider/opts; the
-        // provider arg in the original wrapper was unused.
-        const childBaseToolsRaw = createBuiltinTools(childBash, childMode);
+        // pass modelId so registry can inject analyze_image/ask_vision_proxy for
+        // text-only child models (needsVisionProxy).
+        const childBaseToolsRaw = createBuiltinTools(childBash, childMode, { modelId: childModelId });
         // Wrap with the cumulative cap so the sub-agent's tool loop cannot
         // accumulate unbounded tool_result tokens. See sub-agent-cap.ts for the
         // tiered compression schedule. The cap is per-invocation; each sub-agent
@@ -161,13 +172,6 @@ export class StreamRunner {
         let lastActivity = initialDetail;
         let childTools = childBaseTools;
         let closeMcp;
-        const childModelId = normalizeModelId(isVision
-            ? VISION_MODEL
-            : isComputer
-                ? COMPUTER_MODEL
-                : custom
-                    ? custom.model
-                    : this.deps.resolveModelForTask(isExplore ? "explore" : isVerify || isVerifyDetect || isVerifyManifest ? "verify" : "general"));
         const topModelId = this.deps.getModelId();
         if (childModelId !== topModelId) {
             statusBarStore.setState({ routed_from: topModelId, model: childModelId });
@@ -212,6 +216,11 @@ export class StreamRunner {
         const childSystem = shouldInjectCheapModelPlaybook(childRuntime.modelInfo)
             ? injectCheapModelShellDirective(childWithPlaybook, cheapModelShellLine(resolveShell({}).kind, process.platform))
             : childWithPlaybook;
+        // Inject vision proxy guidance for text-only child models (DeepSeek etc.)
+        // so sub-agents know to use analyze_image / ask_vision_proxy when they
+        // receive image context or file paths. Mirrors top-level in message-processor.
+        const visionGuidance = needsVisionProxy(childModelId) ? getVisionGuidanceForTextOnly(childModelId) : "";
+        const childSystemWithVision = visionGuidance ? `${childSystem}\n\n${visionGuidance}` : childSystem;
         onActivity?.(initialDetail);
         if (childMode === "agent" && taskCaps.supportsClientTools(childRuntime.modelInfo)) {
             const mcpBundle = await acquireMcpTools(loadMcpServers(), {
@@ -245,7 +254,8 @@ export class StreamRunner {
         // signal is intentionally unused on this branch — vision was the only consumer.
         void signal;
         const childMessages = [{ role: "user", content: childPrompt }];
-        const maxSteps = Math.min(this.deps.getMaxToolRounds(), isExplore ? 60 : 120);
+        // The main agent manages its sub-agents, so don't apply an arbitrary hard limit.
+        const maxSteps = request.maxToolRounds ?? (this.deps.getMaxToolRounds() * 2);
         // F1 parity — derive per-turn providerOptions so the sub-agent OpenAI calls
         // carry a stable session-derived promptCacheKey (every tool round routes to
         // the same cache node, keeping the unchanging prefix cached). The top-level
@@ -265,7 +275,7 @@ export class StreamRunner {
                 childMode,
                 childBash,
                 childRuntime,
-                childSystem,
+                childSystem: childSystemWithVision,
                 childMessages,
                 childTools,
                 childProviderOptions,
@@ -348,16 +358,16 @@ export class StreamRunner {
         // Explore sub-agents are READ-ONLY research — a codebase investigation
         // legitimately needs more grep/read steps than the tight general/medium=10
         // cell allows. Cutting it early (esp. for reasoning models that front-load
-        // tool calls) leaves no budget to reach the synthesis turn (root cause of
-        // empty "Task completed. Last action: grep" returns). Give explore the
-        // analyze/large cell (15); edit-capable agents keep general/medium (10).
+        // Sub-agent ceiling is no longer a hard halt. Per user request:
+        // "cũng áp dụng với sub agent nhé không nên hardcode maxtool mà nếu có
+        // vấn đề gì sẽ có main agent (khi spawn) kiểm soát đừng hard"
         const _subCeiling = isExplore ? resolveCeiling("analyze", "large") : resolveCeiling("general", "medium");
         const _subCounterKey = `subagent:${subCallId}`;
         const _subStopWhen = (async (state) => {
+            incSessionStep(_subCounterKey); // Keep telemetry counter ticking
             if (state.steps.length >= maxSteps)
                 return true;
-            const next = incSessionStep(_subCounterKey);
-            return next >= _subCeiling;
+            return false;
         });
         // Silent-hang guard — mirror the top-level loop (message-processor.ts).
         // A sub-agent provider connection can accept the request but never send a
@@ -436,12 +446,19 @@ export class StreamRunner {
                         /* fail-open */
                     }
                 };
+                // T1.1 + T1.2 — reasoning models (DeepSeek V4 Flash, R1) emit 2K-5K
+                // CoT tokens per turn that accumulate across the multi-step loop.
+                // Strip old reasoning and compact earlier (ratio 0.3 vs 0.5) to
+                // cut ~40-60% of cumulative input tokens.
+                const isReasoningModel = childRuntime.modelInfo?.reasoning === true;
                 const compacted = compactSubAgentMessages(stripped, {
                     thresholdChars: compactThreshold,
                     keepLastTurns: compactKeepLast,
                     contextWindowTokens: childCtxWindow,
+                    contextFillRatio: isReasoningModel ? 0.3 : undefined,
                     keepToolIds: subKeepToolIds.length ? subKeepToolIds : undefined,
                     persistArtifact: persistSubArtifact,
+                    stripOldReasoning: isReasoningModel,
                 });
                 if (compacted !== stripped)
                     recordCompaction(stepNumber);
@@ -456,21 +473,26 @@ export class StreamRunner {
                 const _subK = cadenceForSize(_subSize);
                 const _subShouldRemind = shouldInjectReminder(stepNumber, _subK);
                 const _subShouldWarn = shouldInjectSoftWarn(stepNumber, _subCeiling, _subCounterKey);
-                if (_subShouldRemind || _subShouldWarn) {
-                    const _baseReminder = buildScopeReminder({
-                        step: stepNumber,
-                        ceiling: _subCeiling,
-                        taskType: "general",
-                        size: _subSize,
-                        originalPrompt: prepared.request.prompt,
-                    });
-                    const _reminder = _subShouldWarn ? `[approaching ceiling] ${_baseReminder}` : _baseReminder;
-                    const withReminder = attachReminderToMessages(compacted, _reminder);
-                    return { messages: withReminder };
+                const finalMessages = (() => {
+                    if (_subShouldRemind || _subShouldWarn) {
+                        const _baseReminder = buildScopeReminder({
+                            step: stepNumber,
+                            ceiling: _subCeiling,
+                            taskType: "general",
+                            size: _subSize,
+                            originalPrompt: prepared.request.prompt,
+                        });
+                        const _reminder = _subShouldWarn ? `[approaching ceiling] ${_baseReminder}` : _baseReminder;
+                        return attachReminderToMessages(compacted, _reminder);
+                    }
+                    return compacted;
+                })();
+                if (childRuntime.modelId.startsWith("claude")) {
+                    return { messages: applyAnthropicPromptCaching(finalMessages, childRuntime.modelId) };
                 }
                 if (compacted === stripped && stripped === messages)
                     return undefined;
-                return { messages: compacted };
+                return { messages: finalMessages };
             },
             ...(childDropTemperature ? {} : { temperature: isExplore ? 0.2 : 0.5 }),
             ...(childDropMaxOutput ? {} : { maxOutputTokens: Math.min(this.deps.getMaxTokens(), 8_192) }),

package/dist/src/orchestrator/sub-agent-model-tier.js

@@ -24,7 +24,7 @@ export const TASK_TIER_PREFS = {
     // general sub-agents downgrade to balanced (was premium-first) — the top
     // model already planned the delegation; the focused execution doesn't need
     // premium. Premium remains the fallback so premium-only providers are unaffected.
-    general: ["balanced", "premium"],
+    general: ["balanced", "fast", "premium"],
     // verify keeps premium-first: a downgrade here would weaken the very check it
     // exists to perform. Mirrors council `verify` role preference.
     verify: ["premium", "balanced"],

package/dist/src/orchestrator/subagent-compactor.d.ts

@@ -96,6 +96,14 @@ export interface SubAgentCompactorOptions {
      * source:"tool-artifact" so layer3/ee.query can later fetch "full tool result id=xxx".
      */
     persistArtifact?: (toolCallId: string, toolName: string, fullContent: string, reason: string) => void;
+    /**
+     * T1.1 — strip reasoning parts from old assistant turns (older than
+     * keepLastTurns). Reasoning tokens (CoT / <think>) from prior turns are
+     * never re-read by the model but accumulate O(N) chars per turn, costing
+     * full input billing on every subsequent step. Default true for reasoning
+     * models, false otherwise.
+     */
+    stripOldReasoning?: boolean;
 }
 /**
  * G1 — coarse char→token conversion. The real ratio is provider/tokenizer
@@ -140,3 +148,9 @@ export declare function cumulativeMessageChars(messages: ReadonlyArray<ModelMess
  * step.
  */
 export declare function compactSubAgentMessages(messages: ReadonlyArray<ModelMessage>, opts?: SubAgentCompactorOptions): ModelMessage[];
+/**
+ * Injects Anthropic prompt caching (cacheControl) into the last message's content
+ * block(s) if the model is Claude (starts with 'claude').
+ * Creates a copy of the messages array and the last message to avoid mutating in-place.
+ */
+export declare function applyAnthropicPromptCaching(messages: readonly ModelMessage[], modelId: string): ModelMessage[];

package/dist/src/orchestrator/subagent-compactor.js

@@ -104,11 +104,12 @@ export function isHighValueToolResult(toolName, preview, explicitKeepIds, toolCa
         const p = preview.toLowerCase();
         if (/error|fail|todo|plan|done|✔|blocked|critical/.test(p))
             return true;
-        if (/\.(ts|tsx|js|md|json|test|spec)\b/.test(p) || p.includes("src/") || p.includes("PLAN"))
-            return true;
-        if (preview.length > 1500)
-            return true;
-        return true; // read_file/grep etc on source are presumptively high-value
+        if (/\.(ts|tsx|js|md|json|test|spec)\b/.test(p) || p.includes("src/") || p.includes("PLAN")) {
+            // For source code/plans, only keep verbatim if it is relatively small (under 12000 chars)
+            // to prevent large file reads from leaking memory/tokens indefinitely in long sessions.
+            return preview.length <= 12000;
+        }
+        return false;
     }
     if (toolCallId && explicitKeepIds?.has(toolCallId))
         return true;
@@ -126,6 +127,7 @@ function resolveOpts(o) {
         contextFillRatio: Math.min(0.95, Math.max(0.1, o?.contextFillRatio ?? 0.5)),
         keepToolIds: keepIds,
         persistArtifact: o?.persistArtifact,
+        stripOldReasoning: o?.stripOldReasoning ?? false,
     };
 }
 /**
@@ -378,17 +380,43 @@ export function compactSubAgentMessages(messages, opts = {}) {
             continue;
         }
         if (msg.role === "assistant" && Array.isArray(msg.content)) {
-            // F1 — strip args off older assistant tool-call shells. 50+ of these
-            // accumulate ~10-30K chars of args (file paths, bash commands) that
-            // the model does not need once the matching result has been elided.
-            // We keep toolCallId + toolName so pairing with tool-result is intact.
-            out.push(stripAssistantToolCallArgs(msg));
+            // T1.1 — strip reasoning parts from older assistant turns. DeepSeek V4
+            // Flash / R1 emit 2K-5K reasoning tokens per turn that accumulate
+            // across the multi-step loop. These are never re-read by the model
+            // but cost full input billing on every subsequent round. Strip them
+            // from turns older than keepLastTurns to cut ~30-50% of input tokens.
+            // Then F1 — strip args off older assistant tool-call shells.
+            let processed = resolved.stripOldReasoning ? stripAssistantReasoning(msg) : msg;
+            processed = stripAssistantToolCallArgs(processed);
+            out.push(processed);
             continue;
         }
         out.push(msg);
     }
     return out;
 }
+/**
+ * T1.1 — strip reasoning parts from an assistant message. Reasoning tokens
+ * (CoT / `<think>`) from older turns have zero re-read value for the model
+ * on subsequent steps but they accumulate O(N) chars per turn and are billed
+ * as full input tokens. Removing them from turns older than keepLastTurns
+ * cuts ~30-50% of cumulative input in multi-step loops with reasoning models
+ * (DeepSeek V4 Flash, R1, etc.).
+ *
+ * Preserves text + tool-call parts (the structural skeleton the model needs
+ * to maintain coherent tool-call↔tool-result pairing).
+ */
+function stripAssistantReasoning(msg) {
+    if (!Array.isArray(msg.content))
+        return msg;
+    const parts = msg.content;
+    const filtered = parts.filter((part) => part.type !== "reasoning");
+    if (filtered.length === parts.length)
+        return msg; // nothing stripped
+    // Edge case: if ALL parts were reasoning (no text/tool-call), keep the
+    // message with an empty content array to preserve message-count pairing.
+    return { ...msg, content: filtered };
+}
 function stripAssistantToolCallArgs(msg) {
     if (!Array.isArray(msg.content))
         return msg;
@@ -424,4 +452,49 @@ function stripAssistantToolCallArgs(msg) {
         return msg;
     return { ...msg, content: next };
 }
+/**
+ * Injects Anthropic prompt caching (cacheControl) into the last message's content
+ * block(s) if the model is Claude (starts with 'claude').
+ * Creates a copy of the messages array and the last message to avoid mutating in-place.
+ */
+export function applyAnthropicPromptCaching(messages, modelId) {
+    if (!modelId.startsWith("claude")) {
+        return messages;
+    }
+    if (messages.length === 0) {
+        return messages;
+    }
+    const newMessages = [...messages];
+    const lastIndex = newMessages.length - 1;
+    const originalLastMsg = newMessages[lastIndex];
+    if (!originalLastMsg)
+        return messages;
+    const lastMsg = { ...originalLastMsg };
+    if (typeof lastMsg.content === "string") {
+        lastMsg.content = [
+            {
+                type: "text",
+                text: lastMsg.content,
+                providerOptions: {
+                    anthropic: { cacheControl: { type: "ephemeral" } },
+                },
+            },
+        ];
+    }
+    else if (Array.isArray(lastMsg.content)) {
+        const content = [...lastMsg.content];
+        const lastBlockIndex = content.length - 1;
+        if (lastBlockIndex >= 0) {
+            const lastBlock = { ...content[lastBlockIndex] };
+            lastBlock.providerOptions = {
+                ...lastBlock.providerOptions,
+                anthropic: { cacheControl: { type: "ephemeral" } },
+            };
+            content[lastBlockIndex] = lastBlock;
+            lastMsg.content = content;
+        }
+    }
+    newMessages[lastIndex] = lastMsg;
+    return newMessages;
+}
 //# sourceMappingURL=subagent-compactor.js.map

package/dist/src/orchestrator/subagent-compactor.spec.js

@@ -384,5 +384,137 @@ describe("subagent-compactor: compactSubAgentMessages", () => {
         }
         expect(keptExplicit).toBe(true);
     });
+    it("elides low-value large read_file results while keeping high-value ones", () => {
+        // Turn 1: large low-value read_file output (15000 chars of 'x', no ts/src/PLAN/error keywords)
+        const lowValueOutput = "x".repeat(15000);
+        // Turn 2: large high-value read_file output containing 'error'
+        const highValueOutputWithError = "error: failed to load module\n" + "x".repeat(15000);
+        // Turn 3: small source file read (5000 chars of 'x' containing 'src/index.ts')
+        const highValueSourceOutput = "src/index.ts\n" + "x".repeat(5000);
+        const msgs = [
+            { role: "system", content: "You are the agent." },
+            { role: "user", content: "perform task" },
+            {
+                role: "assistant",
+                content: [{ type: "tool-call", toolCallId: "call_low", toolName: "read_file", input: {} }],
+            },
+            {
+                role: "tool",
+                content: [{ type: "tool-result", toolCallId: "call_low", toolName: "read_file", output: { type: "text", value: lowValueOutput } }],
+            },
+            {
+                role: "assistant",
+                content: [{ type: "tool-call", toolCallId: "call_err", toolName: "read_file", input: {} }],
+            },
+            {
+                role: "tool",
+                content: [{ type: "tool-result", toolCallId: "call_err", toolName: "read_file", output: { type: "text", value: highValueOutputWithError } }],
+            },
+            {
+                role: "assistant",
+                content: [{ type: "tool-call", toolCallId: "call_src", toolName: "read_file", input: {} }],
+            },
+            {
+                role: "tool",
+                content: [{ type: "tool-result", toolCallId: "call_src", toolName: "read_file", output: { type: "text", value: highValueSourceOutput } }],
+            },
+            // Add a couple of low-value turns to push past threshold and keepLast turns (keepLast=1)
+            ...toolTurn(9, 10),
+        ];
+        // Force low value on the final kept turn
+        msgs[msgs.length - 1].content[0].toolName = "other_tool";
+        const out = compactSubAgentMessages(msgs, { thresholdChars: 10_000, keepLastTurns: 1 });
+        // low-value large read_file MUST be elided
+        const lowValMsg = out.find(m => m.role === "tool" && Array.isArray(m.content) && m.content[0]?.toolCallId === "call_low");
+        expect((lowValMsg?.content)[0].output.value).toMatch(/elided by sub-agent compactor/);
+        // high-value large error read_file MUST NOT be elided
+        const errValMsg = out.find(m => m.role === "tool" && Array.isArray(m.content) && m.content[0]?.toolCallId === "call_err");
+        expect((errValMsg?.content)[0].output.value).toBe(highValueOutputWithError);
+        // high-value small source read_file MUST NOT be elided
+        const srcValMsg = out.find(m => m.role === "tool" && Array.isArray(m.content) && m.content[0]?.toolCallId === "call_src");
+        expect((srcValMsg?.content)[0].output.value).toBe(highValueSourceOutput);
+    });
+    it("T1.1 — strips reasoning parts from old assistant turns when stripOldReasoning is enabled", () => {
+        // Build history with reasoning parts in assistant messages
+        const msgs = [
+            { role: "system", content: "You are an agent." },
+            { role: "user", content: "fix the bug" },
+        ];
+        // Add 6 tool turns with reasoning in assistant messages
+        for (let i = 1; i <= 6; i++) {
+            msgs.push({
+                role: "assistant",
+                content: [
+                    { type: "reasoning", text: `Thinking about step ${i}... ${"x".repeat(3000)}` },
+                    { type: "text", text: `Step ${i} analysis` },
+                    { type: "tool-call", toolCallId: `call_${i}`, toolName: "bash", input: `echo ${i}` },
+                ],
+            });
+            msgs.push({
+                role: "tool",
+                content: [
+                    { type: "tool-result", toolCallId: `call_${i}`, toolName: "bash", output: { type: "text", value: bigText(`R${i}`, 2) } },
+                ],
+            });
+        }
+        const out = compactSubAgentMessages(msgs, {
+            thresholdChars: 1000, // force compaction
+            keepLastTurns: 2,
+            stripOldReasoning: true,
+        });
+        // Old turns (1-4) should have reasoning stripped
+        const oldAssistants = out.filter((m, idx) => m.role === "assistant" && idx < out.length - 4);
+        for (const m of oldAssistants) {
+            const content = m.content;
+            if (!Array.isArray(content))
+                continue;
+            const hasReasoning = content.some((p) => p.type === "reasoning");
+            expect(hasReasoning).toBe(false);
+        }
+        // Recent turns (last 2) should still have reasoning
+        const recentAssistants = out.filter((m, idx) => m.role === "assistant" && idx >= out.length - 4);
+        for (const m of recentAssistants) {
+            const content = m.content;
+            if (!Array.isArray(content))
+                continue;
+            const hasReasoning = content.some((p) => p.type === "reasoning");
+            expect(hasReasoning).toBe(true);
+        }
+    });
+    it("T1.1 — does NOT strip reasoning when stripOldReasoning is false (default)", () => {
+        const msgs = [
+            { role: "system", content: "You are an agent." },
+            { role: "user", content: "fix the bug" },
+        ];
+        for (let i = 1; i <= 4; i++) {
+            msgs.push({
+                role: "assistant",
+                content: [
+                    { type: "reasoning", text: `Thinking... ${"x".repeat(3000)}` },
+                    { type: "tool-call", toolCallId: `call_${i}`, toolName: "bash", input: `echo ${i}` },
+                ],
+            });
+            msgs.push({
+                role: "tool",
+                content: [
+                    { type: "tool-result", toolCallId: `call_${i}`, toolName: "bash", output: { type: "text", value: bigText(`R${i}`, 2) } },
+                ],
+            });
+        }
+        const out = compactSubAgentMessages(msgs, {
+            thresholdChars: 1000,
+            keepLastTurns: 1,
+            stripOldReasoning: false, // explicitly off
+        });
+        // All assistant messages should still have reasoning parts
+        const assistants = out.filter((m) => m.role === "assistant");
+        for (const m of assistants) {
+            const content = m.content;
+            if (!Array.isArray(content))
+                continue;
+            const hasReasoning = content.some((p) => p.type === "reasoning");
+            expect(hasReasoning).toBe(true);
+        }
+    });
 });
 //# sourceMappingURL=subagent-compactor.spec.js.map

package/dist/src/orchestrator/text-tool-call-detector.d.ts

@@ -42,12 +42,16 @@ export declare function detectTextEmittedToolCall(text: string): TextToolCallDet
  * Parse the DeepSeek-native DSML tool-call markup into a structured list so the
  * re-steer can restate the model's EXACT intent (much more effective than a
  * generic "use the tool interface" nudge). Pure — no execution. Recognizes:
- *   <｜｜DSML｜｜invoke name="read_file">
- *     <｜｜DSML｜｜parameter name="file_path" string="true">src/app/foo.ts</｜｜DSML｜｜parameter>
- *   </｜｜DSML｜｜invoke>
+ *   Old format:  <│invoke name="read_file">
+ *                  <│parameter name="file_path" string="true">src/app/foo.ts</│parameter>
+ *                </│invoke>
+ *   New format:  <│ DSML │invoke name="read_file">
+ *                  <│ DSML │parameter name="file_path" string="true">src/app/foo.ts</│ DSML │parameter>
+ *                </│ DSML │invoke>
+ * Both U+2502 (box-drawing │) and U+FF5C (fullwidth ｜) bars are recognized.
  * Returns one entry per invoke block; args preserve insertion order. Tolerant of
- * missing close tags (cheap models truncate) — captures whatever parameters are
- * present. Returns [] when no parseable invoke block exists.
+ * missing close tags (cheap models truncate). Returns [] when no parseable invoke
+ * block exists.
  */
 export interface ParsedDsmlCall {
     name: string;

package/dist/src/orchestrator/text-tool-call-detector.js

@@ -90,16 +90,18 @@ const PARAM_ALTERNATION = PARAM_TAGS.join("|");
 // is the Anthropic XML style; `<tool_call>` / `<function_calls>` are Qwen/other.
 // These are matched directly (the wrapper itself is the signal).
 const GENERIC_WRAPPER_RE = /<\/?(?:tool_call|function_calls|tool_use)\b|<invoke\b[^>]*\bname\s*=|<function\b[^>]*\bname\s*=/i;
-// DeepSeek native tool-call markup leaking into text content. Signature is the
-// fullwidth-bar sentinel `｜｜DSML｜｜` (U+FF5C, NOT ASCII pipes) wrapping
-// invoke/tool_calls/parameter tokens, e.g. `<｜｜DSML｜｜invoke name="read_file">`.
+// DeepSeek native tool-call markup leaking into text content. Signature is a
+// vertical-bar sentinel — either U+FF5C fullwidth `｜` or U+2502 box-drawing `│`
+// — wrapping invoke/tool_calls/parameter tokens, e.g.:
+//   Old format:  <｜invoke name="read_file">   (U+FF5C, single bar)
+//   New format:  <│ DSML │invoke name="…">   (U+2502, with optional DSML label)
 // Live: storyflow_ui explore-A/B, deepseek T3 (session 799f0508e830) emitted a
-// full `<｜｜DSML｜｜invoke name="read_file">…` block as text and made no real tool
-// call → empty, silent turn. The generic `<invoke` matcher misses it because the
-// `<` is followed by the sentinel, not `invoke`. (BUG-A telemetry already flags
-// the `｜｜DSML｜｜` substring; this wires it into detect → re-steer/surface.)
-const DSML_WRAPPER_RE = /｜｜DSML｜｜\s*(?:invoke|tool_calls?|parameter)\b/i;
-const DSML_INVOKE_NAME_RE = /｜｜DSML｜｜\s*invoke\s+name\s*=\s*"([^"]+)"/i;
+// full DSML invoke block as text and made no real tool call → empty, silent turn.
+// The generic `<invoke` matcher misses it because `<` is followed by the sentinel.
+// Updated 2026-06-24 to cover both U+2502 and U+FF5C (tests use U+2502).
+const DSML_BAR = "[\\s]*[│｜|]+[│｜|\\s]*"; // matches U+2502 (box-drawing), U+FF5C (fullwidth), ASCII pipe |, and spaces
+const DSML_WRAPPER_RE = new RegExp(`${DSML_BAR}\\s*(?:DSML\\s*${DSML_BAR}\\s*)?(?:invoke|tool_calls?|parameter)\\b`, "i");
+const DSML_INVOKE_NAME_RE = new RegExp(`${DSML_BAR}\\s*(?:DSML\\s*${DSML_BAR}\\s*)?invoke\\s+name\\s*=\\s*"([^"]+)"`, "i");
 /** Build a per-tool detector: `<tool>` then (within a small gap) a `<param>` or `</tool>`. */
 function buildToolRegexes() {
     return TOOL_TAGS.map((tag) => 
@@ -136,10 +138,12 @@ function normalizeWrapperName(raw) {
     const m = raw.match(/tool_call|function_calls|tool_use|invoke|function/i);
     return m ? m[0].toLowerCase() : "tool_call";
 }
-const DSML_INVOKE_BLOCK_RE = /｜｜DSML｜｜\s*invoke\s+name\s*=\s*"([^"]+)"([\s\S]*?)(?=｜｜DSML｜｜\s*invoke\s|$)/gi;
-const DSML_PARAM_RE = /｜｜DSML｜｜\s*parameter\s+name\s*=\s*"([^"]+)"[^>]*>([\s\S]*?)<\/?｜｜DSML｜｜\s*parameter/gi;
+// Guard regex: at least one DSML-bar sentinel must exist before we bother scanning
+const DSML_GUARD_RE = /[│｜|]/;
+const DSML_INVOKE_BLOCK_RE = new RegExp(`${DSML_BAR}\\s*(?:DSML\\s*${DSML_BAR}\\s*)?invoke\\s+name\\s*=\\s*"([^"]+)"([\\s\\S]*?)(?=${DSML_BAR}\\s*(?:DSML\\s*${DSML_BAR}\\s*)?invoke\\s|$)`, "gi");
+const DSML_PARAM_RE = new RegExp(`${DSML_BAR}\\s*(?:DSML\\s*${DSML_BAR}\\s*)?parameter\\s+name\\s*=\\s*"([^"]+)"[^>]*>([\\s\\S]*?)<\\/?${DSML_BAR}\\s*(?:DSML\\s*${DSML_BAR}\\s*)?parameter`, "gi");
 export function parseDsmlToolCalls(text) {
-    if (!text || !text.includes("｜｜DSML｜｜"))
+    if (!text || !DSML_GUARD_RE.test(text))
         return [];
     const calls = [];
     DSML_INVOKE_BLOCK_RE.lastIndex = 0;