@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/core/src/__tests__/state-validator.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from "vitest";
+import { validateRuntimeState } from "../state/state-validator.js";
+
+describe("validateRuntimeState", () => {
+  it("rejects hook rows with non-integer numeric fields", () => {
+    const issues = validateRuntimeState({
+      manifest: {
+        schemaVersion: 2,
+        language: "en",
+        lastAppliedChapter: 12,
+        projectionVersion: 1,
+        migrationWarnings: [],
+      },
+      currentState: {
+        chapter: 12,
+        facts: [],
+      },
+      hooks: {
+        hooks: [
+          {
+            hookId: "mentor-debt",
+            startChapter: 1,
+            type: "relationship",
+            status: "open",
+            lastAdvancedChapter: "chapter twelve",
+            expectedPayoff: "Reveal the debt.",
+            notes: "Bad numeric field.",
+          },
+        ],
+      },
+      chapterSummaries: {
+        rows: [],
+      },
+    });
+
+    expect(issues.map((issue) => issue.code)).toContain("invalid_hooks_state");
+  });
+
+  it("rejects duplicate hook ids", () => {
+    const issues = validateRuntimeState({
+      manifest: {
+        schemaVersion: 2,
+        language: "en",
+        lastAppliedChapter: 12,
+        projectionVersion: 1,
+        migrationWarnings: [],
+      },
+      currentState: {
+        chapter: 12,
+        facts: [],
+      },
+      hooks: {
+        hooks: [
+          {
+            hookId: "mentor-debt",
+            startChapter: 1,
+            type: "relationship",
+            status: "open",
+            lastAdvancedChapter: 10,
+            expectedPayoff: "Reveal the debt.",
+            notes: "",
+          },
+          {
+            hookId: "mentor-debt",
+            startChapter: 4,
+            type: "mystery",
+            status: "progressing",
+            lastAdvancedChapter: 12,
+            expectedPayoff: "Identify the courier.",
+            notes: "",
+          },
+        ],
+      },
+      chapterSummaries: {
+        rows: [],
+      },
+    });
+
+    expect(issues).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: "duplicate_hook_id",
+          path: "hooks.mentor-debt",
+        }),
+      ]),
+    );
+  });
+
+  it("accepts stale open hooks as valid runtime state", () => {
+    const issues = validateRuntimeState({
+      manifest: {
+        schemaVersion: 2,
+        language: "zh",
+        lastAppliedChapter: 30,
+        projectionVersion: 1,
+        migrationWarnings: [],
+      },
+      currentState: {
+        chapter: 30,
+        facts: [],
+      },
+      hooks: {
+        hooks: [
+          {
+            hookId: "mentor-oath",
+            startChapter: 2,
+            type: "relationship",
+            status: "open",
+            lastAdvancedChapter: 8,
+            expectedPayoff: "揭开师债真相",
+            notes: "已经很多章没推进，但仍然有效。",
+          },
+        ],
+      },
+      chapterSummaries: {
+        rows: [],
+      },
+    });
+
+    expect(issues).toEqual([]);
+  });
+});

