test: Phase 5 — 添加 12 个测试文件 (+209 tests, 1177 total)

新增覆盖: effort, tokenBudget, displayTags, taggedId,
controlMessageCompat, MCP normalization/envExpansion,
gitConfigParser, formatBriefTimestamp, hyperlink, windowsPaths, notebook

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: claude-code-best

docs/testing-spec.md

@@ -300,7 +300,7 @@ bun test --watch
 
 ## 11. 当前测试覆盖状态
 
-> 更新日期：2026-04-02 | 总计：**968 tests, 52 files, 0 failures**
+> 更新日期：2026-04-02 | 总计：**1177 tests, 64 files, 0 failures**
 
 ### P0 — 核心模块
 
@@ -383,6 +383,23 @@ bun test --watch
 | `src/tools/BashTool/__tests__/destructiveCommandWarning.test.ts` | 22 | getDestructiveCommandWarning (git/rm/database/infrastructure patterns) |
 | `src/tools/BashTool/__tests__/commandSemantics.test.ts` | 11 | interpretCommandResult (grep/diff/test/rg/find exit code semantics) |
 
+### P6 — Phase 5 扩展覆盖
+
+| 测试文件 | 测试数 | 覆盖范围 |
+|----------|--------|----------|
+| `src/utils/__tests__/tokenBudget.test.ts` | 20 | parseTokenBudget, findTokenBudgetPositions, getBudgetContinuationMessage |
+| `src/utils/__tests__/displayTags.test.ts` | 17 | stripDisplayTags, stripDisplayTagsAllowEmpty, stripIdeContextTags |
+| `src/utils/__tests__/taggedId.test.ts` | 10 | toTaggedId (prefix/uniqueness/format) |
+| `src/utils/__tests__/controlMessageCompat.test.ts` | 15 | normalizeControlMessageKeys (snake_case→camelCase 转换) |
+| `src/services/mcp/__tests__/normalization.test.ts` | 11 | normalizeNameForMCP (特殊字符/截断/空字符串/Unicode) |
+| `src/services/mcp/__tests__/envExpansion.test.ts` | 14 | expandEnvVarsInString ($VAR/${VAR}/嵌套/未定义/转义) |
+| `src/utils/git/__tests__/gitConfigParser.test.ts` | 20 | parseConfigString (key=value/section/subsection/多行/注释/引号) |
+| `src/utils/__tests__/formatBriefTimestamp.test.ts` | 10 | formatBriefTimestamp (秒/分/时/天/周/月/年) |
+| `src/utils/__tests__/hyperlink.test.ts` | 10 | createHyperlink (OSC 8 序列/file:///path/fallback) |
+| `src/utils/__tests__/windowsPaths.test.ts` | 20 | windowsPathToPosixPath, posixPathToWindowsPath (驱动器/UNC/相对路径) |
+| `src/utils/__tests__/notebook.test.ts` | 14 | parseCellId, mapNotebookCellsToToolResult (code/markdown/output) |
+| `src/utils/__tests__/effort.test.ts` | 38 | isEffortLevel, parseEffortValue, isValidNumericEffort, convertEffortValueToLevel, getEffortLevelDescription, resolvePickerEffortPersistence |
+
 ### 已知限制
 
 以下模块因 Bun 运行时限制或极重依赖链，暂时无法或不适合测试：
@@ -405,14 +422,20 @@ bun test --watch
 | `src/utils/slowOperations.ts` | tokens.ts, permissions.ts, memoize.ts, PermissionMode.ts |
 | `src/utils/debug.ts` | envValidation.ts, outputLimits.ts |
 | `src/utils/bash/commands.ts` | commandSemantics.ts |
+| `src/utils/thinking.js` | effort.ts |
+| `src/utils/settings/settings.js` | effort.ts |
+| `src/utils/auth.js` | effort.ts |
+| `src/services/analytics/growthbook.js` | effort.ts, tokenBudget.ts |
+| `src/utils/model/modelSupportOverrides.js` | effort.ts |
 
 **关键约束**：`mock.module()` 必须在每个测试文件中内联调用，不能从共享 helper 导入（Bun 在 mock 生效前就解析了 helper 的导入）。
 
 ## 12. 后续测试覆盖计划
 
-> **已完成** — 实际增加 321 tests，从 647 → 968 tests / 52 files
+> **已完成** — Phase 1-4 增加 321 tests (647 → 968)，Phase 5 增加 209 tests (968 → 1177)
 >
 > Phase 1-4 全部完成，详见上方 P3-P5 表格。
+> Phase 5 新增 12 个测试文件覆盖：effort、tokenBudget、displayTags、taggedId、controlMessageCompat、MCP normalization/envExpansion、gitConfigParser、formatBriefTimestamp、hyperlink、windowsPaths、notebook，详见 P6 表格。
 > 实际调整：Phase 3 中 `context.ts` 因极重依赖链（bootstrap/state + claudemd + git 等）且 `getGitStatus` 在 test 环境直接返回 null，替换为 `envValidation.ts`（更实用）；Phase 4 中 GlobTool 纯函数不足，替换为 `commandSemantics.ts` + `destructiveCommandWarning.ts`。
 
 ### 不纳入计划的模块

src/services/mcp/__tests__/envExpansion.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { expandEnvVarsInString } from "../envExpansion";
+
+describe("expandEnvVarsInString", () => {
+  // Save and restore env vars touched by tests
+  const savedEnv: Record<string, string | undefined> = {};
+  const trackedKeys = [
+    "TEST_HOME",
+    "MISSING",
+    "TEST_A",
+    "TEST_B",
+    "TEST_EMPTY",
+    "TEST_X",
+    "VAR",
+    "TEST_FOUND",
+  ];
+
+  beforeEach(() => {
+    for (const key of trackedKeys) {
+      savedEnv[key] = process.env[key];
+    }
+  });
+
+  afterEach(() => {
+    for (const key of trackedKeys) {
+      if (savedEnv[key] === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = savedEnv[key];
+      }
+    }
+  });
+
+  test("expands a single env var that exists", () => {
+    process.env.TEST_HOME = "/home/user";
+    const result = expandEnvVarsInString("${TEST_HOME}");
+    expect(result.expanded).toBe("/home/user");
+    expect(result.missingVars).toEqual([]);
+  });
+
+  test("returns original placeholder and tracks missing var when not found", () => {
+    delete process.env.MISSING;
+    const result = expandEnvVarsInString("${MISSING}");
+    expect(result.expanded).toBe("${MISSING}");
+    expect(result.missingVars).toEqual(["MISSING"]);
+  });
+
+  test("uses default value when var is missing and default is provided", () => {
+    delete process.env.MISSING;
+    const result = expandEnvVarsInString("${MISSING:-fallback}");
+    expect(result.expanded).toBe("fallback");
+    expect(result.missingVars).toEqual([]);
+  });
+
+  test("expands multiple vars", () => {
+    process.env.TEST_A = "hello";
+    process.env.TEST_B = "world";
+    const result = expandEnvVarsInString("${TEST_A}/${TEST_B}");
+    expect(result.expanded).toBe("hello/world");
+    expect(result.missingVars).toEqual([]);
+  });
+
+  test("handles mix of found and missing vars", () => {
+    process.env.TEST_FOUND = "yes";
+    delete process.env.MISSING;
+    const result = expandEnvVarsInString("${TEST_FOUND}-${MISSING}");
+    expect(result.expanded).toBe("yes-${MISSING}");
+    expect(result.missingVars).toEqual(["MISSING"]);
+  });
+
+  test("returns plain string unchanged with empty missingVars", () => {
+    const result = expandEnvVarsInString("plain string");
+    expect(result.expanded).toBe("plain string");
+    expect(result.missingVars).toEqual([]);
+  });
+
+  test("expands empty env var value", () => {
+    process.env.TEST_EMPTY = "";
+    const result = expandEnvVarsInString("${TEST_EMPTY}");
+    expect(result.expanded).toBe("");
+    expect(result.missingVars).toEqual([]);
+  });
+
+  test("prefers env var value over default when var exists", () => {
+    process.env.TEST_X = "real";
+    const result = expandEnvVarsInString("${TEST_X:-default}");
+    expect(result.expanded).toBe("real");
+    expect(result.missingVars).toEqual([]);
+  });
+
+  test("handles default value containing colons", () => {
+    // split(':-', 2) means only the first :- is the delimiter
+    delete process.env.TEST_X;
+    const result = expandEnvVarsInString("${TEST_X:-value:-with:-colons}");
+    // The default is "value" because split(':-', 2) gives ["TEST_X", "value"]
+    // Wait -- actually split(':-', 2) on "TEST_X:-value:-with:-colons" gives:
+    //   ["TEST_X", "value"] because limit=2 stops at 2 pieces
+    expect(result.expanded).toBe("value");
+    expect(result.missingVars).toEqual([]);
+  });
+
+  test("handles nested-looking syntax as literal (not supported)", () => {
+    // ${${VAR}} - the regex [^}]+ matches "${VAR" (up to first })
+    // so varName would be "${VAR" which won't be found in env
+    delete process.env.VAR;
+    const result = expandEnvVarsInString("${${VAR}}");
+    // The regex \$\{([^}]+)\} matches "${${VAR}" with capture "${VAR"
+    // That env var won't exist, so it stays as "${${VAR}" + remaining "}"
+    expect(result.missingVars).toEqual(["${VAR"]);
+    expect(result.expanded).toBe("${${VAR}}");
+  });
+
+  test("handles empty string input", () => {
+    const result = expandEnvVarsInString("");
+    expect(result.expanded).toBe("");
+    expect(result.missingVars).toEqual([]);
+  });
+
+  test("handles var surrounded by text", () => {
+    process.env.TEST_A = "middle";
+    const result = expandEnvVarsInString("before-${TEST_A}-after");
+    expect(result.expanded).toBe("before-middle-after");
+    expect(result.missingVars).toEqual([]);
+  });
+
+  test("handles default value that is empty string", () => {
+    delete process.env.MISSING;
+    const result = expandEnvVarsInString("${MISSING:-}");
+    expect(result.expanded).toBe("");
+    expect(result.missingVars).toEqual([]);
+  });
+
+  test("does not expand $VAR without braces", () => {
+    process.env.TEST_A = "value";
+    const result = expandEnvVarsInString("$TEST_A");
+    expect(result.expanded).toBe("$TEST_A");
+    expect(result.missingVars).toEqual([]);
+  });
+});

src/services/mcp/__tests__/normalization.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import { normalizeNameForMCP } from "../normalization";
+
+describe("normalizeNameForMCP", () => {
+  test("returns simple valid name unchanged", () => {
+    expect(normalizeNameForMCP("my-server")).toBe("my-server");
+  });
+
+  test("replaces dots with underscores", () => {
+    expect(normalizeNameForMCP("my.server.name")).toBe("my_server_name");
+  });
+
+  test("replaces spaces with underscores", () => {
+    expect(normalizeNameForMCP("my server")).toBe("my_server");
+  });
+
+  test("replaces special characters with underscores", () => {
+    expect(normalizeNameForMCP("server@v2!")).toBe("server_v2_");
+  });
+
+  test("returns already valid name unchanged", () => {
+    expect(normalizeNameForMCP("valid_name-123")).toBe("valid_name-123");
+  });
+
+  test("returns empty string for empty input", () => {
+    expect(normalizeNameForMCP("")).toBe("");
+  });
+
+  test("handles claude.ai prefix: collapses consecutive underscores and strips edges", () => {
+    // "claude.ai My Server" -> replace invalid -> "claude_ai_My_Server"
+    // starts with "claude.ai " so collapse + strip -> "claude_ai_My_Server"
+    expect(normalizeNameForMCP("claude.ai My Server")).toBe(
+      "claude_ai_My_Server"
+    );
+  });
+
+  test("handles claude.ai prefix with consecutive invalid chars", () => {
+    // "claude.ai ...test..." -> replace invalid -> "claude_ai____test___"
+    // collapse consecutive _ -> "claude_ai_test_"
+    // strip leading/trailing _ -> "claude_ai_test"
+    expect(normalizeNameForMCP("claude.ai ...test...")).toBe("claude_ai_test");
+  });
+
+  test("non-claude.ai name preserves consecutive underscores", () => {
+    // "a..b" -> "a__b", no claude.ai prefix so no collapse
+    expect(normalizeNameForMCP("a..b")).toBe("a__b");
+  });
+
+  test("non-claude.ai name preserves trailing underscores", () => {
+    expect(normalizeNameForMCP("name!")).toBe("name_");
+  });
+
+  test("handles claude.ai prefix that results in only underscores", () => {
+    // "claude.ai ..." -> replace invalid -> "claude_ai____"
+    // collapse -> "claude_ai_"
+    // strip trailing -> "claude_ai"
+    expect(normalizeNameForMCP("claude.ai ...")).toBe("claude_ai");
+  });
+});

src/utils/__tests__/controlMessageCompat.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, test } from "bun:test";
+import { normalizeControlMessageKeys } from "../controlMessageCompat";
+
+describe("normalizeControlMessageKeys", () => {
+  // --- basic camelCase to snake_case ---
+  test("converts requestId to request_id", () => {
+    const obj = { requestId: "123" };
+    const result = normalizeControlMessageKeys(obj);
+    expect(result).toEqual({ request_id: "123" });
+    expect((result as any).requestId).toBeUndefined();
+  });
+
+  test("leaves request_id unchanged", () => {
+    const obj = { request_id: "123" };
+    normalizeControlMessageKeys(obj);
+    expect(obj).toEqual({ request_id: "123" });
+  });
+
+  // --- both present: snake_case wins ---
+  test("keeps snake_case when both requestId and request_id exist", () => {
+    const obj = { requestId: "camel", request_id: "snake" };
+    const result = normalizeControlMessageKeys(obj) as any;
+    expect(result.request_id).toBe("snake");
+    // requestId is NOT deleted when request_id already exists
+    // because the condition `!('request_id' in record)` prevents the branch
+    expect(result.requestId).toBe("camel");
+  });
+
+  // --- nested response ---
+  test("normalizes nested response.requestId", () => {
+    const obj = { response: { requestId: "456" } };
+    normalizeControlMessageKeys(obj);
+    expect((obj as any).response.request_id).toBe("456");
+    expect((obj as any).response.requestId).toBeUndefined();
+  });
+
+  test("leaves nested response.request_id unchanged", () => {
+    const obj = { response: { request_id: "789" } };
+    normalizeControlMessageKeys(obj);
+    expect((obj as any).response.request_id).toBe("789");
+  });
+
+  test("nested response: snake_case wins when both present", () => {
+    const obj = {
+      response: { requestId: "camel", request_id: "snake" },
+    };
+    normalizeControlMessageKeys(obj);
+    expect((obj as any).response.request_id).toBe("snake");
+    expect((obj as any).response.requestId).toBe("camel");
+  });
+
+  // --- non-object inputs ---
+  test("returns null as-is", () => {
+    expect(normalizeControlMessageKeys(null)).toBeNull();
+  });
+
+  test("returns undefined as-is", () => {
+    expect(normalizeControlMessageKeys(undefined)).toBeUndefined();
+  });
+
+  test("returns string as-is", () => {
+    expect(normalizeControlMessageKeys("hello")).toBe("hello");
+  });
+
+  test("returns number as-is", () => {
+    expect(normalizeControlMessageKeys(42)).toBe(42);
+  });
+
+  // --- empty and edge cases ---
+  test("empty object is unchanged", () => {
+    const obj = {};
+    normalizeControlMessageKeys(obj);
+    expect(obj).toEqual({});
+  });
+
+  test("mutates the original object in place", () => {
+    const obj = { requestId: "abc", other: "data" };
+    const result = normalizeControlMessageKeys(obj);
+    expect(result).toBe(obj); // same reference
+    expect(obj).toEqual({ request_id: "abc", other: "data" });
+  });
+
+  test("does not affect other keys on the object", () => {
+    const obj = { requestId: "123", type: "control_request", payload: {} };
+    normalizeControlMessageKeys(obj);
+    expect((obj as any).type).toBe("control_request");
+    expect((obj as any).payload).toEqual({});
+    expect((obj as any).request_id).toBe("123");
+  });
+
+  test("handles response being null", () => {
+    const obj = { response: null, requestId: "x" };
+    normalizeControlMessageKeys(obj);
+    expect((obj as any).request_id).toBe("x");
+    expect((obj as any).response).toBeNull();
+  });
+
+  test("handles response being a non-object (string)", () => {
+    const obj = { response: "not-an-object" };
+    normalizeControlMessageKeys(obj);
+    expect((obj as any).response).toBe("not-an-object");
+  });
+});