This is a comment left during a code review.
Path: ui/src/ui/chat/tool-cards.ts
Line: 65-84

Comment:
**Double-shift consumes two queue entries per queue-fallback result**

When `args` is `null`/`undefined` and the queue-fallback branch is taken (line 70: `args = queue.shift()`), the "always consume" block immediately shifts the queue a second time (line 82: `queue.shift()`). This means two entries are consumed for a single result card whenever the queue-fallback path is used.

Concretely: if two same-named tool calls exist and their result blocks carry no `toolCallId` and no own args, the second result will incorrectly receive the *third* call's args (or `undefined` if there is no third call).

The "always consume" block is only needed when the first block matched via `toolCallId` (which does not shift) or when the result already has its own args (which also does not shift). For the queue-fallback path, the shift was already performed on line 70 and should not be repeated.

Fix — only run the "always consume" block when the queue-fallback path was *not* already taken:

```
    // Always consume matching queue entry to keep queue in sync
    // Skip if we already consumed via queue fallback above
    const usedQueueFallback = (args !== undefined && args !== null) &&
      !(toolCallId && argsByToolCallId.has(toolCallId)) &&
      !(coerceArgs(item.arguments ?? item.args) !== undefined && coerceArgs(item.arguments ?? item.args) !== null);
```

Or more clearly, track whether the first block already called `shift`:

```typescript
    let args = coerceArgs(item.arguments ?? item.args);
    const toolCallId = ...;
    let usedQueueFallback = false;
    if (toolCallId && argsByToolCallId.has(toolCallId)) {
      args = argsByToolCallId.get(toolCallId);
    } else if (args === undefined || args === null) {
      if (argsQueueByName.has(name)) {
        const queue = argsQueueByName.get(name)!;
        if (queue.length > 0) {
          args = queue.shift();
          usedQueueFallback = true;
        }
      }
    }
    // Consume queue entry to keep it in sync — but only if we haven't already done so
    if (!usedQueueFallback && argsQueueByName.has(name)) {
      const queue = argsQueueByName.get(name)!;
      if (queue.length > 0) {
        queue.shift();
      }
    }
```

How can I resolve this? If you propose a fix, please make it concise.

---

This is a comment left during a code review.
Path: extensions/feishu/src/media.ts
Line: 243-258

Comment:
**Return type does not match implementation**

The function is declared as `(fileName: string): string`, but the early-return on line 244 returns `fileName` as-is — meaning `null` or `undefined` will be returned when a falsy non-string value is passed. The tests confirm this by using `as any` to bypass the type checker.

The callers pass `parsed.file_name` (JSON-parsed `any`), so `null`/`undefined` is a realistic input. The type signature should reflect this to avoid silent type errors elsewhere:

```suggestion
export function decodeFileNameFromFeishu(fileName: string | null | undefined): string | null | undefined {
```

How can I resolve this? If you propose a fix, please make it concise.

---

This is a comment left during a code review.
Path: extensions/feishu/src/media.ts
Line: 241

Comment:
**Stray asterisk in JSDoc comment**

There is an extra `*` mid-sentence, likely a copy-paste artifact.

```suggestion
 * This is used when receiving filenames from Feishu messages
 * to ensure proper display of non-ASCII characters.
```

How can I resolve this? If you propose a fix, please make it concise.