dsh-novel-write-engine 0.2.3 → 0.2.4

package/lib/index.js

@@ -20,6 +20,8 @@ const PANEL_CHAPTER_LIMIT = 30;
 /** Project-relative locations. Every write goes through these constants. */
 const PROJECT_FILE = "novel.yaml";
 const OUTLINE_FILE = "outline/outline.yaml";
+/** Last outline replaced by a normal planning write; one level is enough for repair. */
+const OUTLINE_DEPRECATED_FILE = "outline/outline.deprecated.yaml";
 const WORLDBOOK_FILE = "outline/worldbook.yaml";
 const STATE_DIR = "state";
 const CHAPTERS_DIR = "chapters";
@@ -3810,7 +3812,7 @@ function buildEpub(project, chapters) {
 const escapeXml = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 // src/engine/book.ts
 const LENIENT_TITLE_PREFIX$1 = /^第\s*\d+\s*章\s*/;
-const text$1 = (value, where, max = LIMITS.maxOutlineTextFieldChars) => {
+const text$2 = (value, where, max = LIMITS.maxOutlineTextFieldChars) => {
 	if (typeof value !== "string" || value.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${where} must be a non-empty string`);
 	const trimmed = value.trim();
 	if (Array.from(trimmed).length > max) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${where} is ${Array.from(trimmed).length} characters; limit is ${max}`);
@@ -3829,13 +3831,13 @@ const stringArray$1 = (value, where, maxItems = 20) => {
 	if (value.length > maxItems) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${where} contains ${value.length} items; limit is ${maxItems}`);
 	const seen = /* @__PURE__ */ new Set();
 	return value.map((item, index) => {
-		const entry = text$1(item, `${where}[${index}]`, 200);
+		const entry = text$2(item, `${where}[${index}]`, 200);
 		if (seen.has(entry)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${where} contains duplicate "${entry}"`);
 		seen.add(entry);
 		return entry;
 	});
 };
-const positiveInteger = (value, where) => {
+const positiveInteger$1 = (value, where) => {
 	if (!Number.isInteger(value) || value < 1) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${where} must be a positive integer`);
 	return value;
 };
@@ -3845,7 +3847,7 @@ const wordPair = (value, where) => {
 	if (!Number.isInteger(min) || !Number.isInteger(max) || min <= 0 || max < min) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${where} must be [min, max] positive integers with min <= max`);
 	return [min, max];
 };
