@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/core/src/__tests__/session-transcript.test.ts

@@ -0,0 +1,195 @@
+import { describe, expect, it, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, readFile, mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  appendManualSessionMessages,
+  appendTranscriptEvents,
+  appendTranscriptEvent,
+  nextTranscriptSeq,
+  readTranscriptEvents,
+  transcriptPath,
+} from "../interaction/session-transcript.js";
+import { restoreAgentMessagesFromTranscript } from "../interaction/session-transcript-restore.js";
+import type {
+  MessageEvent,
+  RequestCommittedEvent,
+  RequestStartedEvent,
+} from "../interaction/session-transcript-schema.js";
+
+describe("session transcript codec", () => {
+  let projectRoot: string;
+
+  beforeEach(async () => {
+    projectRoot = await mkdtemp(join(tmpdir(), "inkos-transcript-"));
+  });
+
+  afterEach(async () => {
+    await rm(projectRoot, { recursive: true, force: true });
+  });
+
+  it("一行写入一个 JSON event 并保留 raw AgentMessage 字段", async () => {
+    const started: RequestStartedEvent = {
+      type: "request_started",
+      version: 1,
+      sessionId: "s1",
+      requestId: "r1",
+      seq: 1,
+      timestamp: 100,
+      input: "继续写",
+    };
+    const message: MessageEvent = {
+      type: "message",
+      version: 1,
+      sessionId: "s1",
+      requestId: "r1",
+      uuid: "m1",
+      parentUuid: null,
+      seq: 2,
+      role: "assistant",
+      timestamp: 101,
+      message: {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "推理", signature: "sig-1" },
+          { type: "text", text: "正文" },
+        ],
+        provider: "anthropic",
+        api: "anthropic-messages",
+        model: "claude",
+        usage: {
+          input: 1,
+          output: 2,
+          cacheRead: 0,
+          cacheWrite: 0,
+          totalTokens: 3,
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        stopReason: "stop",
+        timestamp: 101,
+      },
+    };
+
+    await appendTranscriptEvent(projectRoot, started);
+    await appendTranscriptEvent(projectRoot, message);
+
+    const raw = await readFile(transcriptPath(projectRoot, "s1"), "utf-8");
+    expect(raw.trim().split("\n")).toHaveLength(2);
+
+    const events = await readTranscriptEvents(projectRoot, "s1");
+    expect(events).toHaveLength(2);
+    expect((events[1] as MessageEvent).message).toMatchObject({
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking: "推理", signature: "sig-1" },
+        { type: "text", text: "正文" },
+      ],
+    });
+  });
+
+  it("跳过坏行并保留合法 event", async () => {
+    const dir = join(projectRoot, ".inkos", "sessions");
+    await mkdir(dir, { recursive: true });
+    await writeFile(
+      join(dir, "s1.jsonl"),
+      [
+        JSON.stringify({
+          type: "request_started",
+          version: 1,
+          sessionId: "s1",
+          requestId: "r1",
+          seq: 1,
+          timestamp: 1,
+          input: "hi",
+        }),
+        "{bad json",
+        JSON.stringify({
+          type: "request_committed",
+          version: 1,
+          sessionId: "s1",
+          requestId: "r1",
+          seq: 2,
+          timestamp: 2,
+        }),
+      ].join("\n"),
+    );
+
+    const events = await readTranscriptEvents(projectRoot, "s1");
+    expect(events.map((event) => event.type)).toEqual(["request_started", "request_committed"]);
+  });
+
+  it("按已有 transcript 分配单调递增 seq", async () => {
+    const committed: RequestCommittedEvent = {
+      type: "request_committed",
+      version: 1,
+      sessionId: "s1",
+      requestId: "r1",
+      seq: 7,
+      timestamp: 100,
+    };
+
+    await appendTranscriptEvent(projectRoot, committed);
+
+    await expect(nextTranscriptSeq(projectRoot, "s1")).resolves.toBe(8);
+  });
+
+  it("atomically assigns unique seq for concurrent generated events", async () => {
+    await Promise.all(
+      Array.from({ length: 10 }, (_, index) =>
+        appendTranscriptEvents(projectRoot, "s-concurrent", ({ nextSeq }) => [{
+          type: "request_started",
+          version: 1,
+          sessionId: "s-concurrent",
+          requestId: `r-${index}`,
+          seq: nextSeq,
+          timestamp: 100 + index,
+          input: `input-${index}`,
+        }]),
+      ),
+    );
+
+    const events = await readTranscriptEvents(projectRoot, "s-concurrent");
+    expect(events).toHaveLength(10);
+    expect(events.map((event) => event.seq)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  });
+
+  it("appendManualSessionMessages 写入 committed request 并保留 raw assistant message", async () => {
+    await appendManualSessionMessages(projectRoot, "s1", [{
+      role: "assistant",
+      content: [{ type: "text", text: "fallback" }],
+      api: "anthropic-messages",
+      provider: "anthropic",
+      model: "fake",
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+      },
+      stopReason: "stop",
+      timestamp: 10,
+    }], "fallback-input");
+
+    const events = await readTranscriptEvents(projectRoot, "s1");
+    expect(events.map((event) => event.type)).toEqual([
+      "request_started",
+      "message",
+      "request_committed",
+    ]);
+    expect(events[0]).toMatchObject({ type: "request_started", input: "fallback-input" });
+
+    const restored = await restoreAgentMessagesFromTranscript(projectRoot, "s1");
+    expect(restored).toMatchObject([
+      { role: "assistant", content: [{ type: "text", text: "fallback" }] },
+    ]);
+  });
+
+  it("从 core index 导出 transcript helper", async () => {
+    const core = await import("../index.js");
+    expect(typeof core.readTranscriptEvents).toBe("function");
+    expect(typeof core.restoreAgentMessagesFromTranscript).toBe("function");
+    expect(typeof core.TranscriptEventSchema.safeParse).toBe("function");
+  });
+});

