novel-writer-cli 0.3.0 → 0.5.0

package/dist/instructions.js

@@ -1,13 +1,16 @@
 import { readdir } from "node:fs/promises";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { NovelCliError } from "./errors.js";
 import { ensureDir, pathExists, readJsonFile, readTextFile, writeJsonFile, writeTextFileIfMissing } from "./fs-utils.js";
 import { loadContinuityLatestSummary, tryResolveVolumeChapterRange } from "./consistency-auditor.js";
+import { normalizeExcitementType } from "./excitement-type.js";
 import { loadEngagementLatestSummary } from "./engagement.js";
 import { computeForeshadowVisibilityReport, loadForeshadowGlobalItems } from "./foreshadow-visibility.js";
-import { computeEffectiveScoringWeights, loadGenreWeightProfiles } from "./scoring-weights.js";
+import { loadGoldenChapterGates, selectGoldenChapterGatesForPlatform } from "./golden-chapter-gates.js";
+import { computeEffectiveScoringWeights, isKnownScoringDimension, loadGenreWeightProfiles } from "./scoring-weights.js";
 import { parseNovelAskQuestionSpec } from "./novel-ask.js";
 import { loadPlatformProfile } from "./platform-profile.js";
+import { loadAntiAiGenreOverrides, loadAntiAiJudgeContext, loadAntiAiStatisticalTargets } from "./anti-ai-context.js";
 import { computePrejudgeGuardrailsReport, writePrejudgeGuardrailsReport } from "./prejudge-guardrails.js";
 import { loadPromiseLedgerLatestSummary } from "./promise-ledger.js";
 import { QUICKSTART_STAGING_RELS } from "./quickstart.js";
@@ -16,7 +19,7 @@ import { computeTitlePolicyReport } from "./title-policy.js";
 import { chapterRelPaths, formatStepId, pad2, pad3, titleFixSnapshotRel } from "./steps.js";
 import { isPlainObject } from "./type-guards.js";
 import { VOL_REVIEW_RELS } from "./volume-review.js";
-import { computeVolumeChapterRange, volumeFinalRelPaths, volumeStagingRelPaths } from "./volume-planning.js";
+import { QUICKSTART_MINI_PLANNING_RANGE, resolveVolumeChapterRange, volumeFinalRelPaths, volumeStagingRelPaths } from "./volume-planning.js";
 function relIfExists(relPath, exists) {
     return exists ? relPath : null;
 }
@@ -27,6 +30,391 @@ function safeEmbedMode(mode) {
         return "brief";
     throw new NovelCliError(`Unsupported --embed mode: ${mode}. Supported: brief`, 2);
 }
