@co0ontty/wand 1.29.6 → 1.30.3

package/dist/process-manager.js

@@ -634,7 +634,10 @@ export class ProcessManager extends EventEmitter {
             knownClaudeProjectMtimes: knownClaudeProjectMtimes ?? undefined,
             approvalStats: { tool: 0, command: 0, file: 0, total: 0 },
             selectedModel: selectedModel ?? null,
-            ptyCols: opts?.cols !== undefined ? clampDimension(opts.cols, 20, 400) : 120,
+            // cols 上限 256：与 @wterm/dom WASM grid 的 maxCols 硬编码一致，
+            // 防止服务端按 >256 cols 让 Claude 用 CSI 绝对列定位写到 wterm 实际
+            // 渲染不到的列上（表现为"内容神奇复制下行"）。
+            ptyCols: opts?.cols !== undefined ? clampDimension(opts.cols, 20, 256) : 120,
             ptyRows: opts?.rows !== undefined ? clampDimension(opts.rows, 10, 160) : 36,
         };
         if (isClaudeProvider) {
@@ -986,7 +989,7 @@ export class ProcessManager extends EventEmitter {
         if (!record.ptyProcess || record.status !== "running") {
             return this.snapshot(record);
         }
-        const safeCols = clampDimension(cols, 20, 400);
+        const safeCols = clampDimension(cols, 20, 256);
         const safeRows = clampDimension(rows, 10, 160);
         const changed = safeCols !== record.ptyCols || safeRows !== record.ptyRows;
         record.ptyProcess.resize(safeCols, safeRows);

package/dist/structured-session-manager.js

@@ -83,6 +83,84 @@ export function thinkingEffortToCodexFlag(effort) {
         default: return null;
     }
 }
+function captureTaskMeta(blocks, registry) {
+    for (const b of blocks) {
+        if (b.type !== "tool_use")
+            continue;
+        if (registry.has(b.id))
+            continue;
+        const input = b.input ?? {};
+        // Claude SDK 把这类"派 subagent 干活"的内置工具叫做 "Agent"，CLI/旧版本里
+        // 也叫过 "Task"。判定不靠工具名（容易随版本变），而是看 input 是否含有
+        // `subagent_type` 字段——这是 Agent/Task 系列的唯一标志。
+        const agentType = typeof input.subagent_type === "string" ? input.subagent_type : undefined;
+        if (!agentType && b.name !== "Task" && b.name !== "Agent")
+            continue;
+        const description = typeof input.description === "string" ? input.description : undefined;
+        registry.set(b.id, { agentType, description });
+    }
+}
+/**
+ * Stamp every block with `__subagent` meta keyed to `parentToolUseId`. When
+ * the id has no entry yet (rare race: subagent emits before we see the parent
+ * Task tool_use), we still stamp the bare taskId so the UI can group blocks;
+ * agentType / description backfill on later updates.
+ */
+function tagSubagentBlocks(blocks, parentToolUseId, registry) {
+    if (!parentToolUseId)
+        return blocks;
+    const meta = registry.get(parentToolUseId);
+    const stamp = {
+        taskId: parentToolUseId,
+        ...(meta?.agentType ? { agentType: meta.agentType } : {}),
+        ...(meta?.description ? { taskDescription: meta.description } : {}),
+    };
+    return blocks.map((block) => ({ ...block, __subagent: stamp }));
+}
+/**
+ * 给已被 captureTaskMeta 识别为 Task/Agent 的 tool_use block 本身也盖 __subagent 章。
+ * taskId 用自己的 block.id —— 与子消息的 parent_tool_use_id（也等于这个 id）保持一致，
+ * 前端 splitTurnBySubagent 按 taskId 分组时父 Task tool_use 和 SDK 转发的子消息能合并到同一段。
+ */
+function stampSelfTask(blocks, registry) {
+    return blocks.map((b) => {
+        if (b.type !== "tool_use")
+            return b;
+        if (b.__subagent)
+            return b; // 已盖章不重复（防止幂等问题）
+        const meta = registry.get(b.id);
+        if (!meta && b.name !== "Task" && b.name !== "Agent")
+            return b;
+        const stamp = {
+            taskId: b.id,
+            ...(meta?.agentType ? { agentType: meta.agentType } : {}),
+            ...(meta?.description ? { taskDescription: meta.description } : {}),
+        };
+        return { ...b, __subagent: stamp };
+    });
+}
+/**
+ * 当父 assistant 在 parentToolUseId === null 的 user turn 里收到 Task 工具的 tool_result 时，
+ * tagSubagentBlocks 不会被调用（它只在 parentToolUseId 非空时盖章）。这里按 tool_use_id
+ * 反查 registry，给这条 tool_result 单独盖章，让前端能把它归到同一个 subagent 段。
+ */
+function stampParentTaskResults(blocks, registry) {
+    return blocks.map((b) => {
+        if (b.type !== "tool_result")
+            return b;
+        if (b.__subagent)
+            return b;
+        const meta = registry.get(b.tool_use_id);
+        if (!meta)
+            return b;
+        const stamp = {
+            taskId: b.tool_use_id,
+            ...(meta.agentType ? { agentType: meta.agentType } : {}),
+            ...(meta.description ? { taskDescription: meta.description } : {}),
+        };
+        return { ...b, __subagent: stamp };
+    });
+}
 const STREAM_EMIT_DEBOUNCE_MS = 16;
 /** Min interval between full saveSession() calls for an in-progress streaming turn.
  *  saveSession serializes the entire messages array, so doing it on every NDJSON
@@ -1342,6 +1420,9 @@ export class StructuredSessionManager {
             const blocksByKey = new Map();
             const keyOrder = [];
             let toolResultSeq = 0;
+            // 本轮 Task tool_use_id → meta map，由父 assistant 消息里的 Task tool_use
+            // 填充；子 agent message（parent_tool_use_id 非空）来时用它给每个 block 盖章。
+            const taskMetaRegistry = new Map();
             // 估算单个 ContentBlock 的"信息体积"——文字 / thinking / tool input 长度之和。
             // 用于 upsertBlocks 的防御性合并：同一 message.id 重发时，按位置取信息量更大的
             // 那个版本，保证已经吐出的文字 / tool_use input 不会被一条更短的同 id 事件
@@ -1372,22 +1453,25 @@ export class StructuredSessionManager {
                     blocksByKey.set(key, blocks);
                     return;
                 }
-                // claude -p 在同一 message.id 的多次 assistant 事件里是**累积**协议：
-                // 每次 event 的 content 总是包含之前所有 blocks + 可能的新 block，
-                // 长度只增不减、同位置类型不变。两条额外的防御性规则：
+                // claude -p 在同一 message.id 的多次 assistant 事件有两种观察到的协议：
+                //   a) **累积模式**：每次 event 的 content = 之前所有 blocks + 0~N 新 block，
+                //      同位置类型一致。流式 text/thinking 的逐字增量属于这种。
+                //   b) **拼接模式**：SDK 把 thinking 和后续的 tool_use 拆成两条 event 给同
+                //      一 msg.id 发出，第二条只带 tool_use，**不包含**之前的 thinking。
+                //      Opus 4.7 + claude-agent-sdk 实际跑下来就是这种。
                 //
-                // 1) blocks.length < prev.length —— 短数组覆盖。上游异常 frame，直接拒绝
-                //    本次更新，下一帧正常累积 emit 会自然修正。
+                // 老逻辑（"同 index 类型不一致 → 保留 prev"）只对 a) 友好，碰上 b) 会让第
+                // 二条事件里的 tool_use 直接被丢掉——表现是 Agent / Read 等 tool_use 永远
+                // 不出现在 messages 里，subagent 多角色无法关联 agentType 到父 Task。
                 //
-                // 2) 同 index 类型不一致 —— 比如 prev[0]=text 而 incoming[0]=tool_use。
-                //    正常累积下不会发生；一旦发生，**保留 prev[i]**。早期版本走"取
-                //    volume 大者"，会让 tool_use（input JSON 通常更长）抢占 text 位，
-                //    导致流式过程中已经渲染的文字突然消失，只剩工具卡片——直到 result
-                //    event 给出最终 turnState.result，compactContentBlocks 的 fallback
-                //    才补回 text。用户反馈"文字消失，回复完成后又出现"就是这条路径。
+                // 新规则：当类型不一致时，把新 block **追加**到 merged 末尾而非覆盖 prev。
+                // 既兼容 a)（同位置同类型仍按累积取大），又兼容 b)（拼接的新类型 block
+                // 进入末尾），还能挡住 b 早期版本里"短回退"的异常 frame（blocks.length
+                // < prev.length 时直接拒绝）。
                 if (blocks.length < prev.length)
                     return;
                 const merged = [];
+                const appendix = [];
                 for (let i = 0; i < blocks.length; i++) {
                     const a = prev[i];
                     const b = blocks[i];
@@ -1405,11 +1489,14 @@ export class StructuredSessionManager {
                             merged.push(blockVolume(b) >= blockVolume(a) ? b : a);
                         }
                         else {
-                            // 类型变了：保留 prev，不让 tool_use 等抢占 text 位。
+                            // 类型变了：保留 prev[i]，把 incoming block 追加到末尾。
                             merged.push(a);
+                            appendix.push(b);
                         }
                     }
                 }
+                for (const b of appendix)
+                    merged.push(b);
                 blocksByKey.set(key, merged);
             };
             const rebuildTurnBlocks = () => {
@@ -1503,8 +1590,19 @@ export class StructuredSessionManager {
                     const msgId = typeof parsed.message.id === "string" && parsed.message.id
                         ? `assistant:${parsed.message.id}`
                         : `assistant:anon:${keyOrder.length}`;
-                    if (extracted.content.length > 0) {
-                        upsertBlocks(msgId, extracted.content);
+                    // parent_tool_use_id 决定父/子 agent。父 message 里的 Task tool_use 登记
+                    // 到 taskMetaRegistry；子 message 的每个 block 用 __subagent 盖章。
+                    const parentToolUseId = typeof parsed.parent_tool_use_id === "string" && parsed.parent_tool_use_id
+                        ? parsed.parent_tool_use_id
+                        : null;
+                    if (parentToolUseId === null) {
+                        captureTaskMeta(extracted.content, taskMetaRegistry);
+                    }
+                    const stamped = parentToolUseId === null
+                        ? stampSelfTask(extracted.content, taskMetaRegistry)
+                        : tagSubagentBlocks(extracted.content, parentToolUseId, taskMetaRegistry);
+                    if (stamped.length > 0) {
+                        upsertBlocks(msgId, stamped);
                         rebuildTurnBlocks();
                     }
                     // NOTE: usage from streaming "assistant" events contains partial/incremental
@@ -1541,8 +1639,14 @@ export class StructuredSessionManager {
                             });
                         }
                     }
-                    if (collected.length > 0) {
-                        upsertBlocks(`tool_result:${toolResultSeq++}`, collected);
+                    const parentToolUseId = typeof parsed.parent_tool_use_id === "string" && parsed.parent_tool_use_id
+                        ? parsed.parent_tool_use_id
+                        : null;
+                    const stamped = parentToolUseId === null
+                        ? stampParentTaskResults(collected, taskMetaRegistry)
+                        : tagSubagentBlocks(collected, parentToolUseId, taskMetaRegistry);
+                    if (stamped.length > 0) {
+                        upsertBlocks(`tool_result:${toolResultSeq++}`, stamped);
                         rebuildTurnBlocks();
                     }
                     syncSnapshot();
@@ -1794,6 +1898,10 @@ export class StructuredSessionManager {
             ...(permPolicy.allowedTools ? { allowedTools: permPolicy.allowedTools } : {}),
             ...(isManaged ? { disallowedTools: ["AskUserQuestion"] } : {}),
             includePartialMessages: true,
+            // 把子 agent 的 text/thinking 也转发回来，UI 才能把"被 Task 召唤来的协作者"
+            // 渲染成独立角色的群聊消息。关掉这个开关时只会收到子 agent 的 tool_use/tool_result，
+            // text/thinking 被 SDK 吞掉。
+            forwardSubagentText: true,
             ...(systemPromptParts.length > 0 ? { appendSystemPrompt: systemPromptParts.join("\n\n") } : {}),
             ...(sdkClaudeBinary ? { pathToClaudeCodeExecutable: sdkClaudeBinary } : {}),
         };
@@ -1855,6 +1963,11 @@ export class StructuredSessionManager {
         // Tracks in-progress streaming blocks keyed by content_block index from stream_event.
         // The map is cleared whenever a complete `assistant` message arrives — its blocks
         // are then promoted into `finalizedBlocks` below.
+        //
+        // `parentToolUseId` carries through from SDKPartialAssistantMessage so we can
+        // stamp streaming blocks with subagent persona *during* streaming, not only
+        // after the completion event. Without it, subagent text shows up under the
+        // parent's avatar for tens of ms then snaps to the subagent — visible flicker.
         const streamingBlockByIndex = new Map();
         // Blocks from messages that have already completed within this turn — including
         // the parent assistant's prior messages, every subagent assistant message, and
@@ -1862,6 +1975,9 @@ export class StructuredSessionManager {
         // back-to-back; without this list, each new streaming message would visually
         // erase everything that came before it in the same turn.
         const finalizedBlocks = [];
+        // Per-turn Task tool_use_id → meta map; populated from the parent assistant's
+        // Task tool_use blocks and consulted when subagent messages arrive.
+        const taskMetaRegistry = new Map();
         let emitTimer = null;
         const flushEmit = () => {
             if (emitTimer) {
@@ -1884,11 +2000,12 @@ export class StructuredSessionManager {
             const sorted = [...streamingBlockByIndex.entries()].sort((a, b) => a[0] - b[0]);
             const streaming = [];
             for (const [, sb] of sorted) {
+                let block = null;
                 if (sb.type === "text") {
-                    streaming.push({ type: "text", text: sb.text });
+                    block = { type: "text", text: sb.text };
                 }
                 else if (sb.type === "thinking") {
-                    streaming.push({ type: "thinking", thinking: sb.thinking });
+                    block = { type: "thinking", thinking: sb.thinking };
                 }
                 else if (sb.type === "tool_use" && sb.id && sb.name) {
                     let input = {};
@@ -1898,10 +2015,25 @@ export class StructuredSessionManager {
                         }
                         catch { /* partial json */ }
                     }
