@zwbigi/ink-xy 0.1.2 → 0.1.4

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

@@ -0,0 +1,388 @@
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  buildRuntimeStateArtifacts,
+  loadNarrativeMemorySeed,
+  loadRuntimeStateSnapshot,
+  loadSnapshotCurrentStateFacts,
+} from "../state/runtime-state-store.js";
+
+describe("runtime-state-store memory helpers", () => {
+  let root = "";
+
+  afterEach(async () => {
+    if (root) {
+      await rm(root, { recursive: true, force: true });
+      root = "";
+    }
+  });
+
+  it("prefers structured runtime state over stale markdown projections for narrative memory", async () => {
+    root = await mkdtemp(join(tmpdir(), "inkos-runtime-state-store-"));
+    const bookDir = join(root, "book");
+    const storyDir = join(bookDir, "story");
+    const stateDir = join(storyDir, "state");
+    const chaptersDir = join(bookDir, "chapters");
+    await mkdir(stateDir, { recursive: true });
+    await mkdir(chaptersDir, { recursive: true });
+    await writeFile(
+      join(chaptersDir, "index.json"),
+      JSON.stringify([
+        { number: 1, title: "Ch1", status: "approved" },
+        { number: 2, title: "Ch2", status: "approved" },
+        { number: 3, title: "Ch3", status: "approved" },
+      ]),
+      "utf-8",
+    );
+
+    await Promise.all([
+      writeFile(
+        join(storyDir, "pending_hooks.md"),
+        [
+          "| hook_id | start_chapter | type | status | last_advanced | expected_payoff | notes |",
+          "| --- | --- | --- | --- | --- | --- | --- |",
+          "| markdown-hook | 1 | mystery | open | 1 | 4 | Old markdown hook |",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "chapter_summaries.md"),
+        [
+          "| chapter | title | characters | events | stateChanges | hookActivity | mood | chapterType |",
+          "| --- | --- | --- | --- | --- | --- | --- | --- |",
+          "| 1 | Markdown Summary | Lin Yue | Old markdown event | Old markdown state | markdown-hook advanced | tense | fallback |",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(join(stateDir, "manifest.json"), JSON.stringify({
+        schemaVersion: 2,
+        language: "en",
+        lastAppliedChapter: 3,
+        projectionVersion: 1,
+        migrationWarnings: [],
+      }, null, 2), "utf-8"),
+      writeFile(join(stateDir, "current_state.json"), JSON.stringify({
+        chapter: 3,
+        facts: [],
+      }, null, 2), "utf-8"),
+      writeFile(join(stateDir, "hooks.json"), JSON.stringify({
+        hooks: [
+          {
+            hookId: "structured-hook",
+            startChapter: 2,
+            type: "relationship",
+            status: "progressing",
+            lastAdvancedChapter: 3,
+            expectedPayoff: "Reveal the mentor ledger.",
+            notes: "Structured hook should win.",
+          },
+        ],
+      }, null, 2), "utf-8"),
+      writeFile(join(stateDir, "chapter_summaries.json"), JSON.stringify({
+        rows: [
+          {
+            chapter: 3,
+            title: "Structured Summary",
+            characters: "Lin Yue",
+            events: "Structured runtime state event.",
+            stateChanges: "Structured runtime state shift.",
+            hookActivity: "structured-hook advanced",
+            mood: "grim",
+            chapterType: "mainline",
+          },
+        ],
+      }, null, 2), "utf-8"),
+    ]);
+
+    const seed = await loadNarrativeMemorySeed(bookDir);
+
+    expect(seed.hooks).toEqual([
+      expect.objectContaining({
+        hookId: "structured-hook",
+        status: "progressing",
+      }),
+    ]);
+    expect(seed.summaries).toEqual([
+      expect.objectContaining({
+        chapter: 3,
+        title: "Structured Summary",
+        events: "Structured runtime state event.",
+      }),
+    ]);
+  });
+
+  it("prefers structured snapshot state over stale markdown snapshots for fact history rebuild", async () => {
+    root = await mkdtemp(join(tmpdir(), "inkos-runtime-state-snapshot-"));
+    const bookDir = join(root, "book");
+    const snapshotDir = join(bookDir, "story", "snapshots", "5");
+    const snapshotStateDir = join(snapshotDir, "state");
+    await mkdir(snapshotStateDir, { recursive: true });
+
+    await Promise.all([
+      writeFile(
+        join(snapshotDir, "current_state.md"),
+        [
+          "# Current State",
+          "",
+          "| Field | Value |",
+          "| --- | --- |",
+          "| Current Chapter | 5 |",
+          "| Current Location | Markdown harbor |",
+          "| Current Conflict | Old markdown conflict |",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(join(snapshotStateDir, "current_state.json"), JSON.stringify({
+        chapter: 5,
+        facts: [
+          {
+            subject: "current",
+            predicate: "Current Location",
+            object: "Structured watchtower",
+            validFromChapter: 5,
+            validUntilChapter: null,
+            sourceChapter: 5,
+          },
+          {
+            subject: "protagonist",
+            predicate: "Current Conflict",
+            object: "Structured conflict replaces markdown drift.",
+            validFromChapter: 5,
+            validUntilChapter: null,
+            sourceChapter: 5,
+          },
+        ],
+      }, null, 2), "utf-8"),
+    ]);
+
+    const facts = await loadSnapshotCurrentStateFacts(bookDir, 5);
+
+    expect(facts).toEqual([
+      expect.objectContaining({
+        predicate: "Current Location",
+        object: "Structured watchtower",
+      }),
+      expect.objectContaining({
+        predicate: "Current Conflict",
+        object: "Structured conflict replaces markdown drift.",
+      }),
+    ]);
+  });
+
+  it("rejects persisted duplicate summary chapters in structured runtime state", async () => {
+    root = await mkdtemp(join(tmpdir(), "inkos-runtime-state-invalid-"));
+    const bookDir = join(root, "book");
+    const storyDir = join(bookDir, "story");
+    const stateDir = join(storyDir, "state");
+    const chaptersDir = join(bookDir, "chapters");
+    await mkdir(stateDir, { recursive: true });
+    await mkdir(chaptersDir, { recursive: true });
+    await writeFile(
+      join(chaptersDir, "index.json"),
+      JSON.stringify(
+        Array.from({ length: 12 }, (_, i) => ({ number: i + 1, title: `Ch${i + 1}`, status: "approved" })),
+      ),
+      "utf-8",
+    );
+
+    await Promise.all([
+      writeFile(join(stateDir, "manifest.json"), JSON.stringify({
+        schemaVersion: 2,
+        language: "zh",
+        lastAppliedChapter: 12,
+        projectionVersion: 1,
+        migrationWarnings: [],
+      }, null, 2), "utf-8"),
+      writeFile(join(stateDir, "current_state.json"), JSON.stringify({
+        chapter: 12,
+        facts: [],
+      }, null, 2), "utf-8"),
+      writeFile(join(stateDir, "hooks.json"), JSON.stringify({
+        hooks: [],
+      }, null, 2), "utf-8"),
+      writeFile(join(stateDir, "chapter_summaries.json"), JSON.stringify({
+        rows: [
+          {
+            chapter: 12,
+            title: "河埠对账",
+            characters: "林月",
+            events: "第一次写入。",
+            stateChanges: "第一次写入。",
+            hookActivity: "mentor-debt 推进",
+            mood: "紧绷",
+            chapterType: "主线推进",
+          },
+          {
+            chapter: 12,
+            title: "重复河埠对账",
+            characters: "林月",
+            events: "第二次写入。",
+            stateChanges: "第二次写入。",
+            hookActivity: "mentor-debt 推进",
+            mood: "紧绷",
+            chapterType: "主线推进",
+          },
+        ],
+      }, null, 2), "utf-8"),
+    ]);
+
+    // Duplicates are auto-repaired (deduped, keeping last occurrence), not rejected
+    const snapshot = await loadRuntimeStateSnapshot(bookDir);
+    expect(snapshot.chapterSummaries.rows).toHaveLength(1);
+    expect(snapshot.chapterSummaries.rows[0]?.title).toBe("重复河埠对账");
+  });
+
+  it("repairs persisted hooks with empty type instead of failing the library load", async () => {
+    root = await mkdtemp(join(tmpdir(), "inkos-runtime-state-hook-repair-"));
+    const bookDir = join(root, "book");
+    const storyDir = join(bookDir, "story");
+    const stateDir = join(storyDir, "state");
+    const chaptersDir = join(bookDir, "chapters");
+    await mkdir(stateDir, { recursive: true });
+    await mkdir(chaptersDir, { recursive: true });
+
+    await Promise.all([
+      writeFile(
+        join(chaptersDir, "index.json"),
+        JSON.stringify(Array.from({ length: 5 }, (_, i) => ({ number: i + 1, title: `Ch${i + 1}`, status: "approved" }))),
+        "utf-8",
+      ),
+      writeFile(
+        join(storyDir, "pending_hooks.md"),
+        [
+          "| hook_id | start_chapter | type | status | last_advanced | expected_payoff | payoff_timing | notes |",
+          "| --- | --- | --- | --- | --- | --- | --- | --- |",
+          "| h001--broken | 3 |  | open | 5 | 后续揭开账本来源。 | near-term | 模型生成了空 type。 |",
+          "",
+        ].join("\n"),
+        "utf-8",
+      ),
+      writeFile(join(stateDir, "manifest.json"), JSON.stringify({
+        schemaVersion: 2,
+        language: "zh",
+        lastAppliedChapter: 5,
+        projectionVersion: 1,
+        migrationWarnings: [],
+      }, null, 2), "utf-8"),
+      writeFile(join(stateDir, "current_state.json"), JSON.stringify({
+        chapter: 5,
+        facts: [],
+      }, null, 2), "utf-8"),
+      writeFile(join(stateDir, "hooks.json"), JSON.stringify({
+        hooks: [
+          {
+            hookId: "h001--broken",
+            startChapter: 3,
+            type: "",
+            status: "open",
+            lastAdvancedChapter: 5,
+            expectedPayoff: "后续揭开账本来源。",
+            notes: "模型生成了空 type，旧版本会导致 books 接口整体报错。",
+          },
+        ],
+      }, null, 2), "utf-8"),
+      writeFile(join(stateDir, "chapter_summaries.json"), JSON.stringify({
+        rows: [],
+      }, null, 2), "utf-8"),
+    ]);
+
+    const snapshot = await loadRuntimeStateSnapshot(bookDir);
+
+    expect(snapshot.hooks.hooks[0]).toEqual(expect.objectContaining({
+      hookId: "h001--broken",
+      type: "unspecified",
+    }));
+    expect(snapshot.manifest.migrationWarnings.join("\n")).toContain("empty hook type");
+  });
+
+  it("arbitrates new hook candidates before applying structured state updates", async () => {
+    root = await mkdtemp(join(tmpdir(), "inkos-runtime-state-arbiter-"));
+    const bookDir = join(root, "book");
+    const storyDir = join(bookDir, "story");
+    const stateDir = join(storyDir, "state");
+    const chaptersDir = join(bookDir, "chapters");
+    await mkdir(stateDir, { recursive: true });
+    await mkdir(chaptersDir, { recursive: true });
+    await writeFile(
+      join(chaptersDir, "index.json"),
+      JSON.stringify(
+        Array.from({ length: 11 }, (_, i) => ({ number: i + 1, title: `Ch${i + 1}`, status: "approved" })),
+      ),
+      "utf-8",
+    );
+
+    await Promise.all([
+      writeFile(join(stateDir, "manifest.json"), JSON.stringify({
+        schemaVersion: 2,
+        language: "en",
+        lastAppliedChapter: 11,
+        projectionVersion: 1,
+        migrationWarnings: [],
+      }, null, 2), "utf-8"),
+      writeFile(join(stateDir, "current_state.json"), JSON.stringify({
+        chapter: 11,
+        facts: [],
+      }, null, 2), "utf-8"),
+      writeFile(join(stateDir, "hooks.json"), JSON.stringify({
+        hooks: [
+          {
+            hookId: "anonymous-source-scope",
+            startChapter: 3,
+            type: "source-risk",
+            status: "open",
+            lastAdvancedChapter: 8,
+            expectedPayoff: "Reveal how much the anonymous source already knew about the route.",
+            notes: "The source knowledge question remains unresolved.",
+          },
+        ],
+      }, null, 2), "utf-8"),
+      writeFile(join(stateDir, "chapter_summaries.json"), JSON.stringify({
+        rows: [],
+      }, null, 2), "utf-8"),
+      writeFile(join(storyDir, "pending_hooks.md"), "", "utf-8"),
+      writeFile(join(storyDir, "chapter_summaries.md"), "", "utf-8"),
+    ]);
+
+    const artifacts = await buildRuntimeStateArtifacts({
+      bookDir,
+      language: "en",
+      delta: {
+        chapter: 12,
+        hookOps: {
+          upsert: [],
+          mention: [],
+          resolve: [],
+          defer: [],
+        },
+        newHookCandidates: [
+          {
+            type: "source-risk",
+            expectedPayoff: "Reveal how much the anonymous source already knew about the route and address.",
+            notes: "This chapter adds the address angle to the anonymous source question.",
+          },
+        ],
+        notes: [],
+        subplotOps: [],
+        emotionalArcOps: [],
+        characterMatrixOps: [],
+      },
+    });
+
+    expect(artifacts.resolvedDelta.hookOps.upsert).toEqual([
+      expect.objectContaining({
+        hookId: "anonymous-source-scope",
+        lastAdvancedChapter: 12,
+      }),
+    ]);
+    expect(artifacts.snapshot.hooks.hooks).toHaveLength(1);
+    expect(artifacts.snapshot.hooks.hooks[0]).toEqual(expect.objectContaining({
+      hookId: "anonymous-source-scope",
+      lastAdvancedChapter: 12,
+    }));
+  });
+});

package/inkos/packages/core/src/__tests__/scheduler.test.ts

@@ -0,0 +1,123 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Scheduler, type SchedulerConfig } from "../pipeline/scheduler.js";
+import type { BookConfig } from "../models/book.js";
+
+function createConfig(): SchedulerConfig {
+  return {
+    client: {
+      provider: "openai",
+      apiFormat: "chat",
+      stream: false,
+      defaults: {
+        temperature: 0.7,
+        maxTokens: 1024,
+        thinkingBudget: 0,
+      },
+    } as SchedulerConfig["client"],
+    model: "test-model",
+    projectRoot: process.cwd(),
+    radarCron: "*/1 * * * *",
+    writeCron: "*/1 * * * *",
+    maxConcurrentBooks: 1,
+    chaptersPerCycle: 1,
+    retryDelayMs: 0,
+    cooldownAfterChapterMs: 0,
+    maxChaptersPerDay: 10,
+  };
+}
+
+describe("Scheduler", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  it("does not start a second write cycle while one is still running", async () => {
+    const scheduler = new Scheduler(createConfig());
+    let releaseCycle: (() => void) | undefined;
+    const blockedCycle = new Promise<void>((resolve) => {
+      releaseCycle = resolve;
+    });
+
+    const runWriteCycle = vi
+      .spyOn(scheduler as unknown as { runWriteCycle: () => Promise<void> }, "runWriteCycle")
+      .mockImplementation(async () => {
+        if (runWriteCycle.mock.calls.length === 1) {
+          return;
+        }
+        await blockedCycle;
+      });
+    vi.spyOn(scheduler as unknown as { runRadarScan: () => Promise<void> }, "runRadarScan")
+      .mockResolvedValue(undefined);
+
+    await scheduler.start();
+
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(runWriteCycle).toHaveBeenCalledTimes(2);
+
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(runWriteCycle).toHaveBeenCalledTimes(2);
+
+    releaseCycle?.();
+    await blockedCycle;
+    scheduler.stop();
+  });
+
+  it("treats state-degraded chapter results as handled failures", async () => {
+    const onChapterComplete = vi.fn();
+    const scheduler = new Scheduler({
+      ...createConfig(),
+      onChapterComplete,
+    });
+    const bookConfig: BookConfig = {
+      id: "book-1",
+      title: "Book 1",
+      platform: "other",
+      genre: "other",
+      status: "active",
+      targetChapters: 10,
+      chapterWordCount: 2200,
+      createdAt: "2026-04-01T00:00:00.000Z",
+      updatedAt: "2026-04-01T00:00:00.000Z",
+    };
+
+    vi.spyOn(
+      (scheduler as unknown as { pipeline: { writeNextChapter: (bookId: string, words?: number, temp?: number) => Promise<unknown> } }).pipeline,
+      "writeNextChapter",
+    ).mockResolvedValue({
+        chapterNumber: 3,
+        title: "Broken State",
+        wordCount: 2100,
+        revised: false,
+        status: "state-degraded",
+        auditResult: {
+          passed: true,
+          issues: [{
+            severity: "warning",
+            category: "state-validation",
+            description: "state validation still failed after retry",
+            suggestion: "repair state before continuing",
+          }],
+          summary: "clean",
+        },
+    });
+    const handleAuditFailure = vi.spyOn(
+      scheduler as unknown as { handleAuditFailure: (bookId: string, chapterNumber: number, issueCategories?: string[]) => Promise<void> },
+      "handleAuditFailure",
+    ).mockResolvedValue(undefined);
+
+    const success = await (
+      scheduler as unknown as {
+        writeOneChapter: (bookId: string, bookConfig: BookConfig) => Promise<boolean>;
+      }
+    ).writeOneChapter("book-1", bookConfig);
+
+    expect(success).toBe(false);
+    expect(handleAuditFailure).toHaveBeenCalledWith("book-1", 3, ["state-validation"]);
+    expect(onChapterComplete).toHaveBeenCalledWith("book-1", 3, "state-degraded");
+  });
+});

package/inkos/packages/core/src/__tests__/secrets-migration.test.ts

@@ -0,0 +1,71 @@
+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 { loadSecrets } from "../llm/secrets.js";
+
+describe("loadSecrets legacy service id migration", () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), "inkos-secrets-mig-"));
+    await mkdir(join(root, ".inkos"), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  async function seedSecrets(data: unknown): Promise<void> {
+    await writeFile(join(root, ".inkos", "secrets.json"), JSON.stringify(data, null, 2), "utf-8");
+  }
+
+  async function readSecretsRaw(): Promise<any> {
+    return JSON.parse(await readFile(join(root, ".inkos", "secrets.json"), "utf-8"));
+  }
+
+  it("siliconflow -> siliconcloud 重命名（目标 id 不存在）", async () => {
+    await seedSecrets({ services: { siliconflow: { apiKey: "sk-legacy" } } });
+    const result = await loadSecrets(root);
+    expect(result.services.siliconcloud).toEqual({ apiKey: "sk-legacy" });
+    expect(result.services.siliconflow).toBeUndefined();
+
+    const onDisk = await readSecretsRaw();
+    expect(onDisk.services.siliconcloud).toEqual({ apiKey: "sk-legacy" });
+    expect(onDisk.services.siliconflow).toBeUndefined();
+  });
+
+  it("目标 id 已存在时不迁移（幂等）", async () => {
+    await seedSecrets({
+      services: {
+        siliconflow: { apiKey: "sk-legacy" },
+        siliconcloud: { apiKey: "sk-new" },
+      },
+    });
+    const result = await loadSecrets(root);
+    expect(result.services.siliconcloud).toEqual({ apiKey: "sk-new" });
+    expect(result.services.siliconflow).toEqual({ apiKey: "sk-legacy" });
+  });
+
+  it("无迁移时不重写磁盘", async () => {
+    await seedSecrets({ services: { openai: { apiKey: "sk-openai" } } });
+    const before = await readFile(join(root, ".inkos", "secrets.json"), "utf-8");
+    await loadSecrets(root);
+    const after = await readFile(join(root, ".inkos", "secrets.json"), "utf-8");
+    expect(after).toBe(before);
+  });
+
+  it("secrets 文件不存在时返回空 services,不报错", async () => {
+    await rm(join(root, ".inkos", "secrets.json"), { force: true });
+    const result = await loadSecrets(root);
+    expect(result).toEqual({ services: {} });
+  });
+
+  it("重复调用 loadSecrets 是幂等的", async () => {
+    await seedSecrets({ services: { siliconflow: { apiKey: "sk-legacy" } } });
+    await loadSecrets(root);
+    const r2 = await loadSecrets(root);
+    expect(r2.services.siliconcloud).toEqual({ apiKey: "sk-legacy" });
+    expect(r2.services.siliconflow).toBeUndefined();
+  });
+});

