novel-writer-cli 0.0.1

package/dist/hook-policy.js

@@ -0,0 +1,107 @@
+import { isPlainObject } from "./type-guards.js";
+function asBool(value) {
+    return typeof value === "boolean" ? value : null;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function extractHookStrength(evalObj) {
+    const scoresRaw = evalObj.scores;
+    if (isPlainObject(scoresRaw)) {
+        const hsRaw = scoresRaw.hook_strength;
+        if (isPlainObject(hsRaw)) {
+            const score = asNumber(hsRaw.score);
+            const evidence = asString(hsRaw.evidence);
+            return { strength: score, evidence };
+        }
+    }
+    const legacyStrength = asNumber(evalObj.hook_strength);
+    if (legacyStrength !== null)
+        return { strength: legacyStrength, evidence: null };
+    const hookRaw = evalObj.hook;
+    if (isPlainObject(hookRaw)) {
+        const strength = asNumber(hookRaw.strength);
+        const evidence = asString(hookRaw.evidence);
+        return { strength, evidence };
+    }
+    return { strength: null, evidence: null };
+}
+function extractHook(evalObj) {
+    const hookRaw = evalObj.hook;
+    if (!isPlainObject(hookRaw))
+        return { present: null, type: null, evidence: null };
+    const hookObj = hookRaw;
+    return {
+        present: asBool(hookObj.present),
+        type: asString(hookObj.type),
+        evidence: asString(hookObj.evidence)
+    };
+}
+function strengthInRange(strength) {
+    return strength !== null && strength >= 1 && strength <= 5;
+}
+export function checkHookPolicy(args) {
+    if (!args.hookPolicy.required) {
+        return { status: "skipped", reason: "hook_policy.required=false" };
+    }
+    if (!isPlainObject(args.evalRaw)) {
+        return {
+            status: "invalid_eval",
+            reason: "eval is not a JSON object",
+            extracted: { present: null, type: null, evidence: null, strength: null }
+        };
+    }
+    const root = args.evalRaw;
+    const evalObj = isPlainObject(root.eval_used) ? root.eval_used : root;
+    const { strength, evidence: strengthEvidence } = extractHookStrength(evalObj);
+    const hook = extractHook(evalObj);
+    const hookType = hook.type !== null ? hook.type.toLowerCase() : null;
+    const extracted = { ...hook, type: hookType, strength };
+    if (!strengthInRange(strength)) {
+        return { status: "invalid_eval", reason: "missing or invalid hook_strength (expected 1-5)", extracted };
+    }
+    if (hook.present === null) {
+        return { status: "invalid_eval", reason: "missing hook.present (expected boolean)", extracted };
+    }
+    if (hookType === null) {
+        return { status: "invalid_eval", reason: "missing hook.type (expected non-empty string or 'none')", extracted };
+    }
+    const evidence = hook.evidence ?? strengthEvidence;
+    if (evidence === null) {
+        return { status: "invalid_eval", reason: "missing hook evidence snippet (expected hook.evidence or scores.hook_strength.evidence)", extracted };
+    }
+    const allowed = Array.isArray(args.hookPolicy.allowed_types)
+        ? args.hookPolicy.allowed_types
+            .map((t) => (typeof t === "string" ? t.trim().toLowerCase() : ""))
+            .filter((t) => t.length > 0)
+        : [];
+    const minStrength = typeof args.hookPolicy.min_strength === "number" ? args.hookPolicy.min_strength : 1;
+    if (!hook.present || hookType === "none") {
+        return {
+            status: "fail",
+            reason: "missing chapter-end hook",
+            extracted: { ...extracted, evidence }
+        };
+    }
+    if (allowed.length > 0 && !allowed.includes(hookType)) {
+        return {
+            status: "fail",
+            reason: `hook.type not allowed: ${hookType}`,
+            extracted: { ...extracted, evidence }
+        };
+    }
+    if (strength < minStrength) {
+        return {
+            status: "fail",
+            reason: `hook_strength ${strength} < min_strength ${minStrength}`,
+            extracted: { ...extracted, evidence }
+        };
+    }
+    return { status: "pass", reason: "hook policy satisfied", extracted: { ...extracted, evidence } };
+}

package/dist/instruction-gates.js

@@ -0,0 +1,51 @@
+import { NovelCliError } from "./errors.js";
+import { pathExists, readJsonFile } from "./fs-utils.js";
+import { parseNovelAskAnswerSpec, parseNovelAskQuestionSpec, validateNovelAskAnswerAgainstQuestionSpec } from "./novel-ask.js";
+import { rejectPathTraversalInput, resolveProjectRelativePath } from "./safe-path.js";
+export function extractNovelAskGate(packet) {
+    const hasAsk = packet.novel_ask !== undefined;
+    const hasPath = packet.answer_path !== undefined;
+    if (!hasAsk && !hasPath)
+        return null;
+    if (hasAsk && !hasPath)
+        throw new NovelCliError("Invalid instruction packet: 'answer_path' is required when 'novel_ask' is present.", 2);
+    if (!hasAsk && hasPath)
+        throw new NovelCliError("Invalid instruction packet: 'novel_ask' is required when 'answer_path' is present.", 2);
+    const answer_path = packet.answer_path;
+    if (typeof answer_path !== "string" || answer_path.trim().length === 0) {
+        throw new NovelCliError("Invalid instruction packet: 'answer_path' must be a non-empty string.", 2);
+    }
+    rejectPathTraversalInput(answer_path, "answer_path");
+    const novel_ask = parseNovelAskQuestionSpec(packet.novel_ask);
+    return { novel_ask, answer_path };
+}
+export async function loadNovelAskAnswerIfPresent(rootDir, gate) {
+    const questionSpec = parseNovelAskQuestionSpec(gate.novel_ask);
+    const absAnswer = resolveProjectRelativePath(rootDir, gate.answer_path, "answer_path");
+    if (!(await pathExists(absAnswer)))
+        return null;
+    const raw = await readJsonFile(absAnswer);
+    let answerSpec;
+    try {
+        answerSpec = parseNovelAskAnswerSpec(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new NovelCliError(`Invalid AnswerSpec at ${gate.answer_path}: ${message}`, 2);
+    }
+    try {
+        validateNovelAskAnswerAgainstQuestionSpec(questionSpec, answerSpec);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new NovelCliError(`Invalid AnswerSpec at ${gate.answer_path}: ${message}`, 2);
+    }
+    return answerSpec;
+}
+export async function requireNovelAskAnswer(rootDir, gate) {
+    const answer = await loadNovelAskAnswerIfPresent(rootDir, gate);
+    if (answer === null) {
+        throw new NovelCliError(`Step is blocked by NOVEL_ASK gate: missing AnswerSpec record at ${gate.answer_path}. Complete the gate and write a valid AnswerSpec JSON record to this path.`, 2);
+    }
+    return answer;
+}

package/dist/instructions.js

@@ -0,0 +1,406 @@
+import { join } from "node:path";
+import { NovelCliError } from "./errors.js";
+import { ensureDir, pathExists, readJsonFile, readTextFile, writeJsonFile, writeTextFileIfMissing } from "./fs-utils.js";
+import { loadContinuityLatestSummary } from "./consistency-auditor.js";
+import { loadEngagementLatestSummary } from "./engagement.js";
+import { computeForeshadowVisibilityReport, loadForeshadowGlobalItems } from "./foreshadow-visibility.js";
+import { computeEffectiveScoringWeights, loadGenreWeightProfiles } from "./scoring-weights.js";
+import { parseNovelAskQuestionSpec } from "./novel-ask.js";
+import { loadPlatformProfile } from "./platform-profile.js";
+import { computePrejudgeGuardrailsReport, writePrejudgeGuardrailsReport } from "./prejudge-guardrails.js";
+import { loadPromiseLedgerLatestSummary } from "./promise-ledger.js";
+import { resolveProjectRelativePath } from "./safe-path.js";
+import { computeTitlePolicyReport } from "./title-policy.js";
+import { chapterRelPaths, formatStepId, pad2, titleFixSnapshotRel } from "./steps.js";
+import { isPlainObject } from "./type-guards.js";
+function relIfExists(relPath, exists) {
+    return exists ? relPath : null;
+}
+function safeEmbedMode(mode) {
+    if (!mode)
+        return "off";
+    if (mode === "brief")
+        return "brief";
+    throw new NovelCliError(`Unsupported --embed mode: ${mode}. Supported: brief`, 2);
+}
+export async function buildInstructionPacket(args) {
+    const stepId = formatStepId(args.step);
+    if (args.step.kind !== "chapter")
+        throw new NovelCliError(`Unsupported step: ${stepId}`, 2);
+    const volume = args.checkpoint.current_volume;
+    const volumeOutlineRel = `volumes/vol-${pad2(volume)}/outline.md`;
+    const chapterContractRel = `volumes/vol-${pad2(volume)}/chapter-contracts/chapter-${String(args.step.chapter).padStart(3, "0")}.json`;
+    const rel = chapterRelPaths(args.step.chapter);
+    const commonPaths = {};
+    const maybeAddPath = async (target, key, relPath) => {
+        const absPath = join(args.rootDir, relPath);
+        if (await pathExists(absPath))
+            target[key] = relPath;
+    };
+    await maybeAddPath(commonPaths, "project_brief", "brief.md");
+    await maybeAddPath(commonPaths, "style_profile", "style-profile.json");
+    await maybeAddPath(commonPaths, "platform_profile", "platform-profile.json");
+    await maybeAddPath(commonPaths, "ai_blacklist", "ai-blacklist.json");
+    await maybeAddPath(commonPaths, "web_novel_cliche_lint", "web-novel-cliche-lint.json");
+    await maybeAddPath(commonPaths, "genre_weight_profiles", "genre-weight-profiles.json");
+    await maybeAddPath(commonPaths, "style_guide", "skills/novel-writing/references/style-guide.md");
+    await maybeAddPath(commonPaths, "quality_rubric", "skills/novel-writing/references/quality-rubric.md");
+    await maybeAddPath(commonPaths, "current_state", "state/current-state.json");
+    await maybeAddPath(commonPaths, "world_rules", "world/rules.json");
+    await maybeAddPath(commonPaths, "character_voice_profiles", "character-voice-profiles.json");
+    await maybeAddPath(commonPaths, "character_voice_drift", "character-voice-drift.json");
+    // Optional: volume outline and chapter contract.
+    if (await pathExists(join(args.rootDir, volumeOutlineRel)))
+        commonPaths.volume_outline = volumeOutlineRel;
+    if (await pathExists(join(args.rootDir, chapterContractRel)))
+        commonPaths.chapter_contract = chapterContractRel;
+    const embedMode = safeEmbedMode(args.embedMode);
+    const embed = {};
+    if (embedMode === "brief") {
+        const briefAbs = join(args.rootDir, "brief.md");
+        if (await pathExists(briefAbs)) {
+            const content = await readTextFile(briefAbs);
+            embed.brief_preview = content.slice(0, 2000);
+        }
+        else {
+            embed.brief_preview = null;
+        }
+    }
+    let agent;
+    const inline = { chapter: args.step.chapter, volume };
+    const paths = { ...commonPaths };
+    const expected_outputs = [];
+    const next_actions = [];
+    const maybeAttachCharacterVoiceDirectives = async () => {
+        const driftAbs = join(args.rootDir, "character-voice-drift.json");
+        if (!(await pathExists(driftAbs)))
+            return;
+        try {
+            const raw = await readJsonFile(driftAbs);
+            if (!isPlainObject(raw)) {
+                inline.character_voice_drift_degraded = true;
+                return;
+            }
+            const obj = raw;
+            if (obj.schema_version !== 1)
+                return;
+            const charsRaw = obj.characters;
+            if (!Array.isArray(charsRaw))
+                return;
+            const safeInt = (v) => (typeof v === "number" && Number.isInteger(v) ? v : null);
+            const asOf = isPlainObject(obj.as_of) ? obj.as_of : null;
+            const window = isPlainObject(obj.window) ? obj.window : null;
+            const directives = charsRaw
+                .filter(isPlainObject)
+                .map((it) => {
+                const character_id = typeof it.character_id === "string" && it.character_id.trim().length > 0 ? it.character_id.trim() : null;
+                if (!character_id)
+                    return null;
+                const display_name = typeof it.display_name === "string" && it.display_name.trim().length > 0 ? it.display_name.trim() : character_id;
+                const rawDirectives = it.directives;
+                const lines = Array.isArray(rawDirectives)
+                    ? rawDirectives.filter((d) => typeof d === "string" && d.trim().length > 0).map((d) => d.trim())
+                    : [];
+                if (lines.length === 0)
+                    return null;
+                return { character_id, display_name, directives: lines };
+            })
+                .filter((it) => it !== null);
+            if (directives.length === 0)
+                return;
+            inline.character_voice_drift = {
+                as_of: asOf ? { chapter: safeInt(asOf.chapter), volume: safeInt(asOf.volume) } : null,
+                window: window
+                    ? { chapter_start: safeInt(window.chapter_start), chapter_end: safeInt(window.chapter_end), window_chapters: safeInt(window.window_chapters) }
+                    : null,
+                directives
+            };
+        }
+        catch {
+            inline.character_voice_drift_degraded = true;
+        }
+    };
+    const maybeAttachNarrativeHealthSummaries = async () => {
+        const engagementLatestAbs = join(args.rootDir, "logs/engagement/latest.json");
+        if (await pathExists(engagementLatestAbs)) {
+            const summary = await loadEngagementLatestSummary(args.rootDir);
+            if (summary)
+                inline.engagement_report_summary = summary;
+            else
+                inline.engagement_report_summary_degraded = true;
+        }
+        const promiseLatestAbs = join(args.rootDir, "logs/promises/latest.json");
+        if (await pathExists(promiseLatestAbs)) {
+            const summary = await loadPromiseLedgerLatestSummary(args.rootDir);
+            if (summary)
+                inline.promise_ledger_report_summary = summary;
+            else
+                inline.promise_ledger_report_summary_degraded = true;
+        }
+    };
+    if (args.step.stage === "draft") {
+        agent = { kind: "subagent", name: "chapter-writer" };
+        // Optional: inject character voice drift directives (best-effort).
+        await maybeAttachCharacterVoiceDirectives();
+        // Optional: include narrative health source files (best-effort).
+        await maybeAddPath(paths, "promise_ledger", "promise-ledger.json");
+        await maybeAddPath(paths, "engagement_metrics", "engagement-metrics.jsonl");
+        await maybeAddPath(paths, "engagement_report_latest", "logs/engagement/latest.json");
+        await maybeAddPath(paths, "promise_ledger_report_latest", "logs/promises/latest.json");
+        // Optional: inject compact narrative health summaries (best-effort).
+        try {
+            await maybeAttachNarrativeHealthSummaries();
+        }
+        catch {
+            inline.engagement_report_summary_degraded = true;
+            inline.promise_ledger_report_summary_degraded = true;
+        }
+        // Optional: inject non-spoiler light-touch reminders for dormant foreshadowing items (best-effort).
+        try {
+            const loadedPlatform = await loadPlatformProfile(args.rootDir).catch(() => null);
+            const platform = loadedPlatform?.profile.platform ?? null;
+            const genreDriveType = typeof loadedPlatform?.profile.scoring?.genre_drive_type === "string" ? loadedPlatform.profile.scoring.genre_drive_type : null;
+            const items = await loadForeshadowGlobalItems(args.rootDir);
+            const report = computeForeshadowVisibilityReport({
+                items,
+                asOfChapter: args.step.chapter,
+                volume,
+                platform,
+                genreDriveType
+            });
+            const tasks = report.dormant_items.slice(0, 5).map((it) => ({
+                id: it.id,
+                scope: it.scope,
+                status: it.status,
+                chapters_since_last_update: it.chapters_since_last_update,
+                instruction: it.writing_task
+            }));
+            if (tasks.length > 0)
+                inline.foreshadow_light_touch_tasks = tasks;
+        }
+        catch {
+            inline.foreshadow_light_touch_degraded = true;
+        }
+        expected_outputs.push({ path: rel.staging.chapterMd, required: true });
+        next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+        next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+        next_actions.push({
+            kind: "command",
+            command: `novel instructions chapter:${String(args.step.chapter).padStart(3, "0")}:summarize --json`,
+            note: "After advance, proceed to summarize."
+        });
+    }
+    else if (args.step.stage === "summarize") {
+        agent = { kind: "subagent", name: "summarizer" };
+        paths.chapter_draft = relIfExists(rel.staging.chapterMd, await pathExists(join(args.rootDir, rel.staging.chapterMd)));
+        expected_outputs.push({ path: rel.staging.summaryMd, required: true });
+        expected_outputs.push({ path: rel.staging.deltaJson, required: true });
+        expected_outputs.push({ path: rel.staging.crossrefJson, required: true });
+        expected_outputs.push({ path: "staging/storylines/{storyline_id}/memory.md", required: true, note: "storyline_id comes from delta.json" });
+        next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+        next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+    }
+    else if (args.step.stage === "refine") {
+        agent = { kind: "subagent", name: "style-refiner" };
+        // Optional: inject character voice drift directives (best-effort).
+        await maybeAttachCharacterVoiceDirectives();
+        // Optional: include narrative health source files (best-effort).
+        await maybeAddPath(paths, "promise_ledger", "promise-ledger.json");
+        await maybeAddPath(paths, "engagement_metrics", "engagement-metrics.jsonl");
+        await maybeAddPath(paths, "engagement_report_latest", "logs/engagement/latest.json");
+        await maybeAddPath(paths, "promise_ledger_report_latest", "logs/promises/latest.json");
+        // Optional: inject compact narrative health summaries (best-effort).
+        try {
+            await maybeAttachNarrativeHealthSummaries();
+        }
+        catch {
+            inline.engagement_report_summary_degraded = true;
+            inline.promise_ledger_report_summary_degraded = true;
+        }
+        paths.chapter_draft = relIfExists(rel.staging.chapterMd, await pathExists(join(args.rootDir, rel.staging.chapterMd)));
+        expected_outputs.push({ path: rel.staging.chapterMd, required: true });
+        expected_outputs.push({ path: rel.staging.styleRefinerChangesJson, required: false });
+        next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+        next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+    }
+    else if (args.step.stage === "judge") {
+        agent = { kind: "subagent", name: "quality-judge" };
+        const chapterDraftRel = relIfExists(rel.staging.chapterMd, await pathExists(join(args.rootDir, rel.staging.chapterMd)));
+        paths.chapter_draft = chapterDraftRel;
+        paths.cross_references = relIfExists(rel.staging.crossrefJson, await pathExists(join(args.rootDir, rel.staging.crossrefJson)));
+        const loadedPlatform = await loadPlatformProfile(args.rootDir);
+        if (loadedPlatform?.profile.scoring) {
+            const loadedWeights = await loadGenreWeightProfiles(args.rootDir);
+            if (!loadedWeights) {
+                throw new NovelCliError("Missing required file: genre-weight-profiles.json (required when platform-profile.json.scoring is present). Copy it from templates/genre-weight-profiles.json.", 2);
+            }
+            const effective = computeEffectiveScoringWeights({
+                config: loadedWeights.config,
+                scoring: loadedPlatform.profile.scoring,
+                hookPolicy: loadedPlatform.profile.hook_policy
+            });
+            inline.scoring_weights = {
+                ...effective,
+                source: { platform_profile: loadedPlatform.relPath, genre_weight_profiles: loadedWeights.relPath }
+            };
+        }
+        // Optional: inject compact continuity summary for LS-001 evidence (non-blocking).
+        inline.continuity_report_summary = await loadContinuityLatestSummary(args.rootDir);
+        // Optional: pre-judge guardrails report (title/readability/naming). Non-blocking here; gate engine decides.
+        inline.prejudge_guardrails = null;
+        if (loadedPlatform && chapterDraftRel) {
+            try {
+                const report = await computePrejudgeGuardrailsReport({
+                    rootDir: args.rootDir,
+                    chapter: args.step.chapter,
+                    chapterAbsPath: join(args.rootDir, chapterDraftRel),
+                    platformProfileRelPath: loadedPlatform.relPath,
+                    platformProfile: loadedPlatform.profile
+                });
+                const { relPath } = await writePrejudgeGuardrailsReport({ rootDir: args.rootDir, chapter: args.step.chapter, report });
+                paths.prejudge_guardrails = relPath;
+                inline.prejudge_guardrails = {
+                    status: report.status,
+                    has_blocking_issues: report.has_blocking_issues,
+                    blocking_reasons: report.blocking_reasons,
+                    report_path: relPath
+                };
+            }
+            catch {
+                inline.prejudge_guardrails_degraded = true;
+            }
+        }
+        expected_outputs.push({
+            path: rel.staging.evalJson,
+            required: true,
+            note: "QualityJudge returns JSON; the executor should write it to this path."
+        });
+        next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+        next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+        next_actions.push({
+            kind: "command",
+            command: `novel next`,
+            note: "After advance, compute the next deterministic step (may be title-fix/hook-fix/review/commit)."
+        });
+    }
+    else if (args.step.stage === "title-fix") {
+        agent = { kind: "subagent", name: "chapter-writer" };
+        paths.chapter_draft = relIfExists(rel.staging.chapterMd, await pathExists(join(args.rootDir, rel.staging.chapterMd)));
+        inline.fix_mode = "title-fix";
+        const loadedPlatform = await loadPlatformProfile(args.rootDir);
+        if (!loadedPlatform)
+            throw new NovelCliError("Missing required file: platform-profile.json (required for title-fix).", 2);
+        const titlePolicy = loadedPlatform.profile.retention?.title_policy ?? null;
+        if (!titlePolicy) {
+            throw new NovelCliError("platform-profile.json.retention.title_policy is required for title-fix.", 2);
+        }
+        // Snapshot the chapter before title-fix so validate can ensure body is byte-identical.
+        const beforeAbs = join(args.rootDir, rel.staging.chapterMd);
+        const before = await readTextFile(beforeAbs);
+        const snapshotRel = titleFixSnapshotRel(args.step.chapter);
+        await writeTextFileIfMissing(join(args.rootDir, snapshotRel), before);
+        paths.title_fix_before = snapshotRel;
+        const report = computeTitlePolicyReport({ chapter: args.step.chapter, chapterText: before, platformProfile: loadedPlatform.profile });
+        inline.title_policy = {
+            enabled: titlePolicy.enabled,
+            min_chars: titlePolicy.min_chars,
+            max_chars: titlePolicy.max_chars,
+            forbidden_patterns: titlePolicy.forbidden_patterns,
+            required_patterns: titlePolicy.required_patterns ?? null,
+            auto_fix: titlePolicy.auto_fix
+        };
+        inline.title_policy_report = {
+            status: report.status,
+            issues: report.issues.slice(0, 5)
+        };
+        inline.required_fixes = [
+            {
+                target: "chapter_title",
+                instruction: "执行 title-fix：只修改章节 Markdown 的标题行（第一个非空行必须是 H1：`# ...`）。禁止改动正文任何字符（CLI 会校验 body byte-identical）。标题需满足 platform-profile.json.retention.title_policy 的长度与正则规则，且不得包含 compliance.banned_words。避免剧透，保留悬念与吸引力。"
+            }
+        ];
+        expected_outputs.push({ path: rel.staging.chapterMd, required: true, note: "Overwrite chapter draft with title-only fix (body must remain unchanged)." });
+        next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+        next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+        next_actions.push({
+            kind: "command",
+            command: `novel next`,
+            note: "After title-fix, compute the next deterministic step (typically judge)."
+        });
+    }
+    else if (args.step.stage === "hook-fix") {
+        agent = { kind: "subagent", name: "chapter-writer" };
+        paths.chapter_draft = relIfExists(rel.staging.chapterMd, await pathExists(join(args.rootDir, rel.staging.chapterMd)));
+        paths.chapter_eval = relIfExists(rel.staging.evalJson, await pathExists(join(args.rootDir, rel.staging.evalJson)));
+        inline.fix_mode = "hook-fix";
+        inline.required_fixes = [
+            {
+                target: "chapter_end",
+                instruction: "执行 hook-fix：在不改变前文既定事件/信息的前提下，只改最后 1–2 段（或末尾 ~10%），补强章末钩子（读者面对面悬念/威胁/反转/情绪 cliff/下一目标承诺）。钩子类型需遵守 platform-profile.json.hook_policy.allowed_types，目标 hook_strength >= platform-profile.json.hook_policy.min_strength。禁止新增关键设定/新命名角色/新地点，尽量不影响 state/crossref。",
+            }
+        ];
+        expected_outputs.push({ path: rel.staging.chapterMd, required: true, note: "Overwrite chapter draft with ending-only hook fix." });
+        next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
+        next_actions.push({ kind: "command", command: `novel advance ${stepId}` });
+        next_actions.push({
+            kind: "command",
+            command: `novel instructions chapter:${String(args.step.chapter).padStart(3, "0")}:judge --json`,
+            note: "After hook-fix, re-run QualityJudge to refresh eval."
+        });
+    }
+    else if (args.step.stage === "review") {
+        agent = { kind: "cli", name: "manual-review" };
+        paths.chapter_draft = relIfExists(rel.staging.chapterMd, await pathExists(join(args.rootDir, rel.staging.chapterMd)));
+        paths.chapter_eval = relIfExists(rel.staging.evalJson, await pathExists(join(args.rootDir, rel.staging.evalJson)));
+        expected_outputs.push({ path: "(manual)", required: false, note: "Review required: guardrails still failing after bounded auto-fix." });
+        next_actions.push({
+            kind: "command",
+            command: `novel instructions chapter:${String(args.step.chapter).padStart(3, "0")}:judge --json`,
+            note: "After manually fixing the chapter (title/hook/etc), re-run QualityJudge."
+        });
+    }
+    else if (args.step.stage === "commit") {
+        agent = { kind: "cli", name: "novel" };
+        expected_outputs.push({ path: `chapters/chapter-${String(args.step.chapter).padStart(3, "0")}.md`, required: true });
+        next_actions.push({ kind: "command", command: `novel commit --chapter ${args.step.chapter}` });
+    }
+    else {
+        throw new NovelCliError(`Unsupported step stage: ${args.step.stage}`, 2);
+    }
+    const gate = args.novelAskGate ?? null;
+    const gateSpec = gate ? parseNovelAskQuestionSpec(gate.novel_ask) : null;
+    if (gate) {
+        resolveProjectRelativePath(args.rootDir, gate.answer_path, "novelAskGate.answer_path");
+        expected_outputs.unshift({
+            path: gate.answer_path,
+            required: true,
+            note: "AnswerSpec JSON record for the NOVEL_ASK gate (written before main step execution)."
+        });
+    }
+    const packet = {
+        version: 1,
+        step: stepId,
+        agent,
+        ...(gate ? { novel_ask: gateSpec, answer_path: gate.answer_path } : {}),
+        manifest: {
+            mode: embedMode === "off" ? "paths" : "paths+embed",
+            inline,
+            paths,
+            ...(embedMode === "off" ? {} : { embed })
+        },
+        expected_outputs,
+        next_actions
+    };
+    let writtenPath = null;
+    if (args.writeManifest) {
+        const manifestsDir = join(args.rootDir, "staging/manifests");
+        await ensureDir(manifestsDir);
+        const fileName = `${stepId.replaceAll(":", "-")}.packet.json`;
+        writtenPath = `staging/manifests/${fileName}`;
+        await writeJsonFile(join(args.rootDir, writtenPath), packet);
+    }
+    return {
+        packet,
+        ...(writtenPath ? { written_manifest_path: writtenPath } : {})
+    };
+}

package/dist/latest-summary-loader.js

@@ -0,0 +1,29 @@
+import { realpath, stat } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { pathExists, readJsonFile } from "./fs-utils.js";
+import { assertInsideProjectRoot } from "./safe-path.js";
+export const MAX_LATEST_JSON_BYTES = 512 * 1024;
+export async function loadLatestJsonSummary(args) {
+    const abs = join(args.rootDir, args.relPath);
+    if (!(await pathExists(abs)))
+        return null;
+    try {
+        const rootReal = await realpath(args.rootDir);
+        const absReal = await realpath(abs);
+        // Ensure the resolved path stays under the project root (defense against symlink escapes).
+        assertInsideProjectRoot(rootReal, absReal);
+        // Also guard against pathological cases where realpath changes drive letters/roots.
+        if (relative(rootReal, absReal).startsWith(".."))
+            return null;
+        const st = await stat(absReal);
+        if (!st.isFile())
+            return null;
+        if (st.size > (args.maxBytes ?? MAX_LATEST_JSON_BYTES))
+            return null;
+        const raw = await readJsonFile(absReal);
+        return args.summarize(raw);
+    }
+    catch {
+        return null;
+    }
+}