novel-writer-cli 0.2.1 → 0.5.0

package/dist/__tests__/anti-ai-templates.test.js

@@ -0,0 +1,156 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+function repoPath(relPath) {
+    return join(repoRoot, relPath);
+}
+async function readJson(relPath) {
+    return JSON.parse(await readFile(repoPath(relPath), "utf8"));
+}
+function assertPlainObject(value, label) {
+    assert.ok(typeof value === "object" && value !== null && !Array.isArray(value), `${label} must be a JSON object`);
+}
+test("templates/style-profile-template.json includes nullable statistical fields (v0.2+ anti-AI)", async () => {
+    const raw = await readJson("templates/style-profile-template.json");
+    assertPlainObject(raw, "style-profile-template.json");
+    assert.equal(raw.sentence_length_std_dev, null);
+    assert.equal(raw.paragraph_length_cv, null);
+    assert.equal(raw.emotional_volatility, null);
+    assert.equal(raw.register_mixing, null);
+    assert.equal(raw.vocabulary_richness, null);
+    assert.equal(typeof raw._sentence_length_std_dev_comment, "string");
+    assert.match(raw._sentence_length_std_dev_comment, /8-18/);
+    assert.match(raw._sentence_length_std_dev_comment, /<\s*6/);
+    assert.equal(typeof raw._paragraph_length_cv_comment, "string");
+    assert.match(raw._paragraph_length_cv_comment, /0\.4-1\.2/);
+    assert.match(raw._paragraph_length_cv_comment, /<\s*0\.3/);
+    for (const key of ["_emotional_volatility_comment", "_register_mixing_comment", "_vocabulary_richness_comment"]) {
+        assert.equal(typeof raw[key], "string");
+        assert.match(raw[key], /high\|medium\|low/);
+    }
+});
+test("templates/ai-blacklist.json v2 expands entries and supports metadata", async () => {
+    const raw = await readJson("templates/ai-blacklist.json");
+    assertPlainObject(raw, "ai-blacklist.json");
+    assert.match(String(raw.version), /^2\./, "ai-blacklist.json.version must remain in v2.x series");
+    assert.equal(raw.max_words, 250);
+    assert.equal(typeof raw.last_updated, "string");
+    assert.ok(Array.isArray(raw.words), "ai-blacklist.json.words must be an array");
+    assert.ok(raw.words.every((w) => typeof w === "string" && w.trim().length > 0), "words must be non-empty strings");
+    const words = raw.words.map((w) => w.trim());
+    assert.ok(words.length >= 190, `words.length must be >= 190, got ${words.length}`);
+    assert.ok(words.length <= raw.max_words, `words.length must be <= max_words (${raw.max_words})`);
+    const wordSet = new Set(words);
+    assert.equal(wordSet.size, words.length, "words must be unique");
+    assert.ok(Array.isArray(raw.whitelist), "ai-blacklist.json.whitelist must be an array");
+    assert.ok(raw.whitelist.every((w) => typeof w === "string" && w.trim().length > 0), "whitelist entries must be non-empty strings");
+    assertPlainObject(raw.categories, "ai-blacklist.json.categories");
+    const categories = raw.categories;
+    const requiredCategories = [
+        "summary_word",
+        "enumeration_template",
+        "academic_tone",
+        "narration_connector",
+        "paragraph_opener",
+        "smooth_transition",
+        "emotion_cliche",
+        "expression_cliche",
+        "action_cliche",
+        "environment_cliche",
+        "narrative_filler",
+        "abstract_filler",
+        "mechanical_opening",
+        "simile_cliche"
+    ];
+    for (const key of requiredCategories) {
+        assert.ok(key in categories, `Missing category: ${key}`);
+    }
+    assertPlainObject(raw.category_metadata, "ai-blacklist.json.category_metadata");
+    const meta = raw.category_metadata;
+    assertPlainObject(meta.narration_connector, "category_metadata.narration_connector");
+    assert.equal(meta.narration_connector.context, "narration_only");
+    assertPlainObject(meta.abstract_filler, "category_metadata.abstract_filler");
+    assertPlainObject(meta.abstract_filler.genre_override, "category_metadata.abstract_filler.genre_override");
+    assertPlainObject(meta.abstract_filler.genre_override["sci-fi"], "category_metadata.abstract_filler.genre_override.sci-fi");
+    assertPlainObject(meta.abstract_filler.genre_override["sci-fi"].per_chapter_max, "category_metadata.abstract_filler.genre_override.sci-fi.per_chapter_max");
+    const allCategoryWords = new Set();
+    const narrationConnectorWords = new Set();
+    const abstractFillerWords = new Set();
+    const categorizedWordCounts = new Map();
+    const categoryWordSets = new Map();
+    const entryIndex = new Map();
+    for (const [categoryName, entries] of Object.entries(categories)) {
+        assert.ok(Array.isArray(entries), `categories.${categoryName} must be an array`);
+        const categoryWords = new Set();
+        categoryWordSets.set(categoryName, categoryWords);
+        for (const entry of entries) {
+            assertPlainObject(entry, `categories.${categoryName}[]`);
+            assert.equal(typeof entry.word, "string");
+            const word = entry.word.trim();
+            assert.ok(word.length > 0, `categories.${categoryName}[] word must be non-empty`);
+            categoryWords.add(word);
+            entryIndex.set(`${categoryName}:${word}`, entry);
+            assert.equal(typeof entry.replacement_hint, "string");
+            assert.ok(entry.replacement_hint.trim().length > 0, `categories.${categoryName}[] replacement_hint must be non-empty`);
+            const perChapterMax = entry.per_chapter_max;
+            if (perChapterMax !== undefined) {
+                assert.ok(Number.isInteger(perChapterMax) && perChapterMax > 0, `Invalid per_chapter_max for word: ${word}`);
+            }
+            if (categoryName === "narration_connector") {
+                narrationConnectorWords.add(word);
+                continue;
+            }
+            if (categoryName === "abstract_filler")
+                abstractFillerWords.add(word);
+            allCategoryWords.add(word);
+            categorizedWordCounts.set(word, (categorizedWordCounts.get(word) ?? 0) + 1);
+        }
+    }
+    // narration_connector is intentionally excluded from flat words until context-aware lint exists.
+    for (const w of narrationConnectorWords) {
+        assert.equal(wordSet.has(w), false, `narration_connector word must not appear in words[]: ${w}`);
+    }
+    assert.equal(allCategoryWords.size, wordSet.size, "categories (excluding narration_connector) must cover words[] exactly");
+    for (const w of allCategoryWords) {
+        assert.ok(wordSet.has(w), `Missing from words[]: ${w}`);
+    }
+    for (const w of wordSet) {
+        assert.equal(categorizedWordCounts.get(w), 1, `Word must appear exactly once across categories: ${w}`);
+    }
+    const sciFiPerChapterMax = meta.abstract_filler.genre_override["sci-fi"].per_chapter_max;
+    for (const [key, value] of Object.entries(sciFiPerChapterMax)) {
+        assert.ok(abstractFillerWords.has(key), `genre_override.sci-fi.per_chapter_max references missing abstract_filler word: ${key}`);
+        assert.ok(Number.isInteger(value), `genre_override.sci-fi.per_chapter_max must be int: ${key}`);
+        assert.ok(value > 0, `genre_override.sci-fi.per_chapter_max must be positive: ${key}`);
+    }
+    for (const word of ["宛如", "恍若", "仿佛置身于"]) {
+        assert.ok(wordSet.has(word), `Missing from words[]: ${word}`);
+        assert.ok(categoryWordSets.get("simile_cliche")?.has(word), `Missing from simile_cliche: ${word}`);
+    }
+    assert.ok(categoryWordSets.get("paragraph_opener")?.has("下一刻"), "下一刻 should be classified as paragraph_opener");
+    assert.equal(categoryWordSets.get("narrative_filler")?.has("下一刻"), false, "下一刻 should not remain in narrative_filler");
+    for (const [categoryName, word, expectedMax] of [
+        ["enumeration_template", "首先", 2],
+        ["enumeration_template", "其次", 2],
+        ["enumeration_template", "最后", 2],
+        ["academic_tone", "例如", 2],
+        ["emotion_cliche", "不禁", 1],
+        ["emotion_cliche", "心中暗道", 1],
+        ["action_cliche", "缓缓说道", 1],
+        ["action_cliche", "微微一笑", 1]
+    ]) {
+        const entry = entryIndex.get(`${categoryName}:${word}`);
+        assert.ok(entry, `Missing entry metadata: ${categoryName}:${word}`);
+        assert.equal(entry?.per_chapter_max, expectedMax, `Unexpected per_chapter_max for ${categoryName}:${word}`);
+    }
+    assert.ok(Array.isArray(raw.update_log), "ai-blacklist.json.update_log must be an array");
+    const updateLog = raw.update_log;
+    assert.ok(updateLog.length >= 1, "update_log should have at least one entry");
+    const latest = updateLog[updateLog.length - 1];
+    assertPlainObject(latest, "update_log[-1]");
+    assert.equal(latest.version, raw.version);
+    assert.equal(latest.words_count, words.length);
+});