package/inkos/packages/core/src/__tests__/style-analyzer.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from "vitest";
+import { analyzeStyle } from "../agents/style-analyzer.js";
+
+describe("analyzeStyle", () => {
+  const sampleText = [
+    "陈风一脚踩碎了脚下的石板。碎石飞溅，打在旁边的墙壁上发出清脆的声响。他低头看了一眼，嘴角微微上扬。",
+    "",
+    "\"谁？\"他低喝一声，手已经按上了腰间的刀柄。指尖触到冰凉的金属，心跳稍微稳了一些。",
+    "",
+    "黑暗中，一双眼睛正盯着他。那目光冰冷得像冬夜的寒风，带着审视和一丝不易察觉的警惕。来者不善。但陈风并不怕。他经历过比这更恶劣的处境。比这更危险的对手。他攥紧了刀柄，朝着那双眼睛走了过去。脚步声在空旷的巷子里回荡。",
+  ].join("\n");
+
+  it("calculates sentence length statistics", () => {
+    const profile = analyzeStyle(sampleText);
+    expect(profile.avgSentenceLength).toBeGreaterThan(0);
+    expect(profile.sentenceLengthStdDev).toBeGreaterThan(0);
+  });
+
+  it("calculates paragraph length statistics", () => {
+    const profile = analyzeStyle(sampleText);
+    expect(profile.avgParagraphLength).toBeGreaterThan(0);
+    expect(profile.paragraphLengthRange.min).toBeGreaterThan(0);
+    expect(profile.paragraphLengthRange.max).toBeGreaterThanOrEqual(profile.paragraphLengthRange.min);
+  });
+
+  it("calculates vocabulary diversity", () => {
+    const profile = analyzeStyle(sampleText);
+    expect(profile.vocabularyDiversity).toBeGreaterThan(0);
+    expect(profile.vocabularyDiversity).toBeLessThanOrEqual(1);
+  });
+
+  it("includes source name when provided", () => {
+    const profile = analyzeStyle(sampleText, "测试来源");
+    expect(profile.sourceName).toBe("测试来源");
+  });
+
+  it("includes analyzed timestamp", () => {
+    const profile = analyzeStyle(sampleText);
+    expect(profile.analyzedAt).toBeDefined();
+  });
+
+  it("handles empty text", () => {
+    const profile = analyzeStyle("");
+    expect(profile.avgSentenceLength).toBe(0);
+    expect(profile.avgParagraphLength).toBe(0);
+    expect(profile.vocabularyDiversity).toBe(0);
+  });
+
+  it("detects top patterns from repeated sentence openings", () => {
+    const repetitiveText = [
+      "他看着远方。他看着山峰。他看着大海。他看着天空。",
+      "",
+      "风在吹。雨在下。",
+    ].join("\n");
+
+    const profile = analyzeStyle(repetitiveText);
+    // "他看" should be detected as a top pattern
+    const hasHeKan = profile.topPatterns.some((p) => p.includes("他看"));
+    expect(hasHeKan).toBe(true);
+  });
+});

package/inkos/packages/core/src/__tests__/temperature-constraints.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { resolveServicePreset, clampTemperature, getWritingTemperature } from "../llm/service-presets.js";
+
+describe("temperature constraints per service", () => {
+  it("moonshot has range [0, 1] and writingTemperature 1.0", () => {
+    const preset = resolveServicePreset("moonshot");
+    expect(preset?.temperatureRange).toEqual([0, 1]);
+    expect(preset?.writingTemperature).toBe(1.0);
+  });
+
+  it("deepseek has range [0, 2] and writingTemperature 1.5", () => {
+    const preset = resolveServicePreset("deepseek");
+    expect(preset?.temperatureRange).toEqual([0, 2]);
+    expect(preset?.writingTemperature).toBe(1.5);
+  });
+
+  it("anthropic has range [0, 1] and writingTemperature 1.0", () => {
+    const preset = resolveServicePreset("anthropic");
+    expect(preset?.temperatureRange).toEqual([0, 1]);
+    expect(preset?.writingTemperature).toBe(1.0);
+  });
+
+  it("openai has range [0, 2] and writingTemperature 1.0", () => {
+    const preset = resolveServicePreset("openai");
+    expect(preset?.temperatureRange).toEqual([0, 2]);
+    expect(preset?.writingTemperature).toBe(1.0);
+  });
+
+  it("zhipu has range [0, 1]", () => {
+    const preset = resolveServicePreset("zhipu");
+    expect(preset?.temperatureRange).toEqual([0, 1]);
+  });
+
+  it("bailian has range [0, 2]", () => {
+    const preset = resolveServicePreset("bailian");
+    expect(preset?.temperatureRange).toEqual([0, 2]);
+  });
+
+  it("minimax has range [0, 1]", () => {
+    const preset = resolveServicePreset("minimax");
+    expect(preset?.temperatureRange).toEqual([0, 1]);
+  });
+
+  it("clampTemperature respects service range", () => {
+    expect(clampTemperature("moonshot", 1.5)).toBe(1.0);
+    expect(clampTemperature("moonshot", 0.7)).toBe(0.7);
+    expect(clampTemperature("deepseek", 1.5)).toBe(1.5);
+    expect(clampTemperature("deepseek", 2.5)).toBe(2.0);
+    expect(clampTemperature("unknown-service", 1.5)).toBe(1.5);
+  });
+
+  it("getWritingTemperature returns service-specific value", () => {
+    expect(getWritingTemperature("moonshot")).toBe(1.0);
+    expect(getWritingTemperature("deepseek")).toBe(1.5);
+    expect(getWritingTemperature("anthropic")).toBe(1.0);
+  });
+});