package/inkos/packages/core/src/__tests__/settler-delta-parser.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from "vitest";
+import { parseSettlerDeltaOutput } from "../agents/settler-delta-parser.js";
+
+describe("parseSettlerDeltaOutput", () => {
+  it("parses a valid runtime-state delta block", () => {
+    const result = parseSettlerDeltaOutput([
+      "=== POST_SETTLEMENT ===",
+      "| 伏笔变动 | mentor-oath 推进 | 同步更新 |",
+      "",
+      "=== RUNTIME_STATE_DELTA ===",
+      "```json",
+      JSON.stringify({
+        chapter: 12,
+        currentStatePatch: {
+          currentGoal: "追到河埠旧账的尽头",
+          currentConflict: "商会噪音仍在干扰师债主线",
+        },
+        hookOps: {
+          upsert: [
+            {
+              hookId: "mentor-oath",
+              startChapter: 8,
+              type: "relationship",
+              status: "progressing",
+              lastAdvancedChapter: 12,
+              expectedPayoff: "揭开师债真相",
+              notes: "河埠旧账把师债再往前推了一格",
+            },
+          ],
+          resolve: [],
+          defer: [],
+        },
+        chapterSummary: {
+          chapter: 12,
+          title: "河埠对账",
+          characters: "林月",
+          events: "林月核对河埠旧账",
+          stateChanges: "师债线索进一步收束",
+          hookActivity: "mentor-oath advanced",
+          mood: "紧绷",
+          chapterType: "主线推进",
+        },
+        notes: ["保留商会噪音，但不盖过主线"],
+      }, null, 2),
+      "```",
+    ].join("\n"));
+
+    expect(result.postSettlement).toContain("mentor-oath");
+    expect(result.runtimeStateDelta.chapter).toBe(12);
+    expect(result.runtimeStateDelta.hookOps.upsert[0]?.hookId).toBe("mentor-oath");
+    expect(result.runtimeStateDelta.chapterSummary?.title).toBe("河埠对账");
+  });
+
+  it("rejects invalid runtime-state delta payloads", () => {
+    expect(() =>
+      parseSettlerDeltaOutput([
+        "=== RUNTIME_STATE_DELTA ===",
+        "```json",
+        JSON.stringify({
+          chapter: 12,
+          hookOps: {
+            upsert: [
+              {
+                hookId: "mentor-oath",
+                startChapter: 8,
+                type: "relationship",
+                status: "open",
+                lastAdvancedChapter: "chapter twelve",
+              },
+            ],
+            resolve: [],
+            defer: [],
+          },
+        }),
+        "```",
+      ].join("\n")),
+    ).toThrow(/runtime state delta/i);
+  });
+
+  it("parses hook resolve and defer operations", () => {
+    const result = parseSettlerDeltaOutput([
+      "=== RUNTIME_STATE_DELTA ===",
+      "```json",
+      JSON.stringify({
+        chapter: 20,
+        hookOps: {
+          upsert: [],
+          mention: ["mentor-oath"],
+          resolve: ["old-seal"],
+          defer: ["guild-route"],
+        },
+        notes: [],
+      }),
+      "```",
+    ].join("\n"));
+
+    expect(result.runtimeStateDelta.hookOps.mention).toEqual(["mentor-oath"]);
+    expect(result.runtimeStateDelta.hookOps.resolve).toEqual(["old-seal"]);
+    expect(result.runtimeStateDelta.hookOps.defer).toEqual(["guild-route"]);
+  });
+
+  it("parses new hook candidates separately from existing hook ops", () => {
+    const result = parseSettlerDeltaOutput([
+      "=== RUNTIME_STATE_DELTA ===",
+      "```json",
+      JSON.stringify({
+        chapter: 21,
+        hookOps: {
+          upsert: [],
+          mention: ["mentor-oath"],
+          resolve: [],
+          defer: [],
+        },
+        newHookCandidates: [
+          {
+            type: "source-risk",
+            expectedPayoff: "Reveal what the anonymous source already knew about the route and address",
+            notes: "This chapter opens a fresh unresolved question about source knowledge.",
+          },
+        ],
+        notes: [],
+      }),
+      "```",
+    ].join("\n"));
+
+    expect(result.runtimeStateDelta.hookOps.upsert).toEqual([]);
+    expect(result.runtimeStateDelta.newHookCandidates).toEqual([
+      expect.objectContaining({
+        type: "source-risk",
+      }),
+    ]);
+  });
+});

