novel-writer-cli 0.3.0 → 0.5.0

package/dist/__tests__/init.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
@@ -45,6 +45,8 @@ test("resolveInitRootDir rejects path traversal", () => {
 test("normalizePlatformId accepts valid values", () => {
     assert.equal(normalizePlatformId("qidian"), "qidian");
     assert.equal(normalizePlatformId("tomato"), "tomato");
+    assert.equal(normalizePlatformId("fanqie"), "fanqie");
+    assert.equal(normalizePlatformId("jinjiang"), "jinjiang");
 });
 test("normalizePlatformId rejects invalid values", () => {
     assert.throws(() => normalizePlatformId("jjwxc"), (err) => err instanceof NovelCliError && /Invalid --platform.*jjwxc/i.test(err.message));
@@ -56,8 +58,8 @@ test("initProject creates a runnable skeleton with all checkpoint fields", async
     try {
         const result = await initProject({ rootDir });
         assert.equal(result.rootDir, rootDir);
-        // Exact created set (non-minimal = checkpoint + 4 templates)
-        assert.deepEqual(result.created.sort(), [".checkpoint.json", "ai-blacklist.json", "brief.md", "style-profile.json", "web-novel-cliche-lint.json"].sort());
+        // Exact created set (non-minimal = checkpoint + 6 base templates)
+        assert.deepEqual(result.created.sort(), [".checkpoint.json", "ai-blacklist.json", "brief.md", "genre-excitement-map.json", "genre-golden-standards.json", "style-profile.json", "web-novel-cliche-lint.json"].sort());
         // All staging dirs ensured
         assert.equal(result.ensuredDirs.length, 10);
         assert.ok(result.ensuredDirs.includes("staging/chapters"));
@@ -96,9 +98,10 @@ test("initProject creates a runnable skeleton with all checkpoint fields", async
             await assertDir(join(rootDir, relDir));
         }
         // All template files exist
-        for (const relFile of ["brief.md", "style-profile.json", "ai-blacklist.json", "web-novel-cliche-lint.json"]) {
+        for (const relFile of ["brief.md", "style-profile.json", "genre-excitement-map.json", "genre-golden-standards.json", "ai-blacklist.json", "web-novel-cliche-lint.json"]) {
             await assertFile(join(rootDir, relFile));
         }
+        assert.equal(await statExists(join(rootDir, "golden-chapter-gates.json")), false);
     }
     finally {
         await rm(rootDir, { recursive: true, force: true });
@@ -152,6 +155,16 @@ test("initProject skips existing template files without --force", async () => {
         await rm(rootDir, { recursive: true, force: true });
     }
 });
+test("initProject rejects path collisions when a template target is a directory", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-init-dir-collision-"));
+    try {
+        await mkdir(join(rootDir, "brief.md"));
+        await assert.rejects(() => initProject({ rootDir }), (err) => err instanceof NovelCliError && /brief\.md.*not a file/i.test(err.message));
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
 test("initProject overwrites template files with --force", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-init-force-tpl-"));
     try {
@@ -171,14 +184,21 @@ test("initProject overwrites template files with --force", async () => {
 test("initProject writes platform-profile.json + genre-weight-profiles.json for --platform tomato", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-init-platform-tomato-"));
     try {
-        const result = await initProject({ rootDir, minimal: true, platform: "tomato" });
+        const result = await initProject({ rootDir, platform: "tomato" });
         assert.ok(result.created.includes("platform-profile.json"));
         assert.ok(result.created.includes("genre-weight-profiles.json"));
+        assert.ok(result.created.includes("platform-writing-guide.md"));
+        assert.ok(result.created.includes("style-profile.json"));
+        assert.ok(result.created.includes("golden-chapter-gates.json"));
         const raw = await readJson(join(rootDir, "platform-profile.json"));
         const profile = parsePlatformProfile(raw, "platform-profile.json");
         assert.equal(profile.platform, "tomato");
         assert.ok(typeof profile.created_at === "string" && profile.created_at.length > 0);
         assert.ok(typeof profile.schema_version === "number");
+        const styleProfileRaw = await readJson(join(rootDir, "style-profile.json"));
+        assert.equal(styleProfileRaw.platform, "tomato");
+        const guide = await readFile(join(rootDir, "platform-writing-guide.md"), "utf8");
+        assert.match(guide, /番茄平台写作指南/);
         // genre-weight-profiles.json should be a valid JSON object
         const genreRaw = await readJson(join(rootDir, "genre-weight-profiles.json"));
         assert.ok(typeof genreRaw === "object" && genreRaw !== null && !Array.isArray(genreRaw));
@@ -194,15 +214,44 @@ test("initProject writes platform-profile.json for --platform qidian", async ()
         const result = await initProject({ rootDir, minimal: true, platform: "qidian" });
         assert.ok(result.created.includes("platform-profile.json"));
         assert.ok(result.created.includes("genre-weight-profiles.json"));
+        assert.ok(result.created.includes("golden-chapter-gates.json"));
         const raw = await readJson(join(rootDir, "platform-profile.json"));
         const profile = parsePlatformProfile(raw, "platform-profile.json");
         assert.equal(profile.platform, "qidian");
         assert.ok(typeof profile.created_at === "string" && profile.created_at.length > 0);
+        await assertFile(join(rootDir, "golden-chapter-gates.json"));
     }
     finally {
         await rm(rootDir, { recursive: true, force: true });
     }
 });
+test("initProject writes fanqie and jinjiang platform artifacts with populated style profile", async () => {
+    const fanqieRoot = await mkdtemp(join(tmpdir(), "novel-init-platform-fanqie-"));
+    const jinjiangRoot = await mkdtemp(join(tmpdir(), "novel-init-platform-jinjiang-"));
+    try {
+        await initProject({ rootDir: fanqieRoot, platform: "fanqie" });
+        await initProject({ rootDir: jinjiangRoot, platform: "jinjiang" });
+        const fanqieStyle = await readJson(join(fanqieRoot, "style-profile.json"));
+        const jinjiangStyle = await readJson(join(jinjiangRoot, "style-profile.json"));
+        assert.equal(fanqieStyle.platform, "fanqie");
+        assert.equal(jinjiangStyle.platform, "jinjiang");
+        const fanqieProfile = parsePlatformProfile(await readJson(join(fanqieRoot, "platform-profile.json")), "platform-profile.json");
+        const jinjiangProfile = parsePlatformProfile(await readJson(join(jinjiangRoot, "platform-profile.json")), "platform-profile.json");
+        assert.equal(fanqieProfile.platform, "fanqie");
+        assert.equal(jinjiangProfile.platform, "jinjiang");
+        assert.equal(jinjiangProfile.word_count.target_min, 2000);
+        assert.equal(jinjiangProfile.word_count.target_max, 3000);
+        assert.equal(jinjiangProfile.scoring?.genre_drive_type, "character");
+        const fanqieGuide = await readFile(join(fanqieRoot, "platform-writing-guide.md"), "utf8");
+        const jinjiangGuide = await readFile(join(jinjiangRoot, "platform-writing-guide.md"), "utf8");
+        assert.match(fanqieGuide, /番茄平台写作指南/);
+        assert.match(jinjiangGuide, /晋江平台写作指南/);
+    }
+    finally {
+        await rm(fanqieRoot, { recursive: true, force: true });
+        await rm(jinjiangRoot, { recursive: true, force: true });
+    }
+});
 // ── Minimal mode ────────────────────────────────────────────────────────
 test("initProject minimal mode skips templates", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-init-minimal-"));
@@ -215,6 +264,9 @@ test("initProject minimal mode skips templates", async () => {
         assert.equal(await statExists(join(rootDir, "brief.md")), false);
         assert.equal(await statExists(join(rootDir, "style-profile.json")), false);
         assert.equal(await statExists(join(rootDir, "ai-blacklist.json")), false);
+        assert.equal(await statExists(join(rootDir, "genre-excitement-map.json")), false);
+        assert.equal(await statExists(join(rootDir, "genre-golden-standards.json")), false);
+        assert.equal(await statExists(join(rootDir, "golden-chapter-gates.json")), false);
         assert.equal(await statExists(join(rootDir, "web-novel-cliche-lint.json")), false);
     }
     finally {

package/dist/__tests__/instructions-platform-expansion.test.js

@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { buildInstructionPacket } from "../instructions.js";
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+async function readRepoText(relPath) {
+    return readFile(join(repoRoot, relPath), "utf8");
+}
+async function writeText(absPath, contents) {
+    await mkdir(dirname(absPath), { recursive: true });
+    await writeFile(absPath, contents, "utf8");
+}
+async function writeJson(absPath, payload) {
+    await writeText(absPath, `${JSON.stringify(payload, null, 2)}\n`);
+}
+function makeCheckpoint(stage) {
+    return {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: stage,
+        inflight_chapter: 1,
+        revision_count: 0,
+        hook_fix_count: 0,
+        title_fix_count: 0
+    };
+}
+test("buildInstructionPacket includes platform writing guide for chapter and quickstart writer packets", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-platform-guide-packet-"));
+    await writeJson(join(rootDir, "platform-profile.json"), {
+        schema_version: 1,
+        platform: "fanqie",
+        created_at: "2026-03-01T00:00:00Z",
+        word_count: { target_min: 1500, target_max: 2500, hard_min: 1000, hard_max: 3500 },
+        hook_policy: { required: true, min_strength: 3, allowed_types: ["question"], fix_strategy: "hook-fix" },
+        info_load: { max_new_entities_per_chapter: 5, max_unknown_entities_per_chapter: 3, max_new_terms_per_1k_words: 5 },
+        compliance: { banned_words: [], duplicate_name_policy: "soft" },
+        scoring: { genre_drive_type: "plot", weight_profile_id: "plot:v1" }
+    });
+    await writeText(join(rootDir, "platform-writing-guide.md"), "# 平台指南\n");
+    await writeText(join(rootDir, "skills/novel-writing/references/style-guide.md"), "# style guide\n");
+    const chapterPacket = (await buildInstructionPacket({
+        rootDir,
+        checkpoint: makeCheckpoint("committed"),
+        step: { kind: "chapter", chapter: 1, stage: "draft" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    assert.equal(chapterPacket.packet.manifest.paths.platform_writing_guide, "platform-writing-guide.md");
+    assert.equal(chapterPacket.packet.manifest.paths.style_guide, "skills/novel-writing/references/style-guide.md");
+    const quickstartPacket = (await buildInstructionPacket({
+        rootDir,
+        checkpoint: {
+            last_completed_chapter: 0,
+            current_volume: 1,
+            orchestrator_state: "QUICK_START",
+            pipeline_stage: null,
+            inflight_chapter: null
+        },
+        step: { kind: "quickstart", phase: "trial" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    assert.equal(quickstartPacket.packet.manifest.paths.platform_writing_guide, "platform-writing-guide.md");
+    assert.equal(quickstartPacket.packet.manifest.paths.style_guide, "skills/novel-writing/references/style-guide.md");
+});
+test("buildInstructionPacket injects platform-aware scoring and golden chapter gates for judge packets", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-platform-judge-packet-"));
+    await writeJson(join(rootDir, "platform-profile.json"), {
+        schema_version: 1,
+        platform: "tomato",
+        created_at: "2026-03-01T00:00:00Z",
+        word_count: { target_min: 1500, target_max: 2500, hard_min: 1000, hard_max: 3500 },
+        hook_policy: { required: true, min_strength: 3, allowed_types: ["question"], fix_strategy: "hook-fix" },
+        info_load: { max_new_entities_per_chapter: 5, max_unknown_entities_per_chapter: 3, max_new_terms_per_1k_words: 5 },
+        compliance: { banned_words: [], duplicate_name_policy: "soft" },
+        scoring: { genre_drive_type: "plot", weight_profile_id: "plot:v1" }
+    });
+    await writeText(join(rootDir, "platform-writing-guide.md"), "# 番茄平台写作指南\n");
+    await writeJson(join(rootDir, "genre-weight-profiles.json"), JSON.parse(await readRepoText("templates/genre-weight-profiles.json")));
+    await writeJson(join(rootDir, "golden-chapter-gates.json"), JSON.parse(await readRepoText("templates/golden-chapter-gates.json")));
+    await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n正文\n");
+    const packet = (await buildInstructionPacket({
+        rootDir,
+        checkpoint: makeCheckpoint("refined"),
+        step: { kind: "chapter", chapter: 1, stage: "judge" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    assert.equal(packet.packet.manifest.paths.platform_writing_guide, "platform-writing-guide.md");
+    assert.equal(packet.packet.manifest.inline.golden_chapter_gates.platform, "fanqie");
+    assert.equal(packet.packet.manifest.inline.golden_chapter_gates.chapter, 1);
+    assert.equal(packet.packet.manifest.inline.golden_chapter_gates.source, "golden-chapter-gates.json");
+    assert.ok(packet.packet.manifest.inline.scoring_weights.weights.hook_strength > 0);
+});
+test("buildInstructionPacket omits golden chapter gates after chapter 3", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-platform-judge-no-gates-"));
+    await writeJson(join(rootDir, "platform-profile.json"), {
+        schema_version: 1,
+        platform: "jinjiang",
+        created_at: "2026-03-01T00:00:00Z",
+        word_count: { target_min: 2000, target_max: 3000, hard_min: 1500, hard_max: 3800 },
+        hook_policy: { required: true, min_strength: 3, allowed_types: ["emotional_cliff"], fix_strategy: "hook-fix" },
+        info_load: { max_new_entities_per_chapter: 4, max_unknown_entities_per_chapter: 2, max_new_terms_per_1k_words: 4 },
+        compliance: { banned_words: [], duplicate_name_policy: "soft" },
+        scoring: { genre_drive_type: "character", weight_profile_id: "character:v1" }
+    });
+    await writeJson(join(rootDir, "genre-weight-profiles.json"), JSON.parse(await readRepoText("templates/genre-weight-profiles.json")));
+    await writeJson(join(rootDir, "golden-chapter-gates.json"), JSON.parse(await readRepoText("templates/golden-chapter-gates.json")));
+    await writeText(join(rootDir, "staging/chapters/chapter-004.md"), "# 第4章\n\n正文\n");
+    const packet = (await buildInstructionPacket({
+        rootDir,
+        checkpoint: {
+            ...makeCheckpoint("refined"),
+            inflight_chapter: 4
+        },
+        step: { kind: "chapter", chapter: 4, stage: "judge" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    assert.equal(packet.packet.manifest.inline.golden_chapter_gates, undefined);
+});

package/dist/__tests__/next-step-gate-decision-routing.test.js

@@ -25,6 +25,23 @@ test("computeNextStep routes judged+eval to commit on gate pass", async () => {
     assert.equal(next.step, "chapter:001:commit");
     assert.equal(next.reason, "judged:gate:pass");
 });
+test("computeNextStep routes refined+eval to commit only after gate pass", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-next-step-refined-gate-pass-"));
+    await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
+    await writeFile(join(rootDir, "staging/chapters/chapter-001.md"), "chapter text\n", "utf8");
+    await mkdir(join(rootDir, "staging/evaluations"), { recursive: true });
+    await writeJson(join(rootDir, "staging/evaluations/chapter-001-eval.json"), { chapter: 1, overall: 4.2, recommendation: "pass" });
+    const next = await computeNextStep(rootDir, {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "refined",
+        inflight_chapter: 1,
+        revision_count: 0
+    });
+    assert.equal(next.step, "chapter:001:commit");
+    assert.equal(next.reason, "refined:gate:pass");
+});
 test("computeNextStep routes judged+eval to refine on gate polish", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-next-step-gate-polish-"));
     await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
@@ -59,6 +76,33 @@ test("computeNextStep routes judged+eval to draft on gate revise", async () => {
     assert.equal(next.step, "chapter:001:draft");
     assert.equal(next.reason, "judged:gate:revise");
 });
+test("computeNextStep routes refined+eval to draft when golden chapter gates fail", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-next-step-refined-golden-gate-fail-"));
+    await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
+    await writeFile(join(rootDir, "staging/chapters/chapter-001.md"), "chapter text\n", "utf8");
+    await mkdir(join(rootDir, "staging/evaluations"), { recursive: true });
+    await writeJson(join(rootDir, "staging/evaluations/chapter-001-eval.json"), {
+        chapter: 1,
+        overall: 4.8,
+        recommendation: "pass",
+        golden_chapter_gates: {
+            activated: true,
+            passed: false,
+            failed_gate_ids: ["hook_present"],
+            checks: [{ id: "hook_present", status: "fail" }]
+        }
+    });
+    const next = await computeNextStep(rootDir, {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "refined",
+        inflight_chapter: 1,
+        revision_count: 0
+    });
+    assert.equal(next.step, "chapter:001:draft");
+    assert.equal(next.reason, "refined:gate:revise");
+});
 test("computeNextStep routes judged+eval to commit on force_passed when revisions exhausted", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-next-step-gate-force-passed-"));
     await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
@@ -115,3 +159,57 @@ test("computeNextStep forces revise when eval has high-confidence violations", a
     assert.equal(next.step, "chapter:001:draft");
     assert.equal(next.reason, "judged:gate:revise");
 });
+test("computeNextStep forces revise when golden chapter gates fail despite high overall", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-next-step-golden-gate-fail-"));
+    await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
+    await writeFile(join(rootDir, "staging/chapters/chapter-001.md"), "chapter text\n", "utf8");
+    await mkdir(join(rootDir, "staging/evaluations"), { recursive: true });
+    await writeJson(join(rootDir, "staging/evaluations/chapter-001-eval.json"), {
+        chapter: 1,
+        overall: 4.8,
+        recommendation: "pass",
+        golden_chapter_gates: {
+            activated: true,
+            passed: false,
+            failed_gate_ids: ["protagonist_within_200_words"],
+            checks: [{ id: "protagonist_within_200_words", status: "fail" }]
+        }
+    });
+    const next = await computeNextStep(rootDir, {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "judged",
+        inflight_chapter: 1,
+        revision_count: 0
+    });
+    assert.equal(next.step, "chapter:001:draft");
+    assert.equal(next.reason, "judged:gate:revise");
+});
+test("computeNextStep routes to review when golden chapter gate failures persist beyond max revisions", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-next-step-golden-gate-pause-"));
+    await mkdir(join(rootDir, "staging/chapters"), { recursive: true });
+    await writeFile(join(rootDir, "staging/chapters/chapter-001.md"), "chapter text\n", "utf8");
+    await mkdir(join(rootDir, "staging/evaluations"), { recursive: true });
+    await writeJson(join(rootDir, "staging/evaluations/chapter-001-eval.json"), {
+        chapter: 1,
+        overall: 4.8,
+        recommendation: "pass",
+        golden_chapter_gates: {
+            activated: true,
+            passed: false,
+            failed_gate_ids: ["hook_present"],
+            checks: [{ id: "hook_present", status: "fail" }]
+        }
+    });
+    const next = await computeNextStep(rootDir, {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "judged",
+        inflight_chapter: 1,
+        revision_count: 2
+    });
+    assert.equal(next.step, "chapter:001:review");
+    assert.equal(next.reason, "judged:gate:pause_for_user");
+});

package/dist/__tests__/orchestrator-state-write-path.test.js

@@ -43,7 +43,7 @@ test("commitChapter resets orchestrator_state to WRITING", async () => {
     await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（测试）\n`);
     await writeText(join(rootDir, "staging/summaries/chapter-001-summary.md"), `## 第 1 章摘要\n\n- 测试事件\n`);
     await writeJson(join(rootDir, "staging/state/chapter-001-crossref.json"), { schema_version: 1, chapter: 1, entities: [] });
-    await writeJson(join(rootDir, "staging/evaluations/chapter-001-eval.json"), { chapter: 1 });
+    await writeJson(join(rootDir, "staging/evaluations/chapter-001-eval.json"), { chapter: 1, overall: 4.0, recommendation: "pass" });
     await writeText(join(rootDir, "staging/storylines/main-arc/memory.md"), `- 测试记忆\n`);
     await writeJson(join(rootDir, "staging/state/chapter-001-delta.json"), {
         chapter: 1,

package/dist/__tests__/platform-profile.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { readFile } from "node:fs/promises";
 import test from "node:test";
-import { parsePlatformProfile } from "../platform-profile.js";
+import { canonicalPlatformId, parsePlatformProfile } from "../platform-profile.js";
 function makeBaseRaw() {
     return {
         schema_version: 1,
@@ -21,6 +21,18 @@ test("parsePlatformProfile loads legacy profile without retention/readability/na
     assert.equal(Object.prototype.hasOwnProperty.call(profile, "readability"), false);
     assert.equal(Object.prototype.hasOwnProperty.call(profile, "naming"), false);
 });
+test("canonicalPlatformId maps tomato to fanqie and preserves canonical ids", () => {
+    assert.equal(canonicalPlatformId("tomato"), "fanqie");
+    assert.equal(canonicalPlatformId("fanqie"), "fanqie");
+    assert.equal(canonicalPlatformId("qidian"), "qidian");
+    assert.equal(canonicalPlatformId("jinjiang"), "jinjiang");
+});
+test("parsePlatformProfile accepts fanqie and jinjiang platform ids", () => {
+    const fanqie = parsePlatformProfile({ ...makeBaseRaw(), platform: "fanqie" }, "platform-profile.json");
+    const jinjiang = parsePlatformProfile({ ...makeBaseRaw(), platform: "jinjiang" }, "platform-profile.json");
+    assert.equal(fanqie.platform, "fanqie");
+    assert.equal(jinjiang.platform, "jinjiang");
+});
 test("parsePlatformProfile accepts explicit null retention/readability/naming", () => {
     const raw = {
         ...makeBaseRaw(),
@@ -33,6 +45,18 @@ test("parsePlatformProfile accepts explicit null retention/readability/naming",
     assert.equal(profile.readability, null);
     assert.equal(profile.naming, null);
 });
+test("parsePlatformProfile accepts fractional max_new_terms_per_1k_words", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        info_load: {
+            max_new_entities_per_chapter: 0,
+            max_unknown_entities_per_chapter: 0,
+            max_new_terms_per_1k_words: 2.5
+        }
+    };
+    const profile = parsePlatformProfile(raw, "platform-profile.json");
+    assert.equal(profile.info_load.max_new_terms_per_1k_words, 2.5);
+});
 test("parsePlatformProfile loads extended profile with retention/readability/naming", () => {
     const raw = {
         ...makeBaseRaw(),
@@ -156,6 +180,20 @@ test("parsePlatformProfile rejects retention.title_policy min_chars > max_chars"
     };
     assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /min_chars.*<=.*max_chars/i);
 });
+test("parsePlatformProfile rejects word_count target_min > target_max", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        word_count: { target_min: 3000, target_max: 2000, hard_min: 1500, hard_max: 3500 }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /word_count\.target_min.*<=.*word_count\.target_max/i);
+});
+test("parsePlatformProfile rejects word_count hard_min > hard_max", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        word_count: { target_min: 2000, target_max: 3000, hard_min: 3600, hard_max: 3500 }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /word_count\.hard_min.*<=.*word_count\.hard_max/i);
+});
 test("parsePlatformProfile rejects retention.title_policy min_chars when float", () => {
     const raw = {
         ...makeBaseRaw(),
@@ -272,3 +310,21 @@ test("templates/platform-profile.json defaults parse as valid platform profiles"
         assert.ok(profile.naming, `expected defaults.${platform}.naming to be present`);
     }
 });
+test("templates/platform-profile.json keeps fanqie and tomato shared defaults aligned", async () => {
+    const raw = JSON.parse(await readFile("templates/platform-profile.json", "utf8"));
+    assert.ok(raw.defaults, "expected templates/platform-profile.json to have defaults");
+    const fanqie = raw.defaults?.fanqie;
+    const tomato = raw.defaults?.tomato;
+    assert.ok(fanqie && tomato, "expected fanqie and tomato defaults");
+    const sharedSubset = (profile) => ({
+        word_count: profile.word_count,
+        hook_policy: profile.hook_policy,
+        info_load: profile.info_load,
+        compliance: profile.compliance,
+        scoring: profile.scoring,
+        retention: profile.retention,
+        readability: profile.readability,
+        naming: profile.naming
+    });
+    assert.deepEqual(sharedSubset(fanqie), sharedSubset(tomato));
+});

package/dist/__tests__/quickstart-pipeline.test.js

@@ -7,6 +7,7 @@ import { advanceCheckpointForStep } from "../advance.js";
 import { readCheckpoint } from "../checkpoint.js";
 import { buildInstructionPacket } from "../instructions.js";
 import { computeNextStep } from "../next-step.js";
+import { writeCommittedMiniPlanning } from "./helpers/quickstart-mini-planning.js";
 async function writeText(absPath, contents) {
     await mkdir(dirname(absPath), { recursive: true });
     await writeFile(absPath, contents, "utf8");
@@ -101,6 +102,7 @@ test("advance quickstart:trial writes quickstart_phase correctly", async () => {
     await writeJson(join(rootDir, "staging/quickstart/rules.json"), { rules: [] });
     await writeJson(join(rootDir, "staging/quickstart/contracts/hero.json"), { id: "hero", display_name: "阿宁", contracts: [] });
     await writeJson(join(rootDir, "staging/quickstart/style-profile.json"), { source_type: "template" });
+    await writeCommittedMiniPlanning(rootDir);
     await writeText(join(rootDir, "staging/quickstart/trial-chapter.md"), "# Trial\n\nText\n");
     const updated = await advanceCheckpointForStep({ rootDir, step: { kind: "quickstart", phase: "trial" } });
     assert.equal(updated.orchestrator_state, "QUICK_START");
@@ -109,6 +111,21 @@ test("advance quickstart:trial writes quickstart_phase correctly", async () => {
     assert.equal(checkpoint.orchestrator_state, "QUICK_START");
     assert.equal(checkpoint.quickstart_phase, "trial");
 });
+test("advance quickstart:trial requires committed mini-planning artifacts", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-quickstart-trial-requires-f0-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "QUICK_START",
+        pipeline_stage: null,
+        inflight_chapter: null
+    });
+    await writeJson(join(rootDir, "staging/quickstart/rules.json"), { rules: [] });
+    await writeJson(join(rootDir, "staging/quickstart/contracts/hero.json"), { id: "hero", display_name: "阿宁", contracts: [] });
+    await writeJson(join(rootDir, "staging/quickstart/style-profile.json"), { source_type: "template" });
+    await writeText(join(rootDir, "staging/quickstart/trial-chapter.md"), "# Trial\n\nText\n");
+    await assert.rejects(() => advanceCheckpointForStep({ rootDir, step: { kind: "quickstart", phase: "trial" } }), /Missing committed quickstart mini-planning artifacts/);
+});
 test("advance quickstart rejects wrong orchestrator_state", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-quickstart-advance-wrong-state-"));
     await writeJson(join(rootDir, ".checkpoint.json"), {
@@ -140,12 +157,19 @@ test("computeNextStep recovers quickstart phase from staging artifacts", async (
     await writeJson(join(rootDir, "staging/quickstart/contracts/hero.json"), { id: "hero", display_name: "阿宁", contracts: [] });
     next = await computeNextStep(rootDir, await readCheckpoint(rootDir));
     assert.equal(next.step, "quickstart:style");
-    // style profile present → trial
+    // style profile present → f0
     await writeJson(join(rootDir, "staging/quickstart/style-profile.json"), { source_type: "template" });
     next = await computeNextStep(rootDir, await readCheckpoint(rootDir));
+    assert.equal(next.step, "quickstart:f0");
+    // committed mini-planning artifacts present → trial
+    await writeCommittedMiniPlanning(rootDir);
+    next = await computeNextStep(rootDir, await readCheckpoint(rootDir));
     assert.equal(next.step, "quickstart:trial");
     // trial chapter present → results
-    await writeText(join(rootDir, "staging/quickstart/trial-chapter.md"), `# 试写章\n\n（测试）\n`);
+    await writeText(join(rootDir, "staging/quickstart/trial-chapter.md"), `# 试写章
+
+（测试）
+`);
     next = await computeNextStep(rootDir, await readCheckpoint(rootDir));
     assert.equal(next.step, "quickstart:results");
     assert.equal(next.reason, "quickstart:results");
@@ -202,7 +226,7 @@ test("computeNextStep allows redoing style phase when style profile is missing",
     assert.equal(next.step, "quickstart:style");
     assert.equal(next.reason, "quickstart:style");
 });
-test("computeNextStep allows redoing trial phase when trial chapter is missing", async () => {
+test("computeNextStep falls back to f0 when trial phase is missing committed mini-planning artifacts", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-quickstart-recover-trial-"));
     await writeJson(join(rootDir, ".checkpoint.json"), {
         last_completed_chapter: 0,
@@ -216,10 +240,12 @@ test("computeNextStep allows redoing trial phase when trial chapter is missing",
     await writeJson(join(rootDir, "staging/quickstart/contracts/hero.json"), { id: "hero", display_name: "阿宁", contracts: [] });
     await writeJson(join(rootDir, "staging/quickstart/style-profile.json"), { source_type: "template" });
     const next = await computeNextStep(rootDir, await readCheckpoint(rootDir));
-    assert.equal(next.step, "quickstart:trial");
-    assert.equal(next.reason, "quickstart:trial");
+    assert.equal(next.step, "quickstart:f0");
+    assert.match(next.reason, /quickstart:recovery_blocked/);
+    assert.equal(next.evidence.recovery_blocked.checkpoint_phase, "trial");
+    assert.equal(next.evidence.recovery_blocked.expected_path, "volumes/vol-01/outline.md");
 });
-test("computeNextStep continues forward when checkpoint quickstart_phase is consistent with staging artifacts", async () => {
+test("computeNextStep continues forward into f0 when checkpoint quickstart_phase is consistent with style artifacts", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-quickstart-recover-happy-"));
     await writeJson(join(rootDir, ".checkpoint.json"), {
         last_completed_chapter: 0,
@@ -233,6 +259,25 @@ test("computeNextStep continues forward when checkpoint quickstart_phase is cons
     await writeJson(join(rootDir, "staging/quickstart/contracts/hero.json"), { id: "hero", display_name: "阿宁", contracts: [] });
     await writeJson(join(rootDir, "staging/quickstart/style-profile.json"), { source_type: "template" });
     const next = await computeNextStep(rootDir, await readCheckpoint(rootDir));
+    assert.equal(next.step, "quickstart:f0");
+    assert.equal(next.reason, "quickstart:f0");
+    assert.equal(next.evidence.recovery_blocked ?? null, null);
+});
+test("computeNextStep resumes from quickstart_phase=f0 into trial when mini-planning is committed", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-quickstart-resume-f0-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "QUICK_START",
+        pipeline_stage: null,
+        inflight_chapter: null,
+        quickstart_phase: "f0"
+    });
+    await writeJson(join(rootDir, "staging/quickstart/rules.json"), { rules: [] });
+    await writeJson(join(rootDir, "staging/quickstart/contracts/hero.json"), { id: "hero", display_name: "阿宁", contracts: [] });
+    await writeJson(join(rootDir, "staging/quickstart/style-profile.json"), { source_type: "template" });
+    await writeCommittedMiniPlanning(rootDir);
+    const next = await computeNextStep(rootDir, await readCheckpoint(rootDir));
     assert.equal(next.step, "quickstart:trial");
     assert.equal(next.reason, "quickstart:trial");
     assert.equal(next.evidence.recovery_blocked ?? null, null);
@@ -267,6 +312,26 @@ test("buildInstructionPacket (quickstart) includes NOVEL_ASK gate when provided"
     assert.equal(built.packet.novel_ask.topic, questionSpec.topic);
     assert.equal(built.packet.expected_outputs[0].path, answerPath);
 });
+test("advance quickstart:results requires committed mini-planning artifacts", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-quickstart-results-requires-f0-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "QUICK_START",
+        pipeline_stage: null,
+        inflight_chapter: null,
+        volume_pipeline_stage: null
+    });
+    await writeJson(join(rootDir, "staging/quickstart/rules.json"), { rules: [] });
+    await writeJson(join(rootDir, "staging/quickstart/contracts/hero.json"), { id: "hero", display_name: "阿宁", contracts: [] });
+    await writeJson(join(rootDir, "staging/quickstart/style-profile.json"), { source_type: "template" });
+    await writeText(join(rootDir, "staging/quickstart/trial-chapter.md"), `# 试写章
+
+（测试）
+`);
+    await writeJson(join(rootDir, "staging/quickstart/evaluation.json"), { overall: 4.2, recommendation: "pass" });
+    await assert.rejects(() => advanceCheckpointForStep({ rootDir, step: { kind: "quickstart", phase: "results" } }), /Missing committed quickstart mini-planning artifacts/);
+});
 test("advance quickstart:results commits artifacts and transitions to VOL_PLANNING", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-quickstart-commit-"));
     await writeJson(join(rootDir, ".checkpoint.json"), {
@@ -292,6 +357,7 @@ test("advance quickstart:results commits artifacts and transitions to VOL_PLANNI
     });
     await writeJson(join(rootDir, "staging/quickstart/contracts/hero.json"), { id: "hero", display_name: "阿宁", contracts: [] });
     await writeJson(join(rootDir, "staging/quickstart/style-profile.json"), { source_type: "template" });
+    await writeCommittedMiniPlanning(rootDir);
     await writeText(join(rootDir, "staging/quickstart/trial-chapter.md"), `# 试写章\n\n（测试）\n`);
     await writeJson(join(rootDir, "staging/quickstart/evaluation.json"), { overall: 4.2, recommendation: "pass" });
     const updated = await advanceCheckpointForStep({ rootDir, step: { kind: "quickstart", phase: "results" } });
@@ -334,6 +400,7 @@ test("advance quickstart:results validates all contracts (not just a slice)", as
         ]
     });
     await writeJson(join(rootDir, "staging/quickstart/style-profile.json"), { source_type: "template" });
+    await writeCommittedMiniPlanning(rootDir);
     await writeText(join(rootDir, "staging/quickstart/trial-chapter.md"), `# 试写章\n\n（测试）\n`);
     await writeJson(join(rootDir, "staging/quickstart/evaluation.json"), { overall: 4.2, recommendation: "pass" });
     for (let i = 1; i <= 10; i++) {