package/inkos/packages/core/src/__tests__/v13-hotfix-round4.test.ts

@@ -0,0 +1,343 @@
+/**
+ * v13 hotfix round 4 — tests for:
+ *   Issue 1: old-book editing (no outline/story_frame.md) — isNewLayoutBook
+ *   Issue 2: per-chapter promotion pass
+ *   Issue 3: word-boundary + column-scoped regex for advanced_count
+ *
+ * Studio server tests for Issue 1 live in packages/studio/src/api/v13-hotfix-round4.test.ts.
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  isNewLayoutBook,
+} from "../utils/outline-paths.js";
+import {
+  deriveAdvancedCountsFromSummaries,
+  escapeRegex,
+  rerunPromotionPass,
+} from "../utils/hook-promotion.js";
+import {
+  parsePendingHooksMarkdown,
+  renderHookSnapshot,
+} from "../utils/story-markdown.js";
+import type { StoredHook } from "../state/memory-db.js";
+
+// ---------------------------------------------------------------------------
+// Issue 1: isNewLayoutBook — old vs new book detection
+// ---------------------------------------------------------------------------
+
+describe("Issue 1 — isNewLayoutBook detection", () => {
+  let bookDir: string;
+
+  beforeEach(async () => {
+    bookDir = await mkdtemp(join(tmpdir(), "inkos-layout-detect-"));
+    await mkdir(join(bookDir, "story"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(bookDir, { recursive: true, force: true });
+  });
+
+  it("returns false when outline/story_frame.md does not exist (legacy book)", async () => {
+    await writeFile(join(bookDir, "story", "story_bible.md"), "# Story Bible", "utf-8");
+    expect(await isNewLayoutBook(bookDir)).toBe(false);
+  });
+
+  it("returns true when outline/story_frame.md exists (new layout book)", async () => {
+    await mkdir(join(bookDir, "story", "outline"), { recursive: true });
+    await writeFile(join(bookDir, "story", "outline", "story_frame.md"), "# Frame", "utf-8");
+    expect(await isNewLayoutBook(bookDir)).toBe(true);
+  });
+
+  it("returns false when story/ dir does not exist at all", async () => {
+    const emptyDir = await mkdtemp(join(tmpdir(), "inkos-empty-"));
+    try {
+      expect(await isNewLayoutBook(emptyDir)).toBe(false);
+    } finally {
+      await rm(emptyDir, { recursive: true, force: true });
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Issue 1: write_truth_file — old book allows story_bible.md writes
+// ---------------------------------------------------------------------------
+
+describe("Issue 1 — write_truth_file per-book shim detection", () => {
+  let bookDir: string;
+
+  beforeEach(async () => {
+    bookDir = await mkdtemp(join(tmpdir(), "inkos-wt-shim-"));
+    await mkdir(join(bookDir, "story"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(bookDir, { recursive: true, force: true });
+  });
+
+  it("old book: isNewLayoutBook returns false so story_bible.md is writable", async () => {
+    await writeFile(join(bookDir, "story", "story_bible.md"), "# Old", "utf-8");
+    expect(await isNewLayoutBook(bookDir)).toBe(false);
+  });
+
+  it("new book: isNewLayoutBook returns true so story_bible.md is a shim", async () => {
+    await mkdir(join(bookDir, "story", "outline"), { recursive: true });
+    await writeFile(join(bookDir, "story", "outline", "story_frame.md"), "# Frame", "utf-8");
+    await writeFile(join(bookDir, "story", "story_bible.md"), "# Shim", "utf-8");
+    expect(await isNewLayoutBook(bookDir)).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Issue 2: per-chapter promotion pass
+// ---------------------------------------------------------------------------
+
+describe("Issue 2 — rerunPromotionPass", () => {
+  it("promotes hook when mentioned in 2+ chapters of chapter_summaries", () => {
+    const hooks: StoredHook[] = [
+      {
+        hookId: "H05",
+        startChapter: 3,
+        type: "小承诺",
+        status: "open",
+        lastAdvancedChapter: 7,
+        expectedPayoff: "15章",
+        payoffTiming: "near-term",
+        notes: "",
+        promoted: false,
+      },
+    ];
+    const summaries = [
+      "| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| 4 | A | X | event | change | H05 推进 | 压抑 | 铺垫 |",
+      "| 7 | B | X | event2 | change2 | H05 推进 | 紧绷 | 推进 |",
+    ].join("\n");
+
+    const result = rerunPromotionPass(hooks, summaries);
+    expect(result.updated).toBe(true);
+    expect(result.flippedCount).toBe(1);
+    expect(result.hooks[0]!.promoted).toBe(true);
+  });
+
+  it("does not promote when mentioned in only 1 chapter", () => {
+    const hooks: StoredHook[] = [
+      {
+        hookId: "H06",
+        startChapter: 5,
+        type: "小",
+        status: "open",
+        lastAdvancedChapter: 0,
+        expectedPayoff: "",
+        notes: "",
+        promoted: false,
+      },
+    ];
+    const summaries = [
+      "| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| 5 | A | X | event | change | H06 推进 | 压抑 | 铺垫 |",
+    ].join("\n");
+
+    const result = rerunPromotionPass(hooks, summaries);
+    expect(result.updated).toBe(false);
+    expect(result.flippedCount).toBe(0);
+    expect(result.hooks[0]!.promoted).toBe(false);
+  });
+
+  it("skips already-promoted hooks", () => {
+    const hooks: StoredHook[] = [
+      {
+        hookId: "H07",
+        startChapter: 1,
+        type: "主线",
+        status: "open",
+        lastAdvancedChapter: 5,
+        expectedPayoff: "",
+        notes: "",
+        promoted: true,
+      },
+    ];
+    const summaries = [
+      "| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| 3 | A | X | event | change | H07 推进 | 压抑 | 铺垫 |",
+      "| 5 | B | X | event2 | change2 | H07 推进 | 紧绷 | 推进 |",
+    ].join("\n");
+
+    const result = rerunPromotionPass(hooks, summaries);
+    expect(result.updated).toBe(false);
+    expect(result.flippedCount).toBe(0);
+  });
+});
+
+describe("Issue 2 — per-chapter promotion persists to pending_hooks.md", () => {
+  let bookDir: string;
+
+  beforeEach(async () => {
+    bookDir = await mkdtemp(join(tmpdir(), "inkos-perchapt-promo-"));
+    await mkdir(join(bookDir, "story"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(bookDir, { recursive: true, force: true });
+  });
+
+  it("after writing chapter where H05 is mentioned 2nd time, pending_hooks.md shows H05 promoted=true", async () => {
+    const hooks: StoredHook[] = [
+      {
+        hookId: "H05",
+        startChapter: 3,
+        type: "小承诺",
+        status: "open",
+        lastAdvancedChapter: 7,
+        expectedPayoff: "15章",
+        payoffTiming: "near-term",
+        notes: "sister promise",
+        promoted: false,
+      },
+    ];
+    const storyDir = join(bookDir, "story");
+    const ledgerPath = join(storyDir, "pending_hooks.md");
+    await writeFile(ledgerPath, renderHookSnapshot(hooks, "zh"), "utf-8");
+
+    // Simulate chapter_summaries with H05 mentioned in 2 chapters
+    await writeFile(join(storyDir, "chapter_summaries.md"), [
+      "| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| 4 | 旧信 | 林辞 | 收到家书 | 回忆 | H05 推进 | 压抑 | 铺垫 |",
+      "| 7 | 码头 | 林辞 | 查账 | 汇合 | H05 推进 | 紧绷 | 推进 |",
+    ].join("\n"), "utf-8");
+
+    // Run the promotion pass (same logic as runner.ts step 3c)
+    const ledgerRaw = await readFile(ledgerPath, "utf-8");
+    const parsedHooks = parsePendingHooksMarkdown(ledgerRaw);
+    const summariesRaw = await readFile(join(storyDir, "chapter_summaries.md"), "utf-8");
+    const result = rerunPromotionPass(parsedHooks, summariesRaw);
+
+    expect(result.updated).toBe(true);
+    // Write back
+    await writeFile(ledgerPath, renderHookSnapshot([...result.hooks], "zh"), "utf-8");
+
+    // Verify the file on disk
+    const updated = parsePendingHooksMarkdown(await readFile(ledgerPath, "utf-8"));
+    expect(updated.find((h) => h.hookId === "H05")!.promoted).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Issue 3: word-boundary + column-scoped regex
+// ---------------------------------------------------------------------------
+
+describe("Issue 3 — escapeRegex", () => {
+  it("escapes special characters", () => {
+    // `-` is not a regex metachar outside character classes, so not escaped
+    expect(escapeRegex("H-01")).toBe("H-01");
+    expect(escapeRegex("H.01")).toBe("H\\.01");
+    expect(escapeRegex("test(1)")).toBe("test\\(1\\)");
+    expect(escapeRegex("hook[0]")).toBe("hook\\[0\\]");
+  });
+});
+
+describe("Issue 3 — deriveAdvancedCountsFromSummaries", () => {
+  it("H01 does NOT match H010 in the same row", () => {
+    const summaries = [
+      "| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| 5 | title | char | event | change | H010 推进 | mood | type |",
+    ].join("\n");
+
+    const counts = deriveAdvancedCountsFromSummaries(summaries, ["H01"]);
+    expect(counts.get("H01")).toBeUndefined();
+  });
+
+  it("H010 matches H010 correctly", () => {
+    const summaries = [
+      "| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| 5 | title | char | event | change | H010 推进 | mood | type |",
+    ].join("\n");
+
+    const counts = deriveAdvancedCountsFromSummaries(summaries, ["H010"]);
+    expect(counts.get("H010")).toBe(1);
+  });
+
+  it("hook_id in title column does NOT count as advancement", () => {
+    // H01 appears in the title column (index 1), not hookActivity (index 5)
+    const summaries = [
+      "| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| 5 | H01的故事 | char | event | change | 其他线索 | mood | type |",
+    ].join("\n");
+
+    const counts = deriveAdvancedCountsFromSummaries(summaries, ["H01"]);
+    expect(counts.get("H01")).toBeUndefined();
+  });
+
+  it("hook_id in hookActivity column DOES count", () => {
+    const summaries = [
+      "| 章节 | 标题 | 出场人物 | 关键事件 | 状态变化 | 伏笔动态 | 情绪基调 | 章节类型 |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| 5 | 普通标题 | char | event | change | H01 推进 | mood | type |",
+      "| 6 | 另一个 | char | event | change | H01 推进 | mood | type |",
+    ].join("\n");
+
+    const counts = deriveAdvancedCountsFromSummaries(summaries, ["H01"]);
+    expect(counts.get("H01")).toBe(2);
+  });
+
+  it("works with en-locale headers", () => {
+    const summaries = [
+      "| chapter | title | characters | events | stateChanges | hookActivity | mood | chapterType |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| 5 | old letter | Lin | found letter | memory | H01 advanced | tense | setup |",
+      "| 6 | dock | Lin | check | converge | H01 advanced | tense | progress |",
+    ].join("\n");
+
+    const counts = deriveAdvancedCountsFromSummaries(summaries, ["H01"]);
+    expect(counts.get("H01")).toBe(2);
+  });
+
+  it("hook_id in events column (not hookActivity) does not count", () => {
+    const summaries = [
+      "| chapter | title | characters | events | stateChanges | hookActivity | mood | chapterType |",
+      "| --- | --- | --- | --- | --- | --- | --- | --- |",
+      "| 5 | title | char | H01 discovered | change | other stuff | mood | type |",
+    ].join("\n");
+
+    const counts = deriveAdvancedCountsFromSummaries(summaries, ["H01"]);
+    expect(counts.get("H01")).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Issue 1: write_truth_file — old book allows story_bible.md writes
+// ---------------------------------------------------------------------------
+
+describe("Issue 1 — write_truth_file per-book shim detection", () => {
+  let bookDir: string;
+
+  beforeEach(async () => {
+    bookDir = await mkdtemp(join(tmpdir(), "inkos-wt-shim-"));
+    await mkdir(join(bookDir, "story"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(bookDir, { recursive: true, force: true });
+  });
+
+  it("old book: isNewLayoutBook returns false so story_bible.md is writable", async () => {
+    await writeFile(join(bookDir, "story", "story_bible.md"), "# Old", "utf-8");
+    expect(await isNewLayoutBook(bookDir)).toBe(false);
+  });
+
+  it("new book: isNewLayoutBook returns true so story_bible.md is a shim", async () => {
+    await mkdir(join(bookDir, "story", "outline"), { recursive: true });
+    await writeFile(join(bookDir, "story", "outline", "story_frame.md"), "# Frame", "utf-8");
+    await writeFile(join(bookDir, "story", "story_bible.md"), "# Shim", "utf-8");
+    expect(await isNewLayoutBook(bookDir)).toBe(true);
+  });
+});

package/inkos/packages/core/src/__tests__/verify-service.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { verifyService } from "../llm/providers/verify.js";
+
+describe("verifyService (B9)", () => {
+  const originalFetch = global.fetch;
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.restoreAllMocks();
+  });
+
+  it("probe 成功 → probe.ok=true + chat 字段非 null（chat 步骤被执行）", async () => {
+    global.fetch = vi.fn()
+      // probe /models 成功
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ data: [{ id: "gpt-4o" }, { id: "gpt-4o-mini" }] }),
+      } as any)
+      // 后续 chat 请求失败（测试环境没真实 openai SDK 支持），但这 OK —— 只要 chat 被尝试了就行
+      .mockRejectedValue(new Error("test: no real chat backend"));
+
+    const result = await verifyService("openai", "sk-test");
+    expect(result.probe.ok).toBe(true);
+    expect(result.probe.models).toBe(2);
+    // chat 字段不为 null 说明 checkModel 存在 + chat 步骤被执行（ok=true/false 都可以）
+    expect(result.chat).not.toBeNull();
+    expect(typeof result.chat?.ok).toBe("boolean");
+    expect(result.chat?.latencyMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it("probe 401 → probe.ok=false, error 带 401", async () => {
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 401,
+      statusText: "Unauthorized",
+    } as any) as typeof fetch;
+
+    const result = await verifyService("openai", "wrong-key");
+    expect(result.probe.ok).toBe(false);
+    expect(result.probe.error).toContain("401");
+  });
+
+  it("probe 网络挂 → probe.ok=false, error 是 fetch 错误", async () => {
+    global.fetch = vi.fn().mockRejectedValue(new Error("ECONNREFUSED")) as typeof fetch;
+    const result = await verifyService("openai", "sk-test");
+    expect(result.probe.ok).toBe(false);
+    expect(result.probe.error).toContain("ECONNREFUSED");
+  });
+
+  it("probe 使用显式 proxyUrl 连接 /models", async () => {
+    const fetchMock = vi.fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ data: [{ id: "gpt-4o" }] }),
+      } as any)
+      .mockRejectedValue(new Error("test: no real chat backend"));
+    global.fetch = fetchMock as typeof fetch;
+
+    const result = await verifyService("openai", "sk-test", { proxyUrl: "http://127.0.0.1:9910" });
+    expect(result.probe.ok).toBe(true);
+    expect(fetchMock.mock.calls[0]?.[1]).toMatchObject({
+      dispatcher: expect.any(Object),
+    });
+  });
+
+  it("provider 没 checkModel（custom baseUrl 空）→ chat 字段返回 null，不发 chat 请求", async () => {
+    // custom 没 checkModel，verifyService 跳过 chat step
+    const result = await verifyService("custom", "sk-x");
+    expect(result.chat).toBeNull();
+  });
+
+  it("未知 service → probe 报 '无 baseUrl'", async () => {
+    const result = await verifyService("nonexistent-xyz", "sk-test");
+    expect(result.probe.ok).toBe(false);
+    expect(result.probe.error).toContain("baseUrl");
+  });
+});