-const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** Remove a leading 第N章 prefix; stored titles are bodies. */
 function stripChapterPrefix(title) {
 	return title.replace(LENIENT_TITLE_PREFIX$1, "").trim();
@@ -3947,7 +3949,7 @@ const BOOK_PATCH_KEYS = /* @__PURE__ */ new Set([
 /** Apply a partial book patch; omitted fields keep their existing value. */
 function mergeBookPlan(existing, patch) {
 	if (patch === void 0) return { ...existing };
-	if (!isRecord$1(patch)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "book must be an object");
+	if (!isRecord$2(patch)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "book must be an object");
 	for (const key of Object.keys(patch)) if (!BOOK_PATCH_KEYS.has(key)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `book has unknown field "${key}"`, `allowed: ${[...BOOK_PATCH_KEYS].join(", ")}`);
 	const result = { ...existing };
 	for (const key of [
@@ -3975,15 +3977,15 @@ function normalizeVolumes(input, options = { totalChapters: null }) {
 	if (!Array.isArray(input)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "volumes must be an array");
 	if (input.length > LIMITS.maxOutlineVolumes) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `volumes contains ${input.length} items; limit is ${LIMITS.maxOutlineVolumes}`);
 	const volumes = input.map((raw, index) => {
-		if (!isRecord$1(raw)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `volumes[${index}] must be an object`);
-		const start = positiveInteger(raw.start_chapter, `volumes[${index}].start_chapter`);
-		const end = positiveInteger(raw.end_chapter, `volumes[${index}].end_chapter`);
+		if (!isRecord$2(raw)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `volumes[${index}] must be an object`);
+		const start = positiveInteger$1(raw.start_chapter, `volumes[${index}].start_chapter`);
+		const end = positiveInteger$1(raw.end_chapter, `volumes[${index}].end_chapter`);
 		if (end < start) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `volumes[${index}] end_chapter ${end} is before start_chapter ${start}`);
 		const status = raw.status ?? "planned";
 		if (status !== "planned" && status !== "writing" && status !== "done") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `volumes[${index}].status must be planned|writing|done`);
 		return {
-			id: typeof raw.id === "string" && raw.id.trim() !== "" ? raw.id.trim() : `V${index + 1}`,
-			title: text$1(raw.title, `volumes[${index}].title`, 120),
+			id: typeof raw.id === "string" && raw.id.trim() !== "" ? raw.id.trim() : "",
+			title: text$2(raw.title, `volumes[${index}].title`, 120),
 			start_chapter: start,
 			end_chapter: end,
 			goal: optionalText(raw.goal, `volumes[${index}].goal`),
@@ -3992,6 +3994,23 @@ function normalizeVolumes(input, options = { totalChapters: null }) {
 			status
 		};
 	});
+	const usedIds = /* @__PURE__ */ new Set();
+	const usedTitles = /* @__PURE__ */ new Set();
+	for (const volume of volumes) {
+		if (usedTitles.has(volume.title) && options.rejectDuplicateTitles !== false) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `duplicate volume title "${volume.title}"`);
+		usedTitles.add(volume.title);
+		if (volume.id === "") continue;
+		if (usedIds.has(volume.id)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `duplicate volume id "${volume.id}"`);
+		usedIds.add(volume.id);
+	}
+	let nextId = 1;
+	for (const volume of volumes) {
+		if (volume.id !== "") continue;
+		while (usedIds.has(`V${nextId}`)) nextId += 1;
+		volume.id = `V${nextId}`;
+		usedIds.add(volume.id);
+		nextId += 1;
+	}
 	volumes.sort((left, right) => left.start_chapter - right.start_chapter || left.end_chapter - right.end_chapter);
 	const ids = /* @__PURE__ */ new Set();
 	for (const [index, volume] of volumes.entries()) {
@@ -4075,8 +4094,8 @@ function normalizeOutlineChapters(input, options) {
 	const archived = new Map(options.archived.map((record) => [record.num, record]));
 	const normalized = /* @__PURE__ */ new Map();
 	for (const [index, raw] of input.entries()) {
-		if (!isRecord$1(raw)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapters[${index}] must be an object`);
-		const num = positiveInteger(raw.num, `chapters[${index}].num`);
+		if (!isRecord$2(raw)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapters[${index}] must be an object`);
+		const num = positiveInteger$1(raw.num, `chapters[${index}].num`);
 		if (options.totalChapters !== null && num > options.totalChapters) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter ${num} exceeds total_chapters ${options.totalChapters}`, "raise total_chapters with novel_blueprint before planning a longer book");
 		if (normalized.has(num)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter ${num} appears more than once`);
 		const record = archived.get(num);
@@ -4093,9 +4112,9 @@ function normalizeOutlineChapters(input, options) {
 			if (cast.length !== base.cast.length || cast.some((name) => !base.cast.includes(name))) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter ${num} is archived; its cast cannot change`, "call novel_reopen first if the manuscript must be revised");
 			normalized.set(num, {
 				...base,
-				goal: raw.goal === void 0 || raw.goal === base.goal ? base.goal : text$1(raw.goal, `chapter ${num} goal`),
-				conflict: raw.conflict === void 0 || raw.conflict === base.conflict ? base.conflict : text$1(raw.conflict, `chapter ${num} conflict`),
-				hook: raw.hook === void 0 || raw.hook === base.hook ? base.hook : text$1(raw.hook, `chapter ${num} hook`),
+				goal: raw.goal === void 0 || raw.goal === base.goal ? base.goal : text$2(raw.goal, `chapter ${num} goal`),
+				conflict: raw.conflict === void 0 || raw.conflict === base.conflict ? base.conflict : text$2(raw.conflict, `chapter ${num} conflict`),
+				hook: raw.hook === void 0 || raw.hook === base.hook ? base.hook : text$2(raw.hook, `chapter ${num} hook`),
 				notes: raw.notes === void 0 || raw.notes === base.notes ? base.notes : optionalText(raw.notes, `chapter ${num} notes`, LIMITS.maxOutlineNotesChars),
 				volume: volumeForChapter(options.volumes, num, raw.volume === void 0 ? base.volume : raw.volume),
 				status: "archived",
@@ -4114,18 +4133,19 @@ function normalizeOutlineChapters(input, options) {
 			"情感爆发章",
 			"纯叙事章"
 		].includes(raw.scene_type)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapters[${index}].scene_type is invalid`);
-		const cast = stringArray$1(raw.cast, `chapters[${index}].cast`, 8);
+		const previousCard = existing.get(num);
+		const cast = raw.cast == null && previousCard?.status === "planned" ? previousCard.cast : stringArray$1(raw.cast, `chapters[${index}].cast`, 8);
 		normalized.set(num, {
 			num,
-			volume: volumeNumberFor(options.volumes, num, raw.volume),
+			volume: raw.volume !== void 0 ? volumeNumberFor(options.volumes, num, raw.volume) : previousCard?.status === "planned" ? volumeForChapter(options.volumes, num, previousCard.volume) : volumeNumberFor(options.volumes, num, void 0),
 			title,
 			scene_type: raw.scene_type,
-			goal: text$1(raw.goal, `chapters[${index}].goal`),
-			conflict: text$1(raw.conflict, `chapters[${index}].conflict`),
-			hook: text$1(raw.hook, `chapters[${index}].hook`),
+			goal: text$2(raw.goal, `chapters[${index}].goal`),
+			conflict: text$2(raw.conflict, `chapters[${index}].conflict`),
+			hook: text$2(raw.hook, `chapters[${index}].hook`),
 			cast,
 			target_words: wordPair(raw.target_words, `chapters[${index}].target_words`),
-			notes: optionalText(raw.notes, `chapters[${index}].notes`, LIMITS.maxOutlineNotesChars),
+			notes: raw.notes == null && previousCard?.status === "planned" ? previousCard.notes : optionalText(raw.notes, `chapters[${index}].notes`, LIMITS.maxOutlineNotesChars),
 			status: "planned",
 			archived_at: null,
 			word_count: null,
@@ -4148,7 +4168,7 @@ function normalizeOutlineChapters(input, options) {
 }
 /** Validate a document loaded from disk. Throws a fault, not an input error. */
 function validateOutlineDocument(value, options) {
-	if (!isRecord$1(value)) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, "outline/outline.yaml must be a mapping");
+	if (!isRecord$2(value)) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, "outline/outline.yaml must be a mapping");
 	try {
 		if (value.schema_version !== 1) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `outline/outline.yaml schema_version must be 1, got ${String(value.schema_version)}`);
 		const allowedTopLevel = /* @__PURE__ */ new Set([
@@ -4160,7 +4180,7 @@ function validateOutlineDocument(value, options) {
 		]);
 		for (const key of Object.keys(value)) if (!allowedTopLevel.has(key)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `outline/outline.yaml has unknown key "${key}"`);
 		if (typeof value.updated_at !== "string" || value.updated_at.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "outline/outline.yaml updated_at must be a string");
-		if (!isRecord$1(value.book)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "outline/outline.yaml book must be a mapping");
+		if (!isRecord$2(value.book)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "outline/outline.yaml book must be a mapping");
 		const allowedBook = /* @__PURE__ */ new Set([
 			"premise",
 			"logline",
@@ -4175,14 +4195,17 @@ function validateOutlineDocument(value, options) {
 		]);
 		for (const key of Object.keys(value.book)) if (!allowedBook.has(key)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `outline/outline.yaml book has unknown key "${key}"`);
 		const book = mergeBookPlan(emptyBookPlan(), value.book);
-		const volumes = normalizeVolumes(value.volumes, { totalChapters: options.totalChapters });
+		const volumes = normalizeVolumes(value.volumes, {
+			totalChapters: options.totalChapters,
+			rejectDuplicateTitles: false
+		});
 		if (!Array.isArray(value.chapters)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "chapters must be an array");
 		if (value.chapters.length > LIMITS.maxOutlineChapters) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapters contains ${value.chapters.length} items; limit is ${LIMITS.maxOutlineChapters}`);
 		const chapters = [];
 		const seen = /* @__PURE__ */ new Set();
 		for (const [index, raw] of value.chapters.entries()) {
-			if (!isRecord$1(raw)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapters[${index}] must be an object`);
-			const num = positiveInteger(raw.num, `chapters[${index}].num`);
+			if (!isRecord$2(raw)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapters[${index}] must be an object`);
+			const num = positiveInteger$1(raw.num, `chapters[${index}].num`);
 			if (options.totalChapters !== null && num > options.totalChapters) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter ${num} exceeds total_chapters ${options.totalChapters}`);
 			if (seen.has(num)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter ${num} appears more than once`);
 			seen.add(num);
@@ -4208,9 +4231,9 @@ function validateOutlineDocument(value, options) {
 				volume: volumeNumberFor(volumes, num, raw.volume),
 				title: chapterTitleBody(raw.title, options.titleRule, `chapters[${index}].title`),
 				scene_type: scene,
-				goal: planned ? text$1(raw.goal, `chapters[${index}].goal`) : optionalText(raw.goal, `chapters[${index}].goal`),
-				conflict: planned ? text$1(raw.conflict, `chapters[${index}].conflict`) : optionalText(raw.conflict, `chapters[${index}].conflict`),
-				hook: planned ? text$1(raw.hook, `chapters[${index}].hook`) : optionalText(raw.hook, `chapters[${index}].hook`),
+				goal: planned ? text$2(raw.goal, `chapters[${index}].goal`) : optionalText(raw.goal, `chapters[${index}].goal`),
+				conflict: planned ? text$2(raw.conflict, `chapters[${index}].conflict`) : optionalText(raw.conflict, `chapters[${index}].conflict`),
+				hook: planned ? text$2(raw.hook, `chapters[${index}].hook`) : optionalText(raw.hook, `chapters[${index}].hook`),
 				cast: stringArray$1(raw.cast, `chapters[${index}].cast`, 8),
 				target_words: wordPair(raw.target_words, `chapters[${index}].target_words`),
 				notes: optionalText(raw.notes, `chapters[${index}].notes`, LIMITS.maxOutlineNotesChars),
@@ -4247,7 +4270,7 @@ function mergeWorldbook(existing, patch, now) {
 		...existing,
 		updated_at: now
 	};
-	if (!isRecord$1(patch)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "worldbook must be an object");
+	if (!isRecord$2(patch)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "worldbook must be an object");
 	const result = {
 		...existing,
 		updated_at: now,
@@ -4267,21 +4290,21 @@ function mergeWorldbook(existing, patch, now) {
 		if (!Array.isArray(value)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${key} must be an array`);
 		if (value.length > LIMITS.maxWorldbookEntries) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${key} contains ${value.length} items; limit is ${LIMITS.maxWorldbookEntries}`);
 		return value.map((raw, index) => {
-			if (!isRecord$1(raw)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${key}[${index}] must be an object`);
+			if (!isRecord$2(raw)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${key}[${index}] must be an object`);
 			return raw;
 		});
 	};
 	if (patch.rules !== void 0) {
 		result.rules = records(patch.rules, "rules").map((raw, index) => ({
-			name: text$1(raw.name, `rules[${index}].name`, 120),
-			description: text$1(raw.description, `rules[${index}].description`, LIMITS.maxWorldbookTextChars)
+			name: text$2(raw.name, `rules[${index}].name`, 120),
+			description: text$2(raw.description, `rules[${index}].description`, LIMITS.maxWorldbookTextChars)
 		}));
 		uniqueNames(result.rules, "rules");
 	}
 	if (patch.factions !== void 0) {
 		result.factions = records(patch.factions, "factions").map((raw, index) => ({
-			name: text$1(raw.name, `factions[${index}].name`, 120),
-			description: text$1(raw.description, `factions[${index}].description`, LIMITS.maxWorldbookTextChars),
+			name: text$2(raw.name, `factions[${index}].name`, 120),
+			description: text$2(raw.description, `factions[${index}].description`, LIMITS.maxWorldbookTextChars),
 			goal: optionalText(raw.goal, `factions[${index}].goal`)
 		}));
 		uniqueNames(result.factions, "factions");
@@ -4291,8 +4314,8 @@ function mergeWorldbook(existing, patch, now) {
 			const capacity = raw.capacity ?? 0;
 			if (!Number.isInteger(capacity) || capacity < 0) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `locations[${index}].capacity must be a non-negative integer`);
 			return {
-				name: text$1(raw.name, `locations[${index}].name`, 120),
-				description: text$1(raw.description, `locations[${index}].description`, LIMITS.maxWorldbookTextChars),
+				name: text$2(raw.name, `locations[${index}].name`, 120),
+				description: text$2(raw.description, `locations[${index}].description`, LIMITS.maxWorldbookTextChars),
 				layout: optionalText(raw.layout, `locations[${index}].layout`),
 				capacity
 			};
@@ -4301,17 +4324,17 @@ function mergeWorldbook(existing, patch, now) {
 	}
 	if (patch.characters !== void 0) {
 		result.characters = records(patch.characters, "characters").map((raw, index) => ({
-			name: text$1(raw.name, `characters[${index}].name`, 120),
-			role: text$1(raw.role, `characters[${index}].role`, 60),
-			description: text$1(raw.description, `characters[${index}].description`, LIMITS.maxWorldbookTextChars),
+			name: text$2(raw.name, `characters[${index}].name`, 120),
+			role: text$2(raw.role, `characters[${index}].role`, 60),
+			description: text$2(raw.description, `characters[${index}].description`, LIMITS.maxWorldbookTextChars),
 			arc: optionalText(raw.arc, `characters[${index}].arc`)
 		}));
 		uniqueNames(result.characters, "characters");
 	}
 	if (patch.glossary !== void 0) {
 		result.glossary = records(patch.glossary, "glossary").map((raw, index) => ({
-			term: text$1(raw.term, `glossary[${index}].term`, 120),
-			definition: text$1(raw.definition, `glossary[${index}].definition`, LIMITS.maxWorldbookTextChars)
+			term: text$2(raw.term, `glossary[${index}].term`, 120),
+			definition: text$2(raw.definition, `glossary[${index}].definition`, LIMITS.maxWorldbookTextChars)
 		}));
 		const seen = /* @__PURE__ */ new Set();
 		for (const entry of result.glossary) {
@@ -4320,8 +4343,8 @@ function mergeWorldbook(existing, patch, now) {
 		}
 	}
 	if (patch.backstory !== void 0) result.backstory = records(patch.backstory, "backstory").map((raw, index) => ({
-		time: text$1(raw.time, `backstory[${index}].time`, 120),
-		event: text$1(raw.event, `backstory[${index}].event`, LIMITS.maxWorldbookTextChars)
+		time: text$2(raw.time, `backstory[${index}].time`, 120),
+		event: text$2(raw.event, `backstory[${index}].event`, LIMITS.maxWorldbookTextChars)
 	}));
 	if (patch.facts !== void 0) {
 		result.facts = records(patch.facts, "facts").map((raw, index) => {
@@ -4330,9 +4353,9 @@ function mergeWorldbook(existing, patch, now) {
 			const tolerance = raw.tolerance ?? 0;
 			if (typeof tolerance !== "number" || !Number.isFinite(tolerance) || tolerance < 0) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `facts[${index}].tolerance must be a non-negative number`);
 			return {
-				alias: text$1(raw.alias, `facts[${index}].alias`, 120),
+				alias: text$2(raw.alias, `facts[${index}].alias`, 120),
 				value,
-				unit: text$1(raw.unit, `facts[${index}].unit`, 40),
+				unit: text$2(raw.unit, `facts[${index}].unit`, 40),
 				tolerance,
 				...raw.note === void 0 ? {} : { note: optionalText(raw.note, `facts[${index}].note`) }
 			};
@@ -4347,7 +4370,7 @@ function mergeWorldbook(existing, patch, now) {
 }
 /** Validate a worldbook loaded from disk. */
 function validateWorldbookDocument(value, now) {
-	if (!isRecord$1(value)) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, "outline/worldbook.yaml must be a mapping");
+	if (!isRecord$2(value)) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, "outline/worldbook.yaml must be a mapping");
 	try {
 		if (value.schema_version !== 1) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `outline/worldbook.yaml schema_version must be 1, got ${String(value.schema_version)}`);
 		const allowedTopLevel = /* @__PURE__ */ new Set([
@@ -4758,7 +4781,7 @@ function parseOutlineData(content, format) {
 	} catch (error) {
 		throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `outline ${format} is invalid: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (!isRecord$1(parsed)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `outline ${format} must be a mapping`);
+	if (!isRecord$2(parsed)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `outline ${format} must be a mapping`);
 	if (parsed.schema_version !== void 0 && parsed.schema_version !== 1) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `outline ${format} schema_version must be 1, got ${String(parsed.schema_version)}`);
 	const warnings = [];
 	const allowed = /* @__PURE__ */ new Set([
@@ -4855,6 +4878,216 @@ function renderWorldbookMarkdown(project, document) {
 	section("前史", document.backstory.map((entry) => `- ${oneLine(entry.time)}：${oneLine(entry.event)}`));
 	return parts.join("\n");
 }
+// src/engine/outline-merge.ts
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const text$1 = (value, where) => {
+	if (typeof value !== "string" || value.trim() === "") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${where} must be a non-empty string`);
+	return value.trim();
+};
+const positiveInteger = (value, where) => {
+	if (!Number.isInteger(value) || value < 1) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${where} must be a positive integer`);
+	return value;
+};
+const parseChapterNumbers = (value, field) => {
+	if (value === void 0) return /* @__PURE__ */ new Set();
+	if (!Array.isArray(value)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${field} must be an array of chapter numbers`);
+	const result = /* @__PURE__ */ new Set();
+	for (const [index, raw] of value.entries()) {
+		const num = positiveInteger(raw, `${field}[${index}]`);
+		if (result.has(num)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${field} contains duplicate chapter ${num}`);
+		result.add(num);
+	}
+	return result;
+};
+const parseVolumeTitles = (value, field) => {
+	if (value === void 0) return /* @__PURE__ */ new Set();
+	if (!Array.isArray(value)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${field} must be an array of volume titles`);
+	const result = /* @__PURE__ */ new Set();
+	for (const [index, raw] of value.entries()) {
+		const title = text$1(raw, `${field}[${index}]`);
+		if (result.has(title)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${field} contains duplicate "${title}"`);
+		result.add(title);
+	}
+	return result;
+};
+const submittedNumbers = (input) => {
+	const result = /* @__PURE__ */ new Set();
+	if (!Array.isArray(input)) return result;
+	for (const raw of input) {
+		if (!isRecord$1(raw) || !Number.isInteger(raw.num) || raw.num < 1) continue;
+		result.add(raw.num);
+	}
+	return result;
+};
+const volumeByTitle = (volumes) => new Map(volumes.map((volume) => [volume.title, volume]));
+/**
+* `volumes` is an upsert keyed by title: omitted volumes survive, and removal
+* requires naming the volume in `remove_volumes`. This deliberately does not
+* accept a positional or full-list replacement.
+*/
+const mergeVolumes = (options) => {
+	const removed = parseVolumeTitles(options.remove_volumes, "remove_volumes");
+	if (options.volumes === void 0 && removed.size === 0) return {
+		volumes: [...options.existingVolumes],
+		added: [],
+		updated: [],
+		removed: []
+	};
+	if (options.volumes !== void 0 && !Array.isArray(options.volumes)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "volumes must be an array");
+	if (options.volumes !== void 0 || removed.size > 0) {
+		const existingTitles = /* @__PURE__ */ new Set();
+		for (const volume of options.existingVolumes) {
+			if (existingTitles.has(volume.title)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `outline has duplicate volume title "${volume.title}"`, "repair the volume titles with novel_amend before submitting volumes");
+			existingTitles.add(volume.title);
+		}
+	}
+	const byTitle = volumeByTitle(options.existingVolumes);
+	const usedIds = new Set(options.existingVolumes.map((volume) => volume.id));
+	let nextGeneratedId = 1;
+	const generatedId = () => {
+		while (usedIds.has(`V${nextGeneratedId}`)) nextGeneratedId += 1;
+		const id = `V${nextGeneratedId}`;
+		usedIds.add(id);
+		nextGeneratedId += 1;
+		return id;
+	};
+	const submitted = /* @__PURE__ */ new Set();
+	for (const [index, raw] of (options.volumes ?? []).entries()) {
+		if (!isRecord$1(raw)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `volumes[${index}] must be an object`);
+		const title = text$1(raw.title, `volumes[${index}].title`);
+		if (submitted.has(title)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `volumes contains duplicate title "${title}"`);
+		submitted.add(title);
+		const base = byTitle.get(title);
+		const explicitId = typeof raw.id === "string" && raw.id.trim() !== "" ? raw.id.trim() : void 0;
+		const id = base?.id ?? explicitId ?? generatedId();
+		if (!usedIds.has(id)) usedIds.add(id);
+		byTitle.set(title, {
+			...base ?? {},
+			...raw,
+			id,
+			title
+		});
+	}
+	for (const title of removed) {
+		if (submitted.has(title)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `volume "${title}" cannot be both submitted and removed`);
+		const existing = byTitle.get(title);
+		if (existing === void 0) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `cannot remove volume "${title}": it is not in the plan`);
+		if (existing.status === "done") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `cannot remove volume "${title}": its status is done`, "a completed volume is archive evidence; remove only planned/writing volumes");
+		byTitle.delete(title);
+	}
+	const volumes = normalizeVolumes([...byTitle.values()], { totalChapters: options.totalChapters });
+	const before = volumeByTitle(options.existingVolumes);
+	const after = volumeByTitle(volumes);
+	return {
+		volumes,
+		added: [...after.keys()].filter((title) => !before.has(title)),
+		updated: [...after.keys()].filter((title) => before.has(title) && stableJson(before.get(title)) !== stableJson(after.get(title))),
+		removed: [...removed]
+	};
+};
+const remapVolume = (card, oldVolumes, newVolumes) => {
+	if (card.volume === null || card.volume === void 0) return card;
+	const previous = oldVolumes[card.volume - 1];
+	if (previous === void 0) return {
+		...card,
+		volume: null
+	};
+	const nextIndex = newVolumes.findIndex((volume) => volume.title === previous.title);
+	if (nextIndex < 0) return {
+		...card,
+		volume: null
+	};
+	const next = newVolumes[nextIndex];
+	return {
+		...card,
+		volume: card.num >= next.start_chapter && card.num <= next.end_chapter ? nextIndex + 1 : null
+	};
+};
+const assertArchivedVolumes = (options, volumes, removedTitles) => {
+	const removed = new Set(removedTitles);
+	const oldByTitle = volumeByTitle(options.existingVolumes);
+	const newByTitle = volumeByTitle(volumes);
+	for (const record of options.archivedChapters) {
+		const card = options.existing.find((entry) => entry.num === record.num);
+		if (card === void 0 || card.volume === null) continue;
+		const previous = options.existingVolumes[card.volume - 1];
+		if (previous === void 0) continue;
+		if (removed.has(previous.title) || !oldByTitle.has(previous.title)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `cannot remove volume "${previous.title}": archived chapter ${record.num} belongs to it`, "archived cards are evidence; keep the volume or reopen the chapter first");
+		const next = newByTitle.get(previous.title);
+		if (next === void 0 || record.num < next.start_chapter || record.num > next.end_chapter) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `volume "${previous.title}" no longer covers archived chapter ${record.num}`, "keep archived chapter ranges inside their existing volume");
+	}
+};
+/**
+* Merge chapter cards by num. Existing planned cards are appended back when
+* omitted; removal is name-only (`remove`), and archived cards are always
+* backfilled from the chapter index.
+*/
+const mergeOutline = (options) => {
+	const submitted = submittedNumbers(options.chapters);
+	const removed = parseChapterNumbers(options.remove, "remove");
+	const volumeChanges = mergeVolumes(options);
+	assertArchivedVolumes(options, volumeChanges.volumes, volumeChanges.removed);
+	const existingByNum = new Map(options.existing.map((card) => [card.num, card]));
+	const archivedByNum = new Map(options.archivedChapters.map((record) => [record.num, record]));
+	const archivedNums = new Set(archivedByNum.keys());
+	for (const num of removed) {
+		if (submitted.has(num)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter ${num} cannot be both submitted and removed`);
+		if (num === options.activeChapter) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `cannot remove the active chapter ${num} card`, "archive or move the active chapter first; the card is required while the chapter is in flight");
+		if (archivedByNum.has(num)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `cannot remove chapter ${num}: it is archived`, "archived cards are evidence; call novel_reopen first");
+		if (existingByNum.get(num)?.status !== "planned") throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `cannot remove chapter ${num}: it is not a planned card`);
+	}
+	const normalized = normalizeOutlineChapters(options.chapters, {
+		volumes: volumeChanges.volumes,
+		existing: options.existing,
+		archived: options.archivedChapters,
+		titleRule: options.titleRule,
+		totalChapters: options.totalChapters,
+		defaultTargetWords: options.defaultTargetWords,
+		now: options.now
+	});
+	const byNum = new Map(normalized.map((card) => [card.num, card]));
+	const updated = /* @__PURE__ */ new Set();
+	const added = /* @__PURE__ */ new Set();
+	for (const card of normalized) {
+		if (!submitted.has(card.num)) continue;
+		const before = existingByNum.get(card.num);
+		if (before === void 0) added.add(card.num);
+		else if (stableJson(before) !== stableJson(card)) updated.add(card.num);
+	}
+	for (const card of options.existing) {
+		if (submitted.has(card.num) || removed.has(card.num)) continue;
+		if (card.status === "archived" && !archivedNums.has(card.num)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `chapter ${card.num} has an archived outline card but is not in the chapter index`, "repair the outline or reopen/archive the chapter so the card status matches the index");
+		if (archivedNums.has(card.num)) {
+			if (!byNum.has(card.num)) byNum.set(card.num, {
+				...card,
+				status: "archived"
+			});
+			continue;
+		}
+		const remapped = remapVolume(card, options.existingVolumes, volumeChanges.volumes);
+		if (byNum.has(card.num)) {
+			const current = byNum.get(card.num);
+			if (stableJson(current) !== stableJson(remapped)) {
+				byNum.set(card.num, remapped);
+				if (card.status === "planned") updated.add(card.num);
+			}
+		} else {
+			byNum.set(card.num, remapped);
+			if (card.status === "planned" && stableJson(card) !== stableJson(remapped)) updated.add(card.num);
+		}
+	}
+	for (const num of removed) byNum.delete(num);
+	return {
+		chapters: [...byNum.values()].sort((left, right) => left.num - right.num),
+		volumes: volumeChanges.volumes,
+		added: [...added].sort((left, right) => left - right),
+		updated: [...updated].sort((left, right) => left - right),
+		removed: [...removed].sort((left, right) => left - right),
+		volumes_added: volumeChanges.added,
+		volumes_updated: volumeChanges.updated,
+		volumes_removed: volumeChanges.removed
+	};
+};
 // src/engine/state-delta.ts
 const SECTIONS = [
 	"characters",
@@ -6994,7 +7227,7 @@ const outlineAlignment = (input) => {
 	const card = outline.chapters.find((candidate) => candidate.num === input.chapter);
 	if (card === void 0) {
 		if (!outline.book.strict) return [];
-		return [block("PG-13", `chapter ${input.chapter} has no outline card while strict mode is on`, "read novel_state {kind:\"outline\"}, then submit every existing card plus this one with novel_outline (full replacement); or turn strict off with novel_blueprint")];
+		return [block("PG-13", `chapter ${input.chapter} has no outline card while strict mode is on`, "read novel_state {kind:\"outline\"}, then submit only the missing card with novel_outline (upsert by num; omitted cards are kept); do not turn strict off")];
 	}
 	const problems = [];
 	if (card.status === "archived") problems.push(`chapter ${input.chapter} is already archived but is still the active chapter; call novel_reopen first`);
@@ -8212,6 +8445,7 @@ var EngineService = class {
 			"ending",
 			"strict",
 			"volumes",
+			"confirm_remove",
 			"root"
 		]);
 		for (const key of Object.keys(input)) if (!allowed.has(key)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `unknown novel_blueprint argument "${key}"`, `allowed: ${[...allowed].join(", ")}`);
@@ -8228,9 +8462,11 @@ var EngineService = class {
 				this.assertPlanningDocumentReadable(snapshot, "outline", "novel_blueprint");
 				this.assertArchiveIndexReadable(snapshot, "novel_blueprint");
 				const now = this.now().toISOString();
-				const bookPatch = Object.fromEntries(Object.entries(input).filter(([key]) => key !== "volumes" && key !== "root"));
+				const bookPatch = Object.fromEntries(Object.entries(input).filter(([key]) => key !== "volumes" && key !== "confirm_remove" && key !== "root"));
 				const book = mergeBookPlan(snapshot.outline.book, bookPatch);
 				const volumes = input.volumes === void 0 ? snapshot.outline.volumes : normalizeVolumes(input.volumes, { totalChapters: snapshot.project.targets.total_chapters });
+				const removedVolumes = snapshot.outline.volumes.filter((volume) => !volumes.some((next) => next.title === volume.title)).map((volume) => volume.title);
+				if (removedVolumes.length > 0 && input.confirm_remove !== true) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `novel_blueprint would remove volumes: ${removedVolumes.join(", ")}`, "pass confirm_remove:true to replace the volume list, or omit volumes to keep them");
 				let chapters = snapshot.outline.chapters.map((card) => ({
 					...card,
 					volume: volumeForChapter(volumes, card.num, card.volume)
@@ -8284,12 +8520,66 @@ var EngineService = class {
 			}
 		});
 	}
+	outlinePlanChange(snapshot, input, now) {
+		const book = mergeBookPlan(snapshot.outline.book, input.book === void 0 ? void 0 : {
+			...input.book,
+			...input.strict === void 0 ? {} : { strict: input.strict }
+		});
+		if (input.strict !== void 0) {
+			book.strict = input.strict;
+			book.strict_explicit = true;
+		} else if (input.book?.strict === void 0) {
+			if ((input.chapters?.length ?? 0) > 0 && snapshot.outline.chapters.length === 0 && snapshot.outline.book.strict_explicit !== true) {
+				book.strict = true;
+				book.strict_explicit = true;
+			}
+		}
+		const merged = mergeOutline({
+			chapters: input.chapters ?? [],
+			remove: input.remove,
+			volumes: input.volumes,
+			remove_volumes: input.remove_volumes,
+			existing: snapshot.outline.chapters,
+			archivedChapters: snapshot.chapters.chapters,
+			existingVolumes: snapshot.outline.volumes,
+			titleRule: this.rulepack.format.title,
+			totalChapters: snapshot.project.targets.total_chapters,
+			defaultTargetWords: snapshot.project.targets.words_per_chapter,
+			now,
+			activeChapter: snapshot.pipeline.chapter
+		});
+		return {
+			outline: {
+				schema_version: 1,
+				updated_at: now,
+				book,
+				volumes: merged.volumes,
+				chapters: merged.chapters
+			},
+			data: {
+				planned: merged.chapters.filter((card) => card.status === "planned").length,
+				archived: merged.chapters.filter((card) => card.status === "archived").length,
+				total: merged.chapters.length,
+				strict: book.strict,
+				volumes: merged.volumes.length,
+				added: merged.added,
+				updated: merged.updated,
+				removed: merged.removed,
+				volumes_added: merged.volumes_added,
+				volumes_updated: merged.volumes_updated,
+				volumes_removed: merged.volumes_removed
+			}
+		};
+	}
 	async submitOutline(input) {
 		const allowed = /* @__PURE__ */ new Set([
 			"book",
 			"volumes",
 			"chapters",
 			"strict",
+			"remove",
+			"remove_volumes",
+			"dry_run",
 			"root"
 		]);
 		for (const key of Object.keys(input)) if (!allowed.has(key)) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `unknown novel_outline argument "${key}"`, `allowed: ${[...allowed].join(", ")}`);
@@ -8297,6 +8587,41 @@ var EngineService = class {
 		this.assertProjectReadable(current, "novel_outline");
 		this.assertPlanningDocumentReadable(current, "outline", "novel_outline");
 		this.assertArchiveIndexReadable(current, "novel_outline");
+		if ((input.chapters === void 0 || Array.isArray(input.chapters) && input.chapters.length === 0) && (input.remove === void 0 || input.remove.length === 0) && (input.remove_volumes === void 0 || input.remove_volumes.length === 0) && (input.volumes === void 0 || Array.isArray(input.volumes) && input.volumes.length === 0) && (input.book === void 0 || typeof input.book === "object" && input.book !== null && Object.keys(input.book).length === 0) && input.strict === void 0 && input.dry_run !== true) return {
+			data: {
+				planned: current.outline.chapters.filter((card) => card.status === "planned").length,
+				archived: current.outline.chapters.filter((card) => card.status === "archived").length,
+				total: current.outline.chapters.length,
+				strict: current.outline.book.strict,
+				volumes: current.outline.volumes.length,
+				added: [],
+				updated: [],
+				removed: [],
+				volumes_added: [],
+				volumes_updated: [],
+				volumes_removed: []
+			},
+			revision: current.pipeline.revision,
+			warnings: []
+		};
+		if (input.dry_run === true) {
+			const plan = this.outlinePlanChange(current, input, this.now().toISOString());
+			this.assertOutlineWritable(current, plan.outline, "novel_outline");
+			return {
+				data: {
+					...plan.data,
+					added: [],
+					updated: [],
+					removed: [],
+					dry_run: true,
+					would_add: plan.data.added,
+					would_update: plan.data.updated,
+					would_remove: plan.data.removed
+				},
+				revision: current.pipeline.revision,
+				warnings: []
+			};
+		}
 		return this.mutate({
 			root: input.root,
 			op: "submitOutline",
@@ -8305,72 +8630,34 @@ var EngineService = class {
 				this.assertProjectReadable(snapshot, "novel_outline");
 				this.assertPlanningDocumentReadable(snapshot, "outline", "novel_outline");
 				this.assertArchiveIndexReadable(snapshot, "novel_outline");
-				const now = this.now().toISOString();
-				const book = mergeBookPlan(snapshot.outline.book, input.book === void 0 ? void 0 : {
-					...input.book,
-					...input.strict === void 0 ? {} : { strict: input.strict }
-				});
-				if (input.strict !== void 0) {
-					book.strict = input.strict;
-					book.strict_explicit = true;
-				} else if (input.book?.strict === void 0) {
-					if (snapshot.outline.chapters.length === 0 && snapshot.outline.book.strict_explicit !== true) {
-						book.strict = true;
-						book.strict_explicit = true;
-					}
-				}
-				const volumes = input.volumes === void 0 ? snapshot.outline.volumes : normalizeVolumes(input.volumes, { totalChapters: snapshot.project.targets.total_chapters });
-				const chapters = normalizeOutlineChapters(input.chapters, {
-					volumes,
-					existing: snapshot.outline.chapters,
-					archived: snapshot.chapters.chapters,
-					titleRule: this.rulepack.format.title,
-					totalChapters: snapshot.project.targets.total_chapters,
-					defaultTargetWords: snapshot.project.targets.words_per_chapter,
-					now
-				});
-				const outline = {
-					schema_version: 1,
-					updated_at: now,
-					book,
-					volumes,
-					chapters
-				};
-				this.assertActiveCardPreserved(snapshot, book.strict, chapters, "novel_outline");
-				this.assertOutlineWritable(snapshot, outline, "novel_outline");
-				const planned = chapters.filter((card) => card.status === "planned").length;
-				const archived = chapters.filter((card) => card.status === "archived").length;
-				const kept = new Set(chapters.filter((card) => card.status === "planned").map((card) => card.num));
-				const dropped = snapshot.outline.chapters.filter((card) => card.status === "planned" && !kept.has(card.num)).map((card) => card.num);
+				const plan = this.outlinePlanChange(snapshot, input, this.now().toISOString());
+				this.assertOutlineWritable(snapshot, plan.outline, "novel_outline");
 				const nextPipeline = pipelineWith(snapshot, context.revision, { last_action: action("novel_outline", this.now(), shortDigest(stableJson(input))) });
+				const files = [{
+					path: OUTLINE_FILE,
+					text: yaml(plan.outline)
+				}, {
+					path: joinRel(STATE_DIR, STATE_FILES.pipeline),
+					text: yaml(nextPipeline)
+				}];
+				const prior = await context.store.readText(OUTLINE_FILE);
+				if (prior !== null) files.push({
+					path: OUTLINE_DEPRECATED_FILE,
+					text: prior
+				});
 				return {
-					files: [{
-						path: OUTLINE_FILE,
-						text: yaml(outline)
-					}, {
-						path: joinRel(STATE_DIR, STATE_FILES.pipeline),
-						text: yaml(nextPipeline)
-					}],
+					files,
 					backup: true,
-					data: {
-						planned,
-						archived,
-						total: chapters.length,
-						strict: book.strict,
-						volumes: volumes.length
-					},
-					warnings: dropped.length === 0 ? [] : [{
-						code: "OUTLINE_PLANNED_DROPPED",
-						message: `this replacement dropped planned cards: ${dropped.join(", ")}; resubmit every existing card when adding one`
-					}],
+					data: plan.data,
+					warnings: [],
 					event: {
 						name: "novel/planned",
 						payload: {
 							schemaVersion: 1,
 							projectRoot: snapshot.root,
 							kind: "outline",
-							chapters: chapters.length,
-							volumes: volumes.length
+							chapters: plan.data.total,
+							volumes: plan.data.volumes
 						}
 					}
 				};
@@ -8737,6 +9024,53 @@ var EngineService = class {
 			run: async (snapshot, context) => {
 				const manifest = await readBackupManifest(context.store, input.txid);
 				if (manifest === null) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `backup ${input.txid} has no readable manifest`, "list backups with novel_state {kind:\"backups\"}; only marked engine backups can be restored");
+				if (input.paths?.length === 1 && input.paths[0] === "outline/outline.yaml") {
+					this.assertArchiveIndexReadable(snapshot, "novel_restore");
+					if (input.chapter !== void 0) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, "restoring outline/outline.yaml does not accept a chapter", "omit chapter when paths is exactly [outline/outline.yaml]");
+					if (!manifest.files.includes("outline/outline.yaml")) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `backup ${input.txid} does not contain ${OUTLINE_FILE}`, "choose a backup created by novel_outline, novel_blueprint or a planning amendment");
+					const text = await context.store.readText(`backups/${input.txid}/${OUTLINE_FILE}`);
+					if (text === null) throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `backup ${input.txid} does not contain ${OUTLINE_FILE}`, "the file was created by that transaction, so it has no pre-image to restore");
+					let document;
+					try {
+						document = validateOutlineDocument(parse(text), {
+							titleRule: this.rulepack.format.title,
+							totalChapters: snapshot.project.targets.total_chapters
+						});
+					} catch (error) {
+						throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `backup ${input.txid} contains an invalid outline: ${errorMessage(error)}`, "restore a different backup or repair the file manually");
+					}
+					const restoredCards = new Map(document.chapters.map((card) => [card.num, card]));
+					const archivedNums = new Set(snapshot.chapters.chapters.map((record) => record.num));
+					for (const record of snapshot.chapters.chapters) {
+						const restoredCard = restoredCards.get(record.num);
+						if (restoredCard?.status !== "archived") throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `backup ${input.txid} would make archived chapter ${record.num} ${restoredCard === void 0 ? "missing its card" : "a planned card"}`, "call novel_reopen before restoring a pre-archive outline, or choose an outline backup that already contains the archived card");
+					}
+					for (const card of document.chapters) if (card.status === "archived" && !archivedNums.has(card.num)) throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `backup ${input.txid} would restore an archived card for chapter ${card.num}, but that chapter is not archived`, "choose an outline backup that matches the current chapter index, or reopen/archive the chapter first");
+					const files = [{
+						path: OUTLINE_FILE,
+						text
+					}];
+					const prior = await context.store.readText(OUTLINE_FILE);
+					if (prior !== null) files.push({
+						path: OUTLINE_DEPRECATED_FILE,
+						text: prior
+					});
+					const nextPipeline = pipelineWith(snapshot, context.revision, { last_action: action("novel_restore", this.now(), shortDigest(input.txid)) });
+					files.push({
+						path: joinRel(STATE_DIR, STATE_FILES.pipeline),
+						text: yaml(nextPipeline)
+					});
+					return {
+						files,
+						backup: true,
+						data: {
+							txid: input.txid,
+							chapter: snapshot.pipeline.chapter,
+							restored: [OUTLINE_FILE]
+						},
+						warnings: []
+					};
+				}
 				const chapter = input.chapter ?? snapshot.pipeline.chapter;
 				if (snapshot.chapters.chapters.some((record) => record.num === chapter)) throw new EngineInputError(ERROR_CODES.STAGE_ORDER, `chapter ${chapter} is archived; restoring it behind the index would break its content hash`, "call novel_reopen for the chapter, then restore the backup");
 				if (chapter !== snapshot.pipeline.chapter) throw new EngineInputError(ERROR_CODES.STAGE_ORDER, `chapter ${chapter} is not the active chapter ${snapshot.pipeline.chapter}; restore only the active chapter`, "switch the active chapter first, or restore files from the active chapter");
@@ -11963,17 +12297,15 @@ var EngineService = class {
 		throw new EngineFaultError(ERROR_CODES.SCHEMA_INVALID, `${path} is unreadable; ${operation} would overwrite the unreadable planning document`, `read ${path} with novel_state and repair it with novel_amend before ${operation}`);
 	}
 	/**
-	* A strict outline cannot silently lose the active chapter's card while the
-	* chapter is still being written. Otherwise a late replacement turns a
-	* strict project non-strict in effect and archive would auto-create the card
-	* the author was required to provide.
+	* An import is a full replacement, unlike novel_outline's keyed upsert. It
+	* must not silently lose the active card while strict mode still requires it.
 	*/
 	assertActiveCardPreserved(snapshot, strict, chapters, operation) {
 		if (!strict) return;
 		const chapter = snapshot.pipeline.chapter;
 		if (!snapshot.outline.chapters.some((card) => card.num === chapter)) return;
 		if (chapters.some((card) => card.num === chapter)) return;
-		throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${operation} cannot remove the active chapter ${chapter} card while strict mode is on`, "include the active card in the replacement, or turn strict mode off with novel_blueprint {\"strict\":false}");
+		throw new EngineInputError(ERROR_CODES.SCHEMA_INVALID, `${operation} cannot remove the active chapter ${chapter} card while strict mode is on`, "include the active card in the imported outline; import replaces the whole plan and will not turn strict mode off for you");
 	}
 	/**
 	* The outline is a derived progress view and the PG-13 input. Every write
@@ -14164,6 +14496,8 @@ function diffLines(before, after) {
 		hunks
 	};
 }
+// src/tools/semantics.ts
+const arraySemanticsDescription = (semantics, description) => `[x-semantics: ${semantics}] ${description}`;
 // src/tools/index.ts
 /**
 * Providers sometimes serialize a free-form `json` parameter as a JSON string
@@ -14239,10 +14573,11 @@ const jsonOutput = {
 	schema: { type: "json" },
 	render: (_args, raw) => withReplay(text(payload(raw)), raw)
 };
-const stringArray = {
+const stringArray = (semantics, description) => ({
 	type: "array",
-	items: { type: "string" }
-};
+	items: { type: "string" },
+	description: arraySemanticsDescription(semantics, description)
+});
 const root = {
 	type: "string",
 	description: "Project root. Passing it selects this project for the current session and persists the choice. When omitted: session binding -> unique project in the workspace -> single registered project -> configured projectRoot -> error. Multiple projects require an explicit choice."
@@ -14284,7 +14619,8 @@ function createNovelTools(engine, options = {}) {
 				description: { type: "string" },
 				words_per_chapter: {
 					type: "array",
-					items: { type: "integer" }
+					items: { type: "integer" },
+					description: arraySemanticsDescription("replace", "Fixed [min,max] word target for chapters.")
 				},
 				total_chapters: { type: "integer" },
 				premise: {
@@ -14292,11 +14628,11 @@ function createNovelTools(engine, options = {}) {
 					description: "Optional one-sentence premise for the book plan."
 				},
 				logline: { type: "string" },
-				themes: stringArray,
+				themes: stringArray("replace", "Book themes; supplied list replaces the theme list."),
 				tone: { type: "string" },
 				pov: { type: "string" },
 				audience: { type: "string" },
-				selling_points: stringArray,
+				selling_points: stringArray("replace", "Selling points; supplied list replaces the list."),
 				ending: { type: "string" },
 				strict_outline: { type: "boolean" },
 				project_root: initRoot
@@ -14393,10 +14729,16 @@ function createNovelTools(engine, options = {}) {
 					type: "string",
 					required: true
 				},
-				constraints: stringArray,
-				characters: { type: "json" },
-				locations: { type: "json" },
-				continuity_notes: stringArray,
+				constraints: stringArray("replace", "P1 constraints; supplied list replaces the plan list."),
+				characters: {
+					type: "json",
+					description: arraySemanticsDescription("replace", "P1 cast; supplied list replaces the cast.")
+				},
+				locations: {
+					type: "json",
+					description: arraySemanticsDescription("replace", "P1 locations; supplied list replaces them.")
+				},
+				continuity_notes: stringArray("replace", "P1 continuity notes; supplied list replaces them."),
 				project_root: root
 			},
 			output: jsonOutput,
@@ -14428,7 +14770,7 @@ function createNovelTools(engine, options = {}) {
 					required: true
 				},
 				beats: {
-					...stringArray,
+					...stringArray("replace", "Ordered plan beats; supplied list replaces the beats."),
 					required: true
 				},
 				opening: {
@@ -14442,11 +14784,12 @@ function createNovelTools(engine, options = {}) {
 				target_words: {
 					type: "array",
 					items: { type: "integer" },
-					required: true
+					required: true,
+					description: arraySemanticsDescription("replace", "Plan [min,max] word target.")
 				},
 				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."
+					description: arraySemanticsDescription("replace", "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
 			},
@@ -14517,9 +14860,13 @@ function createNovelTools(engine, options = {}) {
 				},
 				dimensions: {
 					type: "json",
-					required: true
+					required: true,
+					description: arraySemanticsDescription("replace", "Fifteen scored dimensions.")
+				},
+				issues: {
+					type: "json",
+					description: arraySemanticsDescription("replace", "Review issue list.")
 				},
-				issues: { type: "json" },
 				total: {
 					type: "integer",
 					required: true,
@@ -14527,7 +14874,8 @@ function createNovelTools(engine, options = {}) {
 				},
 				proof: {
 					type: "json",
-					required: true
+					required: true,
+					description: arraySemanticsDescription("replace", "Three reading-proof quotes.")
 				},
 				project_root: root
 			},
@@ -14560,12 +14908,12 @@ function createNovelTools(engine, options = {}) {
 				summary: { type: "json" },
 				issues: {
 					type: "json",
-					description: "Updated issue statuses and evidence for PG-08."
+					description: arraySemanticsDescription("replace", "Updated issue statuses and evidence for PG-08.")
 				},
 				proof: {
 					type: "json",
 					required: true,
-					description: "Three quotes from the revised text; PG-09 verifies them."
+					description: arraySemanticsDescription("replace", "Three quotes from the revised text; PG-09 verifies them.")
 				},
 				project_root: root
 			},
@@ -14588,16 +14936,16 @@ function createNovelTools(engine, options = {}) {
 					type: "integer",
 					required: true
 				},
-				scope: stringArray,
+				scope: stringArray("replace", "Requested check scopes; supplied list replaces the request."),
 				semantic: {
 					type: "json",
 					required: true,
-					description: "Exactly the five P6 semantic items, each with a verbatim evidence quote."
+					description: arraySemanticsDescription("replace", "Exactly the five P6 semantic items, each with a verbatim evidence quote.")
 				},
 				acknowledge: {
 					type: "array",
 					items: { type: "string" },
-					description: "Advisory codes read and accepted; blockers cannot be acknowledged."
+					description: arraySemanticsDescription("replace", "Advisory codes read and accepted; blockers cannot be acknowledged.")
 				},
 				project_root: root
 			},
@@ -14696,7 +15044,7 @@ function createNovelTools(engine, options = {}) {
 				chapter_range: {
 					type: "array",
 					items: { type: "integer" },
-					description: "For kind=chapters: inclusive [start, end] range."
+					description: arraySemanticsDescription("replace", "For kind=chapters: inclusive [start, end] range.")
 				},
 				project_root: root
 			},
@@ -14864,11 +15212,11 @@ function createNovelTools(engine, options = {}) {
 			parameters: {
 				premise: { type: "string" },
 				logline: { type: "string" },
-				themes: stringArray,
+				themes: stringArray("replace", "Book themes; supplied list replaces the theme list."),
 				tone: { type: "string" },
 				pov: { type: "string" },
 				audience: { type: "string" },
-				selling_points: stringArray,
+				selling_points: stringArray("replace", "Selling points; supplied list replaces the list."),
 				ending: { type: "string" },
 				strict: {
 					type: "boolean",
@@ -14876,7 +15224,11 @@ function createNovelTools(engine, options = {}) {
 				},
 				volumes: {
 					type: "json",
-					description: "Volume list: [{title,start_chapter,end_chapter,goal?,arc?,climax?,status?}]. Replaces the current volumes."
+					description: arraySemanticsDescription("replace", "Volume list: [{title,start_chapter,end_chapter,goal?,arc?,climax?,status?}]. Replaces the current volumes; dropping any volume requires confirm_remove:true.")
+				},
+				confirm_remove: {
+					type: "boolean",
+					description: "Explicitly confirm a volume-list replacement that drops existing volumes."
 				},
 				project_root: root
 			},
@@ -14892,12 +15244,13 @@ function createNovelTools(engine, options = {}) {
 				ending: args.ending,
 				strict: args.strict,
 				volumes: asJson(args.volumes, "volumes"),
+				confirm_remove: args.confirm_remove,
 				root: args.project_root
 			}))
 		}),
 		defineTool({
 			name: "novel_outline",
-			description: "Write volume/chapter cards. Archived cards are preserved and cannot be rewritten. On the first submission strict mode defaults on; with an existing card, PG-13 checks title, scene, target words and cast even in non-strict mode.",
+			description: "Upsert volume/chapter cards by key: chapters by num, volumes by title. Omitted cards are preserved; deletion requires remove/remove_volumes. Archived cards are preserved and cannot be rewritten. Use dry_run to preview. On the first submission strict mode defaults on; with an existing card, PG-13 checks title, scene, target words and cast even in non-strict mode.",
 			parameters: {
 				book: {
 					type: "json",
@@ -14905,12 +15258,25 @@ function createNovelTools(engine, options = {}) {
 				},
 				volumes: {
 					type: "json",
-					description: "Optional full volume list; omitted keeps current volumes."
+					description: arraySemanticsDescription("upsert", "Volume list: [{title,start_chapter,end_chapter,goal?,arc?,climax?,status?}]. Upserts by title; omitted volumes are kept.")
 				},
 				chapters: {
 					type: "json",
-					required: true,
-					description: "Chapter cards: [{num,title,scene_type,goal,conflict,hook,cast?,target_words:[min,max],volume?,notes?}]."
+					description: arraySemanticsDescription("upsert", "Chapter cards: [{num,title,scene_type,goal,conflict,hook,cast?,target_words:[min,max],volume?,notes?}]. Upserts by num; omitted cards are kept.")
+				},
+				remove: {
+					type: "array",
+					items: { type: "integer" },
+					description: arraySemanticsDescription("remove", "Explicit chapter numbers to delete.")
+				},
+				remove_volumes: {
+					type: "array",
+					items: { type: "string" },
+					description: arraySemanticsDescription("remove", "Explicit volume titles to delete.")
+				},
+				dry_run: {
+					type: "boolean",
+					description: "Preview changes without writing or journaling."
 				},
 				strict: { type: "boolean" },
 				project_root: root
@@ -14920,6 +15286,9 @@ function createNovelTools(engine, options = {}) {
 				book: asJson(args.book, "book"),
 				volumes: asJson(args.volumes, "volumes"),
 				chapters: asJson(args.chapters, "chapters"),
+				remove: args.remove,
+				remove_volumes: args.remove_volumes,
+				dry_run: args.dry_run,
 				strict: args.strict,
 				root: args.project_root
 			}))
@@ -14958,17 +15327,35 @@ function createNovelTools(engine, options = {}) {
 			parameters: {
 				premise: { type: "string" },
 				setting: { type: "string" },
-				rules: { type: "json" },
-				factions: { type: "json" },
-				locations: { type: "json" },
-				characters: { type: "json" },
-				glossary: { type: "json" },
-				backstory: { type: "json" },
+				rules: {
+					type: "json",
+					description: arraySemanticsDescription("replace", "Rules section list.")
+				},
+				factions: {
+					type: "json",
+					description: arraySemanticsDescription("replace", "Factions section list.")
+				},
+				locations: {
+					type: "json",
+					description: arraySemanticsDescription("replace", "Locations section list.")
+				},
+				characters: {
+					type: "json",
+					description: arraySemanticsDescription("replace", "Characters section list.")
+				},
+				glossary: {
+					type: "json",
+					description: arraySemanticsDescription("replace", "Glossary section list.")
+				},
+				backstory: {
+					type: "json",
+					description: arraySemanticsDescription("replace", "Backstory section list.")
+				},
 				facts: {
 					type: "json",
-					description: "Declared numeric canon: [{alias,value,unit,tolerance?,note?}]."
+					description: arraySemanticsDescription("replace", "Declared numeric canon: [{alias,value,unit,tolerance?,note?}].")
 				},
-				themes: stringArray,
+				themes: stringArray("replace", "Worldbook themes; supplied list replaces the list."),
 				project_root: root
 			},
 			output: jsonOutput,
@@ -15060,7 +15447,7 @@ function createNovelTools(engine, options = {}) {
 		}),
 		defineTool({
 			name: "novel_restore",
-			description: "Restore an active chapter file from a marked backup transaction. Archived chapters are refused; use novel_reopen first. Every restore is itself journaled and backed up.",
+			description: "Restore an active chapter file, or outline/outline.yaml, from a marked backup transaction. Archived chapters are refused; use novel_reopen first. Every restore is itself journaled and backed up.",
 			parameters: {
 				txid: {
 					type: "string",
@@ -15070,7 +15457,7 @@ function createNovelTools(engine, options = {}) {
 				paths: {
 					type: "array",
 					items: { type: "string" },
-					description: "Project-relative chapter files; omitted restores every restorable chapter file that the backup manifest records."
+					description: arraySemanticsDescription("replace", "Project-relative chapter files, or exactly [outline/outline.yaml]; omitted restores every restorable chapter file the manifest records.")
 				},
 				project_root: root
 			},
@@ -16153,4 +16540,4 @@ function connectionFence(scope) {
 	}
 	if (Object.prototype.hasOwnProperty.call(candidate, "connection")) return candidate.connection;
 }
-export { ARCHIVE_DIGESTS_FILE, BACKUP_DIR, BRIEF_RECEIPTS_FILE, BriefLibrary, CHAPTERS_DIR, CHECK_DIR, CORE_TOOLS, Config, DEFAULT_GENRE, DEFAULT_PLATFORM, ERROR_CODES, EXPORT_DIR, EngineBlockedError, EngineError, EngineFaultError, EngineInputError, EngineService, GENRES, HISTORY_DIR, HISTORY_KINDS, INITIAL_STAGE, LIMITS, LOCK_FILE, METADATA_LOCK_FILE, OPERATIONS, OUTLINE_DIR, OUTLINE_FILE, PANEL_CHAPTER_LIMIT, PANEL_ID, PANEL_ROUTE, PHASE_STRIP, PLAN_DIR, PLATFORMS, PLUGIN_NAME, PROJECT_FILE, REGISTRY_FILE, REMOTE_VERSION, REVIEW_DIR, SCENE_TYPES, SCENE_TYPE_DEFAULT, SCHEMA_VERSION, SESSION_BINDINGS_FILE, SKILL_NAME, STAGING_DIR, STATE_DIR, STATE_FILES, TOOL_NAMES, WORLDBOOK_FILE, applicableGates, apply, blockedError, briefStageFor, chapterFile, chapterHeading, chapterHistoryFile, checkFile, checkHistoryFile, deprecatedChapterFile, deprecatedHistoryFile, evaluateGates, faultError, formatResumePrompt, gateName, inject, inputError, loadRulepack, name, parseParagraphLocation, phaseStrip, planChapterFile, planHistoryFile, planWorldFile, projectChapter, projectChapters, projectGates, projectSummary, renderBlurb, renderCover, renderEpubChapter, renderMarkdown, renderPlainText, renderProposal, reviewFile, reviewHistoryFile, verifyReference };
+export { ARCHIVE_DIGESTS_FILE, BACKUP_DIR, BRIEF_RECEIPTS_FILE, BriefLibrary, CHAPTERS_DIR, CHECK_DIR, CORE_TOOLS, Config, DEFAULT_GENRE, DEFAULT_PLATFORM, ERROR_CODES, EXPORT_DIR, EngineBlockedError, EngineError, EngineFaultError, EngineInputError, EngineService, GENRES, HISTORY_DIR, HISTORY_KINDS, INITIAL_STAGE, LIMITS, LOCK_FILE, METADATA_LOCK_FILE, OPERATIONS, OUTLINE_DEPRECATED_FILE, OUTLINE_DIR, OUTLINE_FILE, PANEL_CHAPTER_LIMIT, PANEL_ID, PANEL_ROUTE, PHASE_STRIP, PLAN_DIR, PLATFORMS, PLUGIN_NAME, PROJECT_FILE, REGISTRY_FILE, REMOTE_VERSION, REVIEW_DIR, SCENE_TYPES, SCENE_TYPE_DEFAULT, SCHEMA_VERSION, SESSION_BINDINGS_FILE, SKILL_NAME, STAGING_DIR, STATE_DIR, STATE_FILES, TOOL_NAMES, WORLDBOOK_FILE, applicableGates, apply, blockedError, briefStageFor, chapterFile, chapterHeading, chapterHistoryFile, checkFile, checkHistoryFile, deprecatedChapterFile, deprecatedHistoryFile, evaluateGates, faultError, formatResumePrompt, gateName, inject, inputError, loadRulepack, name, parseParagraphLocation, phaseStrip, planChapterFile, planHistoryFile, planWorldFile, projectChapter, projectChapters, projectGates, projectSummary, renderBlurb, renderCover, renderEpubChapter, renderMarkdown, renderPlainText, renderProposal, reviewFile, reviewHistoryFile, verifyReference };