+async function loadOutlineExcitementType(args) {
+    const outlineRel = `volumes/vol-${pad2(args.volume)}/outline.md`;
+    const outlineAbs = join(args.rootDir, outlineRel);
+    if (!(await pathExists(outlineAbs)))
+        return null;
+    const lines = (await readTextFile(outlineAbs)).split(/\r?\n/u);
+    const headingRe = /^###\s*第\s*(\d+)\s*章/u;
+    const excitementPrefix = "- **ExcitementType**:";
+    let startLine = -1;
+    let endLine = lines.length;
+    for (let i = 0; i < lines.length; i++) {
+        const match = headingRe.exec(lines[i] ?? "");
+        if (!match)
+            continue;
+        const chapter = Number.parseInt(match[1] ?? "", 10);
+        if (chapter !== args.chapter) {
+            if (startLine >= 0) {
+                endLine = i;
+                break;
+            }
+            continue;
+        }
+        startLine = i;
+    }
+    if (startLine < 0)
+        return null;
+    for (const line of lines.slice(startLine, endLine)) {
+        if (line.startsWith(excitementPrefix)) {
+            return normalizeExcitementType(line.slice(excitementPrefix.length));
+        }
+    }
+    return null;
+}
+async function loadChapterExcitementType(args) {
+    const contractRel = `volumes/vol-${pad2(args.volume)}/chapter-contracts/chapter-${pad3(args.chapter)}.json`;
+    const contractAbs = join(args.rootDir, contractRel);
+    if (await pathExists(contractAbs)) {
+        try {
+            const raw = await readJsonFile(contractAbs);
+            if (isPlainObject(raw) && Object.prototype.hasOwnProperty.call(raw, "excitement_type")) {
+                const normalized = normalizeExcitementType(raw.excitement_type);
+                return normalized === undefined ? null : normalized;
+            }
+        }
+        catch {
+            // Fall through to outline-based backward-compatible parsing.
+        }
+    }
+    const outlineExcitementType = await loadOutlineExcitementType(args);
+    return outlineExcitementType === undefined ? null : outlineExcitementType;
+}
+const GENRE_ALIASES = {
+    xuanhuan: "xuanhuan",
+    "玄幻": "xuanhuan",
+    dushi: "dushi",
+    "都市": "dushi",
+    scifi: "scifi",
+    sci_fi: "scifi",
+    "sci-fi": "scifi",
+    "科幻": "scifi",
+    history: "history",
+    "历史": "history",
+    suspense: "suspense",
+    mystery: "suspense",
+    "悬疑": "suspense",
+    romance: "romance",
+    "言情": "romance"
+};
+function normalizeProjectGenre(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return null;
+    const withoutParens = trimmed.replace(/[（(].*$/u, "").trim();
+    if (withoutParens.length === 0)
+        return null;
+    const compact = withoutParens.replace(/\s+/gu, "");
+    return GENRE_ALIASES[withoutParens] ?? GENRE_ALIASES[compact] ?? GENRE_ALIASES[compact.toLowerCase()] ?? null;
+}
+function toNonEmptyStringArray(raw) {
+    if (!Array.isArray(raw) || raw.length === 0)
+        return null;
+    const out = raw.map((item) => (typeof item === "string" ? item.trim() : "")).filter((item) => item.length > 0);
+    return out.length === raw.length ? out : null;
+}
+function toKnownDimensionArray(raw) {
+    const dimensions = toNonEmptyStringArray(raw);
+    if (!dimensions)
+        return null;
+    return dimensions.every((dimension) => isKnownScoringDimension(dimension)) ? dimensions : null;
+}
+function toNumericThresholds(raw) {
+    if (!isPlainObject(raw))
+        return null;
+    const entries = Object.entries(raw).map(([key, value]) => [key.trim(), value]);
+    if (entries.length === 0
+        || entries.length !== Object.keys(raw).length
+        || entries.some(([key, value]) => key.length === 0 || !isKnownScoringDimension(key) || typeof value !== "number" || !Number.isFinite(value))) {
+        return null;
+    }
+    return Object.fromEntries(entries);
+}
+async function loadProjectGenre(rootDir) {
+    const briefAbs = join(rootDir, "brief.md");
+    if (!(await pathExists(briefAbs)))
+        return null;
+    try {
+        const lines = (await readTextFile(briefAbs)).split(/\r?\n/u);
+        for (const line of lines) {
+            const match = /^\s*-\s*\*\*(?:题材|Genre)\*\*[:：]\s*(.+?)\s*$/u.exec(line);
+            if (!match)
+                continue;
+            const normalized = normalizeProjectGenre(match[1] ?? "");
+            if (normalized)
+                return normalized;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+async function loadSelectedGenreExcitementMap(rootDir) {
+    const genre = await loadProjectGenre(rootDir);
+    if (!genre)
+        return null;
+    const relPath = "genre-excitement-map.json";
+    const absPath = join(rootDir, relPath);
+    if (!(await pathExists(absPath)))
+        return null;
+    try {
+        const raw = await readJsonFile(absPath);
+        if (!isPlainObject(raw) || raw.schema_version !== 1 || !isPlainObject(raw.genres))
+            return null;
+        const entry = raw.genres[genre];
+        if (!isPlainObject(entry) || !isPlainObject(entry.chapters))
+            return null;
+        const chapter1 = normalizeExcitementType(entry.chapters["1"]);
+        const chapter2 = normalizeExcitementType(entry.chapters["2"]);
+        const chapter3 = normalizeExcitementType(entry.chapters["3"]);
+        if (!chapter1 || !chapter2 || !chapter3)
+            return null;
+        return {
+            genre,
+            chapters: { "1": chapter1, "2": chapter2, "3": chapter3 },
+            source: relPath
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function loadSelectedGenreGoldenStandards(rootDir) {
+    const genre = await loadProjectGenre(rootDir);
+    if (!genre)
+        return null;
+    const relPath = "genre-golden-standards.json";
+    const absPath = join(rootDir, relPath);
+    if (!(await pathExists(absPath)))
+        return null;
+    try {
+        const raw = await readJsonFile(absPath);
+        if (!isPlainObject(raw) || raw.schema_version !== 1 || !isPlainObject(raw.genres))
+            return null;
+        const entry = raw.genres[genre];
+        if (!isPlainObject(entry))
+            return null;
+        const focusDimensions = toKnownDimensionArray(entry.focus_dimensions);
+        const criteria = toNonEmptyStringArray(entry.criteria);
+        const minimumThresholds = toNumericThresholds(entry.minimum_thresholds);
+        if (!focusDimensions || !criteria || !minimumThresholds)
+            return null;
+        return {
+            genre,
+            focus_dimensions: focusDimensions,
+            criteria,
+            minimum_thresholds: minimumThresholds,
+            source: relPath
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeCanonStatus(raw, sourceLabel) {
+    if (raw == null)
+        return "established";
+    if (typeof raw !== "string") {
+        console.warn(`[canon_status] Invalid non-string canon_status${sourceLabel ? ` in ${sourceLabel}` : ""}; defaulting to "established".`);
+        return "established";
+    }
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === "")
+        return "established";
+    if (normalized === "planned" || normalized === "deprecated" || normalized === "established")
+        return normalized;
+    console.warn(`[canon_status] Invalid canon_status "${raw}"${sourceLabel ? ` in ${sourceLabel}` : ""}; defaulting to "established".`);
+    return "established";
+}
+function asNonEmptyString(raw) {
+    return typeof raw === "string" && raw.trim().length > 0 ? raw.trim() : null;
+}
+function buildPlannedRuleInfo(args) {
+    const plannedRuleInfo = { canon_status: "planned", rule: args.rule };
+    if (args.id)
+        plannedRuleInfo.id = args.id;
+    if (args.category)
+        plannedRuleInfo.category = args.category;
+    if (args.constraintType)
+        plannedRuleInfo.constraint_type = args.constraintType;
+    return plannedRuleInfo;
+}
+async function loadRuleLifecycleContext(rootDir) {
+    const empty = { hardRulesList: [], plannedRulesInfo: [], degraded: false };
+    const rulesAbs = join(rootDir, "world/rules.json");
+    if (!(await pathExists(rulesAbs)))
+        return empty;
+    try {
+        const raw = await readJsonFile(rulesAbs);
+        if (!isPlainObject(raw))
+            return { ...empty, degraded: true };
+        const rules = raw.rules;
+        if (!Array.isArray(rules))
+            return { ...empty, degraded: true };
+        const hardRulesList = [];
+        const plannedRulesInfo = [];
+        for (const item of rules) {
+            if (!isPlainObject(item))
+                continue;
+            const rule = asNonEmptyString(item.rule);
+            if (!rule)
+                continue;
+            const status = normalizeCanonStatus(item.canon_status, `${relative(rootDir, rulesAbs)}${typeof item.id === "string" ? `#${item.id}` : ""}`);
+            const id = asNonEmptyString(item.id);
+            const category = asNonEmptyString(item.category);
+            const constraintType = asNonEmptyString(item.constraint_type);
+            if (status === "planned") {
+                plannedRulesInfo.push(buildPlannedRuleInfo({ id, category, constraintType, rule }));
+                continue;
+            }
+            if (status === "deprecated")
+                continue;
+            if (constraintType !== "hard")
+                continue;
+            hardRulesList.push(id ? `${id}: ${rule}` : rule);
+        }
+        return { hardRulesList, plannedRulesInfo, degraded: false };
+    }
+    catch {
+        return { ...empty, degraded: true };
+    }
+}
+function selectFallbackCharacterCandidates(candidates, options) {
+    const nonDeprecatedCandidates = candidates.filter((candidate) => candidate.canonStatus !== "deprecated");
+    if (!options.includePlannedCharacters) {
+        return nonDeprecatedCandidates.filter((candidate) => candidate.canonStatus !== "planned").slice(0, 15);
+    }
+    if (!options.prioritizePlannedOnFallback)
+        return nonDeprecatedCandidates.slice(0, 15);
+    const plannedCandidates = nonDeprecatedCandidates.filter((candidate) => candidate.canonStatus === "planned");
+    const activeCandidates = nonDeprecatedCandidates.filter((candidate) => candidate.canonStatus !== "planned");
+    // Fallback uses a shared 15-slot budget across active + planned candidates.
+    // Planned entries go first so future-facing foreshadowing survives truncation;
+    // explicit chapter-contract matches bypass this fallback path entirely.
+    return [...plannedCandidates, ...activeCandidates].slice(0, 15);
+}
+async function loadExistingCharacterProfiles(rootDir, candidates) {
+    const pathsOrNull = await Promise.all(candidates.map(async (candidate) => ((await pathExists(join(rootDir, candidate.mdRel))) ? candidate.mdRel : null)));
+    return pathsOrNull.filter((path) => path !== null);
+}
+async function loadCharacterContext(args) {
+    const empty = {
+        activeCharacterContracts: [],
+        activeCharacterProfiles: [],
+        plannedCharacterContracts: [],
+        plannedCharacterProfiles: []
+    };
+    const charsDirRel = "characters/active";
+    const charsDirAbs = join(args.rootDir, charsDirRel);
+    if (!(await pathExists(charsDirAbs)))
+        return empty;
+    const desiredRefs = new Set();
+    const contractAbs = join(args.rootDir, args.chapterContractRel);
+    if (await pathExists(contractAbs)) {
+        try {
+            const raw = await readJsonFile(contractAbs);
+            if (isPlainObject(raw)) {
+                const preconditions = isPlainObject(raw.preconditions) ? raw.preconditions : null;
+                const characterStates = preconditions && isPlainObject(preconditions.character_states) ? preconditions.character_states : null;
+                if (characterStates) {
+                    for (const key of Object.keys(characterStates)) {
+                        const normalized = key.trim().toLowerCase();
+                        if (normalized.length > 0)
+                            desiredRefs.add(normalized);
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore malformed chapter contracts here; validateStep remains the source of truth.
+        }
+    }
+    try {
+        const entries = await readdir(charsDirAbs, { withFileTypes: true });
+        const candidates = [];
+        const hasDesiredRefs = desiredRefs.size > 0;
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith('.json'))
+                continue;
+            const jsonRel = `${charsDirRel}/${entry.name}`;
+            try {
+                const raw = await readJsonFile(join(args.rootDir, jsonRel));
+                if (!isPlainObject(raw))
+                    continue;
+                const id = asNonEmptyString(raw.id) ?? entry.name.replace(/\.json$/u, "");
+                const displayName = asNonEmptyString(raw.display_name) ?? id;
+                const canonStatus = normalizeCanonStatus(raw.canon_status, jsonRel);
+                const matched = hasDesiredRefs && (desiredRefs.has(id.toLowerCase()) || desiredRefs.has(displayName.toLowerCase()));
+                candidates.push({
+                    id,
+                    displayName,
+                    canonStatus,
+                    jsonRel,
+                    mdRel: `${charsDirRel}/${entry.name.replace(/\.json$/u, '.md')}`,
+                    matched
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+        candidates.sort((left, right) => left.jsonRel.localeCompare(right.jsonRel));
+        const preferred = hasDesiredRefs
+            ? candidates.filter((candidate) => candidate.matched &&
+                candidate.canonStatus !== "deprecated" &&
+                (args.options.includePlannedCharacters || candidate.canonStatus !== "planned"))
+            : [];
+        const selectedCandidates = preferred.length > 0 ? preferred : selectFallbackCharacterCandidates(candidates, args.options);
+        const activeCandidates = selectedCandidates.filter((candidate) => candidate.canonStatus !== "planned");
+        const plannedCandidates = args.options.includePlannedCharacters
+            ? selectedCandidates.filter((candidate) => candidate.canonStatus === "planned")
+            : [];
+        const [activeCharacterProfiles, plannedCharacterProfiles] = await Promise.all([
+            loadExistingCharacterProfiles(args.rootDir, activeCandidates),
+            loadExistingCharacterProfiles(args.rootDir, plannedCandidates)
+        ]);
+        return {
+            activeCharacterContracts: activeCandidates.map((candidate) => candidate.jsonRel),
+            activeCharacterProfiles,
+            plannedCharacterContracts: plannedCandidates.map((candidate) => candidate.jsonRel),
+            plannedCharacterProfiles
+        };
+    }
+    catch {
+        return empty;
+    }
+}
+async function attachCanonStatusContext(args) {
+    const ruleLifecycle = await loadRuleLifecycleContext(args.rootDir);
+    args.inline.hard_rules_list = ruleLifecycle.hardRulesList;
+    if (ruleLifecycle.degraded)
+        args.inline.world_rules_context_degraded = true;
+    if (args.options.includePlannedRulesInfo && ruleLifecycle.plannedRulesInfo.length > 0) {
+        args.inline.planned_rules_info = ruleLifecycle.plannedRulesInfo;
+    }
+    const characterContext = await loadCharacterContext({
+        rootDir: args.rootDir,
+        chapterContractRel: args.chapterContractRel,
+        options: {
+            includePlannedCharacters: args.options.includePlannedCharacters,
+            prioritizePlannedOnFallback: args.options.prioritizePlannedCharactersOnFallback
+        }
+    });
+    if (characterContext.activeCharacterContracts.length > 0)
+        args.paths.character_contracts = characterContext.activeCharacterContracts;
+    if (characterContext.activeCharacterProfiles.length > 0)
+        args.paths.character_profiles = characterContext.activeCharacterProfiles;
+    if (args.options.includePlannedCharacters && characterContext.plannedCharacterContracts.length > 0) {
+        args.paths.planned_character_contracts = characterContext.plannedCharacterContracts;
+    }
+    if (args.options.includePlannedCharacters && characterContext.plannedCharacterProfiles.length > 0) {
+        args.paths.planned_character_profiles = characterContext.plannedCharacterProfiles;
+    }
+}
 async function buildReviewInstructionPacket(args) {
     const stepId = formatStepId(args.step);
     if (args.step.kind !== "review")
@@ -206,6 +594,8 @@ async function buildQuickStartInstructionPacket(args) {
         }
     }
     const trialChapter = Math.max(1, args.checkpoint.last_completed_chapter + 1);
+    const miniPlanningStaging = volumeStagingRelPaths(1);
+    const miniPlanningFinal = volumeFinalRelPaths(1);
     const isTrialMode = step.phase === "trial" || step.phase === "results";
     const inline = {
         quickstart_phase: step.phase,
@@ -221,19 +611,33 @@ async function buildQuickStartInstructionPacket(args) {
     };
     await maybeAddPath("project_brief", "brief.md");
     await maybeAddPath("platform_profile", "platform-profile.json");
+    await maybeAddPath("platform_writing_guide", "platform-writing-guide.md");
+    await maybeAddPath("style_guide", "skills/novel-writing/references/style-guide.md");
     await maybeAddPath("style_profile_template", "style-profile.json");
+    await maybeAddPath("storylines", "storylines/storylines.json");
     // Attach staging quickstart artifacts when present (for resume/debug).
     await maybeAddPath("quickstart_rules", QUICKSTART_STAGING_RELS.rulesJson);
     await maybeAddPath("quickstart_contracts_dir", QUICKSTART_STAGING_RELS.contractsDir);
     await maybeAddPath("quickstart_style_profile", QUICKSTART_STAGING_RELS.styleProfileJson);
     await maybeAddPath("quickstart_trial_chapter", QUICKSTART_STAGING_RELS.trialChapterMd);
     await maybeAddPath("quickstart_evaluation", QUICKSTART_STAGING_RELS.evaluationJson);
+    // Attach committed mini-planning artifacts when present.
+    await maybeAddPath("mini_volume_outline", miniPlanningFinal.outlineMd);
+    await maybeAddPath("mini_storyline_schedule", miniPlanningFinal.storylineScheduleJson);
+    await maybeAddPath("mini_volume_foreshadowing", miniPlanningFinal.foreshadowingJson);
+    if (trialChapter <= QUICKSTART_MINI_PLANNING_RANGE.end) {
+        await maybeAddPath("mini_chapter_contract", miniPlanningFinal.chapterContractJson(trialChapter));
+    }
     const asString = (value) => (typeof value === "string" ? value : null);
     const qsRules = asString(paths.quickstart_rules);
     const qsContractsDir = asString(paths.quickstart_contracts_dir);
     const qsStyleProfile = asString(paths.quickstart_style_profile);
     const qsTrialChapter = asString(paths.quickstart_trial_chapter);
     const styleTemplate = asString(paths.style_profile_template);
+    const miniOutline = asString(paths.mini_volume_outline);
+    const miniStorylineSchedule = asString(paths.mini_storyline_schedule);
+    const miniVolumeForeshadowing = asString(paths.mini_volume_foreshadowing);
+    const miniChapterContract = asString(paths.mini_chapter_contract);
     // Provide canonical manifest keys in addition to quickstart-scoped aliases.
     if (qsRules)
         paths.world_rules = qsRules;
@@ -245,6 +649,14 @@ async function buildQuickStartInstructionPacket(args) {
         paths.style_profile = styleTemplate;
     if (qsTrialChapter)
         paths.chapter_draft = qsTrialChapter;
+    if (miniOutline)
+        paths.volume_outline = miniOutline;
+    if (miniStorylineSchedule)
+        paths.storyline_schedule = miniStorylineSchedule;
+    if (miniVolumeForeshadowing)
+        paths.volume_foreshadowing = miniVolumeForeshadowing;
+    if (miniChapterContract)
+        paths.chapter_contract = miniChapterContract;
     let agent;
     const expected_outputs = [];
     const next_actions = [];
@@ -279,7 +691,27 @@ async function buildQuickStartInstructionPacket(args) {
         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: "Compute next deterministic step (skips already-generated artifacts)." });
-        next_actions.push({ kind: "command", command: `novel instructions quickstart:trial --json`, note: "After advance, proceed to trial chapter." });
+        next_actions.push({ kind: "command", command: `novel instructions quickstart:f0 --json`, note: "After advance, generate the opening mini-plan for chapters 1-3." });
+    }
+    else if (step.phase === "f0") {
+        agent = { kind: "subagent", name: "plot-architect" };
+        inline.quickstart_mini_planning = true;
+        inline.volume_plan = { volume: 1, chapter_range: [QUICKSTART_MINI_PLANNING_RANGE.start, QUICKSTART_MINI_PLANNING_RANGE.end] };
+        inline.expected_outputs_base_dir = miniPlanningStaging.dir;
+        const selectedGenreExcitementMap = await loadSelectedGenreExcitementMap(args.rootDir);
+        if (selectedGenreExcitementMap)
+            inline.genre_excitement_map = selectedGenreExcitementMap;
+        expected_outputs.push({ path: miniPlanningStaging.outlineMd, required: true });
+        expected_outputs.push({ path: miniPlanningStaging.storylineScheduleJson, required: true });
+        expected_outputs.push({ path: miniPlanningStaging.foreshadowingJson, required: true });
+        expected_outputs.push({ path: miniPlanningStaging.newCharactersJson, required: true });
+        for (let ch = QUICKSTART_MINI_PLANNING_RANGE.start; ch <= QUICKSTART_MINI_PLANNING_RANGE.end; ch++) {
+            expected_outputs.push({ path: miniPlanningStaging.chapterContractJson(ch), 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 next`, note: "Compute next deterministic step (skips already-generated artifacts)." });
+        next_actions.push({ kind: "command", command: `novel instructions quickstart:trial --json`, note: "After mini-plan commit, proceed to trial chapter writing." });
     }
     else if (step.phase === "trial") {
         agent = { kind: "subagent", name: "chapter-writer" };
@@ -291,6 +723,43 @@ async function buildQuickStartInstructionPacket(args) {
     }
     else if (step.phase === "results") {
         agent = { kind: "subagent", name: "quality-judge" };
+        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);
+            }
+            inline.scoring_weights = {
+                ...computeEffectiveScoringWeights({
+                    config: loadedWeights.config,
+                    scoring: loadedPlatform.profile.scoring,
+                    hookPolicy: loadedPlatform.profile.hook_policy,
+                    platformId: loadedPlatform.profile.platform
+                }),
+                source: { platform_profile: loadedPlatform.relPath, genre_weight_profiles: loadedWeights.relPath }
+            };
+        }
+        if (loadedPlatform && trialChapter <= 3) {
+            const loadedGoldenGates = await loadGoldenChapterGates(args.rootDir);
+            if (loadedGoldenGates) {
+                const selectedGoldenGates = selectGoldenChapterGatesForPlatform({
+                    config: loadedGoldenGates.config,
+                    platformId: loadedPlatform.profile.platform,
+                    chapter: trialChapter
+                });
+                if (selectedGoldenGates) {
+                    inline.golden_chapter_gates = {
+                        ...selectedGoldenGates,
+                        source: loadedGoldenGates.relPath
+                    };
+                }
+            }
+        }
+        if (trialChapter <= 3) {
+            const selectedGenreGoldenStandards = await loadSelectedGenreGoldenStandards(args.rootDir);
+            if (selectedGenreGoldenStandards)
+                inline.genre_golden_standards = selectedGenreGoldenStandards;
+        }
         expected_outputs.push({
             path: QUICKSTART_STAGING_RELS.evaluationJson,
             required: true,
@@ -354,7 +823,7 @@ export async function buildInstructionPacket(args) {
     if (args.step.kind === "volume") {
         const step = args.step;
         const volume = args.checkpoint.current_volume;
-        const range = computeVolumeChapterRange({ current_volume: volume, last_completed_chapter: args.checkpoint.last_completed_chapter });
+        const range = await resolveVolumeChapterRange({ rootDir: args.rootDir, current_volume: volume, last_completed_chapter: args.checkpoint.last_completed_chapter });
         const embedMode = safeEmbedMode(args.embedMode);
         const embed = {};
         if (embedMode === "brief") {
@@ -402,6 +871,13 @@ export async function buildInstructionPacket(args) {
         const next_actions = [];
         const staging = volumeStagingRelPaths(volume);
         const final = volumeFinalRelPaths(volume);
+        if (range.start > 1) {
+            await maybeAddPath("existing_volume_outline", final.outlineMd);
+            await maybeAddPath("existing_storyline_schedule", final.storylineScheduleJson);
+            await maybeAddPath("existing_foreshadowing", final.foreshadowingJson);
+            await maybeAddPath("existing_chapter_contracts_dir", final.chapterContractsDir);
+            inline.volume_plan_seed_range = [1, range.start - 1];
+        }
         const addPlanningOutputs = (base) => {
             expected_outputs.push({ path: base.outlineMd, required: true });
             expected_outputs.push({ path: base.storylineScheduleJson, required: true });
@@ -413,6 +889,11 @@ export async function buildInstructionPacket(args) {
         };
         if (step.phase === "outline") {
             agent = { kind: "subagent", name: "plot-architect" };
+            if (range.start <= 3) {
+                const selectedGenreExcitementMap = await loadSelectedGenreExcitementMap(args.rootDir);
+                if (selectedGenreExcitementMap)
+                    inline.genre_excitement_map = selectedGenreExcitementMap;
+            }
             inline.expected_outputs_base_dir = staging.dir;
             addPlanningOutputs(staging);
             next_actions.push({ kind: "command", command: `novel validate ${stepId}` });
@@ -498,6 +979,7 @@ export async function buildInstructionPacket(args) {
     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, "platform_writing_guide", "platform-writing-guide.md");
     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");
@@ -613,6 +1095,23 @@ export async function buildInstructionPacket(args) {
             inline.engagement_report_summary_degraded = true;
             inline.promise_ledger_report_summary_degraded = true;
         }
+        await attachCanonStatusContext({
+            rootDir: args.rootDir,
+            chapterContractRel,
+            inline,
+            paths,
+            options: {
+                includePlannedRulesInfo: true,
+                includePlannedCharacters: true,
+                prioritizePlannedCharactersOnFallback: true
+            }
+        });
+        const statisticalTargets = await loadAntiAiStatisticalTargets(args.rootDir);
+        if (statisticalTargets)
+            inline.statistical_targets = statisticalTargets;
+        const genreOverrides = await loadAntiAiGenreOverrides(args.rootDir);
+        if (genreOverrides)
+            inline.genre_overrides = genreOverrides;
         // Optional: inject non-spoiler light-touch reminders for dormant foreshadowing items (best-effort).
         try {
             const loadedPlatform = await loadPlatformProfile(args.rootDir).catch(() => null);
@@ -686,6 +1185,30 @@ export async function buildInstructionPacket(args) {
         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)));
+        if (chapterDraftRel) {
+            const antiAiContext = await loadAntiAiJudgeContext({ rootDir: args.rootDir, chapterRel: chapterDraftRel });
+            if (antiAiContext.blacklistLint)
+                inline.blacklist_lint = antiAiContext.blacklistLint;
+            else if (antiAiContext.degraded.blacklist_lint)
+                inline.blacklist_lint_degraded = true;
+            if (antiAiContext.statisticalProfile)
+                inline.statistical_profile = antiAiContext.statisticalProfile;
+            if (antiAiContext.structuralRuleViolations)
+                inline.structural_rule_violations = antiAiContext.structuralRuleViolations;
+            else if (antiAiContext.degraded.structural_rule_violations)
+                inline.structural_rule_violations_degraded = true;
+        }
+        await attachCanonStatusContext({
+            rootDir: args.rootDir,
+            chapterContractRel,
+            inline,
+            paths,
+            options: {
+                includePlannedRulesInfo: false,
+                includePlannedCharacters: false,
+                prioritizePlannedCharactersOnFallback: false
+            }
+        });
         const loadedPlatform = await loadPlatformProfile(args.rootDir);
         if (loadedPlatform?.profile.scoring) {
             const loadedWeights = await loadGenreWeightProfiles(args.rootDir);
@@ -695,15 +1218,38 @@ export async function buildInstructionPacket(args) {
             const effective = computeEffectiveScoringWeights({
                 config: loadedWeights.config,
                 scoring: loadedPlatform.profile.scoring,
-                hookPolicy: loadedPlatform.profile.hook_policy
+                hookPolicy: loadedPlatform.profile.hook_policy,
+                platformId: loadedPlatform.profile.platform
             });
             inline.scoring_weights = {
                 ...effective,
                 source: { platform_profile: loadedPlatform.relPath, genre_weight_profiles: loadedWeights.relPath }
             };
         }
+        if (loadedPlatform && step.chapter <= 3) {
+            const loadedGoldenGates = await loadGoldenChapterGates(args.rootDir);
+            if (loadedGoldenGates) {
+                const selectedGoldenGates = selectGoldenChapterGatesForPlatform({
+                    config: loadedGoldenGates.config,
+                    platformId: loadedPlatform.profile.platform,
+                    chapter: step.chapter
+                });
+                if (selectedGoldenGates) {
+                    inline.golden_chapter_gates = {
+                        ...selectedGoldenGates,
+                        source: loadedGoldenGates.relPath
+                    };
+                }
+            }
+        }
+        if (step.chapter <= 3) {
+            const selectedGenreGoldenStandards = await loadSelectedGenreGoldenStandards(args.rootDir);
+            if (selectedGenreGoldenStandards)
+                inline.genre_golden_standards = selectedGenreGoldenStandards;
+        }
         // Optional: inject compact continuity summary for LS-001 evidence (non-blocking).
         inline.continuity_report_summary = await loadContinuityLatestSummary(args.rootDir);
+        inline.excitement_type = await loadChapterExcitementType({ rootDir: args.rootDir, volume, chapter: step.chapter });
         // Optional: pre-judge guardrails report (title/readability/naming). Non-blocking here; gate engine decides.
         inline.prejudge_guardrails = null;
         if (loadedPlatform && chapterDraftRel) {