novel-writer-cli 0.0.1

package/dist/__tests__/naming-lint.test.js

@@ -0,0 +1,132 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { parsePlatformProfile } from "../platform-profile.js";
+import { computeNamingReport, writeNamingLintLogs } from "../naming-lint.js";
+function makeProfileRaw(extra) {
+    return {
+        schema_version: 1,
+        platform: "qidian",
+        created_at: "2026-01-01T00:00:00Z",
+        word_count: { target_min: 1, target_max: 2, hard_min: 1, hard_max: 2 },
+        hook_policy: { required: false, min_strength: 3, allowed_types: ["question"], fix_strategy: "hook-fix" },
+        info_load: { max_new_entities_per_chapter: 0, max_unknown_entities_per_chapter: 0, max_new_terms_per_1k_words: 0 },
+        compliance: { banned_words: [], duplicate_name_policy: "warn" },
+        scoring: { genre_drive_type: "plot", weight_profile_id: "plot:v1" },
+        ...extra
+    };
+}
+function makeNamingPolicy(overrides = {}) {
+    return {
+        enabled: true,
+        near_duplicate_threshold: 0.88,
+        blocking_conflict_types: ["duplicate"],
+        exemptions: {},
+        ...overrides
+    };
+}
+async function writeCharacterProfile(rootDir, slug, payload) {
+    const dirAbs = join(rootDir, "characters", "active");
+    await mkdir(dirAbs, { recursive: true });
+    await writeFile(join(dirAbs, `${slug}.json`), `${JSON.stringify({ id: slug, ...payload }, null, 2)}\n`, "utf8");
+}
+test("computeNamingReport skips when naming policy is missing/disabled", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-naming-skip-test-"));
+    const profile = parsePlatformProfile(makeProfileRaw({ naming: null }), "platform-profile.json");
+    const report = await computeNamingReport({
+        rootDir,
+        chapter: 1,
+        chapterText: "# T\n正文\n",
+        platformProfile: profile
+    });
+    assert.equal(report.status, "skipped");
+    assert.equal(report.issues.length, 0);
+});
+test("computeNamingReport flags duplicate canonical display_name as blocking when configured", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-naming-duplicate-test-"));
+    const profile = parsePlatformProfile(makeProfileRaw({ naming: makeNamingPolicy({ blocking_conflict_types: ["duplicate"] }) }), "platform-profile.json");
+    await writeCharacterProfile(rootDir, "lin-feng", { display_name: "林枫" });
+    await writeCharacterProfile(rootDir, "lin-feng-2", { display_name: "林枫" });
+    const report = await computeNamingReport({
+        rootDir,
+        chapter: 1,
+        chapterText: "# T\n正文\n",
+        platformProfile: profile
+    });
+    assert.equal(report.has_blocking_issues, true);
+    assert.equal(report.status, "violation");
+    assert.ok(report.issues.some((i) => i.id === "naming.duplicate_display_name" && i.severity === "hard"));
+});
+test("computeNamingReport flags near-duplicate names based on similarity threshold", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-naming-near-dup-test-"));
+    const profile = parsePlatformProfile(makeProfileRaw({ naming: makeNamingPolicy({ blocking_conflict_types: ["duplicate"] }) }), "platform-profile.json");
+    await writeCharacterProfile(rootDir, "lin-feng", { display_name: "林枫" });
+    await writeCharacterProfile(rootDir, "lin-feng-2", { display_name: "林峰" });
+    const report = await computeNamingReport({
+        rootDir,
+        chapter: 1,
+        chapterText: "# T\n正文\n",
+        platformProfile: profile
+    });
+    const near = report.issues.find((i) => i.id === "naming.near_duplicate");
+    assert.ok(near, "expected naming.near_duplicate issue");
+    assert.equal(near.severity, "soft");
+    assert.ok(typeof near.similarity === "number" && near.similarity >= 0.88);
+    assert.equal(report.has_blocking_issues, false);
+    assert.equal(report.status, "warn");
+});
+test("computeNamingReport flags alias collision when alias matches another character's canonical name", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-naming-alias-collision-test-"));
+    const profile = parsePlatformProfile(makeProfileRaw({ naming: makeNamingPolicy({ blocking_conflict_types: ["alias_collision"] }) }), "platform-profile.json");
+    await writeCharacterProfile(rootDir, "lin-feng", { display_name: "林枫", aliases: ["小枫"] });
+    await writeCharacterProfile(rootDir, "xiao-feng", { display_name: "小枫" });
+    const report = await computeNamingReport({
+        rootDir,
+        chapter: 1,
+        chapterText: "# T\n正文\n",
+        platformProfile: profile
+    });
+    assert.equal(report.has_blocking_issues, true);
+    assert.ok(report.issues.some((i) => i.id === "naming.alias_collision" && i.severity === "hard"));
+});
+test("computeNamingReport uses NER index to warn on confusing unknown character-like entities", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-naming-ner-confusion-test-"));
+    const profile = parsePlatformProfile(makeProfileRaw({ naming: makeNamingPolicy() }), "platform-profile.json");
+    await writeCharacterProfile(rootDir, "lin-feng", { display_name: "林枫" });
+    const current_index = new Map();
+    current_index.set("林峰", { category: "character", evidence: "L1: 林峰走了进来。" });
+    const infoLoadNer = {
+        status: "pass",
+        chapter_fingerprint: null,
+        current_index,
+        recent_texts: new Set()
+    };
+    const report = await computeNamingReport({
+        rootDir,
+        chapter: 1,
+        chapterText: "# T\n林峰走了进来。\n",
+        platformProfile: profile,
+        infoLoadNer
+    });
+    assert.equal(report.has_blocking_issues, false);
+    assert.equal(report.status, "warn");
+    assert.ok(report.issues.some((i) => i.id === "naming.unknown_entity_confusion" && i.severity === "warn"));
+});
+test("writeNamingLintLogs writes history under naming-report-chapter-*.json", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-naming-logs-test-"));
+    const report = {
+        schema_version: 1,
+        generated_at: "2026-01-01T00:00:00.000Z",
+        scope: { chapter: 1 },
+        policy: null,
+        registry: { total_characters: 0, total_names: 0 },
+        status: "pass",
+        issues: [],
+        has_blocking_issues: false
+    };
+    const out = await writeNamingLintLogs({ rootDir, chapter: 1, report });
+    assert.equal(out.latestRel, "logs/naming/latest.json");
+    assert.equal(out.historyRel, "logs/naming/naming-report-chapter-001.json");
+});