package/dist/__tests__/canon-status-lifecycle.test.js

@@ -0,0 +1,481 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, rm, 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("issue 169 prompts and skill docs describe split planned character context", async () => {
+    const chapterWriter = await readRepoText("agents/chapter-writer.md");
+    const qualityJudge = await readRepoText("agents/quality-judge.md");
+    const continueSkill = await readRepoText("skills/continue/SKILL.md");
+    const contextContracts = await readRepoText("skills/continue/references/context-contracts.md");
+    assert.match(chapterWriter, /planned_character_contracts/);
+    assert.match(chapterWriter, /planned_character_profiles/);
+    assert.match(qualityJudge, /planned \/ deprecated 不会进入 judge packet/);
+    assert.match(continueSkill, /planned_character_contracts/);
+    assert.match(contextContracts, /planned_character_contracts\?:/);
+    assert.match(contextContracts, /character_contracts\?: .*仅 established \/ 缺失 canon_status/);
+    assert.match(contextContracts, /preferred 路径，不受 fallback 的 15 角色上限约束/);
+});
+test("buildInstructionPacket splits active and planned character context by canon_status", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-canon-status-"));
+    try {
+        await writeJson(join(rootDir, "world/rules.json"), {
+            schema_version: 1,
+            rules: [
+                { id: "W-001", category: "physics", rule: "旧规则也要生效", constraint_type: "hard" },
+                { id: "W-002", category: "physics", rule: "当前已生效规则", constraint_type: "hard", canon_status: "established" },
+                { id: "W-003", category: "magic_system", rule: "未来卷才生效的设定", constraint_type: "hard", canon_status: " Planned " },
+                { id: "W-004", category: "social", rule: "已废弃规则", constraint_type: "hard", canon_status: "deprecated" },
+                { id: "W-005", category: "social", rule: "未来的软规则提示", constraint_type: "soft", canon_status: " PLANNED " }
+            ]
+        });
+        await writeJson(join(rootDir, "volumes/vol-01/chapter-contracts/chapter-001.json"), {
+            chapter: 1,
+            storyline_id: "main-arc",
+            preconditions: {
+                character_states: {
+                    Alice: { location: "city" },
+                    Bob: { location: "city" },
+                    Carol: { location: "city" }
+                }
+            },
+            objectives: [{ id: "OBJ-1", required: true, description: "x" }]
+        });
+        for (const [slug, displayName, canonStatus] of [
+            ["alice", "Alice", undefined],
+            ["bob", "Bob", " Planned "],
+            ["carol", "Carol", "deprecated"],
+            ["dave", "Dave", "established"]
+        ]) {
+            await writeJson(join(rootDir, `characters/active/${slug}.json`), {
+                id: slug,
+                display_name: displayName,
+                ...(canonStatus ? { canon_status: canonStatus } : {}),
+                contracts: [{ id: `C-${slug.toUpperCase()}-001`, type: "personality", rule: "rule" }]
+            });
+            await writeText(join(rootDir, `characters/active/${slug}.md`), `# ${displayName}\n`);
+        }
+        await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n正文\n");
+        await writeText(join(rootDir, "staging/state/chapter-001-crossref.json"), "{}\n");
+        const draftPacket = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeCheckpoint("committed"),
+            step: { kind: "chapter", chapter: 1, stage: "draft" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.deepEqual(draftPacket.packet.manifest.inline.hard_rules_list, [
+            "W-001: 旧规则也要生效",
+            "W-002: 当前已生效规则"
+        ]);
+        assert.deepEqual(draftPacket.packet.manifest.inline.planned_rules_info, [
+            {
+                id: "W-003",
+                category: "magic_system",
+                constraint_type: "hard",
+                canon_status: "planned",
+                rule: "未来卷才生效的设定"
+            },
+            {
+                id: "W-005",
+                category: "social",
+                constraint_type: "soft",
+                canon_status: "planned",
+                rule: "未来的软规则提示"
+            }
+        ]);
+        assert.equal(Object.prototype.hasOwnProperty.call(draftPacket.packet.manifest.inline, "world_rules_context_degraded"), false);
+        assert.deepEqual(draftPacket.packet.manifest.paths.character_contracts, ["characters/active/alice.json"]);
+        assert.deepEqual(draftPacket.packet.manifest.paths.character_profiles, ["characters/active/alice.md"]);
+        assert.deepEqual(draftPacket.packet.manifest.paths.planned_character_contracts, ["characters/active/bob.json"]);
+        assert.deepEqual(draftPacket.packet.manifest.paths.planned_character_profiles, ["characters/active/bob.md"]);
+        const judgePacket = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeCheckpoint("refined"),
+            step: { kind: "chapter", chapter: 1, stage: "judge" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.deepEqual(judgePacket.packet.manifest.inline.hard_rules_list, [
+            "W-001: 旧规则也要生效",
+            "W-002: 当前已生效规则"
+        ]);
+        assert.equal(Object.prototype.hasOwnProperty.call(judgePacket.packet.manifest.inline, "planned_rules_info"), false);
+        assert.equal(Object.prototype.hasOwnProperty.call(judgePacket.packet.manifest.inline, "world_rules_context_degraded"), false);
+        assert.deepEqual(judgePacket.packet.manifest.paths.character_contracts, ["characters/active/alice.json"]);
+        assert.deepEqual(judgePacket.packet.manifest.paths.character_profiles, ["characters/active/alice.md"]);
+        assert.equal(Object.prototype.hasOwnProperty.call(judgePacket.packet.manifest.paths, "planned_character_contracts"), false);
+        assert.equal(Object.prototype.hasOwnProperty.call(judgePacket.packet.manifest.paths, "planned_character_profiles"), false);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+test("buildInstructionPacket prioritizes planned draft characters on fallback and keeps judge active-only", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-canon-status-fallback-"));
+    try {
+        await writeJson(join(rootDir, "world/rules.json"), {
+            schema_version: 1,
+            rules: []
+        });
+        for (let index = 1; index <= 18; index += 1) {
+            const slug = `char-${String(index).padStart(2, "0")}`;
+            const canonStatus = index === 17 ? "planned" : index === 18 ? "deprecated" : "established";
+            await writeJson(join(rootDir, `characters/active/${slug}.json`), {
+                id: slug,
+                display_name: `角色${index}`,
+                canon_status: canonStatus,
+                contracts: [{ id: `C-${index}`, type: "personality", rule: `rule-${index}` }]
+            });
+            await writeText(join(rootDir, `characters/active/${slug}.md`), `# 角色${index}\n`);
+        }
+        await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n正文\n");
+        await writeText(join(rootDir, "staging/state/chapter-001-crossref.json"), "{}\n");
+        const draftPacket = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeCheckpoint("committed"),
+            step: { kind: "chapter", chapter: 1, stage: "draft" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.deepEqual(draftPacket.packet.manifest.inline.hard_rules_list, []);
+        assert.equal(Object.prototype.hasOwnProperty.call(draftPacket.packet.manifest.inline, "world_rules_context_degraded"), false);
+        assert.deepEqual(draftPacket.packet.manifest.paths.character_contracts, [
+            "characters/active/char-01.json",
+            "characters/active/char-02.json",
+            "characters/active/char-03.json",
+            "characters/active/char-04.json",
+            "characters/active/char-05.json",
+            "characters/active/char-06.json",
+            "characters/active/char-07.json",
+            "characters/active/char-08.json",
+            "characters/active/char-09.json",
+            "characters/active/char-10.json",
+            "characters/active/char-11.json",
+            "characters/active/char-12.json",
+            "characters/active/char-13.json",
+            "characters/active/char-14.json"
+        ]);
+        assert.deepEqual(draftPacket.packet.manifest.paths.character_profiles, [
+            "characters/active/char-01.md",
+            "characters/active/char-02.md",
+            "characters/active/char-03.md",
+            "characters/active/char-04.md",
+            "characters/active/char-05.md",
+            "characters/active/char-06.md",
+            "characters/active/char-07.md",
+            "characters/active/char-08.md",
+            "characters/active/char-09.md",
+            "characters/active/char-10.md",
+            "characters/active/char-11.md",
+            "characters/active/char-12.md",
+            "characters/active/char-13.md",
+            "characters/active/char-14.md"
+        ]);
+        assert.deepEqual(draftPacket.packet.manifest.paths.planned_character_contracts, ["characters/active/char-17.json"]);
+        assert.deepEqual(draftPacket.packet.manifest.paths.planned_character_profiles, ["characters/active/char-17.md"]);
+        assert.equal(draftPacket.packet.manifest.paths.character_contracts.includes("characters/active/char-15.json"), false);
+        await writeJson(join(rootDir, "volumes/vol-01/chapter-contracts/chapter-001.json"), {
+            chapter: 1,
+            storyline_id: "main-arc",
+            preconditions: {
+                character_states: {
+                    "角色17": { location: "city" }
+                }
+            },
+            objectives: [{ id: "OBJ-1", required: true, description: "x" }]
+        });
+        const judgePacket = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeCheckpoint("refined"),
+            step: { kind: "chapter", chapter: 1, stage: "judge" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.deepEqual(judgePacket.packet.manifest.inline.hard_rules_list, []);
+        assert.deepEqual(judgePacket.packet.manifest.paths.character_contracts, [
+            "characters/active/char-01.json",
+            "characters/active/char-02.json",
+            "characters/active/char-03.json",
+            "characters/active/char-04.json",
+            "characters/active/char-05.json",
+            "characters/active/char-06.json",
+            "characters/active/char-07.json",
+            "characters/active/char-08.json",
+            "characters/active/char-09.json",
+            "characters/active/char-10.json",
+            "characters/active/char-11.json",
+            "characters/active/char-12.json",
+            "characters/active/char-13.json",
+            "characters/active/char-14.json",
+            "characters/active/char-15.json"
+        ]);
+        assert.deepEqual(judgePacket.packet.manifest.paths.character_profiles, [
+            "characters/active/char-01.md",
+            "characters/active/char-02.md",
+            "characters/active/char-03.md",
+            "characters/active/char-04.md",
+            "characters/active/char-05.md",
+            "characters/active/char-06.md",
+            "characters/active/char-07.md",
+            "characters/active/char-08.md",
+            "characters/active/char-09.md",
+            "characters/active/char-10.md",
+            "characters/active/char-11.md",
+            "characters/active/char-12.md",
+            "characters/active/char-13.md",
+            "characters/active/char-14.md",
+            "characters/active/char-15.md"
+        ]);
+        assert.equal(judgePacket.packet.manifest.paths.character_contracts.includes("characters/active/char-17.json"), false);
+        assert.equal(Object.prototype.hasOwnProperty.call(judgePacket.packet.manifest.paths, "planned_character_contracts"), false);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+test("buildInstructionPacket fallback uses the shared draft budget to keep planned characters first", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-canon-status-budget-"));
+    try {
+        await writeJson(join(rootDir, "world/rules.json"), {
+            schema_version: 1,
+            rules: []
+        });
+        for (let index = 1; index <= 10; index += 1) {
+            const slug = `active-${String(index).padStart(2, "0")}`;
+            await writeJson(join(rootDir, `characters/active/${slug}.json`), {
+                id: slug,
+                display_name: `已生效角色${index}`,
+                canon_status: "established",
+                contracts: [{ id: `A-${index}`, type: "personality", rule: `active-${index}` }]
+            });
+            await writeText(join(rootDir, `characters/active/${slug}.md`), `# 已生效角色${index}\n`);
+        }
+        for (let index = 1; index <= 12; index += 1) {
+            const slug = `planned-${String(index).padStart(2, "0")}`;
+            await writeJson(join(rootDir, `characters/active/${slug}.json`), {
+                id: slug,
+                display_name: `计划角色${index}`,
+                canon_status: "planned",
+                contracts: [{ id: `P-${index}`, type: "personality", rule: `planned-${index}` }]
+            });
+            await writeText(join(rootDir, `characters/active/${slug}.md`), `# 计划角色${index}\n`);
+        }
+        await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n正文\n");
+        await writeText(join(rootDir, "staging/state/chapter-001-crossref.json"), "{}\n");
+        const draftPacket = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeCheckpoint("committed"),
+            step: { kind: "chapter", chapter: 1, stage: "draft" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.deepEqual(draftPacket.packet.manifest.paths.character_contracts, [
+            "characters/active/active-01.json",
+            "characters/active/active-02.json",
+            "characters/active/active-03.json"
+        ]);
+        assert.deepEqual(draftPacket.packet.manifest.paths.planned_character_contracts, [
+            "characters/active/planned-01.json",
+            "characters/active/planned-02.json",
+            "characters/active/planned-03.json",
+            "characters/active/planned-04.json",
+            "characters/active/planned-05.json",
+            "characters/active/planned-06.json",
+            "characters/active/planned-07.json",
+            "characters/active/planned-08.json",
+            "characters/active/planned-09.json",
+            "characters/active/planned-10.json",
+            "characters/active/planned-11.json",
+            "characters/active/planned-12.json"
+        ]);
+        assert.equal(draftPacket.packet.manifest.paths.character_contracts.includes("characters/active/active-04.json"), false);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+test("buildInstructionPacket keeps all-planned characters out of judge packets", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-canon-status-all-planned-"));
+    try {
+        await writeJson(join(rootDir, "world/rules.json"), {
+            schema_version: 1,
+            rules: []
+        });
+        for (let index = 1; index <= 3; index += 1) {
+            const slug = `planned-${String(index).padStart(2, "0")}`;
+            await writeJson(join(rootDir, `characters/active/${slug}.json`), {
+                id: slug,
+                display_name: `计划角色${index}`,
+                canon_status: "planned",
+                contracts: [{ id: `P-${index}`, type: "personality", rule: `planned-${index}` }]
+            });
+            await writeText(join(rootDir, `characters/active/${slug}.md`), `# 计划角色${index}\n`);
+        }
+        await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n正文\n");
+        await writeText(join(rootDir, "staging/state/chapter-001-crossref.json"), "{}\n");
+        const draftPacket = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeCheckpoint("committed"),
+            step: { kind: "chapter", chapter: 1, stage: "draft" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.equal(Object.prototype.hasOwnProperty.call(draftPacket.packet.manifest.paths, "character_contracts"), false);
+        assert.equal(Object.prototype.hasOwnProperty.call(draftPacket.packet.manifest.paths, "character_profiles"), false);
+        assert.deepEqual(draftPacket.packet.manifest.paths.planned_character_contracts, [
+            "characters/active/planned-01.json",
+            "characters/active/planned-02.json",
+            "characters/active/planned-03.json"
+        ]);
+        assert.deepEqual(draftPacket.packet.manifest.paths.planned_character_profiles, [
+            "characters/active/planned-01.md",
+            "characters/active/planned-02.md",
+            "characters/active/planned-03.md"
+        ]);
+        const judgePacket = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeCheckpoint("refined"),
+            step: { kind: "chapter", chapter: 1, stage: "judge" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.equal(Object.prototype.hasOwnProperty.call(judgePacket.packet.manifest.paths, "character_contracts"), false);
+        assert.equal(Object.prototype.hasOwnProperty.call(judgePacket.packet.manifest.paths, "character_profiles"), false);
+        assert.equal(Object.prototype.hasOwnProperty.call(judgePacket.packet.manifest.paths, "planned_character_contracts"), false);
+        assert.equal(Object.prototype.hasOwnProperty.call(judgePacket.packet.manifest.paths, "planned_character_profiles"), false);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+test("buildInstructionPacket returns empty character context for all deprecated characters and soft rules", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-canon-status-empty-"));
+    try {
+        await writeJson(join(rootDir, "world/rules.json"), {
+            schema_version: 1,
+            rules: [
+                { id: "W-001", category: "physics", rule: "soft established", constraint_type: "soft", canon_status: "established" },
+                { id: "W-002", category: "magic", rule: "soft default", constraint_type: "soft" }
+            ]
+        });
+        for (const slug of ["alice", "bob"]) {
+            await writeJson(join(rootDir, `characters/active/${slug}.json`), {
+                id: slug,
+                display_name: slug,
+                canon_status: "deprecated",
+                contracts: [{ id: `C-${slug}`, type: "personality", rule: "rule" }]
+            });
+            await writeText(join(rootDir, `characters/active/${slug}.md`), `# ${slug}\n`);
+        }
+        await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n正文\n");
+        await writeText(join(rootDir, "staging/state/chapter-001-crossref.json"), "{}\n");
+        const draftPacket = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeCheckpoint("committed"),
+            step: { kind: "chapter", chapter: 1, stage: "draft" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.deepEqual(draftPacket.packet.manifest.inline.hard_rules_list, []);
+        assert.equal(Object.prototype.hasOwnProperty.call(draftPacket.packet.manifest.paths, "character_contracts"), false);
+        assert.equal(Object.prototype.hasOwnProperty.call(draftPacket.packet.manifest.paths, "planned_character_contracts"), false);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+test("buildInstructionPacket warns and degrades invalid canon_status values to established", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-canon-status-invalid-"));
+    const originalWarn = console.warn;
+    const warnings = [];
+    console.warn = (...args) => {
+        warnings.push(args.map((arg) => String(arg)).join(" "));
+    };
+    try {
+        await writeJson(join(rootDir, "world/rules.json"), {
+            schema_version: 1,
+            rules: [{ id: "W-001", category: "physics", rule: "非法值也按 established", constraint_type: "hard", canon_status: "garbage" }]
+        });
+        await writeJson(join(rootDir, "volumes/vol-01/chapter-contracts/chapter-001.json"), {
+            chapter: 1,
+            storyline_id: "main-arc",
+            preconditions: { character_states: { Alice: { location: "city" } } },
+            objectives: [{ id: "OBJ-1", required: true, description: "x" }]
+        });
+        await writeJson(join(rootDir, "characters/active/alice.json"), {
+            id: "alice",
+            display_name: "Alice",
+            canon_status: true,
+            contracts: [{ id: "C-ALICE-001", type: "personality", rule: "rule" }]
+        });
+        await writeText(join(rootDir, "characters/active/alice.md"), "# Alice\n");
+        await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n正文\n");
+        await writeText(join(rootDir, "staging/state/chapter-001-crossref.json"), "{}\n");
+        const draftPacket = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeCheckpoint("committed"),
+            step: { kind: "chapter", chapter: 1, stage: "draft" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.deepEqual(draftPacket.packet.manifest.inline.hard_rules_list, ["W-001: 非法值也按 established"]);
+        assert.deepEqual(draftPacket.packet.manifest.paths.character_contracts, ["characters/active/alice.json"]);
+        assert.equal(warnings.length, 2);
+        const firstWarning = warnings[0] ?? "";
+        const secondWarning = warnings[1] ?? "";
+        assert.match(firstWarning, /Invalid canon_status/);
+        assert.match(secondWarning, /Invalid non-string canon_status/);
+    }
+    finally {
+        console.warn = originalWarn;
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+test("buildInstructionPacket marks malformed world rules as degraded and tolerates missing character directory", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-canon-status-degraded-"));
+    try {
+        await writeText(join(rootDir, "world/rules.json"), '{"rules": [}\n');
+        await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n正文\n");
+        await writeText(join(rootDir, "staging/state/chapter-001-crossref.json"), "{}\n");
+        const draftPacket = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeCheckpoint("committed"),
+            step: { kind: "chapter", chapter: 1, stage: "draft" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.deepEqual(draftPacket.packet.manifest.inline.hard_rules_list, []);
+        assert.equal(draftPacket.packet.manifest.inline.world_rules_context_degraded, true);
+        assert.equal(Object.prototype.hasOwnProperty.call(draftPacket.packet.manifest.paths, "character_contracts"), false);
+        assert.equal(Object.prototype.hasOwnProperty.call(draftPacket.packet.manifest.paths, "character_profiles"), false);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});