package/inkos/packages/core/src/__tests__/short-fiction-public.test.ts

@@ -0,0 +1,241 @@
+import { describe, expect, it, vi } from "vitest";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { LLMClient } from "../llm/provider.js";
+import {
+  ShortFictionDraftReviserAgent,
+  parseShortFictionBatchDraft,
+  validateShortFictionDraftForFinal,
+} from "../agents/short-fiction.js";
+import { saveSecrets } from "../llm/secrets.js";
+import {
+  extractGeminiImageBase64,
+  extractImagesGenerationImage,
+  generateShortFictionCover,
+  resolveCoverGenerationRequest,
+} from "../pipeline/short-fiction-runner.js";
+
+const ZERO_USAGE = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+
+function fakeClient(): LLMClient {
+  return {
+    provider: "openai",
+    apiFormat: "chat",
+    stream: false,
+    defaults: {
+      temperature: 0.7,
+      maxTokens: 8192,
+      thinkingBudget: 0,
+      extra: {},
+    },
+  };
+}
+
+describe("public short-fiction chain", () => {
+  it("parses a complete tagged short-fiction draft", () => {
+    const draft = parseShortFictionBatchDraft(`
+=== SHORT_FICTION_TITLE ===
+我离婚后，全家悔疯了
+=== SHORT_FICTION_OPENING_HOOK ===
+离婚协议递到我面前时，婆婆正在直播间教人做贤妻。
+=== CHAPTER 1 TITLE ===
+她把离婚协议递到直播镜头前
+=== CHAPTER 1 CONTENT ===
+我看着镜头里的红灯亮起，先把桌上的房本推了过去。婆婆脸上的笑僵住，丈夫伸手来抢，我按住合同，问他还记不记得这套房是谁付的首付。
+=== CHAPTER 2 TITLE ===
+三年前那张转账单
+=== CHAPTER 2 CONTENT ===
+第二天早上，家庭群里全是骂我的语音。我没有回，只把三年前的转账单发给律师。十分钟后，丈夫第一次打电话求我回家谈谈。
+`, { expectedChapters: 2 });
+
+    expect(draft.storyTitle).toBe("我离婚后，全家悔疯了");
+    expect(draft.openingHook).toContain("离婚协议");
+    expect(draft.chapters).toHaveLength(2);
+    expect(draft.chapters[0]?.title).toContain("离婚协议");
+    expect(draft.chapters[1]?.charCount).toBeGreaterThan(20);
+    expect(() => validateShortFictionDraftForFinal(draft, { expectedChapters: 2 })).not.toThrow();
+  });
+
+  it("recovers chapter content when a model repeats the title tag instead of the content tag", () => {
+    const draft = parseShortFictionBatchDraft(`
+=== SHORT_FICTION_TITLE ===
+离婚协议签好那天，我甩出十三页证据清单
+=== CHAPTER 1 TITLE ===
+藏在婚纱照后面的摄像头
+=== CHAPTER 1 CONTENT ===
+我摘下婚纱照，看到墙后那个针孔摄像头还亮着红点。
+=== CHAPTER 2 TITLE ===
+她逼小三亲自递上了最后的刀
+=== CHAPTER 2 TITLE ===
+陈磊的慌张，是一个信号。
+林晚等了三天，没有去找陈磊，也没有再发短信。
+第三天傍晚，贺言打来电话：“上钩了，苏念又给陈磊妻子转了五十万。”
+=== CHAPTER 3 TITLE ===
+他砸了家，但没算到我在直播
+=== CHAPTER 3 TITLE ===
+凌晨三点，陆景琛踹开老宅院门，举着铁棍砸碎电视。
+林晚坐在闺蜜家，把早就准备好的直播链接发给了董事会。
+`, { expectedChapters: 3 });
+
+    expect(draft.chapters[1]?.title).toBe("她逼小三亲自递上了最后的刀");
+    expect(draft.chapters[1]?.content).toContain("陈磊的慌张");
+    expect(draft.chapters[2]?.content).toContain("直播链接");
+    expect(() => validateShortFictionDraftForFinal(draft, { expectedChapters: 3 })).not.toThrow();
+  });
+
+  it("uses the previous draft as assistant context for the second writer pass", async () => {
+    const firstDraft = parseShortFictionBatchDraft(`
+=== SHORT_FICTION_TITLE ===
+初稿标题
+=== CHAPTER 1 TITLE ===
+旧章
+=== CHAPTER 1 CONTENT ===
+旧正文有一处时间线问题。
+`, { expectedChapters: 1 });
+
+    const chatSpy = vi
+      .spyOn(ShortFictionDraftReviserAgent.prototype as never, "chat" as never)
+      .mockResolvedValue({
+        content: `
+=== SHORT_FICTION_TITLE ===
+新稿标题
+=== CHAPTER 1 TITLE ===
+新章
+=== CHAPTER 1 CONTENT ===
+新正文修正了时间线。
+`,
+        usage: ZERO_USAGE,
+      });
+
+    const agent = new ShortFictionDraftReviserAgent({
+      client: fakeClient(),
+      model: "fake",
+      projectRoot: "/tmp",
+    });
+
+    const revised = await agent.reviseDraft({
+      direction: "女频短篇 婚姻反杀",
+      outlineMarkdown: "12章完整故事方案",
+      draft: firstDraft,
+      review: "时间线不成立，第二天不能先收到律师函再补证据。",
+      chapterCount: 1,
+      charsPerChapter: 1000,
+    });
+
+    const messages = chatSpy.mock.calls[0]?.[0] as ReadonlyArray<{ role: string; content: string }>;
+    expect(messages.map((message) => message.role)).toEqual(["system", "user", "assistant", "user"]);
+    expect(messages[2]?.content).toContain("旧正文有一处时间线问题");
+    expect(messages[3]?.content).toContain("时间线不成立");
+    expect(revised.storyTitle).toBe("新稿标题");
+
+    chatSpy.mockRestore();
+  });
+
+  it("resolves cover generation from project cover config and stored cover secret", async () => {
+    const root = await mkdtemp(join(tmpdir(), "inkos-short-cover-"));
+    try {
+      await writeFile(join(root, "inkos.json"), JSON.stringify({
+        name: "cover-test",
+        version: "0.1.0",
+        language: "zh",
+        llm: {
+          provider: "openai",
+          service: "kkaiapi",
+          configSource: "studio",
+          baseUrl: "https://api.kkaiapi.com/v1",
+          apiKey: "",
+          model: "deepseek-v4-flash",
+          cover: {
+            service: "kkaiapi",
+            model: "gpt-image-2",
+          },
+        },
+        notify: [],
+      }, null, 2), "utf-8");
+      await saveSecrets(root, {
+        services: {
+          "cover:kkaiapi": { apiKey: "sk-cover" },
+        },
+      });
+
+      await expect(resolveCoverGenerationRequest({ root })).resolves.toMatchObject({
+        api: "images",
+        baseUrl: "https://api.kkaiapi.com/v1",
+        model: "gpt-image-2",
+        apiKey: "sk-cover",
+      });
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("extracts OpenAI-compatible image generation URLs and base64 payloads", () => {
+    expect(extractImagesGenerationImage({
+      data: [{ url: "https://api.kkaiapi.com/files/img_abc123.png" }],
+    })).toEqual({ url: "https://api.kkaiapi.com/files/img_abc123.png" });
+
+    expect(extractImagesGenerationImage({
+      data: [{ b64_json: "ZmFrZQ==" }],
+    })).toEqual({ base64: "ZmFrZQ==", extension: "png" });
+  });
+
+  it("extracts Gemini inline image data from generateContent responses", () => {
+    const image = extractGeminiImageBase64({
+      candidates: [
+        {
+          content: {
+            parts: [
+              { text: "ok" },
+              { inlineData: { mimeType: "image/jpeg", data: "ZmFrZQ==" } },
+            ],
+          },
+        },
+      ],
+    });
+
+    expect(image).toEqual({ base64: "ZmFrZQ==", extension: "jpg" });
+  });
+
+  it("generates a standalone cover artifact without running the short fiction pipeline", async () => {
+    const root = await mkdtemp(join(tmpdir(), "inkos-cover-tool-"));
+    const originalFetch = globalThis.fetch;
+    process.env.INKOS_TEST_COVER_KEY = "sk-cover";
+    try {
+      const fetchMock = vi.fn(async () => new Response(JSON.stringify({
+        data: [{ b64_json: "ZmFrZQ==" }],
+      }), { status: 200, headers: { "content-type": "application/json" } }));
+      globalThis.fetch = fetchMock as never;
+
+      const result = await generateShortFictionCover({
+        projectRoot: root,
+        title: "离婚协议他递了三年",
+        intro: "她签字当天多了十八份附件。",
+        sellingPoints: ["婚姻背叛", "证据反杀"],
+        coverPrompt: "女主冷笑，手里举着离婚协议。",
+        outputDir: "covers/demo",
+        coverEndpoint: "https://images.example.test/v1/images/generations",
+        coverModel: "gpt-image-2",
+        coverApiKeyEnv: "INKOS_TEST_COVER_KEY",
+      });
+
+      expect(result.coverPromptPath).toBe("covers/demo/cover-prompt.md");
+      expect(result.coverImagePath).toBe("covers/demo/cover.png");
+      await expect(readFile(join(root, "covers", "demo", "cover-prompt.md"), "utf-8"))
+        .resolves.toContain("离婚协议他递了三年");
+      await expect(readFile(join(root, "covers", "demo", "cover.png")))
+        .resolves.toEqual(Buffer.from("fake"));
+      expect(fetchMock).toHaveBeenCalledWith(
+        "https://images.example.test/v1/images/generations",
+        expect.objectContaining({
+          method: "POST",
+          body: expect.stringContaining("离婚协议他递了三年"),
+        }),
+      );
+    } finally {
+      globalThis.fetch = originalFetch;
+      delete process.env.INKOS_TEST_COVER_KEY;
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});

package/inkos/packages/core/src/__tests__/spot-fix-patches.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from "vitest";
+import {
+  applySpotFixPatches,
+  parseSpotFixPatches,
+  type SpotFixPatch,
+} from "../utils/spot-fix-patches.js";
+
+describe("spot-fix patches", () => {
+  it("parses patch blocks from the PATCHES section", () => {
+    const patches = parseSpotFixPatches([
+      "=== PATCHES ===",
+      "--- PATCH 1 ---",
+      "TARGET_TEXT:",
+      "原句一。",
+      "REPLACEMENT_TEXT:",
+      "新句一。",
+      "--- END PATCH ---",
+      "--- PATCH 2 ---",
+      "TARGET_TEXT:",
+      "原句二。",
+      "REPLACEMENT_TEXT:",
+      "新句二。",
+      "--- END PATCH ---",
+    ].join("\n"));
+
+    expect(patches).toEqual<SpotFixPatch[]>([
+      { targetText: "原句一。", replacementText: "新句一。" },
+      { targetText: "原句二。", replacementText: "新句二。" },
+    ]);
+  });
+
+  it("applies a uniquely targeted patch while preserving untouched text", () => {
+    const original = [
+      "门轴轻轻响了一下。",
+      "林越没有立刻进去。",
+      "",
+      "巷子尽头的风还在吹。",
+      "他把手按在潮冷的门框上，没有出声。",
+      "更远处传来极轻的脚步回响，又很快断掉。",
+    ].join("\n");
+
+    const result = applySpotFixPatches(original, [
+      {
+        targetText: "林越没有立刻进去。",
+        replacementText: "林越先停在门槛外，侧耳听了一息。",
+      },
+    ]);
+
+    expect(result.applied).toBe(true);
+    expect(result.appliedPatchCount).toBe(1);
+    expect(result.skippedPatchCount).toBe(0);
+    expect(result.revisedContent).toBe([
+      "门轴轻轻响了一下。",
+      "林越先停在门槛外，侧耳听了一息。",
+      "",
+      "巷子尽头的风还在吹。",
+      "他把手按在潮冷的门框上，没有出声。",
+      "更远处传来极轻的脚步回响，又很快断掉。",
+    ].join("\n"));
+  });
+
+  it("skips non-unique patches instead of rejecting all", () => {
+    const original = "他停了一下。\n门里的人也停了一下。\n窗外很静。";
+
+    const result = applySpotFixPatches(original, [
+      { targetText: "停了一下", replacementText: "顿了顿" },
+      { targetText: "窗外很静。", replacementText: "窗外传来虫鸣。" },
+    ]);
+
+    expect(result.applied).toBe(true);
+    expect(result.appliedPatchCount).toBe(1);
+    expect(result.skippedPatchCount).toBe(1);
+    expect(result.revisedContent).toContain("窗外传来虫鸣。");
+    expect(result.revisedContent).toContain("停了一下"); // unchanged — patch was skipped
+  });
+
+  it("applies patches via fuzzy match when whitespace differs", () => {
+    const original = "他慢慢站起来，   看了一眼\n远处的山。";
+
+    const result = applySpotFixPatches(original, [
+      {
+        targetText: "他慢慢站起来， 看了一眼 远处的山。",
+        replacementText: "他猛地起身，盯着远山。",
+      },
+    ]);
+
+    expect(result.applied).toBe(true);
+    expect(result.appliedPatchCount).toBe(1);
+    expect(result.revisedContent).toBe("他猛地起身，盯着远山。");
+  });
+
+  it("reports all skipped when no patches can be matched", () => {
+    const original = "完全不相关的内容。";
+
+    const result = applySpotFixPatches(original, [
+      { targetText: "这段不存在", replacementText: "替换" },
+    ]);
+
+    expect(result.applied).toBe(false);
+    expect(result.appliedPatchCount).toBe(0);
+    expect(result.skippedPatchCount).toBe(1);
+    expect(result.rejectedReason).toContain("No patches could be matched");
+  });
+});