dsh-novel-write-engine 0.1.1 → 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 = {
@@ -1023,10 +1002,16 @@ const adjectiveDensity = (ctx) => {
 	return [v(SEMANTIC_RULES.ADJECTIVE_DENSITY, "advisory", 1, `adjectives every ${(100 / density).toFixed(1)} chars; limit is ${max}%`)];
 };
 const slidingWindows = (text, size) => {
-	if (text.length <= size) return [text];
+	const positions = [];
+	for (let index = 0; index < text.length; index += 1) if (/\S/.test(text[index])) positions.push(index);
+	if (positions.length <= size) return [text];
 	const windows = [];
-	for (let start = 0; start + size <= text.length; start += 1) windows.push(text.slice(start, start + size));
-	const tail = text.slice(text.length - size);
+	for (let startIndex = 0; startIndex + size <= positions.length; startIndex += 1) {
+		const start = positions[startIndex];
+		const end = startIndex + size < positions.length ? positions[startIndex + size] : text.length;
+		windows.push(text.slice(start, end));
+	}
+	const tail = text.slice(positions[positions.length - size]);
 	if (windows[windows.length - 1] !== tail) windows.push(tail);
 	return windows;
 };
@@ -1104,10 +1089,18 @@ const revisitedTooSoon = (ctx) => {
 	}).map((item) => v(CROSS_RULES.FS_REVISITED_TOO_SOON, "advisory", 1, `foreshadow ${item.id} reappears after ${ctx.chapter - item.last_touched} chapters (minimum ${min})`));
 };
 const resourceMismatch = (ctx) => {
-	return (ctx.summary?.resource_changes ?? []).flatMap((change) => {
+	const changes = ctx.summary?.resource_changes ?? [];
+	const positive = /(增加|多了|得到|获得|赚|加|上升|增|\+)/;
+	const negative = /(减少|少了|失去|消耗|花|损失|下降|减|-|−)/;
+	return changes.flatMap((change) => {
 		if (change.delta === 0) return [];
-		const magnitude = String(Math.abs(change.delta));
-		return ctx.text.includes(change.character) && ctx.text.includes(magnitude) ? [] : [v(CROSS_RULES.RESOURCE_MISMATCH, "advisory", 1, `${change.character}'s ${change.resource} change (${change.delta}) is not stated in the text`)];
+		const magnitude = Math.abs(change.delta);
+		return [...ctx.text.matchAll(/\d+/g)].some((match) => {
+			if (Number(match[0]) !== magnitude) return false;
+			const index = match.index ?? 0;
+			const window = ctx.text.slice(Math.max(0, index - 80), Math.min(ctx.text.length, index + match[0].length + 80));
+			return window.includes(change.character) && window.includes(change.resource) && (change.delta > 0 ? positive : negative).test(window);
+		}) ? [] : [v(CROSS_RULES.RESOURCE_MISMATCH, "advisory", 1, `${change.character}'s ${change.resource} change (${change.delta}) is not stated with the right sign in the text`)];
 	});
 };
 const timeRegression = (ctx) => {
@@ -1263,6 +1256,11 @@ const lexiconCodes = /* @__PURE__ */ new Set([
 	"GOD_VIEW",
 	"CONCLUSION_FIRST"
 ]);
+const integrityCodes = new Set(Object.values(CROSS_RULES));
+/** Which runCheck scope owns one machine finding. */
+function scopeOfRule(code) {
+	return integrityCodes.has(code) ? "integrity" : "content";
+}
 /**
 * Run the deterministic pass. Format and punctuation run before the lexicon so
 * the report reads in the order an author fixes things; the lexicon runs last
@@ -2101,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");
 	}
 }
@@ -2474,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;
@@ -2548,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. */
@@ -2588,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
@@ -2824,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,
@@ -2841,13 +3007,113 @@ 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
 * guessing who exists, what was locked, or what the previous chapter ended on.
 */
-function briefContext(input) {
+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,
@@ -2859,26 +3125,38 @@ function briefContext(input) {
 		stage: input.pipeline.stage,
 		scene_distribution: sceneDistribution(input.chapters),
 		previous_ending: previousEnding,
-		...input.plan_error === void 0 || input.plan_error === null ? {} : { plan_error: input.plan_error }
+		...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)
@@ -2887,8 +3165,11 @@ function briefContext(input) {
 			...base,
 			text: input.text ?? "",
 			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,
@@ -2898,15 +3179,23 @@ function briefContext(input) {
 		case "P5": return {
 			...base,
 			text: input.text ?? "",
+			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,
@@ -2922,6 +3211,7 @@ function briefContext(input) {
 		};
 		case "P8": return {
 			...base,
+			plan: input.plan,
 			check: input.check,
 			review: input.review,
 			summary: input.plan?.summary ?? null,
@@ -2931,6 +3221,264 @@ function briefContext(input) {
 		default: return base;
 	}
 }
+/** Per-stage context budgets, measured in JSON characters (metadata excluded). */
+const CONTEXT_BUDGETS = {
+	P1: 6e3,
+	P2: 8e3,
+	P3: 16e3,
+	P4: 24e3,
+	P5: 24e3,
+	P6: 32e3,
+	P8: 12e3
+};
+const asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+const asArray = (value) => Array.isArray(value) ? value : null;
+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
+* are never candidates; optional ledgers are trimmed round-robin so one large
+* list cannot starve every other kind of context.
+*/
+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",
+		"stage",
+		"previous_ending",
+		"text",
+		"plan",
+		"precheck",
+		"review",
+		"check",
+		"machine",
+		"summary",
+		"world_plan",
+		"active_cast",
+		...stage === "P3" || stage === "P4" || stage === "P5" || smallP2Candidates ? ["characters"] : []
+	];
+	const mentioned = [
+		typeof context.text === "string" ? context.text : "",
+		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 stableJson(value);
+		for (const key of [
+			"id",
+			"name",
+			"title"
+		]) {
+			const item = row[key];
+			if (typeof item === "string" && item !== "") return item;
+		}
+		return stableJson(row);
+	};
+	const addArray = (key, array, rank, tie = stableKey) => {
+		if (protectedKeys.includes(key)) return;
+		let prepared = false;
+		const sort = () => {
+			if (prepared) return;
+			prepared = true;
+			array()?.sort((left, right) => {
+				const byRank = rank(right) - rank(left);
+				return byRank !== 0 ? byRank : compareText(tie(left), tie(right));
+			});
+		};
+		candidates.push({
+			key,
+			count: () => array()?.length ?? 0,
+			trim: () => {
+				sort();
+				const list = array();
+				if (list === null || list.length === 0) return false;
+				list.pop();
+				return true;
+			},
+			prepare: sort
+		});
+	};
+	const addObject = (key, map, rank) => {
+		if (protectedKeys.includes(key)) return;
+		let keys = null;
+		const ensure = () => {
+			const target = map();
+			keys ??= target === null ? [] : Object.keys(target);
+			keys.sort((left, right) => {
+				const byRank = rank(right, map()?.[right]) - rank(left, map()?.[left]);
+				return byRank !== 0 ? byRank : compareText(left, right);
+			});
+			return keys;
+		};
+		candidates.push({
+			key,
+			count: () => Object.keys(map() ?? {}).length,
+			trim: () => {
+				const target = map();
+				if (target === null) return false;
+				const keyToDelete = ensure().pop();
+				if (keyToDelete === void 0 || !Object.hasOwn(target, keyToDelete)) return false;
+				delete target[keyToDelete];
+				return true;
+			},
+			prepare: ensure
+		});
+	};
+	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 (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);
+	});
+	const world = asRecord(context.world);
+	for (const key of [
+		"locations",
+		"abilities",
+		"artifacts",
+		"factions",
+		"rules"
+	]) addArray(`world.${key}`, () => asArray(world?.[key]), (value) => {
+		const row = asRecord(value);
+		const name = typeof row?.name === "string" ? row.name : "";
+		return mentionScore(mentioned, name) * 1e3 + Number(row?.first_appearance ?? 0);
+	}, (value) => {
+		const row = asRecord(value);
+		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) => (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 : "";
+		return mentionScore(mentioned, title) * 1e3 - Number(row?.last_touched ?? 0);
+	}, (value) => {
+		const row = asRecord(value);
+		return `${typeof row?.title === "string" ? row.title : ""}\u0000${typeof row?.id === "string" ? row.id : ""}`;
+	});
+	const foreshadows = asRecord(context.foreshadows);
+	addArray("foreshadows", () => asArray(foreshadows?.items), (value) => {
+		const row = asRecord(value);
+		const title = typeof row?.title === "string" ? row.title : "";
+		const id = typeof row?.id === "string" ? row.id : "";
+		return Math.max(mentionScore(mentioned, title), mentionScore(mentioned, id)) * 1e3 - Number(row?.last_touched ?? 0);
+	}, (value) => {
+		const row = asRecord(value);
+		return `${typeof row?.id === "string" ? row.id : ""}\u0000${typeof row?.title === "string" ? row.title : ""}`;
+	});
+	addArray("timeline", () => asArray(context.timeline), (value) => {
+		const row = asRecord(value);
+		const text = `${String(row?.description ?? "")}${String(row?.location ?? "")}`;
+		return mentionScore(mentioned, text) * 1e3 + Number(row?.chapter ?? 0);
+	}, (value) => {
+		const row = asRecord(value);
+		return `${typeof row?.id === "string" ? row.id : ""}\u0000${String(row?.chapter ?? "")}`;
+	});
+	const relationships = asRecord(context.relationships);
+	addArray("relationships", () => asArray(relationships?.items), (value) => {
+		const row = asRecord(value);
+		const text = `${String(row?.a ?? "")}${String(row?.b ?? "")}`;
+		return mentionScore(mentioned, text) * 1e3 + Number(row?.since ?? 0);
+	}, (value) => {
+		const row = asRecord(value);
+		return `${typeof row?.id === "string" ? row.id : ""}\u0000${String(row?.a ?? "")}\u0000${String(row?.b ?? "")}`;
+	});
+	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 = () => jsonSize(context);
+	const buildMeta = (finalUsed) => ({
+		version: 1,
+		stage,
+		budget,
+		used: finalUsed,
+		over_budget: false,
+		protected: protectedKeys,
+		truncated: [...truncated].sort(compareText),
+		omitted: Object.fromEntries(Object.entries(omitted).sort(([left], [right]) => compareText(left, right))),
+		strategy: "stage-v2"
+	});
+	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) {
+			if (totalWith(finalUsed, metaBase) <= budget) break;
+			if (candidate.count() === 0) continue;
+			candidate.prepare();
+			if (candidate.trim()) {
+				omitted[candidate.key] = (omitted[candidate.key] ?? 0) + 1;
+				truncated.add(candidate.key);
+				changed = true;
+				finalUsed = used();
+				metaBase = buildMeta(finalUsed);
+			}
+		}
+		if (!changed) break;
+	}
+	const overBudget = totalWith(finalUsed, metaBase) > budget;
+	const meta = {
+		...metaBase,
+		over_budget: overBudget
+	};
+	return {
+		...context,
+		context_meta: meta
+	};
+}
+/**
+* Build the stage-specific context pack plus the deterministic budget report.
+* The budget report is part of the brief digest; a truncated pack cannot be
+* silently mistaken for the full ledger set.
+*/
+function briefContext(input) {
+	return withContextBudget(input.stage, unbudgetedBriefContext(input));
+}
 // src/engine/state-delta.ts
 const SECTIONS = [
 	"characters",
@@ -3545,6 +4093,7 @@ const wordCount = (input) => {
 };
 /** PG-04: format blockers must be zero before length is judged. */
 const format = (input, options) => {
+	if (input.scope !== void 0 && !input.scope.includes("content")) return [];
 	const violations = runRules([
 		"MD_CONTAMINATION",
 		"ILLEGAL_QUOTE",
@@ -3626,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");
@@ -3717,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}`;
@@ -3757,6 +4306,7 @@ const readingProof = (input) => {
 };
 /** PG-10: cross-chapter reconciliation must be clean. */
 const consistency = (input, options) => {
+	if (input.scope !== void 0 && !input.scope.includes("integrity")) return [];
 	const violations = runRules([
 		"DUPLICATE_PARAGRAPH",
 		"FORESHADOW_DORMANT",
@@ -3803,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 = {
@@ -3857,7 +4408,8 @@ function applicableGates(input) {
 			"PG-03",
 			"PG-05",
 			"PG-09",
-			"PG-08"
+			"PG-08",
+			"PG-11"
 		];
 		case "submitReview": return [
 			...always,
@@ -3868,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",
@@ -3915,7 +4470,7 @@ const STAGE_TO_PHASE = {
 	P4: "P4",
 	P5: "P5",
 	P6: "P6",
-	ready_to_archive: "P8",
+	ready_to_archive: "P7",
 	done: "P9"
 };
 /** The nine-phase progress strip: phases before the active one are done. */
@@ -3961,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,
@@ -3971,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,
@@ -4093,7 +4655,31 @@ const ROUND_TRANSITIONS = {
 	P5: "P5",
 	P6: "P6"
 };
+/** Forward order of stages; rollback may only move to an equal or earlier rank. */
+const STAGE_RANK = {
+	idle: 0,
+	P2: 1,
+	P3: 2,
+	P4: 3,
+	P5: 4,
+	P6: 5,
+	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",
@@ -4113,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. */
@@ -4180,6 +4768,8 @@ var EngineService = class {
 	async initProject(input) {
 		const title = typeof input.title === "string" ? input.title.trim() : "";
 		if (title === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "title must not be empty");
+		if (input.author !== void 0 && typeof input.author !== "string") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "author must be a string");
+		if (input.description !== void 0 && typeof input.description !== "string") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "description must be a string");
 		if (!GENRES.includes(input.genre)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `unknown genre "${String(input.genre)}"`, `allowed: ${GENRES.join(", ")}`);
 		if (!PLATFORMS.includes(input.platform)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `unknown platform "${String(input.platform)}"`, `allowed: ${PLATFORMS.join(", ")}`);
 		if (input.words_per_chapter !== void 0) {
@@ -4246,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: {
@@ -4264,8 +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,
@@ -4291,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,
@@ -4337,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)),
@@ -4373,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,
@@ -4381,7 +5106,8 @@ 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,
 			warnings: []
@@ -4416,7 +5142,10 @@ 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.planError === null ? {} : { plan_error: snapshot.planError }
+					...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 }
 				};
 				const data = {
 					stage: input.stage,
@@ -4457,6 +5186,27 @@ var EngineService = class {
 	}
 	async submitWorldPlan(input) {
 		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`);
+			requireText(character, "role", `characters[${index}].role`);
+			requireText(character, "current_state", `characters[${index}].current_state`);
+		}
+		const locations = objectList(input.locations, "locations");
+		for (const [index, location] of locations.entries()) {
+			requireText(location, "name", `locations[${index}].name`);
+			requireText(location, "layout", `locations[${index}].layout`);
+			if (typeof location.capacity !== "number" || !Number.isFinite(location.capacity)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `locations[${index}].capacity must be a finite number`);
+		}
 		return this.mutate({
 			root: input.root,
 			op: "submitWorldPlan",
@@ -4467,10 +5217,10 @@ var EngineService = class {
 				const plan = {
 					chapter,
 					objective: input.objective,
-					constraints: input.constraints,
-					characters: input.characters,
-					locations: input.locations,
-					continuity_notes: input.continuity_notes
+					constraints,
+					characters,
+					locations,
+					continuity_notes
 				};
 				const path = planWorldFile(chapter);
 				const nextPipeline = pipelineWith(snapshot, context.revision, {
@@ -4505,6 +5255,15 @@ 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 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 < 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");
+		for (const [field, value] of [["opening", input.opening], ["ending", input.ending]]) if (typeof value !== "string" || value.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter plan ${field} must not be empty`);
 		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(", ")}`);
 		if (!Array.isArray(input.target_words) || input.target_words.length !== 2) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "target_words must be [min, max] positive integers with min <= max");
 		const [min, max] = input.target_words;
@@ -4515,11 +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;
@@ -4548,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,
@@ -4574,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: [],
@@ -4653,6 +5414,11 @@ var EngineService = class {
 						"fix"
 					]) if (typeof issue[field] !== "string" || issue[field].trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `issue ${issue.id} has no ${field}`, "every issue needs id, severity, status, dimension, location, problem and fix");
 					if (issue.evidence !== void 0 && typeof issue.evidence !== "string") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `issue ${issue.id} evidence must be a string`, "quote the revised text as evidence, or omit the field");
+					if (issue.severity === "blocker" && issue.status === "waived") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `issue ${issue.id} is a blocker and cannot be waived`, "fix the issue and quote the revised text, or keep it open");
+					if (this.rulepack.quality.dimensions.find((item) => item.id === issue.dimension) === void 0) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `issue ${issue.id} references unknown dimension "${issue.dimension}"`, `use one of: ${this.rulepack.quality.dimensions.map((item) => item.id).join(", ")}`);
+					const paragraph = parseParagraphLocation(issue.location);
+					const paragraphCount = splitParagraphs(text).length;
+					if (paragraph === null || paragraph < 1 || paragraph > paragraphCount) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `issue ${issue.id} location "${issue.location}" is outside the chapter`, `use 第 1 段 .. 第 ${paragraphCount} 段`);
 				}
 				const review = {
 					schema_version: 1,
@@ -4757,7 +5523,15 @@ var EngineService = class {
 							seen.add(submitted.id);
 							const before = byId.get(submitted.id);
 							if (before === void 0) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `revision references unknown issue ${submitted.id}`, "only update issues from the current review; new issues belong in the next review");
-							if (before.severity === "blocker" && submitted.severity !== "blocker") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `issue ${submitted.id} is a blocker and cannot be downgraded`, "keep severity blocker and mark it fixed with evidence");
+							for (const field of [
+								"dimension",
+								"location",
+								"problem",
+								"fix"
+							]) if (submitted[field] !== void 0 && submitted[field] !== before[field]) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `issue ${submitted.id} cannot change its ${field} during revision`, "only status and evidence may change; new findings belong in the next review");
+							if (submitted.severity !== void 0 && submitted.severity !== before.severity) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `issue ${submitted.id} cannot change severity during revision`, "only status and evidence may change; a blocker stays a blocker until re-reviewed");
+							if (before.severity === "blocker" && submitted.severity !== void 0 && submitted.severity !== "blocker") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `issue ${submitted.id} is a blocker and cannot be downgraded`, "keep severity blocker and mark it fixed with evidence");
+							if (before.severity === "blocker" && submitted.status === "waived") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `issue ${submitted.id} is a blocker and cannot be waived`, "keep severity blocker and mark it fixed with evidence");
 							const index = issues.findIndex((issue) => issue.id === submitted.id);
 							issues[index] = {
 								...before,
@@ -4786,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);
@@ -4835,12 +5609,13 @@ var EngineService = class {
 		});
 	}
 	async runCheck(input) {
+		const scope = normalizeCheckScope(input.scope);
 		return this.mutate({
 			root: input.root,
 			op: "runCheck",
 			key: (snapshot) => `check:${input.chapter}:${sha256(snapshot.text ?? "")}:${sha256(stableJson({
 				semantic: input.semantic ?? [],
-				scope: input.scope ?? []
+				scope
 			}))}`,
 			run: async (snapshot, context) => {
 				this.assertChapter(snapshot, input.chapter);
@@ -4850,35 +5625,41 @@ var EngineService = class {
 					briefStage: "P6",
 					text,
 					proof: snapshot.review?.proof ?? null,
-					semantic
+					semantic,
+					scope
 				});
 				const machine = this.machine(snapshot, text, { summary: snapshot.plan?.summary ?? null });
-				const machineBlocking = machine.violations.filter((violation) => violation.severity === "blocker");
+				const scopedMachine = {
+					...machine,
+					violations: machine.violations.filter((violation) => scope.includes(scopeOfRule(violation.code)))
+				};
+				const machineBlocking = scopedMachine.violations.filter((violation) => violation.severity === "blocker");
 				const semanticResult = evaluateSemantic(text, semantic);
 				const verdict = machineBlocking.length === 0 && !semanticResult.failed ? "pass" : "fail";
 				const check = {
 					schema_version: 1,
 					chapter: input.chapter,
-					scope: input.scope ?? ["content", "integrity"],
+					scope,
 					content_hash: sha256(text),
 					machine: {
-						violations: machine.violations,
-						metrics: machine.metrics
+						violations: scopedMachine.violations,
+						metrics: scopedMachine.metrics
 					},
 					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))
@@ -4894,21 +5675,25 @@ var EngineService = class {
 					data: {
 						chapter: input.chapter,
 						verdict,
-						violations: machine.violations.length,
-						metrics: machine.metrics,
-						stage: nextStage
+						violations: scopedMachine.violations.length,
+						metrics: scopedMachine.metrics,
+						stage: nextStage$2
 					},
-					warnings: machineWarnings(machine)
+					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",
@@ -4920,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 {
@@ -4939,6 +5724,7 @@ var EngineService = class {
 				const text = snapshot.text ?? "";
 				const summary = snapshot.plan?.summary;
 				if (summary === void 0) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "the draft has no summary; resubmit the draft with a summary", "call novel_write_draft with the full summary block");
+				if (snapshot.review !== null && snapshot.pipeline.review_digest === void 0) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, "the stored review has no review_digest; it predates digest-bound reviews and cannot be archived blindly", "re-run novel_review for this chapter, then re-run the archive");
 				if (snapshot.review !== null && snapshot.pipeline.review_digest !== void 0 && snapshot.pipeline.review_digest !== sha256(stableJson(snapshot.review))) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, "the stored review changed after submission; its digest no longer matches", "re-run novel_review instead of editing reviews/ directly");
 				await this.assertGates(snapshot, "archiveChapter", {
 					briefStage: "P8",
@@ -4962,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,
@@ -4997,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
 					})),
@@ -5036,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: [
 						{
@@ -5077,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,
@@ -5105,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: [{
@@ -5155,6 +6015,7 @@ var EngineService = class {
 				this.assertChapter(snapshot, input.chapter);
 				if (!Object.prototype.hasOwnProperty.call(ROUND_TRANSITIONS, input.toStage)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `unknown rollback target "${String(input.toStage)}"`, `allowed targets: ${Object.keys(ROUND_TRANSITIONS).join(", ")}`);
 				const stage = ROUND_TRANSITIONS[input.toStage];
+				if (STAGE_RANK[stage] > STAGE_RANK[snapshot.pipeline.stage]) throw new EngineInputError(ERROR_CODES.STAGE_ORDER, `cannot roll back from ${snapshot.pipeline.stage} to later stage ${stage}`, "rollback only moves to the current stage or an earlier one; use the normal stage tools to advance");
 				const nextPipeline = pipelineWith(snapshot, context.revision, {
 					chapter: input.chapter,
 					stage,
@@ -5236,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) => {
@@ -5380,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: [{
@@ -5408,10 +6278,10 @@ 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: snapshot.pipeline.blocking.length > 0 ? "blocked" : "draft",
+			status: this.effectiveBlocking(snapshot).length > 0 ? "blocked" : "draft",
 			details: (snapshot.plan?.summary?.events ?? []).join("；").slice(0, 240)
 		};
 		return {
@@ -5424,17 +6294,97 @@ 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;
+		}
+		const reviewDigest = this.reviewDigestProblem(snapshot);
+		if (reviewDigest !== null) return {
+			tool: "novel_rollback",
+			args: {
+				chapter,
+				to_stage: "P4"
+			},
+			reason: `${reviewDigest.code}: ${reviewDigest.detail}; ${reviewDigest.hint}`
+		};
 		const step = STAGE_NEXT[stage];
 		const target = snapshot.project.targets.total_chapters;
 		if (stage === "done" && target !== null && snapshot.chapters.chapters.length >= target) return {
@@ -5463,6 +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",
@@ -5489,20 +6458,176 @@ 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) {
+		const state = this.stateErrors(snapshot).map((error) => ({
+			code: "STATE_UNREADABLE",
+			scope: "state",
+			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);
-		if (extra === null) return snapshot.pipeline.blocking;
-		return snapshot.pipeline.blocking.some((item) => item.code === extra.code) ? snapshot.pipeline.blocking : [...snapshot.pipeline.blocking, extra];
+		const reviewDigest = this.reviewDigestProblem(snapshot);
+		const archive = this.archivePreflight(snapshot);
+		const base = [
+			...state,
+			...active,
+			...archive === null ? [] : [archive.item],
+			...reviewDigest === null ? [] : [reviewDigest],
+			...snapshot.pipeline.blocking
+		];
+		if (extra === null) return base;
+		return base.some((item) => item.code === extra.code) ? base : [...base, extra];
+	}
+	/**
+	* A review that exists but cannot be tied to the pipeline digest would let a
+	* hand-edited review pass archive. Archive already fails closed; status and
+	* next must surface the same repair path instead of pointing at the archive
+	* command forever.
+	*/
+	reviewDigestProblem(snapshot) {
+		if (snapshot.pipeline.stage !== "ready_to_archive" || snapshot.review === null) return null;
+		const chapter = snapshot.pipeline.chapter;
+		const hint = "call novel_rollback with to_stage P4, then re-run novel_review before archiving";
+		if (snapshot.pipeline.review_digest === void 0) return {
+			code: "REVIEW_DIGEST_MISSING",
+			scope: "state",
+			detail: `review ${reviewFile(chapter)} has no pipeline.review_digest; it predates digest-bound reviews`,
+			hint
+		};
+		if (snapshot.pipeline.review_digest !== sha256(stableJson(snapshot.review))) return {
+			code: "REVIEW_DIGEST_MISMATCH",
+			scope: "state",
+			detail: `review ${reviewFile(chapter)} changed after submission; its digest no longer matches`,
+			hint
+		};
+		return null;
+	}
+	stateErrors(snapshot) {
+		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",
+			message: snapshot.planError
+		});
+		if (snapshot.reviewError !== null) errors.push({
+			path: reviewFile(chapter),
+			code: "REVIEW_UNREADABLE",
+			message: snapshot.reviewError
+		});
+		if (snapshot.checkError !== null) errors.push({
+			path: checkFile(chapter),
+			code: "CHECK_UNREADABLE",
+			message: snapshot.checkError
+		});
+		return errors;
+	}
+	/** The earliest rebuild point for the current state damage. */
+	recoveryFor(snapshot) {
+		const chapter = snapshot.pipeline.chapter;
+		const errors = this.stateErrors(snapshot);
+		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 {
+			tool: "novel_rollback",
+			args: {
+				chapter,
+				to_stage: target
+			},
+			reason: `${errors.map((error) => `${error.code}@${error.path}`).join("; ")}; ${action}`
+		};
+	}
+	/** Never point at a stage later than the current one; rollback only moves backward. */
+	clampRollbackTarget(stage, desired) {
+		if (STAGE_RANK[ROUND_TRANSITIONS[desired]] <= STAGE_RANK[stage]) return desired;
+		return {
+			idle: "P1",
+			P2: "P2",
+			P3: "P3",
+			P4: "P4",
+			P5: "P5",
+			P6: "P6",
+			ready_to_archive: "P6",
+			done: "P6"
+		}[stage];
+	}
+	/** State damage that makes this operation unsafe to start. */
+	stateGateBlock(snapshot, operation) {
+		const planSensitive = [
+			"submitDraft",
+			"submitReview",
+			"submitRevision",
+			"runCheck",
+			"archiveChapter"
+		];
+		const worldPlanSensitive = ["submitChapterPlan", ...planSensitive];
+		const reviewSensitive = [
+			"submitRevision",
+			"runCheck",
+			"archiveChapter"
+		];
+		const checkSensitive = ["archiveChapter"];
+		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"));
+		return relevant.map((error) => ({
+			code: "STATE_UNREADABLE",
+			scope: "state",
+			detail: `${error.code}: ${error.message}`,
+			hint: this.recoveryFor(snapshot).reason
+		}));
 	}
 	/** Whether the stored brief still signs the current snapshot. */
 	briefIsCurrent(snapshot, stage) {
@@ -5552,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");
@@ -5561,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,
@@ -5579,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,
@@ -5596,15 +6729,21 @@ 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,
+			review_error: snapshot.reviewError,
 			check: snapshot.check,
+			check_error: snapshot.checkError,
 			text: snapshot.text,
 			machine,
 			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;
@@ -5632,15 +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 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,
@@ -5650,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,
@@ -5658,6 +6801,7 @@ var EngineService = class {
 			check: extras.check ?? snapshot.check,
 			semantic: extras.semantic ?? [],
 			proof: extras.proof ?? null,
+			scope: extras.scope,
 			rounds: snapshot.pipeline.rounds,
 			archive,
 			evidence: {
@@ -5671,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
 		});
@@ -5698,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;
@@ -5740,12 +6930,36 @@ var EngineService = class {
 		let plan = null;
 		let planError = null;
 		if (planRaw !== null) try {
-			plan = parsePlanYaml(planRaw, planChapterFile(chapter));
+			const parsed = parsePlanYaml(planRaw, planChapterFile(chapter));
+			validateStoredChapterPlan(parsed, planChapterFile(chapter));
+			plan = parsed;
+		} catch (error) {
+			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) {
-			planError = error instanceof Error ? error.message : String(error);
+			if (error instanceof EngineFaultError && error.code === ERROR_CODES.SCHEMA_TOO_NEW) throw error;
+			worldPlanError = errorMessage(error);
 		}
-		const review = await store.readDoc(reviewFile(chapter), "review");
-		const check = await store.readDoc(checkFile(chapter), "check");
+		const reviewRead = await this.recoverableDoc(store, reviewFile(chapter), "review");
+		const checkRead = await this.recoverableDoc(store, checkFile(chapter), "check");
+		const review = reviewRead.value;
+		let reviewError = reviewRead.error;
+		const check = checkRead.value;
+		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);
@@ -5755,6 +6969,7 @@ var EngineService = class {
 		return {
 			root: store.root,
 			project,
+			projectError,
 			pipeline,
 			chapters,
 			characters,
@@ -5764,15 +6979,46 @@ var EngineService = class {
 			foreshadows,
 			relationships,
 			handoff,
+			worldPlan,
+			ledgerErrors,
 			text,
 			previousText,
 			previousTexts,
 			plan,
 			planError,
+			worldPlanError,
 			review,
-			check
+			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 {
+			return {
+				value: await store.readDoc(path, kind),
+				error: null
+			};
+		} catch (error) {
+			if (error instanceof EngineFaultError && error.code === ERROR_CODES.SCHEMA_TOO_NEW) throw error;
+			return {
+				value: null,
+				error: errorMessage(error)
+			};
+		}
+	}
 	async mutate(options) {
 		const root = await this.resolveRoot(options.root);
 		const signal = this.signalContext.getStore();
@@ -5834,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) {
@@ -5895,6 +7141,7 @@ var EngineService = class {
 		return {
 			root,
 			project: { ...ENGINE_PROJECT_INITIAL },
+			projectError: null,
 			pipeline: emptyPipeline({
 				revision: 1,
 				chapter: 1,
@@ -5925,13 +7172,18 @@ var EngineService = class {
 				items: []
 			},
 			handoff: null,
+			worldPlan: null,
+			ledgerErrors: [],
 			text: null,
 			previousText: null,
 			previousTexts: [],
 			plan: null,
 			planError: null,
+			worldPlanError: null,
 			review: null,
-			check: null
+			reviewError: null,
+			check: null,
+			checkError: null
 		};
 	}
 };
@@ -6007,18 +7259,415 @@ 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) => {
+		throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `${path} is not a usable chapter plan: ${detail}`);
+	};
+	const rawVersion = plan.schema_version;
+	if (rawVersion !== void 0) {
+		const version = typeof rawVersion === "number" ? rawVersion : null;
+		if (version === null) fail("schema_version must be a positive integer");
+		const checkedVersion = version;
+		if (!Number.isInteger(checkedVersion) || checkedVersion < 1) fail("schema_version must be a positive integer");
+		if (checkedVersion > 1) throw new EngineFaultError(ERROR_CODES.SCHEMA_TOO_NEW, `${path} uses schema_version ${checkedVersion}, newer than supported 1`, "upgrade the plugin; the plan was left untouched");
+		if (checkedVersion !== 1) fail(`schema_version must be 1`);
+	}
+	if (!Number.isInteger(plan.chapter) || plan.chapter < 1) fail("chapter must be a positive integer");
+	for (const key of [
+		"title",
+		"narrator",
+		"opening",
+		"ending"
+	]) if (typeof plan[key] !== "string" || plan[key].trim() === "") fail(`${key} must be non-empty`);
+	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) {
+		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) => {
+	if (value === void 0) return [...CHECK_SCOPES];
+	if (!Array.isArray(value) || value.length === 0) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "scope must contain at least one of content, integrity");
+	const unique = [...new Set(value)];
+	for (const scope of unique) if (scope !== "content" && scope !== "integrity") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `unknown check scope "${String(scope)}"`, `allowed: ${CHECK_SCOPES.join(", ")}`);
+	return CHECK_SCOPES.filter((scope) => unique.includes(scope));
+};
+const stringList = (value, field) => {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${field} must be an array of non-empty strings`);
+	return value;
+};
+const objectList = (value, field) => {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "object" || item === null || Array.isArray(item))) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${field} must be an array of objects`);
+	return value;
+};
+const requireText = (object, key, path) => {
+	if (typeof object[key] !== "string" || object[key].trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${path} must be a non-empty string`);
 };
 /** Parse a plan file with a machine code instead of leaking a YAML parser error. */
 const parsePlanYaml = (text, path) => {
@@ -6294,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,
@@ -6306,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
 			}))
 		}),
@@ -6517,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
 			}))
 		}),
@@ -6534,6 +8199,7 @@ function createNovelTools(engine) {
 					type: "string",
 					required: true,
 					enum: [
+						"novel.yaml",
 						"state/chapters.yaml",
 						"state/characters.yaml",
 						"state/world.yaml",