package/dist/__tests__/narrative-health-injection.test.js

@@ -0,0 +1,359 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { buildInstructionPacket } from "../instructions.js";
+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`);
+}
+test("buildInstructionPacket injects compact narrative health summaries into draft/refine packets (best-effort)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-narrative-health-injection-"));
+    const longSummary = `${"x".repeat(238)}😀${"y".repeat(20)}`;
+    await writeJson(join(rootDir, "logs/engagement/latest.json"), {
+        schema_version: 1,
+        generated_at: "2026-03-03T00:00:00.000Z",
+        as_of: { chapter: 10, volume: 1 },
+        scope: { volume: 1, chapter_start: 1, chapter_end: 10 },
+        metrics_stream_path: "engagement-metrics.jsonl",
+        metrics: [],
+        stats: {
+            chapters: 10,
+            avg_word_count: 3000,
+            avg_plot_progression_beats: 2,
+            avg_conflict_intensity: 3,
+            avg_payoff_score: 2,
+            avg_new_info_load_score: 3
+        },
+        issues: Array.from({ length: 7 }).map((_, i) => ({
+            id: `engagement.issue.${i + 1}`,
+            severity: "warn",
+            summary: i === 0 ? longSummary : `Issue ${i + 1}`,
+            suggestion: "Add a small reveal or reward beat in the next chapter."
+        })),
+        has_blocking_issues: false
+    });
+    await writeJson(join(rootDir, "logs/promises/latest.json"), {
+        schema_version: 1,
+        generated_at: "2026-03-03T00:00:00.000Z",
+        as_of: { chapter: 10, volume: 1 },
+        scope: { volume: 1, chapter_start: 1, chapter_end: 10 },
+        ledger_path: "promise-ledger.json",
+        policy: { dormancy_threshold_chapters: 12 },
+        stats: {
+            total_promises: 2,
+            promised_total: 2,
+            advanced_total: 0,
+            delivered_total: 0,
+            open_total: 2,
+            dormant_total: 1
+        },
+        dormant_promises: Array.from({ length: 7 }).map((_, i) => ({
+            id: `promise.${i + 1}`,
+            type: "core_mystery",
+            promise_text: `承诺 ${i + 1}`,
+            status: "promised",
+            introduced_chapter: 1,
+            last_touched_chapter: 1,
+            chapters_since_last_touch: i,
+            dormancy_threshold_chapters: 12,
+            suggestion: "轻触谜团：加入一个微小线索（不要揭示答案）。"
+        })),
+        issues: [
+            {
+                id: "promise_ledger.dormancy.dormant_promises",
+                severity: "warn",
+                summary: "Dormant promises detected.",
+                suggestion: "Use light-touch reminders to reduce perceived stalling."
+            }
+        ],
+        has_blocking_issues: false
+    });
+    await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const draftOut = (await buildInstructionPacket({
+        rootDir,
+        checkpoint,
+        step: { kind: "chapter", chapter: 1, stage: "draft" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    const draftInline = draftOut.packet.manifest.inline;
+    assert.equal(typeof draftInline.engagement_report_summary, "object");
+    assert.equal(typeof draftInline.promise_ledger_report_summary, "object");
+    assert.equal(draftInline.engagement_report_summary.issues.length, 5);
+    assert.equal(draftInline.promise_ledger_report_summary.dormant_promises.length, 5);
+    assert.ok(String(draftInline.engagement_report_summary.issues[0]?.summary ?? "").endsWith("…"));
+    const truncated = String(draftInline.engagement_report_summary.issues[0]?.summary ?? "");
+    const lastBeforeEllipsis = truncated.charCodeAt(Math.max(0, truncated.length - 2));
+    assert.ok(lastBeforeEllipsis < 0xd800 || lastBeforeEllipsis > 0xdbff);
+    assert.equal(draftOut.packet.manifest.paths.engagement_report_latest, "logs/engagement/latest.json");
+    assert.equal(draftOut.packet.manifest.paths.promise_ledger_report_latest, "logs/promises/latest.json");
+    const refineOut = (await buildInstructionPacket({
+        rootDir,
+        checkpoint,
+        step: { kind: "chapter", chapter: 1, stage: "refine" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    const refineInline = refineOut.packet.manifest.inline;
+    assert.equal(typeof refineInline.engagement_report_summary, "object");
+    assert.equal(typeof refineInline.promise_ledger_report_summary, "object");
+    assert.equal(refineInline.engagement_report_summary.issues.length, 5);
+    assert.equal(refineInline.promise_ledger_report_summary.dormant_promises.length, 5);
+    assert.equal(refineOut.packet.manifest.paths.engagement_report_latest, "logs/engagement/latest.json");
+    assert.equal(refineOut.packet.manifest.paths.promise_ledger_report_latest, "logs/promises/latest.json");
+});
+test("buildInstructionPacket marks degraded when latest reports exist but are invalid", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-narrative-health-injection-degraded-"));
+    // Engagement latest exists but is invalid JSON.
+    await writeText(join(rootDir, "logs/engagement/latest.json"), "{");
+    // Promise latest is valid.
+    await writeJson(join(rootDir, "logs/promises/latest.json"), {
+        schema_version: 1,
+        generated_at: "2026-03-03T00:00:00.000Z",
+        as_of: { chapter: 10, volume: 1 },
+        scope: { volume: 1, chapter_start: 1, chapter_end: 10 },
+        ledger_path: "promise-ledger.json",
+        policy: { dormancy_threshold_chapters: 12 },
+        stats: { total_promises: 0, promised_total: 0, advanced_total: 0, delivered_total: 0, open_total: 0, dormant_total: 0 },
+        dormant_promises: [],
+        issues: [],
+        has_blocking_issues: false
+    });
+    await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const out = (await buildInstructionPacket({
+        rootDir,
+        checkpoint,
+        step: { kind: "chapter", chapter: 1, stage: "draft" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    const inline = out.packet.manifest.inline;
+    assert.equal(inline.engagement_report_summary, undefined);
+    assert.equal(inline.engagement_report_summary_degraded, true);
+    assert.equal(typeof inline.promise_ledger_report_summary, "object");
+    assert.equal(inline.promise_ledger_report_summary_degraded, undefined);
+});
+test("buildInstructionPacket does not inject narrative health when logs are missing (no summary, no degraded)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-narrative-health-no-logs-"));
+    await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
+    const checkpoint = { last_completed_chapter: 0, current_volume: 1 };
+    const out = (await buildInstructionPacket({
+        rootDir,
+        checkpoint,
+        step: { kind: "chapter", chapter: 1, stage: "draft" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    const inline = out.packet.manifest.inline;
+    assert.equal(inline.engagement_report_summary, undefined);
+    assert.equal(inline.engagement_report_summary_degraded, undefined);
+    assert.equal(inline.promise_ledger_report_summary, undefined);
+    assert.equal(inline.promise_ledger_report_summary_degraded, undefined);
+    const paths = out.packet.manifest.paths;
+    assert.equal(paths.engagement_report_latest, undefined);
+    assert.equal(paths.promise_ledger_report_latest, undefined);
+});
+test("buildInstructionPacket does not inject narrative health summaries for stage=summarize/judge", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-narrative-health-no-inject-stages-"));
+    await writeJson(join(rootDir, "logs/engagement/latest.json"), {
+        schema_version: 1,
+        generated_at: "2026-03-03T00:00:00.000Z",
+        as_of: { chapter: 10, volume: 1 },
+        scope: { volume: 1, chapter_start: 1, chapter_end: 10 },
+        metrics_stream_path: "engagement-metrics.jsonl",
+        metrics: [],
+        stats: {
+            chapters: 10,
+            avg_word_count: 3000,
+            avg_plot_progression_beats: 2,
+            avg_conflict_intensity: 3,
+            avg_payoff_score: 2,
+            avg_new_info_load_score: 3
+        },
+        issues: [],
+        has_blocking_issues: false
+    });
+    await writeJson(join(rootDir, "logs/promises/latest.json"), {
+        schema_version: 1,
+        generated_at: "2026-03-03T00:00:00.000Z",
+        as_of: { chapter: 10, volume: 1 },
+        scope: { volume: 1, chapter_start: 1, chapter_end: 10 },
+        ledger_path: "promise-ledger.json",
+        policy: { dormancy_threshold_chapters: 12 },
+        stats: { total_promises: 0, promised_total: 0, advanced_total: 0, delivered_total: 0, open_total: 0, dormant_total: 0 },
+        dormant_promises: [],
+        issues: [],
+        has_blocking_issues: false
+    });
+    await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const summarizeOut = (await buildInstructionPacket({
+        rootDir,
+        checkpoint,
+        step: { kind: "chapter", chapter: 1, stage: "summarize" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    const summarizeInline = summarizeOut.packet.manifest.inline;
+    assert.equal(summarizeInline.engagement_report_summary, undefined);
+    assert.equal(summarizeInline.engagement_report_summary_degraded, undefined);
+    assert.equal(summarizeInline.promise_ledger_report_summary, undefined);
+    assert.equal(summarizeInline.promise_ledger_report_summary_degraded, undefined);
+    const judgeOut = (await buildInstructionPacket({
+        rootDir,
+        checkpoint,
+        step: { kind: "chapter", chapter: 1, stage: "judge" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    const judgeInline = judgeOut.packet.manifest.inline;
+    assert.equal(judgeInline.engagement_report_summary, undefined);
+    assert.equal(judgeInline.engagement_report_summary_degraded, undefined);
+    assert.equal(judgeInline.promise_ledger_report_summary, undefined);
+    assert.equal(judgeInline.promise_ledger_report_summary_degraded, undefined);
+});
+test("buildInstructionPacket marks degraded on schema_version mismatch when latest files exist", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-narrative-health-schema-mismatch-"));
+    await writeJson(join(rootDir, "logs/engagement/latest.json"), {
+        schema_version: 2,
+        generated_at: "2026-03-03T00:00:00.000Z",
+        issues: []
+    });
+    await writeJson(join(rootDir, "logs/promises/latest.json"), {
+        schema_version: 1,
+        generated_at: "2026-03-03T00:00:00.000Z",
+        as_of: { chapter: 10, volume: 1 },
+        scope: { volume: 1, chapter_start: 1, chapter_end: 10 },
+        ledger_path: "promise-ledger.json",
+        policy: { dormancy_threshold_chapters: 12 },
+        stats: { total_promises: 0, promised_total: 0, advanced_total: 0, delivered_total: 0, open_total: 0, dormant_total: 0 },
+        dormant_promises: [],
+        issues: [],
+        has_blocking_issues: false
+    });
+    await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const out = (await buildInstructionPacket({
+        rootDir,
+        checkpoint,
+        step: { kind: "chapter", chapter: 1, stage: "draft" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    const inline = out.packet.manifest.inline;
+    assert.equal(inline.engagement_report_summary, undefined);
+    assert.equal(inline.engagement_report_summary_degraded, true);
+    assert.equal(typeof inline.promise_ledger_report_summary, "object");
+    assert.equal(inline.promise_ledger_report_summary_degraded, undefined);
+});
+test("buildInstructionPacket marks promise ledger degraded on schema_version mismatch when latest file exists", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-narrative-health-promise-schema-mismatch-"));
+    await writeJson(join(rootDir, "logs/engagement/latest.json"), {
+        schema_version: 1,
+        generated_at: "2026-03-03T00:00:00.000Z",
+        as_of: { chapter: 10, volume: 1 },
+        scope: { volume: 1, chapter_start: 1, chapter_end: 10 },
+        metrics_stream_path: "engagement-metrics.jsonl",
+        metrics: [],
+        stats: {
+            chapters: 10,
+            avg_word_count: 3000,
+            avg_plot_progression_beats: 2,
+            avg_conflict_intensity: 3,
+            avg_payoff_score: 2,
+            avg_new_info_load_score: 3
+        },
+        issues: [],
+        has_blocking_issues: false
+    });
+    await writeJson(join(rootDir, "logs/promises/latest.json"), {
+        schema_version: 2,
+        generated_at: "2026-03-03T00:00:00.000Z",
+        issues: []
+    });
+    await writeText(join(rootDir, "staging/chapters/chapter-001.md"), `# 第1章\n\n（占位）\n`);
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const out = (await buildInstructionPacket({
+        rootDir,
+        checkpoint,
+        step: { kind: "chapter", chapter: 1, stage: "draft" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    const inline = out.packet.manifest.inline;
+    assert.equal(typeof inline.engagement_report_summary, "object");
+    assert.equal(inline.engagement_report_summary_degraded, undefined);
+    assert.equal(inline.promise_ledger_report_summary, undefined);
+    assert.equal(inline.promise_ledger_report_summary_degraded, true);
+});
+test("buildInstructionPacket marks both degraded when both latest files are invalid", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-narrative-health-both-degraded-"));
+    await writeText(join(rootDir, "logs/engagement/latest.json"), "not-json");
+    await writeText(join(rootDir, "logs/promises/latest.json"), "not-json");
+    await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n（占位）\n");
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const out = (await buildInstructionPacket({
+        rootDir,
+        checkpoint,
+        step: { kind: "chapter", chapter: 1, stage: "draft" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    const inline = out.packet?.manifest?.inline;
+    assert.equal(inline.engagement_report_summary, undefined);
+    assert.equal(inline.engagement_report_summary_degraded, true);
+    assert.equal(inline.promise_ledger_report_summary, undefined);
+    assert.equal(inline.promise_ledger_report_summary_degraded, true);
+});
+test("buildInstructionPacket treats oversized latest.json as degraded", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-narrative-health-oversized-"));
+    // Write a latest.json that exceeds 512KB
+    const oversizedContent = JSON.stringify({
+        schema_version: 1,
+        generated_at: "2026-03-03T00:00:00.000Z",
+        as_of: { chapter: 10, volume: 1 },
+        scope: { volume: 1, chapter_start: 1, chapter_end: 10 },
+        metrics_stream_path: "engagement-metrics.jsonl",
+        metrics: [],
+        stats: { chapters: 10, avg_word_count: 3000, avg_plot_progression_beats: 2, avg_conflict_intensity: 3, avg_payoff_score: 2, avg_new_info_load_score: 3 },
+        issues: [{ id: "pad", severity: "warn", summary: "x".repeat(600000), suggestion: "y" }],
+        has_blocking_issues: false
+    });
+    await writeText(join(rootDir, "logs/engagement/latest.json"), oversizedContent);
+    // Promise latest is valid and small
+    await writeJson(join(rootDir, "logs/promises/latest.json"), {
+        schema_version: 1,
+        generated_at: "2026-03-03T00:00:00.000Z",
+        as_of: { chapter: 10, volume: 1 },
+        scope: { volume: 1, chapter_start: 1, chapter_end: 10 },
+        ledger_path: "promise-ledger.json",
+        policy: { dormancy_threshold_chapters: 12 },
+        stats: { total_promises: 0, promised_total: 0, advanced_total: 0, delivered_total: 0, open_total: 0, dormant_total: 0 },
+        dormant_promises: [],
+        issues: [],
+        has_blocking_issues: false
+    });
+    await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n（占位）\n");
+    const checkpoint = { last_completed_chapter: 10, current_volume: 1 };
+    const out = (await buildInstructionPacket({
+        rootDir,
+        checkpoint,
+        step: { kind: "chapter", chapter: 1, stage: "draft" },
+        embedMode: null,
+        writeManifest: false
+    }));
+    const inline = out.packet?.manifest?.inline;
+    // Engagement should be degraded due to oversized file
+    assert.equal(inline.engagement_report_summary, undefined);
+    assert.equal(inline.engagement_report_summary_degraded, true);
+    // Promise should be fine
+    assert.ok(inline.promise_ledger_report_summary);
+    assert.equal(inline.promise_ledger_report_summary_degraded, undefined);
+});