dsh-novel-write-engine 0.1.2 → 0.1.3

package/lib/index.js

@@ -54,7 +54,13 @@ const LIMITS = {
 	/** How long a writer waits for the keyed mutex before failing. */
 	lockWaitMs: 1e4,
 	/** Reading proofs shorter than this cannot be verified. */
-	minQuoteChars: 12
+	minQuoteChars: 12,
+	/** World-plan text fields are protected context, so they need a hard bound. */
+	maxWorldPlanItems: 64,
+	maxWorldPlanTextChars: 4e3,
+	maxWorldPlanObjectiveChars: 2e3,
+	/** Cast plus summary may exceed eight, but not without a bound. */
+	maxActiveCast: 12
 };
 /** The order used to render the nine-phase progress strip. */
 const PHASE_STRIP = [
@@ -455,6 +461,16 @@ function dialogueCharacterRatio(paragraph) {
 	for (const match of paragraph.matchAll(/["“]([^"“”]*)["”]/g)) quoted += Array.from(match[1]).length;
 	return quoted / total;
 }
+/**
+* The opening quote rule is shared by PG-05 (draft/revise) and the P5 fast
+* check. Keeping one implementation prevents the two paths from disagreeing
+* about what counts as the first two paragraphs.
+*/
+function openingInFirstTwoParagraphs(text, opening) {
+	const needle = opening.trim();
+	if (needle === "") return false;
+	return splitParagraphs(text).slice(0, 2).some((paragraph) => paragraph.includes(needle));
+}
 // src/domain/simhash.ts
 const MASK64 = (1n << 64n) - 1n;
 /** FNV-1a over UTF-16 code units; deterministic across platforms and Node versions. */
@@ -529,105 +545,47 @@ const TRANSITIONS = [
 	{
 		from: "idle",
 		op: "submitWorldPlan",
-		to: () => "P2",
-		guards: ["PG-01", "PG-02"]
+		to: () => "P2"
 	},
 	{
 		from: "done",
 		op: "submitWorldPlan",
-		to: () => "P2",
-		guards: ["PG-01", "PG-02"]
+		to: () => "P2"
 	},
 	{
 		from: "P2",
 		op: "submitChapterPlan",
-		to: () => "P3",
-		guards: ["PG-01", "PG-02"]
+		to: () => "P3"
 	},
 	{
 		from: "P3",
 		op: "submitDraft",
-		to: () => "P4",
-		guards: [
-			"PG-01",
-			"PG-02",
-			"PG-03",
-			"PG-04",
-			"PG-05",
-			"PG-06"
-		]
+		to: () => "P4"
 	},
 	{
 		from: "P4",
 		op: "submitReview",
-		to: (context) => context.openBlockers > 0 ? "P5" : "P6",
-		guards: [
-			"PG-01",
-			"PG-02",
-			"PG-07",
-			"PG-09",
-			"PG-11"
-		]
+		to: (context) => context.openBlockers > 0 ? "P5" : "P6"
 	},
 	{
 		from: "P5",
 		op: "submitRevision",
-		to: () => "P4",
-		guards: [
-			"PG-01",
-			"PG-02",
-			"PG-03",
-			"PG-04",
-			"PG-05",
-			"PG-08",
-			"PG-09"
-		]
+		to: () => "P4"
 	},
 	{
 		from: "P6",
 		op: "submitRevision",
-		to: () => "P4",
-		guards: [
-			"PG-01",
-			"PG-02",
-			"PG-03",
-			"PG-04",
-			"PG-05",
-			"PG-08",
-			"PG-09"
-		]
+		to: () => "P4"
 	},
 	{
 		from: "P6",
 		op: "runCheck",
-		to: () => "ready_to_archive",
-		guards: [
-			"PG-01",
-			"PG-02",
-			"PG-04",
-			"PG-05",
-			"PG-08",
-			"PG-09",
-			"PG-10",
-			"PG-11"
-		]
+		to: (context) => context.completeCheck === false ? "P6" : "ready_to_archive"
 	},
 	{
 		from: "ready_to_archive",
 		op: "archiveChapter",
-		to: () => "done",
-		guards: [
-			"PG-01",
-			"PG-02",
-			"PG-03",
-			"PG-04",
-			"PG-05",
-			"PG-06",
-			"PG-07",
-			"PG-08",
-			"PG-10",
-			"PG-12"
-		]
+		to: () => "done"
 	}
 ];
 /** Find the row for this (stage, op), if any. */
@@ -639,10 +597,13 @@ function canRun(stage, op) {
 	return findTransition(stage, op) !== void 0;
 }
 /** Compute the next stage, or throw `ENGINE_STAGE_ORDER` with an actionable message. */
-function nextStage(stage, op, openBlockers) {
+function nextStage(stage, op, openBlockers, context = {}) {
 	const transition = findTransition(stage, op);
 	if (transition === void 0) throw new EngineInputError(ERROR_CODES.STAGE_ORDER, `operation ${op} is not allowed at stage ${stage}`, `allowed here: ${availableOps(stage).join(", ")}; call novel_status for the full picture`);
-	return transition.to({ openBlockers });
+	return transition.to({
+		openBlockers,
+		...context
+	});
 }
 /** Operations legal at a stage, in table order. */
 function availableOps(stage) {
@@ -732,6 +693,24 @@ function countWordMetrics(text) {
 function countWordMetricsOfParagraph(paragraph) {
 	return matchCount(paragraph, CJK) + matchCount(paragraph, ENGLISH_WORD) + matchCount(paragraph, NUMBER) + matchCount(paragraph, CHINESE_PUNCT) + matchCount(paragraph, ENGLISH_PUNCT);
 }
+// src/domain/stable.ts
+/**
+* Locale-independent ordering and hashing primitives.
+*
+* A digest must not depend on the process locale. `localeCompare` can reorder
+* CJK keys differently under different ICU collations, so every persisted sort
+* and every digest uses UTF-16 code-unit order instead.
+*/
+const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const normalize$1 = (input) => {
+	if (Array.isArray(input)) return input.map(normalize$1);
+	if (input instanceof Date) return input;
+	if (typeof input === "object" && input !== null && typeof input.toJSON === "function") return input;
+	if (typeof input === "object" && input !== null) return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0).sort(([left], [right]) => compareText(left, right)).map(([key, value]) => [key, normalize$1(value)]));
+	return input;
+};
+/** Deterministic JSON used by every replay key and digest. */
+const stableJson = (value) => JSON.stringify(normalize$1(value)) ?? "null";
 // src/codes.ts
 /** Stable rule codes. One owner per code: the rules registry refuses duplicates. */
 const FORMAT_RULES = {
@@ -2120,16 +2099,25 @@ async function recoverPending(store) {
 	}
 	throw new EngineFaultError(ERROR_CODES.TXN_ABORTED, `pending transaction ${last.txid} partially changed the project; automatic recovery is unsafe`, `restore from backups/ or ${STAGING_DIR}/${last.txid}/before/ before retrying`);
 }
-/** Throw before a write when the journal or the last commit is inconsistent. */
-async function assertJournalConsistent(store) {
+/**
+* Throw before a write when the journal or the last commit is inconsistent.
+*
+* `repairPaths` is used only by an explicit amend: a damaged ledger is by
+* definition a file whose bytes no longer match the last committed hash, and
+* refusing every write would make the documented repair path unreachable. All
+* other mismatches still fail closed.
+*/
+async function assertJournalConsistent(store, repairPaths = []) {
 	await recoverPending(store);
 	const { records } = await readJournal(store);
 	const committed = new Set(records.filter((record) => record.status === "committed" && record.op !== "lock_reclaimed").map((record) => record.txid));
 	for (const entry of await store.list(STAGING_DIR)) if (committed.has(entry)) await store.removeTree(joinRel(STAGING_DIR, entry)).catch(() => void 0);
 	const { malformed, mismatches } = await reconcileJournal(store);
 	assertJournalHealthy(malformed);
-	if (mismatches.length > 0) {
-		const first = mismatches[0];
+	const allowed = new Set(repairPaths);
+	const fatal = mismatches.filter((mismatch) => !allowed.has(mismatch.path));
+	if (fatal.length > 0) {
+		const first = fatal[0];
 		throw new EngineFaultError(ERROR_CODES.TXN_ABORTED, `journal hash mismatch for ${first.path} (txid ${first.txid}); expected ${first.expected}, found ${first.actual ?? "missing"}`, "restore the file from backups/ or fix the external change before retrying");
 	}
 }
@@ -2493,7 +2481,7 @@ var ProjectRegistry = class {
 		rows.push(row);
 		const next = {
 			...document,
-			projects: rows.sort((a, b) => a.root.localeCompare(b.root))
+			projects: rows.sort((a, b) => compareText(a.root, b.root))
 		};
 		await this.write(next);
 		return next;
@@ -2567,18 +2555,20 @@ const escapeHtml = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").r
 function chapterHeading(chapter) {
 	return `第${chapter.num}章 ${chapter.title}`;
 }
+/** Remove blank lines at the document edges, never manuscript indentation. */
+const trimBlankEdges = (text) => text.replace(/^\n+|\n+$/g, "");
 /** Markdown export: one heading per chapter, body unchanged (it is plain text). */
 function renderMarkdown(project, chapters) {
 	const parts = [`# ${project.title}`, ""];
 	if (project.author !== "") parts.push(`作者：${project.author}`, "");
 	if (project.description !== "") parts.push(`> ${project.description}`, "");
-	for (const chapter of chapters) parts.push(`## ${chapterHeading(chapter)}`, "", chapter.text.trim(), "");
+	for (const chapter of chapters) parts.push(`## ${chapterHeading(chapter)}`, "", trimBlankEdges(chapter.text), "");
 	return parts.join("\n");
 }
 /** Plain-text export: no markdown syntax, no BOM. */
 function renderPlainText(project, chapters) {
 	const parts = [project.title, ""];
-	for (const chapter of chapters) parts.push(chapterHeading(chapter), "", chapter.text.trim(), "");
+	for (const chapter of chapters) parts.push(chapterHeading(chapter), "", trimBlankEdges(chapter.text), "");
 	return parts.join("\n");
 }
 /** Blurb built from the project record; deterministic, no model call. */
@@ -2607,9 +2597,10 @@ function renderCover(project) {
 }
 /** XHTML chapter document for the EPUB package. */
 function renderEpubChapter(chapter) {
-	const paragraphs = chapter.text.split(/\n+/).map((line) => line.trim()).filter((line) => line !== "").map((line) => `<p>${escapeHtml(line)}</p>`).join("\n");
+	const paragraphs = chapter.text.split(/\n+/).map((line) => line.replace(/\r$/, "")).filter((line) => line.trim() !== "").map((line) => `<p class="body">${escapeHtml(line)}</p>`).join("\n");
 	return `<?xml version="1.0" encoding="utf-8"?>
-<html xmlns="http://www.w3.org/1999/xhtml"><head><title>${escapeHtml(chapterHeading(chapter))}</title></head>
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>${escapeHtml(chapterHeading(chapter))}</title>
+<style>.body { white-space: pre-wrap; margin: 0 0 0.6em; }</style></head>
 <body><h1>${escapeHtml(chapterHeading(chapter))}</h1>${paragraphs}</body></html>`;
 }
 // src/export/epub.ts
@@ -2843,6 +2834,162 @@ var BriefLibrary = class {
 	}
 };
 const hash = (text) => `sha256:${createHash("sha256").update(text, "utf8").digest("hex")}`;
+// src/engine/handoff.ts
+const ACT_DIGITS = [
+	"零",
+	"一",
+	"二",
+	"三",
+	"四",
+	"五",
+	"六",
+	"七",
+	"八",
+	"九"
+];
+/** Chinese numerals for the act labels the task books use. */
+const chineseNumber = (value) => {
+	if (!Number.isInteger(value) || value < 0) return String(value);
+	if (value < 10) return ACT_DIGITS[value];
+	if (value === 10) return "十";
+	if (value < 20) return `十${ACT_DIGITS[value - 10]}`;
+	if (value < 100) {
+		const tens = Math.floor(value / 10);
+		const ones = value % 10;
+		return `${ACT_DIGITS[tens]}十${ones === 0 ? "" : ACT_DIGITS[ones]}`;
+	}
+	return String(value);
+};
+const parseActNumber = (act) => {
+	const match = /^第\s*([零一二三四五六七八九十百\d]+)\s*幕$/.exec(act.trim());
+	if (match === null) return null;
+	const raw = match[1];
+	if (/^\d+$/.test(raw)) return Number(raw);
+	if (raw === "十") return 10;
+	const ten = raw.indexOf("十");
+	if (ten !== -1) {
+		const left = raw.slice(0, ten);
+		const right = raw.slice(ten + 1);
+		const tens = left === "" ? 1 : ACT_DIGITS.indexOf(left);
+		const ones = right === "" ? 0 : ACT_DIGITS.indexOf(right);
+		if (tens < 0 || ones < 0) return null;
+		return tens * 10 + ones;
+	}
+	const index = ACT_DIGITS.indexOf(raw);
+	return index < 0 ? null : index;
+};
+const nextAct = (act) => {
+	const value = parseActNumber(act);
+	return value === null ? act : `第${chineseNumber(value + 1)}幕`;
+};
+/** `n/d`, with a non-zero denominator; `0/0` is the initialized handoff. */
+const parseActProgress = (value) => {
+	if (typeof value !== "string") return null;
+	const match = /^(\d+)\/(\d+)$/.exec(value.trim());
+	if (match === null) return null;
+	const done = Number(match[1]);
+	const total = Number(match[2]);
+	if (!Number.isSafeInteger(done) || !Number.isSafeInteger(total)) return null;
+	if (done < 0 || total < 0 || done > total) return null;
+	return {
+		done,
+		total
+	};
+};
+const firstPosition = (chapter) => {
+	const block = Math.max(0, chapter - 1);
+	return {
+		volume: 1,
+		volume_name: "第一卷",
+		act: `第${chineseNumber(Math.floor(block / 5) + 1)}幕`,
+		act_progress: `${block % 5 + 1}/5`
+	};
+};
+const advanceProgress = (previous) => {
+	const act = typeof previous.act === "string" && previous.act.trim() !== "" ? previous.act : "第一幕";
+	const progress = parseActProgress(previous.act_progress);
+	if (progress === null || progress.total === 0) return {
+		act,
+		act_progress: "1/5"
+	};
+	if (progress.done < progress.total) return {
+		act,
+		act_progress: `${progress.done + 1}/${progress.total}`
+	};
+	return {
+		act: nextAct(act),
+		act_progress: `1/${progress.total}`
+	};
+};
+const volumeOf = (previous) => previous !== null && Number.isInteger(previous.volume) && previous.volume >= 1 ? previous.volume : 1;
+const volumeNameOf = (previous, volume) => previous !== null && typeof previous.volume_name === "string" && previous.volume_name.trim() !== "" ? previous.volume_name : `第${volume}卷`;
+/**
+* Advance from the stored handoff of the previous chapter to the next chapter.
+* The archive override is applied as a starting point: changing volume resets
+* the act, while changing only the act starts its first beat.
+*/
+const advanceHandoff = (previous, chapter, override) => {
+	if (previous === null) {
+		const position = firstPosition(chapter);
+		const volume = override?.volume ?? position.volume;
+		return {
+			volume,
+			volume_name: override?.volume_name ?? (volume === position.volume ? position.volume_name : `第${volume}卷`),
+			act: override?.act ?? position.act,
+			act_progress: override?.act_progress ?? (volume === position.volume ? position.act_progress : "1/5")
+		};
+	}
+	const previousVolume = volumeOf(previous);
+	const volume = override?.volume ?? previousVolume;
+	const volumeChanged = volume !== previousVolume;
+	const base = volumeChanged ? {
+		act: "第一幕",
+		act_progress: "1/5"
+	} : advanceProgress(previous);
+	const act = override?.act ?? base.act;
+	const actProgress = override?.act_progress ?? (override?.act !== void 0 && override.act !== previous.act ? "1/5" : base.act_progress);
+	return {
+		volume,
+		volume_name: override?.volume_name ?? (volumeChanged ? `第${volume}卷` : volumeNameOf(previous, volume)),
+		act,
+		act_progress: actProgress
+	};
+};
+/** Project the stored handoff to the active chapter without changing the file. */
+const projectHandoff = (previous, chapter) => {
+	if (previous === null) return firstPosition(chapter);
+	const current = Number.isInteger(previous.current_chapter) ? previous.current_chapter : chapter - 1;
+	if (current >= chapter) {
+		const volume = volumeOf(previous);
+		return {
+			volume,
+			volume_name: volumeNameOf(previous, volume),
+			act: previous.act,
+			act_progress: previous.act_progress
+		};
+	}
+	let position = {
+		volume: volumeOf(previous),
+		volume_name: volumeNameOf(previous, volumeOf(previous)),
+		act: previous.act,
+		act_progress: previous.act_progress
+	};
+	for (let step = current; step < chapter; step += 1) {
+		const fake = {
+			...previous,
+			volume: position.volume,
+			volume_name: position.volume_name,
+			act: position.act,
+			act_progress: position.act_progress
+		};
+		position = {
+			volume: position.volume,
+			volume_name: position.volume_name,
+			...advanceProgress(fake)
+		};
+	}
+	return position;
+};
 // src/engine/context.ts
 const compactSummary = (row) => ({
 	num: row.num,
@@ -2860,6 +3007,93 @@ const sceneDistribution = (chapters) => {
 	return counts;
 };
 const pendingForeshadows = (ledger) => ledger.items.filter((item) => item.status !== "resolved");
+const unique = (values) => {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const value of values) {
+		if (value === "" || seen.has(value)) continue;
+		seen.add(value);
+		result.push(value);
+	}
+	return result;
+};
+/** Match known names at occurrence level, longest first, without substring theft. */
+const mentionedNames = (text, characters) => {
+	let remaining = text;
+	const names = [...new Set(characters.characters.map((character) => character.name))].filter((name) => name !== "").sort((left, right) => {
+		const length = Array.from(right).length - Array.from(left).length;
+		return length !== 0 ? length : compareText(left, right);
+	});
+	const matched = [];
+	for (const name of names) {
+		if (!remaining.includes(name)) continue;
+		matched.push(name);
+		remaining = remaining.split(name).join("\0");
+	}
+	return matched;
+};
+/** The names the current chapter is actually about. */
+const activeCastNames = (plan, characters, text, appearances) => {
+	const explicit = unique([...(plan?.cast ?? []).map((member) => member.name), ...plan?.summary?.characters_appeared ?? []]);
+	const narrator = (plan?.narrator ?? "").split(/[（(]/, 1)[0].trim();
+	const narratorKnown = narrator !== "" && characters.characters.some((character) => character.name === narrator);
+	const planText = [
+		plan?.title ?? "",
+		plan?.narrator ?? "",
+		plan?.opening ?? "",
+		plan?.ending ?? "",
+		...plan?.beats ?? [],
+		text ?? ""
+	].join("\n");
+	const byName = new Map(characters.characters.map((character) => [character.name, character]));
+	const orderedMentioned = mentionedNames(planText, characters).map((name) => byName.get(name)).sort((left, right) => {
+		const byRecency = recencyOf(right, appearances) - recencyOf(left, appearances);
+		return byRecency !== 0 ? byRecency : compareText(left.name, right.name);
+	}).map((character) => character.name);
+	if (explicit.length > 0) return unique([...explicit, ...orderedMentioned]).slice(0, LIMITS.maxActiveCast);
+	return unique([...narratorKnown ? [narrator] : [], ...orderedMentioned]).slice(0, 8);
+};
+const recencyOf = (character, appearances) => Math.max(Number(character.updated_at ?? 0), appearances.get(character.name) ?? 0);
+const appearancesByChapter = (chapters) => {
+	const result = /* @__PURE__ */ new Map();
+	for (const row of chapters.chapters) for (const name of row.summary.characters_appeared) result.set(name, Math.max(result.get(name) ?? 0, row.num));
+	return result;
+};
+const compactCharacter = (character, appearances) => ({
+	name: character.name,
+	role: character.role,
+	first_appearance: character.first_appearance,
+	last_seen: recencyOf(character, appearances)
+});
+const castCard = (name, character, member, declared) => {
+	return {
+		...character ?? declared ?? { name },
+		name,
+		...member === void 0 ? {} : {
+			entry_state: member.entry_state,
+			goal: member.goal,
+			knowledge: member.knowledge,
+			exit_change: member.exit_change
+		}
+	};
+};
+const worldPlanBrief = (plan) => plan === null ? null : {
+	chapter: plan.chapter,
+	objective: plan.objective,
+	constraints: plan.constraints,
+	characters: plan.characters,
+	locations: plan.locations,
+	continuity_notes: plan.continuity_notes
+};
+const filterLocks = (locks, cast, locations) => {
+	const characterNames = new Set(cast);
+	const locationNames = new Set(locations);
+	return {
+		...locks,
+		characters: characterNames.size === 0 ? locks.characters : Object.fromEntries(Object.entries(locks.characters).filter(([name]) => characterNames.has(name))),
+		locations: locationNames.size === 0 ? locks.locations : Object.fromEntries(Object.entries(locks.locations).filter(([name]) => locationNames.has(name)))
+	};
+};
 /**
 * Build the stage-specific context pack. The task book explains the rules; this
 * pack is the minimum project state the model needs to apply them without
@@ -2867,6 +3101,19 @@ const pendingForeshadows = (ledger) => ledger.items.filter((item) => item.status
 */
 function unbudgetedBriefContext(input) {
 	const previousEnding = input.previousText === null ? "" : input.previousText.trim().slice(-400);
+	const appearances = appearancesByChapter(input.chapters);
+	const activeNames = activeCastNames(input.plan, input.characters, input.text, appearances);
+	const activeSet = new Set(activeNames);
+	const planCast = new Map((input.plan?.cast ?? []).map((member) => [member.name, member]));
+	const byName = new Map(input.characters.characters.map((character) => [character.name, character]));
+	const worldPlanByName = new Map((input.worldPlan?.characters ?? []).map((character) => [character.name, character]));
+	const activeCast = activeNames.map((name) => castCard(name, byName.get(name), planCast.get(name), worldPlanByName.get(name)));
+	const candidateNames = new Set(input.stage === "P2" ? (input.worldPlan?.characters ?? []).map((character) => character.name) : []);
+	const otherCharacters = input.characters.characters.filter((character) => !activeSet.has(character.name) && !candidateNames.has(character.name)).sort((left, right) => {
+		const byRecency = recencyOf(right, appearances) - recencyOf(left, appearances);
+		return byRecency !== 0 ? byRecency : compareText(left.name, right.name);
+	}).map((character) => compactCharacter(character, appearances));
+	const worldPlan = worldPlanBrief(input.worldPlan ?? null);
 	const base = {
 		project: {
 			title: input.project.title,
@@ -2878,28 +3125,38 @@ function unbudgetedBriefContext(input) {
 		stage: input.pipeline.stage,
 		scene_distribution: sceneDistribution(input.chapters),
 		previous_ending: previousEnding,
+		...input.world_plan_error === void 0 || input.world_plan_error === null ? {} : { world_plan_error: input.world_plan_error },
 		...input.plan_error === void 0 || input.plan_error === null ? {} : { plan_error: input.plan_error },
 		...input.review_error === void 0 || input.review_error === null ? {} : { review_error: input.review_error },
 		...input.check_error === void 0 || input.check_error === null ? {} : { check_error: input.check_error }
 	};
 	switch (input.stage) {
-		case "P1": return {
-			...base,
-			recent_summaries: input.chapters.chapters.slice(-5).map(compactSummary),
-			open_foreshadows: pendingForeshadows(input.foreshadows),
-			volume: input.handoff?.volume ?? 1,
-			volume_name: input.handoff?.volume_name ?? "",
-			act: input.handoff?.act ?? ""
-		};
+		case "P1": {
+			const position = input.handoff === null ? null : projectHandoff(input.handoff, input.chapter);
+			return {
+				...base,
+				recent_summaries: input.chapters.chapters.slice(-5).map(compactSummary),
+				open_foreshadows: pendingForeshadows(input.foreshadows),
+				volume: position?.volume ?? 1,
+				volume_name: position?.volume_name ?? "",
+				act: position?.act ?? "",
+				act_progress: position?.act_progress ?? ""
+			};
+		}
 		case "P2": return {
 			...base,
+			world_plan: worldPlan,
+			characters: [...input.worldPlan?.characters ?? []],
+			other_characters: otherCharacters,
 			plan: input.plan,
 			open_foreshadows: pendingForeshadows(input.foreshadows)
 		};
 		case "P3": return {
 			...base,
-			characters: input.characters.characters,
-			locks: input.locks,
+			world_plan: worldPlan,
+			characters: activeCast,
+			other_characters: otherCharacters,
+			locks: filterLocks(input.locks, activeNames, (input.worldPlan?.locations ?? []).map((location) => location.name)),
 			precheck: input.plan,
 			open_foreshadows: pendingForeshadows(input.foreshadows),
 			recent_summaries: input.chapters.chapters.slice(-5).map(compactSummary)
@@ -2910,7 +3167,9 @@ function unbudgetedBriefContext(input) {
 			summary: input.plan?.summary ?? null,
 			plan: input.plan,
 			machine: input.machine ?? null,
-			characters: input.characters.characters,
+			world_plan: worldPlan,
+			characters: activeCast,
+			other_characters: otherCharacters,
 			check: input.check,
 			score_history: input.chapters.chapters.slice(-5).map((row) => ({
 				num: row.num,
@@ -2923,14 +3182,20 @@ function unbudgetedBriefContext(input) {
 			plan: input.plan,
 			machine: input.machine ?? null,
 			review: input.review,
-			issues: input.review?.issues ?? []
+			issues: input.review?.issues ?? [],
+			world_plan: worldPlan,
+			characters: activeCast,
+			other_characters: otherCharacters
 		};
 		case "P6": return {
 			...base,
 			text: input.text ?? "",
 			plan: input.plan,
 			machine: input.machine ?? null,
+			world_plan: worldPlan,
 			characters: input.characters.characters,
+			active_cast: activeCast,
+			other_characters: otherCharacters,
 			world: input.world,
 			locks: input.locks,
 			foreshadows: input.foreshadows,
@@ -2968,7 +3233,7 @@ const CONTEXT_BUDGETS = {
 };
 const asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 const asArray = (value) => Array.isArray(value) ? value : null;
-const jsonSize = (value) => Array.from(JSON.stringify(value)).length;
+const jsonSize = (value) => JSON.stringify(value).length;
 const mentionScore = (mentioned, value) => value !== "" && mentioned.includes(value) ? 1 : 0;
 /**
 * Apply the stage budget after the stage-specific pack exists. Protected keys
@@ -2978,6 +3243,7 @@ const mentionScore = (mentioned, value) => value !== "" && mentioned.includes(va
 function withContextBudget(stage, raw) {
 	const context = structuredClone(raw);
 	const budget = CONTEXT_BUDGETS[stage] ?? 8e3;
+	const smallP2Candidates = stage === "P2" && Array.isArray(context.characters) && context.characters.length <= 32;
 	const protectedKeys = [
 		"project",
 		"chapter",
@@ -2989,21 +3255,25 @@ function withContextBudget(stage, raw) {
 		"review",
 		"check",
 		"machine",
-		"summary"
+		"summary",
+		"world_plan",
+		"active_cast",
+		...stage === "P3" || stage === "P4" || stage === "P5" || smallP2Candidates ? ["characters"] : []
 	];
 	const mentioned = [
 		typeof context.text === "string" ? context.text : "",
-		JSON.stringify(context.plan ?? ""),
-		JSON.stringify(context.review ?? ""),
-		JSON.stringify(context.check ?? ""),
-		JSON.stringify(context.summary ?? "")
+		stableJson(context.plan ?? ""),
+		stableJson(context.review ?? ""),
+		stableJson(context.check ?? ""),
+		stableJson(context.summary ?? ""),
+		stableJson(context.world_plan ?? "")
 	].join("\n");
 	const omitted = {};
 	const truncated = /* @__PURE__ */ new Set();
 	const candidates = [];
 	const stableKey = (value) => {
 		const row = asRecord(value);
-		if (row === null) return JSON.stringify(value) ?? "";
+		if (row === null) return stableJson(value);
 		for (const key of [
 			"id",
 			"name",
@@ -3012,10 +3282,10 @@ function withContextBudget(stage, raw) {
 			const item = row[key];
 			if (typeof item === "string" && item !== "") return item;
 		}
-		return JSON.stringify(row);
+		return stableJson(row);
 	};
-	const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
 	const addArray = (key, array, rank, tie = stableKey) => {
+		if (protectedKeys.includes(key)) return;
 		let prepared = false;
 		const sort = () => {
 			if (prepared) return;
@@ -3039,6 +3309,7 @@ function withContextBudget(stage, raw) {
 		});
 	};
 	const addObject = (key, map, rank) => {
+		if (protectedKeys.includes(key)) return;
 		let keys = null;
 		const ensure = () => {
 			const target = map();
@@ -3064,10 +3335,36 @@ function withContextBudget(stage, raw) {
 		});
 	};
 	const chapter = (value) => asRecord(value)?.num ?? 0;
+	const activeNames = new Set(Array.isArray(context.active_cast) ? context.active_cast.map((value) => asRecord(value)?.name ?? "").filter((name) => name !== "") : []);
+	const recency = (row) => Math.max(Number(row.updated_at ?? 0), Number(row.last_seen ?? 0));
 	addArray("characters", () => asArray(context.characters), (value) => {
 		const row = asRecord(value);
 		const name = typeof row?.name === "string" ? row.name : "";
-		return mentionScore(mentioned, name) * 1e3 + Number(row?.first_appearance ?? 0);
+		return (activeNames.has(name) ? 1e6 : 0) + mentionScore(mentioned, name) * 1e5 + recency(row ?? {});
+	}, (value) => {
+		const row = asRecord(value);
+		return typeof row?.name === "string" ? row.name : stableKey(value);
+	});
+	addArray("other_characters", () => asArray(context.other_characters), (value) => {
+		const row = asRecord(value);
+		return Number(row?.last_seen ?? 0);
+	}, (value) => {
+		const row = asRecord(value);
+		return typeof row?.name === "string" ? row.name : stableKey(value);
+	});
+	const worldPlan = asRecord(context.world_plan);
+	addArray("world_plan.characters", () => asArray(worldPlan?.characters), (value) => {
+		const row = asRecord(value);
+		const name = typeof row?.name === "string" ? row.name : "";
+		return (activeNames.has(name) ? 1e6 : 0) + mentionScore(mentioned, name) * 1e5;
+	}, (value) => {
+		const row = asRecord(value);
+		return typeof row?.name === "string" ? row.name : stableKey(value);
+	});
+	addArray("world_plan.locations", () => asArray(worldPlan?.locations), (value) => {
+		const row = asRecord(value);
+		const name = typeof row?.name === "string" ? row.name : "";
+		return mentionScore(mentioned, name) * 1e3;
 	}, (value) => {
 		const row = asRecord(value);
 		return typeof row?.name === "string" ? row.name : stableKey(value);
@@ -3088,7 +3385,7 @@ function withContextBudget(stage, raw) {
 		return typeof row?.name === "string" ? row.name : stableKey(value);
 	});
 	const locks = asRecord(context.locks);
-	for (const key of ["characters", "locations"]) addObject(`locks.${key}`, () => asRecord(locks?.[key]), (name) => mentionScore(mentioned, name) * 1e3);
+	for (const key of ["characters", "locations"]) addObject(`locks.${key}`, () => asRecord(locks?.[key]), (name) => (activeNames.has(name) ? 1e6 : 0) + mentionScore(mentioned, name) * 1e3);
 	addArray("open_foreshadows", () => asArray(context.open_foreshadows), (value) => {
 		const row = asRecord(value);
 		const title = typeof row?.title === "string" ? row.title : "";
@@ -3127,11 +3424,7 @@ function withContextBudget(stage, raw) {
 	addArray("recent_summaries", () => asArray(context.recent_summaries), (value) => chapter(value), (value) => String(chapter(value)).padStart(8, "0"));
 	addArray("score_history", () => asArray(context.score_history), (value) => Number(asRecord(value)?.num ?? 0), (value) => String(Number(asRecord(value)?.num ?? 0)).padStart(8, "0"));
 	for (const candidate of candidates) candidate.prepare();
-	const used = () => {
-		const measure = { ...context };
-		delete measure.context_meta;
-		return jsonSize(measure);
-	};
+	const used = () => jsonSize(context);
 	const buildMeta = (finalUsed) => ({
 		version: 1,
 		stage,
@@ -3139,24 +3432,22 @@ function withContextBudget(stage, raw) {
 		used: finalUsed,
 		over_budget: false,
 		protected: protectedKeys,
-		truncated: [...truncated].sort(),
-		omitted: Object.fromEntries(Object.entries(omitted).sort(([left], [right]) => left.localeCompare(right))),
-		strategy: "stage-v1"
+		truncated: [...truncated].sort(compareText),
+		omitted: Object.fromEntries(Object.entries(omitted).sort(([left], [right]) => compareText(left, right))),
+		strategy: "stage-v2"
 	});
-	const totalWith = (finalUsed, meta) => jsonSize({
-		...context,
-		context_meta: {
+	const totalWith = (finalUsed, meta) => {
+		const metaSize = jsonSize({
 			...meta,
 			used: finalUsed
-		}
-	});
+		});
+		return finalUsed + 1 + 15 + metaSize;
+	};
 	let finalUsed = used();
 	let metaBase = buildMeta(finalUsed);
 	while (totalWith(finalUsed, metaBase) > budget) {
 		let changed = false;
 		for (const candidate of candidates) {
-			finalUsed = used();
-			metaBase = buildMeta(finalUsed);
 			if (totalWith(finalUsed, metaBase) <= budget) break;
 			if (candidate.count() === 0) continue;
 			candidate.prepare();
@@ -3164,10 +3455,10 @@ function withContextBudget(stage, raw) {
 				omitted[candidate.key] = (omitted[candidate.key] ?? 0) + 1;
 				truncated.add(candidate.key);
 				changed = true;
+				finalUsed = used();
+				metaBase = buildMeta(finalUsed);
 			}
 		}
-		finalUsed = used();
-		metaBase = buildMeta(finalUsed);
 		if (!changed) break;
 	}
 	const overBudget = totalWith(finalUsed, metaBase) > budget;
@@ -3884,7 +4175,7 @@ const summarySchema = (input) => {
 	else {
 		const opening = summary.opening;
 		if (Array.from(opening).length < LIMITS.minQuoteChars) problems.push(`opening must be at least ${LIMITS.minQuoteChars} characters`);
-		if (!splitParagraphs(input.text).slice(0, 2).some((paragraph) => paragraph.includes(opening))) problems.push("opening must be quoted from the first two paragraphs");
+		if (!openingInFirstTwoParagraphs(input.text, opening)) problems.push("opening must be quoted from the first two paragraphs");
 	}
 	const continuity = summary.continuity;
 	if (typeof continuity !== "object" || continuity === null) problems.push("continuity must be an object");
@@ -3975,8 +4266,8 @@ function verifyReference(text, reference) {
 	if (typeof reference !== "object" || reference === null) return "reading proof reference is not an object";
 	if (typeof reference.quote !== "string") return "reading proof quote is not text";
 	if (!Number.isInteger(reference.paragraph) || reference.paragraph < 1) return "reading proof paragraph must be a positive integer";
-	const quote = reference.quote;
-	if (Array.from(quote.trim()).length < LIMITS.minQuoteChars) return `quote "${quote}" is shorter than ${LIMITS.minQuoteChars} characters`;
+	const quote = reference.quote.trim();
+	if (Array.from(quote).length < LIMITS.minQuoteChars) return `quote "${reference.quote}" is shorter than ${LIMITS.minQuoteChars} characters`;
 	const actual = splitParagraphs(text).findIndex((paragraph) => paragraph.includes(quote));
 	if (actual === -1) return `quote "${quote}" does not appear in the text`;
 	if (Math.abs(actual + 1 - reference.paragraph) > 1) return `quote "${quote}" is at paragraph ${actual + 1}, not ${reference.paragraph}`;
@@ -4062,7 +4353,8 @@ const archiveAtomic = (input) => {
 	if (input.archive.chapterExists) problems.push("this chapter is already in the index");
 	if (!input.archive.checkPassed) problems.push("the check document has not passed");
 	if (!input.archive.hashMatches) problems.push("the manuscript changed since the check was written");
-	return problems.length === 0 ? [] : [block("PG-12", problems.join("; "), "re-run novel_check on the current manuscript")];
+	if (input.check === null || !Array.isArray(input.check.scope) || !input.check.scope.includes("content") || !input.check.scope.includes("integrity")) problems.push("the check document did not cover content+integrity");
+	return problems.length === 0 ? [] : [block("PG-12", problems.join("; "), "call novel_rollback to P6, then re-run novel_check on the current manuscript")];
 };
 /** Fixed order; evaluation collects every failure instead of stopping at the first. */
 const GATE_FUNCTIONS = {
@@ -4116,7 +4408,8 @@ function applicableGates(input) {
 			"PG-03",
 			"PG-05",
 			"PG-09",
-			"PG-08"
+			"PG-08",
+			"PG-11"
 		];
 		case "submitReview": return [
 			...always,
@@ -4127,7 +4420,10 @@ function applicableGates(input) {
 		case "runCheck": return [
 			...always,
 			"PG-04",
+			"PG-03",
 			"PG-05",
+			"PG-06",
+			"PG-07",
 			"PG-08",
 			"PG-09",
 			"PG-10",
@@ -4220,6 +4516,11 @@ function projectSummary(snapshot) {
 		revision: snapshot.revision,
 		totalWords: snapshot.totalWords,
 		totalChapters: snapshot.chapters.length,
+		averageScore: snapshot.averageScore ?? (snapshot.chapters.length === 0 ? 0 : snapshot.chapters.reduce((sum, chapter) => sum + chapter.score, 0) / snapshot.chapters.length),
+		...snapshot.volume === void 0 ? {} : { volume: snapshot.volume },
+		...snapshot.volume_name === void 0 ? {} : { volume_name: snapshot.volume_name },
+		...snapshot.act === void 0 ? {} : { act: snapshot.act },
+		...snapshot.act_progress === void 0 ? {} : { act_progress: snapshot.act_progress },
 		phases: snapshot.phases,
 		blocking: snapshot.blocking,
 		finished: snapshot.finished,
@@ -4230,9 +4531,11 @@ function projectSummary(snapshot) {
 	};
 }
 function projectChapters(snapshot) {
-	const rows = snapshot.chapters.map(projectChapter);
 	const draft = snapshot.draft;
-	if (draft !== void 0 && draft !== null && !rows.some((row) => row.num === draft.num)) rows.push({
+	const draftNeedsRow = draft !== void 0 && draft !== null && !snapshot.chapters.some((row) => row.num === draft.num);
+	const archivedLimit = draftNeedsRow ? 29 : 30;
+	const rows = snapshot.chapters.slice(-archivedLimit).map(projectChapter);
+	if (draftNeedsRow) rows.push({
 		num: draft.num,
 		title: draft.title,
 		wordCount: draft.wordCount,
@@ -4363,7 +4666,20 @@ const STAGE_RANK = {
 	ready_to_archive: 6,
 	done: 7
 };
+/** Internal, journal-tracked archive idempotency ledger; not a user state doc. */
+const ARCHIVE_DIGESTS = joinRel(STATE_DIR, "archive-digests.json");
+const LEDGER_PATHS = {
+	chapters: joinRel(STATE_DIR, STATE_FILES.chapters),
+	characters: joinRel(STATE_DIR, STATE_FILES.characters),
+	world: joinRel(STATE_DIR, STATE_FILES.world),
+	locks: joinRel(STATE_DIR, STATE_FILES.locks),
+	timeline: joinRel(STATE_DIR, STATE_FILES.timeline),
+	foreshadows: joinRel(STATE_DIR, STATE_FILES.foreshadows),
+	relationships: joinRel(STATE_DIR, STATE_FILES.relationships),
+	handoff: joinRel(STATE_DIR, STATE_FILES.handoff)
+};
 const MUTABLE_STATE = {
+	[PROJECT_FILE]: "project",
 	[joinRel(STATE_DIR, STATE_FILES.pipeline)]: "pipeline",
 	[joinRel(STATE_DIR, STATE_FILES.chapters)]: "chapters",
 	[joinRel(STATE_DIR, STATE_FILES.characters)]: "characters",
@@ -4383,6 +4699,8 @@ var EngineService = class {
 	stores = /* @__PURE__ */ new Map();
 	mutex = new KeyedMutex();
 	replay = /* @__PURE__ */ new Map();
+	/** Status, panel and gates ask for the same stage context repeatedly. */
+	briefContextCache = /* @__PURE__ */ new WeakMap();
 	briefs;
 	now;
 	/** The project this process last touched; the panel follows it without a workspace hint. */
@@ -4518,12 +4836,50 @@ var EngineService = class {
 			emptyAllowed: true
 		});
 	}
+	/**
+	* Read-only paths must surface a committed-journal mismatch. The write path
+	* already fails closed; without this, status recommends the next write and
+	* the model only learns about the mismatch when that write aborts.
+	*/
+	async journalBlocking(snapshot) {
+		const store = this.storeFor(snapshot.root);
+		if (await store.exists(".engine.lock")) return [];
+		try {
+			const { malformed, mismatches } = await reconcileJournal(store);
+			const items = [];
+			if (malformed > 0) items.push({
+				code: "JOURNAL_MALFORMED",
+				scope: "journal",
+				detail: `${malformed} malformed journal line(s)`,
+				hint: "inspect the journal with novel_audit; restore a known-good journal before writing"
+			});
+			for (const mismatch of mismatches) items.push({
+				code: "JOURNAL_HASH_MISMATCH",
+				scope: "journal",
+				detail: `${mismatch.path} changed after commit ${mismatch.txid}`,
+				hint: "restore the file from backups/ or inspect with novel_audit; writes remain fail-closed"
+			});
+			return items;
+		} catch (error) {
+			return [{
+				code: "JOURNAL_UNREADABLE",
+				scope: "journal",
+				detail: errorMessage(error),
+				hint: "inspect state/journal.jsonl and restore a known-good copy"
+			}];
+		}
+	}
 	async getStatus(input = {}) {
 		if (input.chapter !== void 0) this.assertChapterParameter(input.chapter);
 		const snapshot = await this.load(input.root);
 		const chapter = input.chapter ?? snapshot.pipeline.chapter;
 		const metrics = await this.metricsFor(snapshot, chapter);
-		const next = this.nextStep(snapshot);
+		const journal = await this.journalBlocking(snapshot);
+		const next = journal.length > 0 && this.stateErrors(snapshot).length === 0 ? {
+			tool: "novel_audit",
+			args: {},
+			reason: `${journal[0].code}: ${journal[0].detail}; inspect and restore before the next write`
+		} : this.nextStep(snapshot);
 		return {
 			data: {
 				project: {
@@ -4536,9 +4892,18 @@ var EngineService = class {
 				active_chapter: snapshot.pipeline.chapter,
 				stage: snapshot.pipeline.stage,
 				rounds: { ...snapshot.pipeline.rounds },
-				blocking: this.effectiveBlocking(snapshot),
+				blocking: [...this.effectiveBlocking(snapshot), ...journal],
 				state_errors: this.stateErrors(snapshot),
 				metrics,
+				...snapshot.handoff === null ? {} : (() => {
+					const position = projectHandoff(snapshot.handoff, snapshot.pipeline.chapter);
+					return {
+						volume: position.volume,
+						volume_name: position.volume_name,
+						act: position.act,
+						act_progress: position.act_progress
+					};
+				})(),
 				next
 			},
 			revision: snapshot.pipeline.revision,
@@ -4564,17 +4929,50 @@ var EngineService = class {
 		const snapshot = await this.load(input.root);
 		const chapter = input.chapter ?? snapshot.pipeline.chapter;
 		const store = this.storeFor(snapshot.root);
-		switch (input.kind) {
-			case "pipeline": return {
-				data: snapshot.pipeline,
+		const ledgerPath = LEDGER_PATHS[input.kind];
+		if (ledgerPath !== void 0) {
+			const damage = snapshot.ledgerErrors.find((error) => error.path === ledgerPath);
+			if (damage !== void 0) return {
+				data: {
+					error: damage.code,
+					message: damage.message,
+					path: damage.path,
+					raw: await store.readText(damage.path)
+				},
 				revision: snapshot.pipeline.revision,
 				warnings: []
 			};
-			case "chapters": return {
-				data: snapshot.chapters,
+		}
+		switch (input.kind) {
+			case "pipeline": return {
+				data: snapshot.pipeline,
 				revision: snapshot.pipeline.revision,
 				warnings: []
 			};
+			case "chapters": {
+				const range = input.chapter_range;
+				if (range !== void 0) {
+					if (!Array.isArray(range) || range.length !== 2 || !Number.isInteger(range[0]) || !Number.isInteger(range[1]) || range[0] < 1 || range[1] < range[0]) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "chapter_range must be [start, end] positive integers with start <= end");
+				}
+				const rows = range === void 0 ? snapshot.chapters.chapters : snapshot.chapters.chapters.filter((row) => row.num >= range[0] && row.num <= range[1]);
+				return {
+					data: input.include_summary === true ? {
+						schema_version: 1,
+						chapters: rows
+					} : {
+						schema_version: 1,
+						chapters: rows.map((row) => ({
+							num: row.num,
+							title: row.title,
+							word_count: row.word_count,
+							score: row.score,
+							status: row.status
+						}))
+					},
+					revision: snapshot.pipeline.revision,
+					warnings: []
+				};
+			}
 			case "characters": return {
 				data: snapshot.characters,
 				revision: snapshot.pipeline.revision,
@@ -4610,30 +5008,79 @@ var EngineService = class {
 				revision: snapshot.pipeline.revision,
 				warnings: []
 			};
-			case "review": return {
-				data: chapter === snapshot.pipeline.chapter ? snapshot.review : await store.readDoc(reviewFile(chapter), "review"),
-				revision: snapshot.pipeline.revision,
-				warnings: []
-			};
-			case "check": return {
-				data: chapter === snapshot.pipeline.chapter ? snapshot.check : await store.readDoc(checkFile(chapter), "check"),
-				revision: snapshot.pipeline.revision,
-				warnings: []
-			};
-			case "novel": return {
-				data: snapshot.project,
-				revision: snapshot.pipeline.revision,
-				warnings: []
-			};
+			case "review":
+				if (chapter === snapshot.pipeline.chapter && snapshot.reviewError !== null) return {
+					data: {
+						error: "REVIEW_UNREADABLE",
+						message: snapshot.reviewError,
+						path: reviewFile(chapter),
+						raw: await store.readText(reviewFile(chapter))
+					},
+					revision: snapshot.pipeline.revision,
+					warnings: []
+				};
+				return {
+					data: chapter === snapshot.pipeline.chapter ? snapshot.review : await store.readDoc(reviewFile(chapter), "review"),
+					revision: snapshot.pipeline.revision,
+					warnings: []
+				};
+			case "check":
+				if (chapter === snapshot.pipeline.chapter && snapshot.checkError !== null) return {
+					data: {
+						error: "CHECK_UNREADABLE",
+						message: snapshot.checkError,
+						path: checkFile(chapter),
+						raw: await store.readText(checkFile(chapter))
+					},
+					revision: snapshot.pipeline.revision,
+					warnings: []
+				};
+				return {
+					data: chapter === snapshot.pipeline.chapter ? snapshot.check : await store.readDoc(checkFile(chapter), "check"),
+					revision: snapshot.pipeline.revision,
+					warnings: []
+				};
+			case "novel":
+				if (snapshot.projectError !== null) return {
+					data: {
+						error: "PROJECT_UNREADABLE",
+						message: snapshot.projectError,
+						path: PROJECT_FILE,
+						raw: await store.readText(PROJECT_FILE)
+					},
+					revision: snapshot.pipeline.revision,
+					warnings: []
+				};
+				return {
+					data: snapshot.project,
+					revision: snapshot.pipeline.revision,
+					warnings: []
+				};
 			case "planWorld": {
+				if (chapter === snapshot.pipeline.chapter) {
+					if (snapshot.worldPlanError !== null) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `${planWorldFile(chapter)}: ${snapshot.worldPlanError}`, "run novel_status and repair or re-plan the world plan");
+					return {
+						data: snapshot.worldPlan,
+						revision: snapshot.pipeline.revision,
+						warnings: []
+					};
+				}
 				const raw = await store.readText(planWorldFile(chapter));
 				return {
-					data: raw === null ? null : parsePlanYaml(raw, planWorldFile(chapter)),
+					data: raw === null ? null : narrow("worldPlan", parsePlanYaml(raw, planWorldFile(chapter))),
 					revision: snapshot.pipeline.revision,
 					warnings: []
 				};
 			}
 			case "planChapter": {
+				if (chapter === snapshot.pipeline.chapter) {
+					if (snapshot.planError !== null) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `${planChapterFile(chapter)}: ${snapshot.planError}`, "run novel_status and repair or re-plan the chapter");
+					return {
+						data: snapshot.plan,
+						revision: snapshot.pipeline.revision,
+						warnings: []
+					};
+				}
 				const raw = await store.readText(planChapterFile(chapter));
 				return {
 					data: raw === null ? null : parsePlanYaml(raw, planChapterFile(chapter)),
@@ -4646,7 +5093,12 @@ var EngineService = class {
 	}
 	async advise(input = {}) {
 		const snapshot = await this.load(input.root);
-		const next = this.nextStep(snapshot);
+		const journal = await this.journalBlocking(snapshot);
+		const next = journal.length > 0 && this.stateErrors(snapshot).length === 0 ? {
+			tool: "novel_audit",
+			args: {},
+			reason: `${journal[0].code}: ${journal[0].detail}; inspect and restore before the next write`
+		} : this.nextStep(snapshot);
 		return {
 			data: {
 				stage: snapshot.pipeline.stage,
@@ -4654,7 +5106,7 @@ var EngineService = class {
 				tool: next.tool,
 				args: next.args,
 				reason: next.reason,
-				blocking: this.effectiveBlocking(snapshot),
+				blocking: [...this.effectiveBlocking(snapshot), ...journal],
 				state_errors: this.stateErrors(snapshot)
 			},
 			revision: snapshot.pipeline.revision,
@@ -4690,6 +5142,7 @@ var EngineService = class {
 					/** P4 must apply exclusions before its arithmetic closes. */
 					score_exclusions: this.rulepack.exclusions,
 					next_tool: NEXT_TOOL_BY_BRIEF[input.stage],
+					...snapshot.worldPlanError === null ? {} : { world_plan_error: snapshot.worldPlanError },
 					...snapshot.planError === null ? {} : { plan_error: snapshot.planError },
 					...snapshot.reviewError === null ? {} : { review_error: snapshot.reviewError },
 					...snapshot.checkError === null ? {} : { check_error: snapshot.checkError }
@@ -4735,6 +5188,13 @@ var EngineService = class {
 		if (typeof input.objective !== "string" || input.objective.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "world plan objective must not be empty");
 		const constraints = stringList(input.constraints, "constraints");
 		const continuity_notes = stringList(input.continuity_notes, "continuity_notes");
+		const objectiveChars = Array.from(input.objective).length;
+		if (objectiveChars > LIMITS.maxWorldPlanObjectiveChars) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `world plan objective is ${objectiveChars} characters; limit is ${LIMITS.maxWorldPlanObjectiveChars}`, "keep the protected objective within the P2 context budget");
+		for (const [field, values] of [["constraints", constraints], ["continuity_notes", continuity_notes]]) {
+			if (values.length > LIMITS.maxWorldPlanItems) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `world plan ${field} has ${values.length} items; limit is ${LIMITS.maxWorldPlanItems}`, "merge related constraints/notes so the protected context stays bounded");
+			const chars = values.reduce((total, value) => total + Array.from(value).length, 0);
+			if (chars > LIMITS.maxWorldPlanTextChars) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `world plan ${field} has ${chars} characters; limit is ${LIMITS.maxWorldPlanTextChars}`, "keep constraints/continuity notes concise; the protected context has a fixed budget");
+		}
 		const characters = objectList(input.characters, "characters");
 		for (const [index, character] of characters.entries()) {
 			requireText(character, "name", `characters[${index}].name`);
@@ -4795,9 +5255,11 @@ var EngineService = class {
 	}
 	async submitChapterPlan(input) {
 		if (typeof input.title !== "string" || input.title.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "chapter plan title must not be empty");
-		const titleBody = input.title.replace(/^第\s*\d+\s*章\s*/, "").trim();
+		const titleTemplate = this.rulepack.format.title;
+		if (LENIENT_TITLE_PREFIX.test(input.title)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "chapter plan title must not include the 第N章 prefix", "submit the title body only; the engine adds the canonical prefix");
+		const titleBody = input.title.trim();
 		const titleLength = Array.from(titleBody).length;
-		if (titleLength < 4 || titleLength > 8) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter plan title body must be 4..8 characters, got ${titleLength}`, "use the same 4..8 character body the P3 title rule will judge");
+		if (titleLength < titleTemplate.min_chars || titleLength > titleTemplate.max_chars) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter plan title body must be ${titleTemplate.min_chars}..${titleTemplate.max_chars} characters, got ${titleLength}`, "use the same title body the P3 title rule will judge");
 		if (typeof input.narrator !== "string" || input.narrator.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "chapter plan narrator must not be empty");
 		const beats = stringList(input.beats, "beats");
 		if (beats.length < 5 || beats.length > 8) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter plan beats must contain 5..8 non-empty items, got ${beats.length}`, "write the five to eight causal beats the P2 task book requires");
@@ -4812,12 +5274,14 @@ var EngineService = class {
 			key: (snapshot) => `plan:${snapshot.pipeline.chapter}:${sha256(stableJson(input))}`,
 			run: async (snapshot, context) => {
 				await this.assertGates(snapshot, "submitChapterPlan", { briefStage: "P2" });
+				const cast = normalizeCast(input.cast, snapshot);
 				const chapter = snapshot.pipeline.chapter;
 				const path = planChapterFile(chapter);
 				const plan = {
 					...input,
 					chapter,
 					beats,
+					...cast === void 0 ? {} : { cast },
 					schema_version: 1
 				};
 				delete plan.root;
@@ -4846,6 +5310,7 @@ var EngineService = class {
 	async submitDraft(input) {
 		if (typeof input.content !== "string" || input.content.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "draft content must not be empty");
 		if (typeof input.chapter_title !== "string" || input.chapter_title.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "chapter_title must not be empty");
+		if (typeof input.narrator !== "string" || input.narrator.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "narrator must not be empty", "use the narration person/name validated at P2; a blank narrator would make the stored plan unreadable");
 		if (!SCENE_TYPES.includes(input.scene_type)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `unknown scene_type "${String(input.scene_type)}"`, `allowed: ${SCENE_TYPES.join(", ")}`);
 		return this.mutate({
 			root: input.root,
@@ -4872,18 +5337,16 @@ var EngineService = class {
 					summary: input.summary
 				});
 				const chapter = input.chapter;
-				const planPath = planChapterFile(chapter);
-				const planText = await context.store.readText(planPath);
+				const plan = snapshot.plan;
+				if (plan === null) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter ${chapter} has no usable plan`, "rollback to P2 and submit novel_plan_chapter; the draft was not written");
 				const mergedPlan = {
-					...(planText === null ? null : parsePlanYaml(planText, planPath)) ?? {
-						schema_version: 1,
-						chapter
-					},
+					...plan,
 					title: input.chapter_title,
 					scene_type: input.scene_type,
 					narrator: input.narrator,
 					summary: input.summary
 				};
+				const planPath = planChapterFile(chapter);
 				const nextPipeline = pipelineWith(snapshot, context.revision, {
 					stage: "P4",
 					blocking: [],
@@ -5097,7 +5560,7 @@ var EngineService = class {
 				});
 				if (input.summary === void 0 && snapshot.plan?.summary !== void 0) {
 					const opening = snapshot.plan.summary.opening;
-					if (!splitParagraphs(input.content).slice(0, 2).some((paragraph) => paragraph.includes(opening))) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "summary omitted, but the stored opening no longer appears in the revised first two paragraphs", "resubmit novel_revise with a summary whose opening quotes the revised text");
+					if (!openingInFirstTwoParagraphs(input.content, opening)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "summary omitted, but the stored opening no longer appears in the revised first two paragraphs", "resubmit novel_revise with a summary whose opening quotes the revised text");
 				}
 				const machine = this.machine(snapshot, input.content, { summary: input.summary ?? snapshot.plan?.summary ?? null });
 				const nextStage$1 = nextStage(snapshot.pipeline.stage, "submitRevision", 0);
@@ -5185,17 +5648,18 @@ var EngineService = class {
 					semantic: { items: semantic },
 					verdict
 				};
-				const nextStage = verdict === "pass" ? "ready_to_archive" : "P6";
+				const fullScope = scope.includes("content") && scope.includes("integrity");
+				const nextStage$2 = verdict === "pass" ? nextStage(snapshot.pipeline.stage, "runCheck", 0, { completeCheck: fullScope }) : "P6";
 				const blockingItems = verdict === "fail" ? [...machineBlocking.map((violation) => ({
 					code: violation.code,
 					scope: "check",
 					detail: violation.detail
 				})), ...semanticResult.blocking] : [];
 				const nextPipeline = pipelineWith(snapshot, context.revision, {
-					stage: nextStage,
+					stage: nextStage$2,
 					rounds: {
 						...snapshot.pipeline.rounds,
-						check: snapshot.pipeline.rounds.check + 1
+						check: snapshot.pipeline.rounds.check + (verdict === "fail" || fullScope ? 1 : 0)
 					},
 					blocking: blockingItems,
 					last_action: action("novel_check", this.now(), sha256(text))
@@ -5213,19 +5677,23 @@ var EngineService = class {
 						verdict,
 						violations: scopedMachine.violations.length,
 						metrics: scopedMachine.metrics,
-						stage: nextStage
+						stage: nextStage$2
 					},
-					warnings: machineWarnings(scopedMachine)
+					warnings: [...machineWarnings(scopedMachine), ...verdict === "pass" && !fullScope ? [{
+						code: "CHECK_SCOPE_PARTIAL",
+						message: `scope ${scope.join("+")} passed, but archive requires content+integrity; the pipeline stays at P6`
+					}] : []]
 				};
 			}
 		});
 	}
 	async archiveChapter(input) {
-		const archiveDigest = sha256(stableJson({
+		const handoffOverride = normalizeHandoffOverride(input.handoff);
+		const archiveDigest = `v2:${sha256(stableJson({
 			chapter: input.chapter,
 			state_delta: input.state_delta,
-			handoff: input.handoff
-		}));
+			handoff: handoffOverride
+		}))}`;
 		return this.mutate({
 			root: input.root,
 			op: "archiveChapter",
@@ -5237,7 +5705,7 @@ var EngineService = class {
 				const already = snapshot.chapters.chapters.find((record) => record.num === input.chapter);
 				if (already !== void 0) {
 					if (already.archive_digest === void 0) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `chapter ${input.chapter} has no archive_digest; the index entry is not trustworthy`, "restore the chapter index from backups/ or re-archive from the original manuscript");
-					if (already.archive_digest !== archiveDigest) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter ${input.chapter} is already archived with a different state_delta`, "archive is idempotent by chapter; start the next chapter instead of replaying old data");
+					if (already.archive_digest !== archiveDigest && already.archive_digest !== legacyArchiveDigest(input)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter ${input.chapter} is already archived with a different state_delta`, "archive is idempotent by chapter; start the next chapter instead of replaying old data");
 					const archivedText = await this.readChapter(snapshot, input.chapter);
 					if (archivedText === null || sha256(archivedText) !== already.content_hash) throw new EngineFaultError(ERROR_CODES.TXN_ABORTED, `archived chapter ${input.chapter} no longer matches its index`, "restore the chapter from backups/ before retrying");
 					return {
@@ -5280,7 +5748,7 @@ var EngineService = class {
 				const metrics = countWordMetrics(text);
 				const score = snapshot.review?.total ?? 0;
 				const chapter = input.chapter;
-				const storedTitle = (snapshot.plan?.title ?? "").replace(/^第\s*\d+\s*章\s*/, "").trim();
+				const storedTitle = stripTitlePrefix(snapshot.plan?.title ?? "");
 				const record = {
 					num: chapter,
 					title: storedTitle === "" ? `第${chapter}章` : storedTitle,
@@ -5315,18 +5783,22 @@ var EngineService = class {
 				for (const item of foreshadows.items) if (item.status !== "resolved" && chapter - item.last_touched >= this.rulepack.crosschapter.foreshadow_dormant_after) item.status = "dormant";
 				const chapters = structuredClone(snapshot.chapters);
 				chapters.chapters.push(record);
-				const totalChapters = snapshot.project.targets.total_chapters;
-				const derivedVolume = Math.max(1, Math.ceil(chapter / 20));
+				const position = advanceHandoff(snapshot.handoff, chapter, handoffOverride);
 				const handoff = {
 					schema_version: 1,
 					current_chapter: chapter,
-					volume: input.handoff?.volume ?? derivedVolume,
-					volume_name: input.handoff?.volume_name ?? `第${derivedVolume}卷`,
-					act: input.handoff?.act ?? `第${Math.max(1, Math.ceil((chapter - 1) % 20 / 5) + 1)}幕`,
-					act_progress: input.handoff?.act_progress ?? (totalChapters === null ? `进至第${chapter}章` : `${chapter}/${totalChapters}`),
+					volume: position.volume,
+					volume_name: position.volume_name,
+					act: position.act,
+					act_progress: position.act_progress,
 					next_chapter: chapter + 1,
 					last_summary: summary.events.join("；").slice(0, 200),
-					open_hooks: foreshadows.items.filter((item) => item.status !== "resolved").slice(-5).map((item) => ({
+					open_hooks: foreshadows.items.filter((item) => item.status !== "resolved").sort((left, right) => {
+						const byAge = left.last_touched - right.last_touched;
+						if (byAge !== 0) return byAge;
+						const byId = compareText(left.id, right.id);
+						return byId !== 0 ? byId : compareText(left.title, right.title);
+					}).slice(0, 5).map((item) => ({
 						id: item.id,
 						title: item.title
 					})),
@@ -5354,6 +5826,20 @@ var EngineService = class {
 					["relationships", ledger.relationships],
 					["handoff", handoff]
 				]);
+				const digestRaw = await context.store.readText(ARCHIVE_DIGESTS);
+				let archiveDigests = {};
+				if (digestRaw !== null) {
+					let parsed;
+					try {
+						parsed = JSON.parse(digestRaw);
+					} catch (error) {
+						throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `${ARCHIVE_DIGESTS} is not valid JSON`, "restore the internal archive ledger before archiving; it protects idempotent replays", { cause: error });
+					}
+					const record = recordOf(parsed);
+					if (record === null || Object.values(record).some((value) => typeof value !== "string")) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `${ARCHIVE_DIGESTS} must be a JSON object of chapter -> digest`, "restore the internal archive ledger before archiving");
+					archiveDigests = record;
+				}
+				archiveDigests[String(chapter)] = archiveDigest;
 				return {
 					files: [
 						{
@@ -5395,6 +5881,10 @@ var EngineService = class {
 						{
 							path: joinRel(STATE_DIR, STATE_FILES.relationships),
 							text: yaml(ledger.relationships)
+						},
+						{
+							path: ARCHIVE_DIGESTS,
+							text: `${JSON.stringify(archiveDigests, null, 2)}\n`
 						}
 					],
 					backup: true,
@@ -5423,20 +5913,72 @@ var EngineService = class {
 		if (typeof input.reason !== "string" || input.reason.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "amend requires a reason");
 		if (typeof input.content !== "object" || input.content === null || Array.isArray(input.content)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "amend content must be an object");
 		const resolvedRoot = await this.resolveRoot(input.root);
-		const absolute = this.storeFor(resolvedRoot).path(input.path);
+		const store = this.storeFor(resolvedRoot);
+		const absolute = store.path(input.path);
 		const kind = Object.hasOwn(MUTABLE_STATE, input.path) ? MUTABLE_STATE[input.path] : void 0;
 		if (kind === void 0 || absolute.length === 0) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `amend can only target state documents: ${Object.keys(MUTABLE_STATE).join(", ")}`, "edit novel content through the draft/revision tools, not amend");
+		const repairPaths = [];
+		for (const [path, docKind] of Object.entries(MUTABLE_STATE)) {
+			if (docKind === "pipeline") continue;
+			if (await this.stateDocIsUnreadable(store, path, docKind)) repairPaths.push(path);
+		}
 		return this.mutate({
 			root: resolvedRoot,
 			op: "amend",
+			...repairPaths.length === 0 ? {} : { repairPaths },
 			key: (snapshot) => `amend:${input.path}:${snapshot.pipeline.revision}`,
 			run: async (snapshot, context) => {
 				if (input.reason.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "amend requires a reason", "state the intent so the journal explains the change");
 				if (kind === "pipeline") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "pipeline cannot be amended directly", "use novel_rollback or the stage operations");
-				const document = narrow(kind, {
+				let projectBaseline = snapshot.project;
+				let projectDamaged = snapshot.projectError !== null;
+				if (kind === "project" && snapshot.projectError !== null) {
+					const backup = await this.latestBackup(context.store, PROJECT_FILE);
+					if (backup !== null) try {
+						projectBaseline = narrow("project", parse(backup));
+						projectDamaged = false;
+					} catch {}
+				}
+				const document = kind === "project" ? snapshot.projectError !== null ? narrow("project", {
+					...input.content,
+					schema_version: input.content.schema_version ?? 1
+				}) : mergeProjectAmendment(input.content, snapshot.project) : narrow(kind, {
 					...input.content,
 					schema_version: input.content.schema_version ?? 1
 				});
+				let oldDocument = snapshot[kind];
+				if (kind === "project") oldDocument = projectBaseline;
+				else if (snapshot.ledgerErrors.some((error) => error.path === input.path)) {
+					const backup = await this.latestBackup(context.store, input.path);
+					if (backup !== null) try {
+						oldDocument = narrow(kind, parse(backup));
+					} catch {}
+				}
+				const archivedFiles = kind === "chapters" || kind === "project" ? (await context.store.list(CHAPTERS_DIR)).map((name) => /^chapter-(\d{3})\.md$/.exec(name)).filter((match) => match !== null).map((match) => Number(match[1])).filter((num) => num !== snapshot.pipeline.chapter).length : 0;
+				let archiveDigests = {};
+				if (kind === "chapters") {
+					const digestRaw = await context.store.readText(ARCHIVE_DIGESTS);
+					if (digestRaw !== null) {
+						let parsed;
+						try {
+							parsed = JSON.parse(digestRaw);
+						} catch (error) {
+							throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `${ARCHIVE_DIGESTS} is not valid JSON`, "restore the internal archive ledger before repairing chapters", { cause: error });
+						}
+						const record = recordOf(parsed);
+						if (record === null || Object.values(record).some((value) => typeof value !== "string")) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `${ARCHIVE_DIGESTS} must be a JSON object of chapter -> digest`, "restore the internal archive ledger before repairing chapters");
+						archiveDigests = record;
+					}
+				}
+				const problems = amendProblems(kind, oldDocument, document, snapshot, input.path, archivedFiles, projectBaseline, projectDamaged, archiveDigests);
+				if (kind === "chapters") for (const raw of Array.isArray(document.chapters) ? document.chapters : []) {
+					const row = recordOf(raw);
+					if (row === null || typeof row.file !== "string" || typeof row.content_hash !== "string") continue;
+					const text = await context.store.readText(row.file);
+					if (text === null) problems.push(`archived chapter ${String(row.num)} has no manuscript at ${row.file}`);
+					else if (sha256(text) !== row.content_hash) problems.push(`archived chapter ${String(row.num)} content_hash does not match ${row.file}`);
+				}
+				if (problems.length > 0) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `amend would break a state invariant: ${problems.join("; ")}`, "keep archived chapters, entity references and next_seq monotonic; nothing was written");
 				const nextPipeline = pipelineWith(snapshot, context.revision, { last_action: action("novel_amend", this.now(), shortDigest(input.reason)) });
 				return {
 					files: [{
@@ -5555,8 +6097,14 @@ var EngineService = class {
 			root: input.root,
 			op: "export",
 			key: (snapshot) => `export:${input.kind}:${input.chapter ?? "all"}:${sha256(stableJson({
+				chapter: snapshot.pipeline.chapter,
 				text: sha256(snapshot.text ?? ""),
-				chapters: snapshot.chapters.chapters.map((chapter) => chapter.content_hash),
+				plan_title: stripTitlePrefix(snapshot.plan?.title ?? ""),
+				project: sha256(stableJson(snapshot.project)),
+				chapters: snapshot.chapters.chapters.map((chapter) => ({
+					content_hash: chapter.content_hash,
+					title: chapter.title
+				})),
 				title: snapshot.project.title
 			}))}`,
 			run: async (snapshot, context) => {
@@ -5699,6 +6247,9 @@ var EngineService = class {
 			op: "amend",
 			key: () => `import:${input.kind}:${sha256(stableJson(input.content))}`,
 			run: async (fresh, context) => {
+				if (fresh.pipeline.revision !== snapshot.pipeline.revision) throw new EngineFaultError(ERROR_CODES.TXN_ABORTED, `${input.kind} import was prepared against revision ${snapshot.pipeline.revision}, but the project is now at ${fresh.pipeline.revision}`, "re-run the import against the current project; nothing was written");
+				const problems = amendProblems(input.kind, fresh[input.kind], document, fresh, path);
+				if (problems.length > 0) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `import would break a state invariant: ${problems.join("; ")}`, "fix the pack or the referencing ledgers; nothing was written");
 				const nextPipeline = pipelineWith(fresh, context.revision, { last_action: action("novel_import", this.now(), shortDigest(input.kind)) });
 				return {
 					files: [{
@@ -5727,7 +6278,7 @@ var EngineService = class {
 		const draftWords = snapshot.text === null ? 0 : countWordMetrics(snapshot.text).total_word_count;
 		const draft = archivedCurrent || snapshot.pipeline.stage === "done" ? null : {
 			num: snapshot.pipeline.chapter,
-			title: (snapshot.plan?.title ?? "").replace(/^第\s*\d+\s*章\s*/, "").trim() || `第${snapshot.pipeline.chapter}章`,
+			title: stripTitlePrefix(snapshot.plan?.title ?? "") || `第${snapshot.pipeline.chapter}章`,
 			wordCount: draftWords,
 			score: snapshot.review?.total ?? 0,
 			status: this.effectiveBlocking(snapshot).length > 0 ? "blocked" : "draft",
@@ -5743,19 +6294,85 @@ var EngineService = class {
 			revision: snapshot.pipeline.revision,
 			rounds: snapshot.pipeline.rounds,
 			blocking: this.effectiveBlocking(snapshot),
+			...snapshot.handoff === null ? {} : (() => {
+				const position = projectHandoff(snapshot.handoff, snapshot.pipeline.chapter);
+				return {
+					volume: position.volume,
+					volume_name: position.volume_name,
+					act: position.act,
+					act_progress: position.act_progress
+				};
+			})(),
 			next: finished ? void 0 : this.nextStep(snapshot),
 			finished,
 			chapters: archived,
 			draft,
 			totalWords: archived.reduce((total, chapter) => total + chapter.word_count, 0) + (draft === null ? 0 : draft.wordCount),
+			averageScore: archived.length === 0 ? 0 : archived.reduce((total, chapter) => total + chapter.score, 0) / archived.length,
 			phases: phaseStrip(snapshot.pipeline.stage, finished)
 		};
 	}
+	/**
+	* The archive stage has only one legal operation, so a status/panel that
+	* recommends it without checking the same gates as the archive creates a
+	* loop. Evaluate the real archive gates through `gateInput`, then add the
+	* machine pass and semantic evidence that archive re-checks separately.
+	*/
+	archivePreflight(snapshot) {
+		if (snapshot.pipeline.stage !== "ready_to_archive") return null;
+		const text = snapshot.text ?? "";
+		const gateResult = evaluateGates(this.gateInput(snapshot, "archiveChapter", {
+			briefStage: "P8",
+			proof: snapshot.review?.proof ?? null
+		}), {
+			rulepack: this.rulepack,
+			minScore: this.config.quality.minScore
+		});
+		if (!gateResult.passed) {
+			const first = gateResult.blocking[0];
+			const target = first.code === "PG-03" || first.code === "PG-04" || first.code === "PG-05" || first.code === "PG-06" ? "P3" : first.code === "PG-07" || first.code === "PG-08" || first.code === "PG-09" ? "P4" : first.code === "PG-11" ? "P4" : "P6";
+			return {
+				item: {
+					...first,
+					scope: first.scope ?? "archive"
+				},
+				to_stage: target
+			};
+		}
+		const summary = snapshot.plan?.summary ?? null;
+		const blockers = this.machine(snapshot, text, { summary }).violations.filter((violation) => violation.severity === "blocker");
+		if (blockers.length > 0) return {
+			item: {
+				code: blockers[0].code,
+				scope: "archive",
+				detail: `${blockers.length} machine blocker(s) remain; first: ${blockers[0].detail}`,
+				hint: "call novel_rollback with to_stage P3 and re-submit the draft and plan fields"
+			},
+			to_stage: "P3"
+		};
+		const semantic = evaluateSemantic(text, Array.isArray(snapshot.check?.semantic.items) ? snapshot.check.semantic.items : []);
+		if (semantic.failed) return {
+			item: {
+				code: semantic.blocking[0]?.code ?? "SEMANTIC_CHECK_FAILED",
+				scope: "archive",
+				detail: `${semantic.blocking.length} semantic check item(s) fail`,
+				hint: "call novel_rollback with to_stage P6, then re-run novel_check"
+			},
+			to_stage: "P6"
+		};
+		return null;
+	}
 	nextStep(snapshot) {
 		const stage = snapshot.pipeline.stage;
 		const chapter = snapshot.pipeline.chapter;
+		if (snapshot.chapters.chapters.some((record) => record.num === chapter)) return {
+			tool: "novel_amend",
+			args: { path: joinRel(STATE_DIR, STATE_FILES.chapters) },
+			reason: `chapter ${chapter} is the active chapter but is already in the index; read novel_state {kind:"chapters", include_summary:true}, remove it with novel_amend, then continue`
+		};
 		if (this.stateErrors(snapshot).length > 0) {
 			const recovery = this.recoveryFor(snapshot);
+			if (recovery.tool === "novel_amend") return recovery;
 			const target = recovery.args.to_stage;
 			if (STAGE_RANK[ROUND_TRANSITIONS[target]] < STAGE_RANK[stage]) return recovery;
 		}
@@ -5796,11 +6413,25 @@ var EngineService = class {
 			},
 			reason: detail === "" ? `fetch the ${briefStage} brief before ${followUp}` : `${detail}; fetch the ${briefStage} brief, then ${followUp}`
 		};
+		if (stage === "P6" && snapshot.check !== null && snapshot.check.verdict === "pass" && (!snapshot.check.scope.includes("content") || !snapshot.check.scope.includes("integrity"))) return {
+			tool: "novel_check",
+			args: this.nextArgs("P6", chapter),
+			reason: "the last check covered only one scope; run novel_check without scope (content+integrity) to reach archive"
+		};
 		if (stage === "P6" && snapshot.checkError !== null) return {
 			tool: "novel_check",
 			args: this.nextArgs("P6", chapter),
 			reason: `CHECK_UNREADABLE@${checkFile(chapter)}; repair the check with novel_check before any stale revision blocker`
 		};
+		const archive = this.archivePreflight(snapshot);
+		if (archive !== null) return {
+			tool: "novel_rollback",
+			args: {
+				chapter,
+				to_stage: archive.to_stage
+			},
+			reason: `${archive.item.code}: ${archive.item.detail}; ${archive.item.hint ?? ""}`.trim()
+		};
 		if (snapshot.pipeline.blocking.length > 0) {
 			if (stage === "P5" || stage === "P6") return {
 				tool: "novel_revise",
@@ -5827,14 +6458,17 @@ var EngineService = class {
 			"P5",
 			"P6"
 		].includes(stage)) return null;
-		const counter = stage === "P4" ? "review" : stage === "P5" ? "revise" : "check";
-		if (!roundsExhausted(snapshot.pipeline.rounds, counter)) return null;
-		return {
+		const block = (counter) => ({
 			code: "PG-11",
 			scope: "rounds",
 			detail: `round limit reached for ${counter} (review ${snapshot.pipeline.rounds.review}, revise ${snapshot.pipeline.rounds.revise}, check ${snapshot.pipeline.rounds.check})`,
 			hint: "call novel_rollback with to_stage P4; the manuscript is kept for reference"
-		};
+		});
+		if (stage === "P4") return roundsExhausted(snapshot.pipeline.rounds, "review") ? block("review") : null;
+		if (stage === "P5") return roundsExhausted(snapshot.pipeline.rounds, "revise") ? block("revise") : null;
+		if (roundsExhausted(snapshot.pipeline.rounds, "check")) return block("check");
+		if (snapshot.pipeline.blocking.length > 0 && roundsExhausted(snapshot.pipeline.rounds, "revise")) return block("revise");
+		return null;
 	}
 	/** Pipeline blockers plus budget exhaustion, so status/panel cannot say "all clear". */
 	effectiveBlocking(snapshot) {
@@ -5844,10 +6478,19 @@ var EngineService = class {
 			detail: `${error.code}: ${error.message}`,
 			hint: this.recoveryFor(snapshot).reason
 		}));
+		const active = snapshot.chapters.chapters.some((record) => record.num === snapshot.pipeline.chapter) ? [{
+			code: "ACTIVE_CHAPTER_INDEXED",
+			scope: "state",
+			detail: `chapter ${snapshot.pipeline.chapter} is active but already exists in state/chapters.yaml`,
+			hint: "read the index with novel_state {kind:\"chapters\", include_summary:true}, remove the active row with novel_amend, then continue"
+		}] : [];
 		const extra = this.roundsLimitBlock(snapshot);
 		const reviewDigest = this.reviewDigestProblem(snapshot);
+		const archive = this.archivePreflight(snapshot);
 		const base = [
 			...state,
+			...active,
+			...archive === null ? [] : [archive.item],
 			...reviewDigest === null ? [] : [reviewDigest],
 			...snapshot.pipeline.blocking
 		];
@@ -5879,8 +6522,18 @@ var EngineService = class {
 		return null;
 	}
 	stateErrors(snapshot) {
-		const errors = [];
+		const errors = [...snapshot.ledgerErrors];
+		if (snapshot.projectError !== null) errors.push({
+			path: PROJECT_FILE,
+			code: "PROJECT_UNREADABLE",
+			message: snapshot.projectError
+		});
 		const chapter = snapshot.pipeline.chapter;
+		if (snapshot.worldPlanError !== null) errors.push({
+			path: planWorldFile(chapter),
+			code: "WORLD_PLAN_UNREADABLE",
+			message: snapshot.worldPlanError
+		});
 		if (snapshot.planError !== null) errors.push({
 			path: planChapterFile(chapter),
 			code: "PLAN_UNREADABLE",
@@ -5902,7 +6555,26 @@ var EngineService = class {
 	recoveryFor(snapshot) {
 		const chapter = snapshot.pipeline.chapter;
 		const errors = this.stateErrors(snapshot);
-		const desired = snapshot.planError !== null ? "P2" : snapshot.reviewError !== null ? "P4" : "P6";
+		if (snapshot.projectError !== null) return {
+			tool: "novel_amend",
+			args: {
+				path: PROJECT_FILE,
+				reason: `repair PROJECT_UNREADABLE: ${snapshot.projectError}`
+			},
+			reason: `${errors.map((error) => `${error.code}@${error.path}`).join("; ")}; read novel_state novel for the raw document, then amend with a complete project document`
+		};
+		if (snapshot.ledgerErrors.length > 0) {
+			const first = snapshot.ledgerErrors[0];
+			return {
+				tool: "novel_amend",
+				args: {
+					path: first.path,
+					reason: `repair ${first.code}: ${first.message}`
+				},
+				reason: `${errors.map((error) => `${error.code}@${error.path}`).join("; ")}; read novel_state for the raw document, then amend it with a complete replacement`
+			};
+		}
+		const desired = snapshot.worldPlanError !== null ? "P1" : snapshot.planError !== null ? "P2" : snapshot.reviewError !== null ? "P4" : "P6";
 		const target = this.clampRollbackTarget(snapshot.pipeline.stage, desired);
 		const action = STAGE_RANK[ROUND_TRANSITIONS[target]] < STAGE_RANK[snapshot.pipeline.stage] ? `rollback to ${target} and rebuild through the normal stage tools` : `repair the file at ${snapshot.pipeline.stage} with its normal stage tool`;
 		return {
@@ -5937,13 +6609,16 @@ var EngineService = class {
 			"runCheck",
 			"archiveChapter"
 		];
+		const worldPlanSensitive = ["submitChapterPlan", ...planSensitive];
 		const reviewSensitive = [
 			"submitRevision",
 			"runCheck",
 			"archiveChapter"
 		];
 		const checkSensitive = ["archiveChapter"];
-		const relevant = [];
+		const relevant = [...snapshot.ledgerErrors];
+		if (snapshot.projectError !== null) relevant.push(...this.stateErrors(snapshot).filter((error) => error.code === "PROJECT_UNREADABLE"));
+		if (snapshot.worldPlanError !== null && worldPlanSensitive.includes(operation)) relevant.push(...this.stateErrors(snapshot).filter((error) => error.code === "WORLD_PLAN_UNREADABLE"));
 		if (snapshot.planError !== null && planSensitive.includes(operation)) relevant.push(...this.stateErrors(snapshot).filter((error) => error.code === "PLAN_UNREADABLE"));
 		if (snapshot.reviewError !== null && reviewSensitive.includes(operation)) relevant.push(...this.stateErrors(snapshot).filter((error) => error.code === "REVIEW_UNREADABLE"));
 		if (snapshot.checkError !== null && checkSensitive.includes(operation)) relevant.push(...this.stateErrors(snapshot).filter((error) => error.code === "CHECK_UNREADABLE"));
@@ -6002,7 +6677,7 @@ var EngineService = class {
 		}
 		if (chapters.length === 0 && snapshot.text !== null && (chapter === void 0 || chapter === snapshot.pipeline.chapter)) chapters.push({
 			num: snapshot.pipeline.chapter,
-			title: snapshot.plan?.title ?? "未命名",
+			title: stripTitlePrefix(snapshot.plan?.title ?? "") || "未命名",
 			text: snapshot.text
 		});
 		if (chapters.length === 0) throw new EngineInputError(ERROR_CODES.STAGE_ORDER, "no chapter is available to export", "write or archive at least one chapter first");
@@ -6011,7 +6686,7 @@ var EngineService = class {
 	machine(snapshot, text, extra) {
 		return runMachineChecks(text, {
 			chapter: snapshot.pipeline.chapter,
-			title: composeTitle(snapshot.pipeline.chapter, extra.title ?? snapshot.plan?.title ?? null),
+			title: composeTitle(snapshot.pipeline.chapter, extra.title ?? snapshot.plan?.title ?? null, this.rulepack.format.title.pattern),
 			genre: snapshot.project.genre,
 			sceneType: extra.sceneType ?? snapshot.plan?.scene_type ?? "日常过渡章",
 			rulepack: this.rulepack,
@@ -6029,12 +6704,20 @@ var EngineService = class {
 		});
 	}
 	briefContextFor(stage, snapshot, chapter) {
+		let cache = this.briefContextCache.get(snapshot);
+		if (cache === void 0) {
+			cache = /* @__PURE__ */ new Map();
+			this.briefContextCache.set(snapshot, cache);
+		}
+		const cacheKey = `${stage}:${chapter}`;
+		const cached = cache.get(cacheKey);
+		if (cached !== void 0) return cached;
 		const machine = [
 			"P4",
 			"P5",
 			"P6"
 		].includes(stage) && snapshot.text !== null ? this.machine(snapshot, snapshot.text, { summary: snapshot.plan?.summary ?? null }) : void 0;
-		return briefContext({
+		const context = briefContext({
 			stage,
 			chapter,
 			project: snapshot.project,
@@ -6046,6 +6729,8 @@ var EngineService = class {
 			foreshadows: snapshot.foreshadows,
 			timeline: snapshot.timeline,
 			relationships: snapshot.relationships,
+			worldPlan: snapshot.worldPlan,
+			world_plan_error: snapshot.worldPlanError,
 			plan: snapshot.plan,
 			plan_error: snapshot.planError,
 			review: snapshot.review,
@@ -6057,6 +6742,8 @@ var EngineService = class {
 			previousText: snapshot.previousText,
 			handoff: snapshot.handoff
 		});
+		cache.set(cacheKey, context);
+		return context;
 	}
 	briefDigest(stage, snapshot, context) {
 		const briefHash = this.briefs.render(stage, this.briefVariables(snapshot, snapshot.pipeline.chapter)).contentHash;
@@ -6084,17 +6771,19 @@ var EngineService = class {
 			round: snapshot.pipeline.stage === "P5" ? snapshot.pipeline.rounds.revise + 1 : snapshot.pipeline.rounds.review + 1
 		};
 	}
-	async assertGates(snapshot, operation, extras) {
+	/**
+	* The one place a gate input is assembled. Archive preflight evaluates the
+	* same object as the real archive, so a gate cannot pass preflight and then
+	* fail the write (the old PG-06/scope holes did exactly that).
+	*/
+	gateInput(snapshot, operation, extras = {}) {
 		const text = extras.text ?? snapshot.text ?? "";
-		if (!canRun(snapshot.pipeline.stage, operation)) throw new EngineInputError(ERROR_CODES.STAGE_ORDER, `${operation} is not allowed at stage ${snapshot.pipeline.stage}`, "call novel_status to see the next legal step");
-		const stateBlocking = this.stateGateBlock(snapshot, operation);
-		if (stateBlocking.length > 0) throw new EngineBlockedError(ERROR_CODES.GATE_BLOCKED, `${operation} blocked by unreadable state: ${stateBlocking[0].detail}`, stateBlocking, this.recoveryFor(snapshot).reason);
 		const archive = operation === "archiveChapter" ? {
 			chapterExists: snapshot.chapters.chapters.some((record) => record.num === snapshot.pipeline.chapter),
 			checkPassed: snapshot.check?.verdict === "pass",
 			hashMatches: snapshot.check !== null && snapshot.text !== null && snapshot.check.content_hash === sha256(snapshot.text)
 		} : null;
-		const result = evaluateGates({
+		return {
 			operation,
 			stage: snapshot.pipeline.stage,
 			text,
@@ -6104,7 +6793,7 @@ var EngineService = class {
 			chapters: snapshot.chapters,
 			briefDigest: extras.briefDigest ?? (extras.briefStage === void 0 || extras.briefStage === null ? null : this.briefDigest(extras.briefStage, snapshot, this.briefContextFor(extras.briefStage, snapshot, snapshot.pipeline.chapter))),
 			briefStage: extras.briefStage ?? briefStageFor(operation, snapshot.pipeline.stage),
-			draftTitle: composeTitle(snapshot.pipeline.chapter, extras.draftTitle ?? snapshot.plan?.title ?? null),
+			draftTitle: composeTitle(snapshot.pipeline.chapter, extras.draftTitle ?? snapshot.plan?.title ?? null, this.rulepack.format.title.pattern),
 			sceneType: extras.sceneType ?? snapshot.plan?.scene_type ?? null,
 			summary: extras.summary ?? snapshot.plan?.summary ?? null,
 			summaryProvided: extras.summaryProvided,
@@ -6126,7 +6815,13 @@ var EngineService = class {
 			previousText: snapshot.previousText,
 			previousTexts: snapshot.previousTexts,
 			priorSceneTypes: snapshot.chapters.chapters.map((record) => record.scene_type)
-		}, {
+		};
+	}
+	async assertGates(snapshot, operation, extras) {
+		if (!canRun(snapshot.pipeline.stage, operation)) throw new EngineInputError(ERROR_CODES.STAGE_ORDER, `${operation} is not allowed at stage ${snapshot.pipeline.stage}`, "call novel_status to see the next legal step");
+		const stateBlocking = this.stateGateBlock(snapshot, operation);
+		if (stateBlocking.length > 0) throw new EngineBlockedError(ERROR_CODES.GATE_BLOCKED, `${operation} blocked by unreadable state: ${stateBlocking[0].detail}`, stateBlocking, this.recoveryFor(snapshot).reason);
+		const result = evaluateGates(this.gateInput(snapshot, operation, extras), {
 			rulepack: this.rulepack,
 			minScore: this.config.quality.minScore
 		});
@@ -6153,36 +6848,76 @@ var EngineService = class {
 	}
 	async load(root, retries = 1) {
 		const store = this.storeFor(await this.resolveRoot(root));
-		if (!await store.exists("novel.yaml")) throw new EngineInputError(ERROR_CODES.PROJECT_NOT_FOUND, `no novel project at ${store.root}`, "call novel_init to create one, or pass the correct project root");
-		const project = await store.readDoc(PROJECT_FILE, "project");
-		if (project === null) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `${PROJECT_FILE} disappeared mid-read`);
+		const projectExists = await store.exists(PROJECT_FILE);
+		if (!projectExists) {
+			const stateFiles = [
+				STATE_FILES.pipeline,
+				STATE_FILES.chapters,
+				STATE_FILES.characters,
+				STATE_FILES.world,
+				STATE_FILES.locks,
+				STATE_FILES.timeline,
+				STATE_FILES.foreshadows,
+				STATE_FILES.relationships,
+				STATE_FILES.handoff
+			].map((file) => joinRel(STATE_DIR, file));
+			if (!((await Promise.all(stateFiles.map((path) => store.exists(path)))).some(Boolean) || (await store.list("chapters")).length > 0 || (await store.list("plans")).length > 0 || (await store.list("reviews")).length > 0 || (await store.list("checks")).length > 0)) throw new EngineInputError(ERROR_CODES.PROJECT_NOT_FOUND, `no novel project at ${store.root}`, "call novel_init to create one, or pass the correct project root");
+		}
+		let project = {
+			...ENGINE_PROJECT_INITIAL,
+			title: "（项目文件不可读）"
+		};
+		let projectError = projectExists ? null : `${PROJECT_FILE} is missing`;
+		if (projectExists) try {
+			const read = await store.readDoc(PROJECT_FILE, "project");
+			if (read === null) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `${PROJECT_FILE} disappeared mid-read`);
+			project = read;
+		} catch (error) {
+			if (error instanceof EngineFaultError && (error.code === ERROR_CODES.SCHEMA_TOO_NEW || error.code === ERROR_CODES.PATH_ESCAPE)) throw error;
+			projectError = errorMessage(error);
+		}
 		const pipeline = await store.readDoc(joinRel(STATE_DIR, STATE_FILES.pipeline), "pipeline");
 		if (pipeline === null) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, "state/pipeline.yaml is missing");
-		const chapters = await store.readDoc(joinRel("state", STATE_FILES.chapters), "chapters") ?? emptyChapters();
-		const characters = await store.readDoc(joinRel("state", STATE_FILES.characters), "characters") ?? emptyCharacters();
-		const world = await store.readDoc(joinRel("state", STATE_FILES.world), "world") ?? emptyWorld();
-		const locks = await store.readDoc(joinRel("state", STATE_FILES.locks), "locks") ?? {
+		const ledgerErrors = [];
+		const ledger = async (path, kind, code, fallback) => {
+			const read = await this.recoverableDoc(store, path, kind);
+			if (read.error !== null) ledgerErrors.push({
+				path,
+				code,
+				message: read.error
+			});
+			else if (read.value === null) ledgerErrors.push({
+				path,
+				code,
+				message: `${path} is missing`
+			});
+			return read.value ?? fallback;
+		};
+		const chapters = await ledger(joinRel(STATE_DIR, STATE_FILES.chapters), "chapters", "CHAPTERS_UNREADABLE", emptyChapters());
+		const characters = await ledger(joinRel(STATE_DIR, STATE_FILES.characters), "characters", "CHARACTERS_UNREADABLE", emptyCharacters());
+		const world = await ledger(joinRel(STATE_DIR, STATE_FILES.world), "world", "WORLD_UNREADABLE", emptyWorld());
+		const locks = await ledger(joinRel(STATE_DIR, STATE_FILES.locks), "locks", "LOCKS_UNREADABLE", {
 			schema_version: 1,
 			locked_at_chapter: 0,
 			characters: {},
 			locations: {}
-		};
-		const timeline = await store.readDoc(joinRel("state", STATE_FILES.timeline), "timeline") ?? {
+		});
+		const timeline = await ledger(joinRel(STATE_DIR, STATE_FILES.timeline), "timeline", "TIMELINE_UNREADABLE", {
 			schema_version: 1,
 			next_seq: 1,
 			items: []
-		};
-		const foreshadows = await store.readDoc(joinRel("state", STATE_FILES.foreshadows), "foreshadows") ?? {
+		});
+		const foreshadows = await ledger(joinRel(STATE_DIR, STATE_FILES.foreshadows), "foreshadows", "FORESHADOWS_UNREADABLE", {
 			schema_version: 1,
 			next_seq: 1,
 			items: []
-		};
-		const relationships = await store.readDoc(joinRel("state", STATE_FILES.relationships), "relationships") ?? {
+		});
+		const relationships = await ledger(joinRel(STATE_DIR, STATE_FILES.relationships), "relationships", "RELATIONSHIPS_UNREADABLE", {
 			schema_version: 1,
 			next_seq: 1,
 			items: []
-		};
-		const handoff = await store.readDoc(joinRel(STATE_DIR, STATE_FILES.handoff), "handoff");
+		});
+		const handoff = await ledger(joinRel(STATE_DIR, STATE_FILES.handoff), "handoff", "HANDOFF_UNREADABLE", null);
 		const chapter = pipeline.chapter;
 		const text = await store.readText(chapterFile(chapter));
 		const previousText = chapter > 1 ? await store.readText(chapterFile(chapter - 1)) : null;
@@ -6202,12 +6937,29 @@ var EngineService = class {
 			if (error instanceof EngineFaultError && error.code === ERROR_CODES.SCHEMA_TOO_NEW) throw error;
 			planError = errorMessage(error);
 		}
+		const worldPlanPath = planWorldFile(chapter);
+		const worldPlanRaw = await store.readText(worldPlanPath);
+		let worldPlan = null;
+		let worldPlanError = null;
+		if (worldPlanRaw !== null) try {
+			const narrowed = narrow("worldPlan", parsePlanYaml(worldPlanRaw, worldPlanPath));
+			validateWorldPlanShape(narrowed, worldPlanPath);
+			worldPlan = narrowed;
+		} catch (error) {
+			if (error instanceof EngineFaultError && error.code === ERROR_CODES.SCHEMA_TOO_NEW) throw error;
+			worldPlanError = errorMessage(error);
+		}
 		const reviewRead = await this.recoverableDoc(store, reviewFile(chapter), "review");
 		const checkRead = await this.recoverableDoc(store, checkFile(chapter), "check");
 		const review = reviewRead.value;
-		const reviewError = reviewRead.error;
+		let reviewError = reviewRead.error;
 		const check = checkRead.value;
-		const checkError = checkRead.error;
+		let checkError = checkRead.error;
+		const cycleRank = pipeline.stage === "done" ? STAGE_RANK.idle : STAGE_RANK[pipeline.stage];
+		if (worldPlanRaw === null && worldPlanError === null && cycleRank >= STAGE_RANK.P2) worldPlanError = `${planWorldFile(chapter)} is missing`;
+		if (planRaw === null && planError === null && cycleRank >= STAGE_RANK.P3) planError = `${planChapterFile(chapter)} is missing`;
+		if (review === null && reviewError === null && cycleRank >= STAGE_RANK.P5) reviewError = `${reviewFile(chapter)} is missing`;
+		if (check === null && checkError === null && pipeline.stage === "ready_to_archive") checkError = `${checkFile(chapter)} is missing`;
 		const latest = await store.readDoc(joinRel(STATE_DIR, STATE_FILES.pipeline), "pipeline");
 		if (latest === null || latest.revision !== pipeline.revision) {
 			if (retries > 0) return this.load(store.root, retries - 1);
@@ -6217,6 +6969,7 @@ var EngineService = class {
 		return {
 			root: store.root,
 			project,
+			projectError,
 			pipeline,
 			chapters,
 			characters,
@@ -6226,17 +6979,31 @@ var EngineService = class {
 			foreshadows,
 			relationships,
 			handoff,
+			worldPlan,
+			ledgerErrors,
 			text,
 			previousText,
 			previousTexts,
 			plan,
 			planError,
+			worldPlanError,
 			review,
 			reviewError,
 			check,
 			checkError
 		};
 	}
+	/** A repair may bypass the journal hash only when the document is unreadable. */
+	async stateDocIsUnreadable(store, path, kind) {
+		if (await store.readText(path) === null) return true;
+		try {
+			await store.readDoc(path, kind);
+			return false;
+		} catch (error) {
+			if (error instanceof EngineFaultError && error.code === ERROR_CODES.SCHEMA_TOO_NEW) return false;
+			return true;
+		}
+	}
 	/** Read a review/check without letting one corrupt file wedge every read. */
 	async recoverableDoc(store, path, kind) {
 		try {
@@ -6313,7 +7080,7 @@ var EngineService = class {
 						};
 					}
 				}
-				await assertJournalConsistent(store);
+				await assertJournalConsistent(store, options.repairPaths ?? []);
 				const snapshot = await this.load(root);
 				const key = options.key?.(snapshot);
 				if (key !== void 0) {
@@ -6374,6 +7141,7 @@ var EngineService = class {
 		return {
 			root,
 			project: { ...ENGINE_PROJECT_INITIAL },
+			projectError: null,
 			pipeline: emptyPipeline({
 				revision: 1,
 				chapter: 1,
@@ -6404,11 +7172,14 @@ var EngineService = class {
 				items: []
 			},
 			handoff: null,
+			worldPlan: null,
+			ledgerErrors: [],
 			text: null,
 			previousText: null,
 			previousTexts: [],
 			plan: null,
 			planError: null,
+			worldPlanError: null,
 			review: null,
 			reviewError: null,
 			check: null,
@@ -6488,20 +7259,362 @@ const machineWarnings = (machine) => machine.violations.filter((violation) => vi
 	code: violation.code,
 	message: `${violation.detail} (paragraph ${violation.location.paragraph})`
 }));
-/** Titles are stored as bodies; the format rule judges the rendered heading. */
-const composeTitle = (chapter, title) => {
-	if (title === null) return null;
-	return /^第\s*\d+\s*章/.test(title) ? title : `第${chapter}章 ${title}`;
-};
-const stableJson = (value) => {
+/** 0.1.2 archive digests used localeCompare; keep that comparison only for upgrades. */
+const legacyStableJson = (value) => {
 	const normalize = (input) => {
 		if (Array.isArray(input)) return input.map(normalize);
-		if (typeof input === "object" && input !== null) return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => [key, normalize(value)]));
+		if (typeof input === "object" && input !== null) return Object.fromEntries(Object.entries(input).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, normalize(item)]));
 		return input;
 	};
-	return JSON.stringify(normalize(value));
+	return JSON.stringify(normalize(value)) ?? "null";
+};
+const normalizeHandoffOverride = (value) => {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value !== "object" || Array.isArray(value)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "handoff must be an object");
+	const volume = value.volume;
+	if (volume !== void 0 && (!Number.isInteger(volume) || volume < 1)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "handoff.volume must be a positive integer");
+	const volumeName = value.volume_name;
+	if (volumeName !== void 0 && (typeof volumeName !== "string" || volumeName.trim() === "")) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "handoff.volume_name must be non-empty");
+	const act = value.act;
+	if (act !== void 0 && (typeof act !== "string" || act.trim() === "")) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "handoff.act must be non-empty");
+	const actProgress = value.act_progress;
+	if (actProgress !== void 0 && parseActProgress(actProgress) === null) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "handoff.act_progress must be n/d with a positive denominator and n <= d");
+	return {
+		...volume === void 0 ? {} : { volume },
+		...volumeName === void 0 ? {} : { volume_name: volumeName.trim() },
+		...act === void 0 ? {} : { act: act.trim() },
+		...actProgress === void 0 ? {} : { act_progress: actProgress.trim() }
+	};
+};
+const legacyArchiveDigest = (input) => sha256(legacyStableJson({
+	chapter: input.chapter,
+	state_delta: input.state_delta,
+	handoff: input.handoff
+}));
+const LENIENT_TITLE_PREFIX = /^第\s*\d+\s*章\s*/;
+/** Titles are stored as bodies; the format rule judges the rendered heading. */
+const stripTitlePrefix = (title) => title.replace(LENIENT_TITLE_PREFIX, "").trim();
+const composeTitle = (chapter, title, pattern) => {
+	if (title === null) return null;
+	const text = title.trim();
+	if (pattern !== void 0 && new RegExp(pattern).test(text)) return text;
+	const body = stripTitlePrefix(text);
+	return `第${chapter}章 ${body === "" ? text : body}`;
 };
 const errorMessage = (error) => error instanceof Error ? `${error.message}${error.cause instanceof Error ? `: ${error.cause.message}` : ""}` : String(error);
+const recordOf = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+const mergeProjectAmendment = (content, old) => {
+	const allowed = /* @__PURE__ */ new Set([
+		"schema_version",
+		"title",
+		"author",
+		"description",
+		"targets",
+		"total_chapters"
+	]);
+	for (const key of Object.keys(content)) if (!allowed.has(key)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `novel.yaml amend cannot change "${key}"`, "only title, author, description and targets.total_chapters are mutable");
+	const merged = {
+		...old,
+		...content
+	};
+	if (content.targets !== void 0) {
+		const targets = recordOf(content.targets);
+		if (targets === null) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "targets must be an object");
+		const allowedTargets = /* @__PURE__ */ new Set([
+			"words_per_chapter",
+			"dialogue_ratio",
+			"total_chapters"
+		]);
+		for (const key of Object.keys(targets)) if (!allowedTargets.has(key)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `novel.yaml targets cannot change "${key}"`, "only targets.total_chapters is mutable; words_per_chapter and dialogue_ratio are immutable");
+		merged.targets = {
+			...old.targets,
+			...targets
+		};
+	}
+	if (Object.hasOwn(content, "total_chapters")) merged.targets = {
+		...recordOf(merged.targets) ?? {},
+		total_chapters: content.total_chapters
+	};
+	delete merged.total_chapters;
+	return narrow("project", merged);
+};
+const amendProblems = (kind, oldDocument, nextDocument, snapshot, path, archivedFiles = 0, projectBaseline = snapshot.project, projectDamaged = false, archiveDigests = {}) => {
+	const problems = [];
+	const old = recordOf(oldDocument);
+	if (kind === "project") {
+		const next = nextDocument;
+		const targets = recordOf(next.targets);
+		if (typeof next.title !== "string" || next.title.trim() === "") problems.push("title must not be empty");
+		if (!projectDamaged) {
+			if (next.genre !== projectBaseline.genre) problems.push("genre is immutable");
+			if (next.platform !== projectBaseline.platform) problems.push("platform is immutable");
+			if (next.created_at !== projectBaseline.created_at) problems.push("created_at is immutable");
+		}
+		const oldTargets = projectBaseline.targets;
+		if (targets === null) problems.push("targets must be an object");
+		else {
+			if (!projectDamaged && (JSON.stringify(targets.words_per_chapter) !== JSON.stringify(oldTargets.words_per_chapter) || JSON.stringify(targets.dialogue_ratio) !== JSON.stringify(oldTargets.dialogue_ratio))) problems.push("words_per_chapter and dialogue_ratio are immutable; only total_chapters may change");
+			const total = targets.total_chapters;
+			if (total !== null && (!Number.isInteger(total) || total < 1)) problems.push("targets.total_chapters must be a positive integer or null");
+			const archivedCount = Math.max(snapshot.chapters.chapters.length, archivedFiles);
+			if (typeof total === "number" && Number.isInteger(total) && total < archivedCount) problems.push(`targets.total_chapters ${total} is below the ${archivedCount} archived chapter(s)`);
+		}
+		return problems;
+	}
+	if (kind === "chapters") {
+		const active = snapshot.pipeline.chapter;
+		const oldRows = Array.isArray(old?.chapters) ? old.chapters : [];
+		const nextRows = Array.isArray(nextDocument.chapters) ? nextDocument.chapters : [];
+		const rowNum = (raw) => {
+			const row = recordOf(raw);
+			return row !== null && Number.isInteger(row.num) ? row.num : null;
+		};
+		const oldArchived = oldRows.filter((raw) => {
+			const num = rowNum(raw);
+			return num !== null && num < active;
+		});
+		const nextArchived = nextRows.filter((raw) => {
+			const num = rowNum(raw);
+			return num !== null && num < active;
+		});
+		if (nextArchived.length < oldArchived.length) problems.push("archived chapters may not be deleted");
+		const archivedCount = Math.max(0, active - 1, archivedFiles);
+		if (nextArchived.length < archivedCount) problems.push(`chapters index has ${nextArchived.length} archived rows but ${archivedCount} chapter(s) are archived`);
+		const byNum = /* @__PURE__ */ new Map();
+		for (const [index, raw] of nextRows.entries()) {
+			const row = recordOf(raw);
+			if (row === null || !Number.isInteger(row.num)) {
+				problems.push(`chapters[${index}] is not a valid record`);
+				continue;
+			}
+			const num = row.num;
+			if (num !== index + 1) problems.push(`chapters[${index}].num must be ${index + 1}`);
+			if (num >= active) problems.push(`chapter ${num} is active or in the future; the index may contain only archived chapters`);
+			if (byNum.has(num)) problems.push(`chapter ${num} appears more than once`);
+			byNum.set(num, row);
+			const knownDigest = archiveDigests[String(num)];
+			if (knownDigest !== void 0 && row.archive_digest !== knownDigest) problems.push(`archived chapter ${num} cannot change its archive_digest`);
+		}
+		for (const raw of oldArchived) {
+			const before = recordOf(raw);
+			if (before === null || !Number.isInteger(before.num)) continue;
+			const after = byNum.get(before.num);
+			if (after === void 0) {
+				problems.push(`archived chapter ${String(before.num)} is missing`);
+				continue;
+			}
+			if (before.content_hash !== after.content_hash) problems.push(`archived chapter ${String(before.num)} cannot change its content_hash`);
+			if (before.archive_digest !== after.archive_digest) problems.push(`archived chapter ${String(before.num)} cannot change its archive_digest`);
+			if (stableJson(before.assigned_ids ?? {}) !== stableJson(after.assigned_ids ?? {})) problems.push(`archived chapter ${String(before.num)} cannot change its assigned_ids`);
+		}
+		return problems;
+	}
+	if (kind === "timeline" || kind === "foreshadows" || kind === "relationships") {
+		if (snapshot.ledgerErrors.some((error) => error.code === "CHAPTERS_UNREADABLE")) {
+			problems.push("cannot validate next_seq while chapters.yaml is unreadable");
+			return problems;
+		}
+		if (kind === "foreshadows" && snapshot.ledgerErrors.some((error) => error.code === "HANDOFF_UNREADABLE")) {
+			problems.push("cannot validate next_seq while handoff.yaml is unreadable");
+			return problems;
+		}
+		const items = Array.isArray(nextDocument.items) ? nextDocument.items : [];
+		const ids = /* @__PURE__ */ new Set();
+		let maxSuffix = 0;
+		for (const [index, raw] of items.entries()) {
+			const row = recordOf(raw);
+			if (row === null || typeof row.id !== "string" || row.id === "") {
+				problems.push(`items[${index}].id must be a non-empty string`);
+				continue;
+			}
+			if (ids.has(row.id)) problems.push(`item id "${row.id}" appears more than once`);
+			ids.add(row.id);
+			const match = /-(\d+)$/.exec(row.id);
+			if (match !== null) maxSuffix = Math.max(maxSuffix, Number(match[1]));
+		}
+		const nextSeq = nextDocument.next_seq;
+		const prefix = kind === "foreshadows" ? "FS-" : kind === "timeline" ? "TE-" : "RL-";
+		let engineFloor = 0;
+		for (const chapter of snapshot.chapters.chapters) for (const value of Object.values(chapter.assigned_ids ?? {})) {
+			if (typeof value !== "string" || !value.startsWith(prefix)) continue;
+			const match = /-(\d+)$/.exec(value);
+			if (match !== null) engineFloor = Math.max(engineFloor, Number(match[1]));
+		}
+		if (kind === "foreshadows" && snapshot.handoff !== null) for (const hook of snapshot.handoff.open_hooks) {
+			if (!hook.id.startsWith(prefix)) continue;
+			const match = /-(\d+)$/.exec(hook.id);
+			if (match !== null) engineFloor = Math.max(engineFloor, Number(match[1]));
+		}
+		if (!Number.isInteger(nextSeq) || nextSeq < 1) problems.push("next_seq must be a positive integer");
+		else {
+			if (nextSeq < maxSuffix + 1) problems.push(`next_seq ${String(nextSeq)} would collide with existing id suffix ${maxSuffix}`);
+			if (nextSeq < items.length + 1) problems.push(`next_seq ${String(nextSeq)} is below items.length + 1`);
+			if (nextSeq < engineFloor + 1) problems.push(`next_seq ${String(nextSeq)} would reuse an id already assigned by an archived chapter (${prefix}${String(engineFloor).padStart(3, "0")})`);
+			const oldSeq = old?.next_seq;
+			if (typeof oldSeq === "number" && nextSeq < oldSeq) problems.push(`next_seq cannot decrease from ${oldSeq} to ${String(nextSeq)}`);
+		}
+		if (kind !== "relationships") return problems;
+	}
+	if (kind === "characters") {
+		const names = new Set((Array.isArray(nextDocument.characters) ? nextDocument.characters : []).map((raw) => recordOf(raw)?.name).filter((name) => typeof name === "string"));
+		if (!snapshot.ledgerErrors.some((error) => error.code === "LOCKS_UNREADABLE")) {
+			for (const name of Object.keys(snapshot.locks.characters)) if (!names.has(name)) problems.push(`lock for removed character "${name}" still exists`);
+		}
+		if (!snapshot.ledgerErrors.some((error) => error.code === "RELATIONSHIPS_UNREADABLE")) {
+			for (const relationship of snapshot.relationships.items) if (!names.has(relationship.a) || !names.has(relationship.b)) problems.push(`relationship ${relationship.id} would reference a removed character`);
+		}
+		return problems;
+	}
+	if (kind === "world") {
+		const locations = new Set((Array.isArray(nextDocument.locations) ? nextDocument.locations : []).map((raw) => recordOf(raw)?.name).filter((name) => typeof name === "string"));
+		if (!snapshot.ledgerErrors.some((error) => error.code === "LOCKS_UNREADABLE")) {
+			for (const name of Object.keys(snapshot.locks.locations)) if (!locations.has(name)) problems.push(`lock for removed location "${name}" still exists`);
+		}
+		return problems;
+	}
+	if (kind === "locks") {
+		const characters = new Set(snapshot.characters.characters.map((character) => character.name));
+		const locations = new Set(snapshot.world.locations.map((location) => location.name));
+		if (snapshot.ledgerErrors.some((error) => error.code === "CHARACTERS_UNREADABLE")) problems.push("cannot validate locks while characters.yaml is unreadable");
+		if (snapshot.ledgerErrors.some((error) => error.code === "WORLD_UNREADABLE")) problems.push("cannot validate locks while world.yaml is unreadable");
+		for (const name of Object.keys(recordOf(nextDocument.characters) ?? {})) if (!characters.has(name)) problems.push(`lock references unknown character "${name}"`);
+		for (const name of Object.keys(recordOf(nextDocument.locations) ?? {})) if (!locations.has(name)) problems.push(`lock references unknown location "${name}"`);
+		return problems;
+	}
+	if (kind === "relationships") {
+		if (snapshot.ledgerErrors.some((error) => error.code === "CHARACTERS_UNREADABLE")) {
+			problems.push("cannot validate relationships while characters.yaml is unreadable");
+			return problems;
+		}
+		const names = new Set(snapshot.characters.characters.map((character) => character.name));
+		for (const raw of Array.isArray(nextDocument.items) ? nextDocument.items : []) {
+			const row = recordOf(raw);
+			if (row !== null && (typeof row.a !== "string" || typeof row.b !== "string")) problems.push("relationship endpoints must be strings");
+			else if (row !== null && (!names.has(row.a) || !names.has(row.b))) problems.push(`relationship ${String(row.id)} references an unknown character`);
+		}
+		return problems;
+	}
+	if (kind === "handoff") {
+		const current = nextDocument.current_chapter;
+		const next = nextDocument.next_chapter;
+		if (!Number.isInteger(current) || current < 0) problems.push("handoff.current_chapter must be a non-negative integer");
+		if (!Number.isInteger(next) || next < 1) problems.push("handoff.next_chapter must be a positive integer");
+		else if (typeof current === "number" && Number.isInteger(current) && next !== current + 1) problems.push("handoff.next_chapter must equal current_chapter + 1");
+		if (!Number.isInteger(nextDocument.volume) || nextDocument.volume < 1) problems.push("handoff.volume must be a positive integer");
+		for (const field of ["volume_name", "act"]) if (typeof nextDocument[field] !== "string" || nextDocument[field].trim() === "") problems.push(`handoff.${field} must be non-empty`);
+		if (parseActProgress(nextDocument.act_progress) === null) problems.push("handoff.act_progress must be n/d with a positive denominator and n <= d");
+		if (!snapshot.ledgerErrors.some((error) => error.code === "CHAPTERS_UNREADABLE")) {
+			const archivedMax = snapshot.chapters.chapters.reduce((max, record) => Math.max(max, record.num), 0);
+			if (typeof current === "number" && Number.isInteger(current) && current !== archivedMax) problems.push(`handoff.current_chapter ${String(current)} must match archived chapter ${archivedMax}`);
+		}
+		const hooks = Array.isArray(nextDocument.open_hooks) ? nextDocument.open_hooks : [];
+		const seenHooks = /* @__PURE__ */ new Set();
+		if (!snapshot.ledgerErrors.some((error) => error.code === "FORESHADOWS_UNREADABLE")) {
+			const openById = new Map(snapshot.foreshadows.items.map((item) => [item.id, item]));
+			for (const raw of hooks) {
+				const hook = recordOf(raw);
+				if (hook === null || typeof hook.id !== "string" || typeof hook.title !== "string") {
+					problems.push("handoff.open_hooks must contain id/title strings");
+					continue;
+				}
+				if (seenHooks.has(hook.id)) problems.push(`handoff.open_hooks duplicate ${hook.id}`);
+				seenHooks.add(hook.id);
+				const known = openById.get(hook.id);
+				if (known === void 0) problems.push(`handoff.open_hooks references unknown foreshadow ${hook.id}`);
+				else if (known.title !== hook.title) problems.push(`handoff.open_hooks title for ${hook.id} does not match foreshadows`);
+			}
+		}
+		return problems;
+	}
+	return problems;
+};
+const castShapeProblems = (value) => {
+	if (!Array.isArray(value)) return ["cast must be an array"];
+	if (value.length < 1 || value.length > 8) return ["cast must contain 1..8 members"];
+	const problems = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const [index, raw] of value.entries()) {
+		if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+			problems.push(`cast[${index}] must be an object`);
+			continue;
+		}
+		const member = raw;
+		if (typeof member.name !== "string" || member.name.trim() === "") {
+			problems.push(`cast[${index}].name must be non-empty`);
+			continue;
+		}
+		if (names.has(member.name)) problems.push(`cast contains duplicate name "${member.name}"`);
+		names.add(member.name);
+		for (const field of [
+			"entry_state",
+			"goal",
+			"exit_change"
+		]) if (member[field] !== void 0 && typeof member[field] !== "string") problems.push(`cast[${index}].${field} must be a string`);
+		if (member.knowledge !== void 0 && (!Array.isArray(member.knowledge) || member.knowledge.some((item) => typeof item !== "string"))) problems.push(`cast[${index}].knowledge must be a string array`);
+	}
+	return problems;
+};
+const normalizeCast = (value, snapshot) => {
+	if (value === void 0) return void 0;
+	const problems = castShapeProblems(value);
+	if (problems.length > 0) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, problems.join("; "));
+	const members = value;
+	const known = /* @__PURE__ */ new Set([...(snapshot.worldPlan?.characters ?? []).map((character) => character.name), ...snapshot.characters.characters.map((character) => character.name)]);
+	for (const member of members) if (!known.has(member.name)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `cast member "${member.name}" is not declared in the P1 world plan or the character ledger`, "add the character to novel_plan_world first; cast cannot invent an actor");
+	return members;
+};
+/** The summary fields the read model dereferences at P3–P6 and in the panel. */
+const summaryContextProblems = (value) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return ["summary must be an object when present"];
+	const summary = value;
+	const problems = [];
+	const strings = (key) => {
+		if (!Array.isArray(summary[key]) || summary[key].some((item) => typeof item !== "string")) problems.push(`summary.${key} must be a string array`);
+	};
+	strings("events");
+	strings("characters_appeared");
+	strings("pleasure_points");
+	const foreshadows = recordOf(summary.foreshadows);
+	if (foreshadows === null) problems.push("summary.foreshadows must be an object");
+	else for (const key of [
+		"planted",
+		"advanced",
+		"resolved"
+	]) if (!Array.isArray(foreshadows[key])) problems.push(`summary.foreshadows.${key} must be an array`);
+	const elements = recordOf(summary.new_elements);
+	if (elements === null) problems.push("summary.new_elements must be an object");
+	else for (const key of [
+		"locations",
+		"abilities",
+		"artifacts"
+	]) if (!Array.isArray(elements[key]) || elements[key].some((item) => typeof item !== "string")) problems.push(`summary.new_elements.${key} must be a string array`);
+	if (!Array.isArray(summary.resource_changes)) problems.push("summary.resource_changes must be an array");
+	if (typeof summary.opening !== "string") problems.push("summary.opening must be a string");
+	const continuity = recordOf(summary.continuity);
+	if (continuity === null) problems.push("summary.continuity must be an object");
+	else for (const key of ["opens_from", "ends_with"]) if (typeof continuity[key] !== "string") problems.push(`summary.continuity.${key} must be a string`);
+	if (!Number.isInteger(summary.hook_strength)) problems.push("summary.hook_strength must be an integer");
+	if (![
+		"high",
+		"mid",
+		"low"
+	].includes(summary.plot_advancement)) problems.push("summary.plot_advancement must be high|mid|low");
+	return problems;
+};
+/** Validate the nested roster fields the context builder dereferences. */
+const validateWorldPlanShape = (plan, path) => {
+	const fail = (detail) => {
+		throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `${path} is not a usable world plan: ${detail}`);
+	};
+	for (const key of ["constraints", "continuity_notes"]) if (!Array.isArray(plan[key]) || plan[key].some((item) => typeof item !== "string")) fail(`${key} must be a string array`);
+	for (const key of ["characters", "locations"]) {
+		if (!Array.isArray(plan[key])) fail(`${key} must be an array`);
+		for (const [index, raw] of plan[key].entries()) {
+			const row = recordOf(raw);
+			if (row === null || typeof row.name !== "string" || row.name.trim() === "") fail(`${key}[${index}].name must be a non-empty string`);
+		}
+	}
+};
 /** Validate the shape a stored chapter plan must have before any stage uses it. */
 const validateStoredChapterPlan = (plan, path) => {
 	const fail = (detail) => {
@@ -6526,7 +7639,14 @@ const validateStoredChapterPlan = (plan, path) => {
 	if (!SCENE_TYPES.includes(plan.scene_type)) fail(`unknown scene_type "${String(plan.scene_type)}"`);
 	if (!Array.isArray(plan.beats) || plan.beats.some((beat) => typeof beat !== "string")) fail("beats must be a string array");
 	if (!Array.isArray(plan.target_words) || plan.target_words.length !== 2 || plan.target_words.some((value) => !Number.isInteger(value) || value <= 0)) fail("target_words must be [min, max] positive integers");
-	if (plan.summary !== void 0 && (typeof plan.summary !== "object" || plan.summary === null)) fail("summary must be an object when present");
+	if (plan.summary !== void 0) {
+		const problems = summaryContextProblems(plan.summary);
+		if (problems.length > 0) fail(problems.join("; "));
+	}
+	if (plan.cast !== void 0) {
+		const problems = castShapeProblems(plan.cast);
+		if (problems.length > 0) fail(problems.join("; "));
+	}
 };
 const CHECK_SCOPES = ["content", "integrity"];
 const normalizeCheckScope = (value) => {
@@ -6823,6 +7943,10 @@ function createNovelTools(engine) {
 					type: "array",
 					items: { type: "integer" }
 				},
+				cast: {
+					type: "json",
+					description: "Optional 1–8 characters on stage this chapter. Each: name, entry_state, goal, knowledge, exit_change. Names must exist in the P1 world plan or the character ledger."
+				},
 				project_root: root
 			},
 			output: jsonOutput,
@@ -6835,6 +7959,7 @@ function createNovelTools(engine) {
 				opening: args.opening ?? "",
 				ending: args.ending ?? "",
 				target_words: [args.target_words?.[0] ?? 2e3, args.target_words?.[1] ?? 3e3],
+				...args.cast === void 0 ? {} : { cast: asJson(args.cast, "cast") },
 				root: args.project_root
 			}))
 		}),
@@ -7046,12 +8171,23 @@ function createNovelTools(engine) {
 					]
 				},
 				chapter: { type: "integer" },
+				include_summary: {
+					type: "boolean",
+					description: "For kind=chapters: include the full ten-field summary (default compact)."
+				},
+				chapter_range: {
+					type: "array",
+					items: { type: "integer" },
+					description: "For kind=chapters: inclusive [start, end] range."
+				},
 				project_root: root
 			},
 			output: jsonOutput,
 			execute: guarded(async (args) => engine.queryState({
 				kind: args.kind,
 				chapter: args.chapter,
+				...args.include_summary === void 0 ? {} : { include_summary: args.include_summary },
+				...args.chapter_range === void 0 ? {} : { chapter_range: args.chapter_range },
 				root: args.project_root
 			}))
 		}),
@@ -7063,6 +8199,7 @@ function createNovelTools(engine) {
 					type: "string",
 					required: true,
 					enum: [
+						"novel.yaml",
 						"state/chapters.yaml",
 						"state/characters.yaml",
 						"state/world.yaml",