-                    streaming.push({ type: "tool_use", id: sb.id, name: sb.name, input });
+                    block = { type: "tool_use", id: sb.id, name: sb.name, input };
+                }
+                if (!block)
+                    continue;
+                if (sb.parentToolUseId) {
+                    const [stamped] = tagSubagentBlocks([block], sb.parentToolUseId, taskMetaRegistry);
+                    streaming.push(stamped);
+                }
+                else {
+                    streaming.push(block);
                 }
             }
-            return [...finalizedBlocks, ...streaming];
+            // 流式阶段就给 Task/Agent tool_use 本身盖章，防止"先显示工具卡片几秒再跳为
+            // handoff 行"的闪烁。content_block_start 阶段就有 name=Task/Agent，
+            // stampSelfTask 据此即可命中；agentType 字段藏在 input 里，delta 累计后再由
+            // 后续 captureTaskMeta 回填 registry，下次 rebuild 自动补上更完整的 stamp。
+            captureTaskMeta(streaming, taskMetaRegistry);
+            const stampedStreaming = stampSelfTask(streaming, taskMetaRegistry);
+            return [...finalizedBlocks, ...stampedStreaming];
         };
         const syncSnapshot = () => {
             const current = this.sessions.get(sessionId);
@@ -1950,7 +2082,9 @@ export class StructuredSessionManager {
                     break;
                 // Incremental streaming events (opt-in via includePartialMessages: true)
                 if (msg.type === "stream_event") {
-                    const ev = msg.event;
+                    const partial = msg;
+                    const ev = partial.event;
+                    const partialParentId = partial.parent_tool_use_id ?? null;
                     if (ev.type === "content_block_start") {
                         const cb = ev.content_block;
                         const blockType = cb.type;
@@ -1963,6 +2097,7 @@ export class StructuredSessionManager {
                                 thinking: typeof cb.thinking === "string" ? cb.thinking : "",
                                 partialInput: "",
                                 finalized: false,
+                                parentToolUseId: partialParentId,
                             });
                             turnState.blocks = rebuildStreamingBlocks();
                             syncSnapshot();
@@ -2005,7 +2140,16 @@ export class StructuredSessionManager {
                 if (msg.type === "assistant") {
                     const assistantMsg = msg;
                     const extracted = this.extractAssistantMessage(assistantMsg.message);
-                    finalizedBlocks.push(...extracted.content);
+                    // 父 assistant 的 Task tool_use → 注册到本轮 taskMeta map；
+                    // 子 agent 的 message（parent_tool_use_id 非空）→ 给每个 block 盖章。
+                    const parentToolUseId = assistantMsg.parent_tool_use_id ?? null;
+                    if (parentToolUseId === null) {
+                        captureTaskMeta(extracted.content, taskMetaRegistry);
+                        finalizedBlocks.push(...stampSelfTask(extracted.content, taskMetaRegistry));
+                    }
+                    else {
+                        finalizedBlocks.push(...tagSubagentBlocks(extracted.content, parentToolUseId, taskMetaRegistry));
+                    }
                     streamingBlockByIndex.clear();
                     turnState.blocks = rebuildStreamingBlocks();
                     if (assistantMsg.session_id)
@@ -2041,11 +2185,13 @@ export class StructuredSessionManager {
                 // tool call, or a subagent's tool_result during Task execution).
                 if (msg.type === "user") {
                     const userMsg = msg;
+                    const parentToolUseId = userMsg.parent_tool_use_id ?? null;
                     const content = Array.isArray(userMsg.message?.content) ? userMsg.message.content : [];
+                    const collected = [];
                     for (const block of content) {
                         const b = block;
                         if (b?.type === "tool_result") {
-                            finalizedBlocks.push({
+                            collected.push({
                                 type: "tool_result",
                                 tool_use_id: typeof b.tool_use_id === "string" ? b.tool_use_id : "",
                                 content: this.normalizeToolResultContent(b.content),
@@ -2053,6 +2199,12 @@ export class StructuredSessionManager {
                             });
                         }
                     }
+                    if (parentToolUseId === null) {
+                        finalizedBlocks.push(...stampParentTaskResults(collected, taskMetaRegistry));
+                    }
+                    else {
+                        finalizedBlocks.push(...tagSubagentBlocks(collected, parentToolUseId, taskMetaRegistry));
+                    }
                     turnState.blocks = rebuildStreamingBlocks();
                     syncSnapshot();
                     scheduleEmit();
@@ -2227,11 +2379,17 @@ export class StructuredSessionManager {
             const previous = compacted[compacted.length - 1];
             if (previous
                 && previous.type === "text"
-                && block.type === "text") {
+                && block.type === "text"
+                // 子 agent 边界不合并：父 assistant 的 text 与子 agent 的 text 必须保持独立，
+                // 渲染层才能切段并给子 agent 单独发头像。同一 subagent 内部允许合并。
+                && (previous.__subagent?.taskId ?? null) === (block.__subagent?.taskId ?? null)) {
                 // 用新对象替换 compacted 末尾，**不要**就地改 previous.text —— previous
                 // 通常和调用方持有的 turnState.blocks 共享引用，原地 mutate 会让下次
                 // syncSnapshot 把已合并的内容再合并一次，呈指数级复制。
-                compacted[compacted.length - 1] = { type: "text", text: `${previous.text}${block.text}` };
+                const merged = { type: "text", text: `${previous.text}${block.text}` };
+                if (previous.__subagent)
+                    merged.__subagent = previous.__subagent;
+                compacted[compacted.length - 1] = merged;
                 continue;
             }
             compacted.push(block);

package/dist/types.d.ts

@@ -299,13 +299,30 @@ export interface ChatMessage {
     role: "user" | "assistant";
     content: string;
 }
+/**
+ * Meta marker attached to blocks emitted by a Task-spawned subagent. Present
+ * on every block (text / thinking / tool_use / tool_result) whose origin is a
+ * subagent's stream rather than the main assistant. Drives the multi-persona
+ * chat rendering ("third cat joining the conversation").
+ *
+ * `taskId` is the parent Task tool_use id (= SDK's `parent_tool_use_id`).
+ * The parent Task tool_use block itself is NOT marked — it lives in the
+ * main assistant's stream.
+ */
+export interface SubagentMeta {
+    taskId: string;
+    agentType?: string;
+    taskDescription?: string;
+}
 export interface TextBlock {
     type: "text";
     text: string;
+    __subagent?: SubagentMeta;
 }
 export interface ThinkingBlock {
     type: "thinking";
     thinking: string;
+    __subagent?: SubagentMeta;
 }
 export interface ToolUseBlock {
     type: "tool_use";
@@ -313,6 +330,7 @@ export interface ToolUseBlock {
     name: string;
     description?: string;
     input: Record<string, unknown>;
+    __subagent?: SubagentMeta;
 }
 export interface ToolResultBlock {
     type: "tool_result";
@@ -324,6 +342,7 @@ export interface ToolResultBlock {
     is_error?: boolean;
     /** When true, content has been truncated for transport. Client should fetch full content via API. */
     _truncated?: boolean;
+    __subagent?: SubagentMeta;
 }
 export type ContentBlock = TextBlock | ThinkingBlock | ToolUseBlock | ToolResultBlock;
 export interface ConversationTurn {