dsh-novel-write-engine 0.1.1 → 0.1.2

package/lib/index.js

@@ -1023,10 +1023,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 +1110,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 +1277,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
@@ -2846,7 +2865,7 @@ const pendingForeshadows = (ledger) => ledger.items.filter((item) => item.status
 * 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 base = {
 		project: {
@@ -2859,7 +2878,9 @@ 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.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 {
@@ -2887,6 +2908,7 @@ function briefContext(input) {
 			...base,
 			text: input.text ?? "",
 			summary: input.plan?.summary ?? null,
+			plan: input.plan,
 			machine: input.machine ?? null,
 			characters: input.characters.characters,
 			check: input.check,
@@ -2898,6 +2920,7 @@ function briefContext(input) {
 		case "P5": return {
 			...base,
 			text: input.text ?? "",
+			plan: input.plan,
 			machine: input.machine ?? null,
 			review: input.review,
 			issues: input.review?.issues ?? []
@@ -2905,6 +2928,7 @@ function briefContext(input) {
 		case "P6": return {
 			...base,
 			text: input.text ?? "",
+			plan: input.plan,
 			machine: input.machine ?? null,
 			characters: input.characters.characters,
 			world: input.world,
@@ -2922,6 +2946,7 @@ function briefContext(input) {
 		};
 		case "P8": return {
 			...base,
+			plan: input.plan,
 			check: input.check,
 			review: input.review,
 			summary: input.plan?.summary ?? null,
@@ -2931,6 +2956,238 @@ 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) => Array.from(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 protectedKeys = [
+		"project",
+		"chapter",
+		"stage",
+		"previous_ending",
+		"text",
+		"plan",
+		"precheck",
+		"review",
+		"check",
+		"machine",
+		"summary"
+	];
+	const mentioned = [
+		typeof context.text === "string" ? context.text : "",
+		JSON.stringify(context.plan ?? ""),
+		JSON.stringify(context.review ?? ""),
+		JSON.stringify(context.check ?? ""),
+		JSON.stringify(context.summary ?? "")
+	].join("\n");
+	const omitted = {};
+	const truncated = /* @__PURE__ */ new Set();
+	const candidates = [];
+	const stableKey = (value) => {
+		const row = asRecord(value);
+		if (row === null) return JSON.stringify(value) ?? "";
+		for (const key of [
+			"id",
+			"name",
+			"title"
+		]) {
+			const item = row[key];
+			if (typeof item === "string" && item !== "") return item;
+		}
+		return JSON.stringify(row);
+	};
+	const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+	const addArray = (key, array, rank, tie = stableKey) => {
+		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) => {
+		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;
+	addArray("characters", () => asArray(context.characters), (value) => {
+		const row = asRecord(value);
+		const name = typeof row?.name === "string" ? row.name : "";
+		return mentionScore(mentioned, name) * 1e3 + Number(row?.first_appearance ?? 0);
+	}, (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) => 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 = () => {
+		const measure = { ...context };
+		delete measure.context_meta;
+		return jsonSize(measure);
+	};
+	const buildMeta = (finalUsed) => ({
+		version: 1,
+		stage,
+		budget,
+		used: finalUsed,
+		over_budget: false,
+		protected: protectedKeys,
+		truncated: [...truncated].sort(),
+		omitted: Object.fromEntries(Object.entries(omitted).sort(([left], [right]) => left.localeCompare(right))),
+		strategy: "stage-v1"
+	});
+	const totalWith = (finalUsed, meta) => jsonSize({
+		...context,
+		context_meta: {
+			...meta,
+			used: finalUsed
+		}
+	});
+	let finalUsed = used();
+	let metaBase = buildMeta(finalUsed);
+	while (totalWith(finalUsed, metaBase) > budget) {
+		let changed = false;
+		for (const candidate of candidates) {
+			finalUsed = used();
+			metaBase = buildMeta(finalUsed);
+			if (totalWith(finalUsed, metaBase) <= budget) break;
+			if (candidate.count() === 0) continue;
+			candidate.prepare();
+			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 +3802,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",
@@ -3757,6 +4015,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",
@@ -3915,7 +4174,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. */
@@ -4093,6 +4352,17 @@ 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
+};
 const MUTABLE_STATE = {
 	[joinRel(STATE_DIR, STATE_FILES.pipeline)]: "pipeline",
 	[joinRel(STATE_DIR, STATE_FILES.chapters)]: "chapters",
@@ -4180,6 +4450,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) {
@@ -4265,6 +4537,7 @@ var EngineService = class {
 				stage: snapshot.pipeline.stage,
 				rounds: { ...snapshot.pipeline.rounds },
 				blocking: this.effectiveBlocking(snapshot),
+				state_errors: this.stateErrors(snapshot),
 				metrics,
 				next
 			},
@@ -4381,7 +4654,8 @@ var EngineService = class {
 				tool: next.tool,
 				args: next.args,
 				reason: next.reason,
-				blocking: this.effectiveBlocking(snapshot)
+				blocking: this.effectiveBlocking(snapshot),
+				state_errors: this.stateErrors(snapshot)
 			},
 			revision: snapshot.pipeline.revision,
 			warnings: []
@@ -4416,7 +4690,9 @@ 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.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 +4733,20 @@ 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 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 +4757,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 +4795,13 @@ var EngineService = class {
 	}
 	async submitChapterPlan(input) {
 		if (typeof input.title !== "string" || input.title.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "chapter plan title must not be empty");
+		const titleBody = input.title.replace(/^第\s*\d+\s*章\s*/, "").trim();
+		const titleLength = Array.from(titleBody).length;
+		if (titleLength < 4 || titleLength > 8) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter plan title body must be 4..8 characters, got ${titleLength}`, "use the same 4..8 character body the P3 title rule will judge");
+		if (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;
@@ -4520,6 +4817,7 @@ var EngineService = class {
 				const plan = {
 					...input,
 					chapter,
+					beats,
 					schema_version: 1
 				};
 				delete plan.root;
@@ -4653,6 +4951,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 +5060,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,
@@ -4835,12 +5146,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,20 +5162,25 @@ 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
@@ -4894,11 +5211,11 @@ var EngineService = class {
 					data: {
 						chapter: input.chapter,
 						verdict,
-						violations: machine.violations.length,
-						metrics: machine.metrics,
+						violations: scopedMachine.violations.length,
+						metrics: scopedMachine.metrics,
 						stage: nextStage
 					},
-					warnings: machineWarnings(machine)
+					warnings: machineWarnings(scopedMachine)
 				};
 			}
 		});
@@ -4939,6 +5256,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",
@@ -5155,6 +5473,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,
@@ -5411,7 +5730,7 @@ var EngineService = class {
 			title: (snapshot.plan?.title ?? "").replace(/^第\s*\d+\s*章\s*/, "").trim() || `第${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 {
@@ -5435,6 +5754,20 @@ var EngineService = class {
 	nextStep(snapshot) {
 		const stage = snapshot.pipeline.stage;
 		const chapter = snapshot.pipeline.chapter;
+		if (this.stateErrors(snapshot).length > 0) {
+			const recovery = this.recoveryFor(snapshot);
+			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 +5796,11 @@ var EngineService = class {
 			},
 			reason: detail === "" ? `fetch the ${briefStage} brief before ${followUp}` : `${detail}; fetch the ${briefStage} brief, then ${followUp}`
 		};
+		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`
+		};
 		if (snapshot.pipeline.blocking.length > 0) {
 			if (stage === "P5" || stage === "P6") return {
 				tool: "novel_revise",
@@ -5500,9 +5838,121 @@ var EngineService = class {
 	}
 	/** 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 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 base = [
+			...state,
+			...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 = [];
+		const chapter = snapshot.pipeline.chapter;
+		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);
+		const desired = 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 reviewSensitive = [
+			"submitRevision",
+			"runCheck",
+			"archiveChapter"
+		];
+		const checkSensitive = ["archiveChapter"];
+		const relevant = [];
+		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) {
@@ -5599,7 +6049,9 @@ var EngineService = class {
 			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,
@@ -5635,6 +6087,8 @@ var EngineService = class {
 	async assertGates(snapshot, operation, extras) {
 		const text = extras.text ?? snapshot.text ?? "";
 		if (!canRun(snapshot.pipeline.stage, operation)) throw new EngineInputError(ERROR_CODES.STAGE_ORDER, `${operation} is not allowed at stage ${snapshot.pipeline.stage}`, "call novel_status to see the next legal step");
+		const stateBlocking = this.stateGateBlock(snapshot, operation);
+		if (stateBlocking.length > 0) throw new EngineBlockedError(ERROR_CODES.GATE_BLOCKED, `${operation} blocked by unreadable state: ${stateBlocking[0].detail}`, stateBlocking, this.recoveryFor(snapshot).reason);
 		const archive = operation === "archiveChapter" ? {
 			chapterExists: snapshot.chapters.chapters.some((record) => record.num === snapshot.pipeline.chapter),
 			checkPassed: snapshot.check?.verdict === "pass",
@@ -5658,6 +6112,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: {
@@ -5740,12 +6195,19 @@ 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) {
-			planError = error instanceof Error ? error.message : String(error);
+			if (error instanceof EngineFaultError && error.code === ERROR_CODES.SCHEMA_TOO_NEW) throw error;
+			planError = 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;
+		const reviewError = reviewRead.error;
+		const check = checkRead.value;
+		const checkError = checkRead.error;
 		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);
@@ -5770,9 +6232,26 @@ var EngineService = class {
 			plan,
 			planError,
 			review,
-			check
+			reviewError,
+			check,
+			checkError
 		};
 	}
+	/** 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();
@@ -5931,7 +6410,9 @@ var EngineService = class {
 			plan: null,
 			planError: null,
 			review: null,
-			check: null
+			reviewError: null,
+			check: null,
+			checkError: null
 		};
 	}
 };
@@ -6020,6 +6501,54 @@ const stableJson = (value) => {
 	};
 	return JSON.stringify(normalize(value));
 };
+const errorMessage = (error) => error instanceof Error ? `${error.message}${error.cause instanceof Error ? `: ${error.cause.message}` : ""}` : String(error);
+/** 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 && (typeof plan.summary !== "object" || plan.summary === null)) fail("summary must be an object when present");
+};
+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) => {
 	let parsed;