fix(studio): address recent issue regressions

Author: Narcooo

packages/core/src/__tests__/edit-controller.test.ts

@@ -283,6 +283,45 @@ describe("edit controller", () => {
     expect(result.reviewRequired).toBe(true);
   });
 
+  it("patches chapter text when the target only differs by whitespace", async () => {
+    const bookDir = join(projectRoot, "books", "harbor");
+    await writeFile(
+      join(bookDir, "chapters", "0004_雨巷.md"),
+      "# 第4章 雨巷\n\n她把账本\n塞进外套里，继续往前走。",
+      "utf-8",
+    );
+    const chapterIndex = [{
+      number: 4,
+      title: "雨巷",
+      status: "ready-for-review" as const,
+      wordCount: 18,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      auditIssues: [],
+      lengthWarnings: [],
+    }];
+
+    const result = await executeEditTransaction(
+      {
+        bookDir: (bookId) => join(projectRoot, "books", bookId),
+        loadChapterIndex: async () => chapterIndex,
+        saveChapterIndex: async () => undefined,
+      },
+      {
+        kind: "chapter-local-edit",
+        bookId: "harbor",
+        chapterNumber: 4,
+        instruction: "Patch wrapped text",
+        targetText: "她把账本 塞进外套里",
+        replacementText: "她把账本贴着胸口藏好",
+      },
+    );
+
+    await expect(readFile(join(bookDir, "chapters", "0004_雨巷.md"), "utf-8"))
+      .resolves.toContain("她把账本贴着胸口藏好，继续往前走。");
+    expect(result.reviewRequired).toBe(true);
+  });
+
   it("executes whole-chapter replacement and marks the chapter for review", async () => {
     const bookDir = join(projectRoot, "books", "replacebook");
     await mkdir(join(bookDir, "chapters"), { recursive: true });

packages/core/src/__tests__/state-manager.test.ts

@@ -95,6 +95,22 @@ describe("StateManager", () => {
       expect(loaded).toEqual([]);
     });
 
+    it("rebuilds the chapter index from chapter files when index.json is empty", async () => {
+      const bookDir = manager.bookDir("rebuild-book");
+      await mkdir(join(bookDir, "chapters"), { recursive: true });
+      await writeFile(join(bookDir, "chapters", "index.json"), "[]", "utf-8");
+      await writeFile(join(bookDir, "chapters", "0001_雨棚.md"), "# 第1章 雨棚\n\n正文。", "utf-8");
+      await writeFile(join(bookDir, "chapters", "0002_账页.md"), "# 第2章 账页\n\n正文。", "utf-8");
+
+      const loaded = await manager.loadChapterIndex("rebuild-book");
+
+      expect(loaded.map((chapter) => chapter.number)).toEqual([1, 2]);
+      expect(loaded[0]).toMatchObject({
+        title: "雨棚",
+        status: "ready-for-review",
+      });
+    });
+
     it("creates the chapters directory on save", async () => {
       await manager.saveChapterIndex("book-b", []);
       const dirStat = await stat(

packages/core/src/interaction/edit-controller.ts

@@ -354,7 +354,7 @@ async function executeChapterLocalEdit(
   }
 
   const content = await readFile(chapterPath, "utf-8");
-  const nextContent = content.split(request.targetText).join(request.replacementText);
+  const nextContent = replaceChapterTargetText(content, request.targetText, request.replacementText);
   if (nextContent === content) {
     throw new Error(`Target text was not found in chapter ${request.chapterNumber}.`);
   }
@@ -382,6 +382,27 @@ async function executeChapterLocalEdit(
   };
 }
 
+function replaceChapterTargetText(content: string, targetText: string, replacementText: string): string {
+  const exact = content.split(targetText).join(replacementText);
+  if (exact !== content) return exact;
+
+  const pattern = flexibleWhitespacePattern(targetText);
+  if (!pattern) return content;
+  let matched = false;
+  const replaced = content.replace(pattern, () => {
+    matched = true;
+    return replacementText;
+  });
+  return matched ? replaced : content;
+}
+
+function flexibleWhitespacePattern(targetText: string): RegExp | null {
+  const parts = targetText.trim().split(/\s+/).filter(Boolean);
+  if (parts.length < 2) return null;
+  const escaped = parts.map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(escaped.join("\\s+"), "g");
+}
+
 export async function executeEditTransaction(
   deps: EditExecutionDeps,
   request: EditRequest,

packages/core/src/models/book.ts

@@ -65,6 +65,9 @@ export const BookConfigSchema = z.object({
   updatedAt: z.string().datetime(),
   parentBookId: z.string().optional(),
   fanficMode: FanficModeSchema.optional(),
+  writing: z.object({
+    reviewMode: z.enum(["auto", "manual"]).optional(),
+  }).optional(),
 });
 
 export type BookConfig = z.infer<typeof BookConfigSchema>;

packages/core/src/state/manager.ts

@@ -267,10 +267,55 @@ export class StateManager {
     const indexPath = join(this.bookDir(bookId), "chapters", "index.json");
     try {
       const raw = await readFile(indexPath, "utf-8");
-      return JSON.parse(raw);
+      const parsed = JSON.parse(raw) as unknown;
+      if (Array.isArray(parsed) && parsed.length > 0) return parsed as ReadonlyArray<ChapterMeta>;
+      if (Array.isArray(parsed)) {
+        const rebuilt = await this.rebuildChapterIndexFromFiles(bookId);
+        return rebuilt.length > 0 ? rebuilt : parsed as ReadonlyArray<ChapterMeta>;
+      }
+    } catch {
+      const rebuilt = await this.rebuildChapterIndexFromFiles(bookId);
+      if (rebuilt.length > 0) return rebuilt;
+    }
+    return [];
+  }
+
+  private async rebuildChapterIndexFromFiles(bookId: string): Promise<ReadonlyArray<ChapterMeta>> {
+    const chaptersDir = join(this.bookDir(bookId), "chapters");
+    let files: string[];
+    try {
+      files = await readdir(chaptersDir);
     } catch {
       return [];
     }
+
+    const rows = await Promise.all(files.flatMap(async (file) => {
+      const match = file.match(/^(\d+)[_-]?(.*?)\.md$/);
+      if (!match) return [];
+      const number = parseInt(match[1]!, 10);
+      if (!Number.isFinite(number) || number <= 0) return [];
+      const filePath = join(chaptersDir, file);
+      const [metadata, content] = await Promise.all([
+        stat(filePath).catch(() => null),
+        readFile(filePath, "utf-8").catch(() => ""),
+      ]);
+      const timestamp = (metadata?.mtime ?? new Date()).toISOString();
+      const rawTitle = match[2]?.replace(/^_+/, "").replace(/_/g, " ").trim();
+      return [{
+        number,
+        title: rawTitle || `第${number}章`,
+        status: "ready-for-review" as const,
+        wordCount: content.replace(/\s+/g, "").length,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        auditIssues: [],
+        lengthWarnings: [],
+      }];
+    }));
+
+    return rows
+      .flat()
+      .sort((a, b) => a.number - b.number);
   }
 
   async saveChapterIndex(

packages/studio/src/api/server.test.ts

@@ -4132,6 +4132,80 @@ describe("createStudioServer daemon lifecycle", () => {
     await expect(after.json()).resolves.toMatchObject({ mode: "manual" });
   });
 
+  it("stores chapter review mode per book without changing the project default", async () => {
+    await writeCompleteBookFixture(root, "demo-book", "Demo Book");
+    const { createStudioServer } = await import("./server.js");
+    const app = createStudioServer(cloneProjectConfig() as never, root);
+
+    const saveBookMode = await app.request("http://localhost/api/v1/books/demo-book/chapter-review-mode", {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ mode: "manual" }),
+    });
+    await expect(saveBookMode.json()).resolves.toMatchObject({
+      ok: true,
+      mode: "manual",
+      bookMode: "manual",
+      projectMode: "auto",
+    });
+
+    const bookMode = await app.request("http://localhost/api/v1/books/demo-book/chapter-review-mode");
+    await expect(bookMode.json()).resolves.toMatchObject({
+      mode: "manual",
+      bookMode: "manual",
+      projectMode: "auto",
+    });
+
+    const projectMode = await app.request("http://localhost/api/v1/project/chapter-review-mode");
+    await expect(projectMode.json()).resolves.toMatchObject({ mode: "auto" });
+    const rawBook = JSON.parse(await readFile(join(root, "books", "demo-book", "book.json"), "utf-8"));
+    expect(rawBook.writing.reviewMode).toBe("manual");
+  });
+
+  it("uses a book-level manual review override when writing the next chapter", async () => {
+    await writeCompleteBookFixture(root, "demo-book", "Demo Book");
+    const rawBookPath = join(root, "books", "demo-book", "book.json");
+    const rawBook = JSON.parse(await readFile(rawBookPath, "utf-8"));
+    await writeFile(rawBookPath, JSON.stringify({
+      ...rawBook,
+      writing: { reviewMode: "manual" },
+    }, null, 2), "utf-8");
+
+    const { createStudioServer } = await import("./server.js");
+    const app = createStudioServer(cloneProjectConfig() as never, root);
+
+    const response = await app.request("http://localhost/api/v1/books/demo-book/write-next", { method: "POST" });
+
+    expect(response.status).toBe(200);
+    expect(pipelineConfigs.at(-1)).toMatchObject({ chapterReviewMode: "manual" });
+  });
+
+  it("exposes a global default model endpoint backed by llm.defaultModel", async () => {
+    const { createStudioServer } = await import("./server.js");
+    const app = createStudioServer(cloneProjectConfig() as never, root);
+
+    const initial = await app.request("http://localhost/api/v1/project/default-model");
+    await expect(initial.json()).resolves.toMatchObject({
+      defaultModel: "gpt-5.4",
+    });
+
+    const save = await app.request("http://localhost/api/v1/project/default-model", {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ service: "kkaiapi", defaultModel: "deepseek-v4-flash" }),
+    });
+    await expect(save.json()).resolves.toMatchObject({
+      ok: true,
+      service: "kkaiapi",
+      defaultModel: "deepseek-v4-flash",
+    });
+
+    const raw = JSON.parse(await readFile(join(root, "inkos.json"), "utf-8"));
+    expect(raw.llm.service).toBe("kkaiapi");
+    expect(raw.llm.defaultModel).toBe("deepseek-v4-flash");
+    expect(raw.llm.model).toBe("deepseek-v4-flash");
+  });
+
   it("project advanced settings expose input governance and detection config", async () => {
     const { createStudioServer } = await import("./server.js");
     const app = createStudioServer(cloneProjectConfig() as never, root);