package/inkos/packages/core/src/__tests__/secrets.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { loadSecrets, saveSecrets, getServiceApiKey } from "../llm/secrets.js";
+import { mkdtemp, rm, mkdir, writeFile, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("secrets", () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), "inkos-secrets-"));
+  });
+
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  describe("loadSecrets", () => {
+    it("returns empty when .inkos/secrets.json does not exist", async () => {
+      const secrets = await loadSecrets(root);
+      expect(secrets).toEqual({ services: {} });
+    });
+
+    it("reads existing secrets file", async () => {
+      await mkdir(join(root, ".inkos"), { recursive: true });
+      await writeFile(
+        join(root, ".inkos", "secrets.json"),
+        JSON.stringify({ services: { moonshot: { apiKey: "sk-test" } } }),
+      );
+      const secrets = await loadSecrets(root);
+      expect(secrets.services.moonshot.apiKey).toBe("sk-test");
+    });
+  });
+
+  describe("saveSecrets", () => {
+    it("creates .inkos dir and writes secrets file", async () => {
+      await saveSecrets(root, {
+        services: { deepseek: { apiKey: "sk-deep" } },
+      });
+      const raw = await readFile(join(root, ".inkos", "secrets.json"), "utf-8");
+      const parsed = JSON.parse(raw);
+      expect(parsed.services.deepseek.apiKey).toBe("sk-deep");
+    });
+
+    it("overwrites existing secrets file", async () => {
+      await mkdir(join(root, ".inkos"), { recursive: true });
+      await writeFile(
+        join(root, ".inkos", "secrets.json"),
+        JSON.stringify({ services: { old: { apiKey: "old-key" } } }),
+      );
+      await saveSecrets(root, {
+        services: { new: { apiKey: "new-key" } },
+      });
+      const secrets = await loadSecrets(root);
+      expect(secrets.services.new.apiKey).toBe("new-key");
+      expect(secrets.services.old).toBeUndefined();
+    });
+  });
+
+  describe("getServiceApiKey", () => {
+    it("returns key from secrets.json first", async () => {
+      await mkdir(join(root, ".inkos"), { recursive: true });
+      await writeFile(
+        join(root, ".inkos", "secrets.json"),
+        JSON.stringify({ services: { moonshot: { apiKey: "sk-from-file" } } }),
+      );
+      const key = await getServiceApiKey(root, "moonshot");
+      expect(key).toBe("sk-from-file");
+    });
+
+    it("falls back to environment variable", async () => {
+      vi.stubEnv("MOONSHOT_API_KEY", "sk-from-env");
+      const key = await getServiceApiKey(root, "moonshot");
+      expect(key).toBe("sk-from-env");
+      vi.unstubAllEnvs();
+    });
+
+    it("returns null when neither secrets nor env exists", async () => {
+      const key = await getServiceApiKey(root, "moonshot");
+      expect(key).toBeNull();
+    });
+
+    it("handles custom service with colon key format", async () => {
+      await mkdir(join(root, ".inkos"), { recursive: true });
+      await writeFile(
+        join(root, ".inkos", "secrets.json"),
+        JSON.stringify({
+          services: { "custom:内网GPT": { apiKey: "sk-custom" } },
+        }),
+      );
+      const key = await getServiceApiKey(root, "custom:内网GPT");
+      expect(key).toBe("sk-custom");
+    });
+  });
+});