novelforge-agent 0.1.1 → 0.2.0

package/README.md

@@ -2,7 +2,7 @@
 
 A local-first long-form novel workflow engine for any MCP host (Claude Code, Codex CLI, Cursor, …) or any CLI shell.
 
-**The host's LLM writes the prose. This package does everything else** — it manages a 9-step state machine, returns the exact instruction and packed context the host should follow next, validates returned content against zod schemas, persists Markdown + JSON to a project directory, archives chapter versions on revision, and provides BM25 lexical retrieval over every word the project has ever produced.
+**The host's LLM writes the prose. This package does everything else** — it manages a gated long-form state machine, returns the exact instruction and packed context the host should follow next, validates returned content against zod schemas, persists Markdown + JSON to a project directory, archives chapter versions on revision, and provides BM25 lexical retrieval over every word the project has ever produced.
 
 No external API. No LLM dependency. No vendor lock-in.
 
@@ -57,15 +57,17 @@ The installer is **idempotent and safe**: it never overwrites an existing entry
 |-------|------|---------------------|----------------------|
 | Setup | `novel_metadata` | Output JSON: title, genre, premise, cast | `novel.json` |
 |  | `story_bible` | Output Markdown: characters, world rules, plot threads | `story-bible.md` |
-|  | `architecture` | Output JSON: full / volume / chapter outlines | `architecture/{full.md, volumes.json, chapters.json}` |
+|  | `architecture` | Output JSON: full / volume / pacing / chapter outlines | `architecture/{full.md, volumes.json, volume-pacing.json, chapters.json}` |
 | Loop  | `chapter` | Write chapter N Markdown | `chapters/NNN.md` |
-|  | `memory_card` | Extract chapter N memory JSON | `memory/chapter-NNN.json` |
+|  | `chapter_review` | Enforce the chapter acceptance gate: required beats, plot/character/thread progress, story-bible consistency, ending hook, repetition check | `reviews/chapter/chapter-NNN.json` |
+|  | `chapter_revision` | If review finds issues, rewrite the chapter; previous version is archived | `chapters/.versions/NNN.<ts>.md` |
+|  | `memory_card` | After a clean review, extract chapter N memory JSON and update character/thread state | `memory/chapter-NNN.json`, `characters.json`, `threads.json` |
 | Wrap  | `continuity_review` | Audit chapters 1..N for conflicts | `reviews/continuity-S-E.json` |
 | Side-track | `chapter_review` | Single-chapter editorial review | `reviews/chapter/chapter-NNN.json` |
 |  | `chapter_revision` | Rewrite a chapter; previous version auto-archived | `chapters/.versions/NNN.<ts>.md` |
 |  | `cross_chapter_review` | Cross-chapter continuity audit | `reviews/cross/cross-S-E.json` |
 
-Each chapter / bible / memory write also feeds a per-project BM25 index (`.index/`) so the agent can hand the host semantically relevant snippets when later chapters are generated, or answer ad-hoc `retrieve` queries from the host.
+Each chapter / bible / memory write also feeds a per-project BM25 index (`.index/`) so the agent can hand the host semantically relevant snippets when later chapters are generated, or answer ad-hoc `retrieve` queries from the host. Chapter generation context also includes the independent character state table (`characters.json`) and current volume pacing board (`architecture/volume-pacing.json`) when available.
 
 ## Install
 
@@ -165,7 +167,7 @@ NOVELFORGE_WORKSPACE = "/absolute/path/where/projects/should/live"
 
 `list_projects` finds every project under `NOVELFORGE_WORKSPACE/novels/`, sorted newest first. The host should call it before anything else when a session opens; pick the desired `projectPath` from the result, then `get_project_status` for a one-screen briefing, then `get_next_step` to resume.
 
-## Tool reference (13 MCP tools)
+## Tool reference
 
 ### Project lifecycle
 - **`start_novel_project`** `(prompt, language?, outputDir?, targetChapters?)` — create a new project under `<workspaceRoot>/<outputDir>/<slug>-<rand6>/` and return the first step's instruction.
@@ -185,6 +187,15 @@ NOVELFORGE_WORKSPACE = "/absolute/path/where/projects/should/live"
 - **`cross_chapter_review`** `(projectPath, start?, end?)` — switch into a cross-chapter audit side-track over the given range (defaults to all generated chapters).
 - **`save_chapter`** `(projectPath, chapterNumber, title, content)` — write a chapter Markdown file directly, without going through the state machine.
 
+### Project operations
+- **`amend_story_bible`** `(projectPath, content, reason?)` — replace `story-bible.md`, archive the previous version, and rebuild the bible index.
+- **`list_bible_versions`** `(projectPath)` — list archived story-bible versions.
+- **`list_threads`** `(projectPath, status?)` — list foreshadow threads collected from memory cards.
+- **`update_thread`** `(projectPath, id, patch)` — update one foreshadow thread.
+- **`fork_project`** `(sourceProjectPath, label?)` — copy a project to a sibling fork with a new project id.
+- **`delete_chapter`** `(projectPath, chapterNumber)` — remove a chapter, its memory, reviews, archived versions, and index entries.
+- **`redo_step`** `(projectPath, step, chapterNumber?)` — roll the workflow back to regenerate an artifact.
+
 ### Retrieval
 - **`retrieve`** `(projectPath, query, topK?, types?, chapterStart?, chapterEnd?)` — BM25-style lexical retrieval over indexed paragraphs (chapters), bible H2 sections, and memory cards. Supports CJK + Latin queries via a built-in CJK bigram tokenizer; no external embedding model.
 
@@ -196,10 +207,12 @@ A project on disk:
 novels/<slug>-<rand6>/
 ├── agent-state.json              # workflow state (currentStep, currentChapter, files map, …)
 ├── novel.json                    # metadata (NovelMetadataSchema)
+├── characters.json               # independent character state table
 ├── story-bible.md
 ├── architecture/
 │   ├── full.md
 │   ├── volumes.json
+│   ├── volume-pacing.json
 │   └── chapters.json
 ├── chapters/
 │   ├── 001.md
@@ -226,17 +239,26 @@ The whole directory is self-contained — copy it, share it, delete it.
 ```
 novel_metadata → story_bible → architecture → chapter
                                               ↓
-                                          memory_card
+                                         chapter_review
                                               ↓
-                              ┌───────────────┴───────────────┐
-                  (more chapters)                       (all done)
-                              ↓                               ↓
-                          chapter                    continuity_review
-                                                              ↓
-                                                          complete
+                                   ┌──────────┴──────────┐
+                                 clean             issues_found
+                                   ↓                    ↓
+                              memory_card       chapter_revision
+                                   ↓                    ↓
+                     ┌─────────────┴─────────────┐      │
+             (more chapters)                (all done)   │
+                     ↓                            ↓       │
+                  chapter                continuity_review│
+                                                  ↓       │
+                                              complete    │
+                                                       (back to
+                                                    chapter_review)
 ```
 
-Side-track steps (`chapter_review`, `chapter_revision`, `cross_chapter_review`) can be triggered at any moment via the semantic-action tools. When the side-track completes via `submit_step_result`, the workflow returns to whatever `currentStep` it was on before the side-track started.
+`chapter_review` is both a manual side-track and the automatic chapter acceptance gate. In the normal chapter loop, the workflow cannot advance to `memory_card` until the review status is `clean`. If the review returns `issues_found`, the workflow forces `chapter_revision`, then returns to `chapter_review` for another pass.
+
+Side-track steps (`chapter_review`, `chapter_revision`, `cross_chapter_review`) can still be triggered at any moment via the semantic-action tools. When a manual side-track completes via `submit_step_result`, the workflow returns to whatever `currentStep` it was on before the side-track started.
 
 The full transition map lives in the `next:` declaration of each handler under [src/core/steps/](src/core/steps/). To change the workflow, edit those files — that is the entire state machine, there is no graph engine.
 
@@ -249,6 +271,7 @@ src/
 │   ├── schemas.ts                # zod schemas (the only validator)
 │   ├── projectStore.ts           # filesystem persistence
 │   ├── projectDiscovery.ts       # list / status
+│   ├── characterStore.ts         # independent character state table
 │   ├── prompts/                  # per-language prompt packs (zh-CN, en-US)
 │   ├── steps/                    # one file per WorkflowStep handler
 │   ├── retrieval/                # BM25 index + CJK tokenizer + chunker

package/dist/src/cli/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { readFile } from 'node:fs/promises';
-import { buildContext, createProject, getNextStep, getProjectStatus, listProjects, requestSideTrack, retrieve, submitStepResult, } from '../core/index.js';
+import { amendStoryBible, buildContext, createProject, deleteChapter, forkProject, getNextStep, getProjectStatus, listProjects, loadThreads, redoStep, requestSideTrack, retrieve, submitStepResult, updateThread, } from '../core/index.js';
 import { formatInstallResult, runInstall } from './install.js';
 function valueAfter(args, name) {
     const index = args.indexOf(name);
@@ -136,7 +136,76 @@ export async function runCli(argv = process.argv.slice(2), cwd = process.cwd())
         console.log(JSON.stringify({ query, hits }, null, 2));
         return;
     }
-    throw new Error('Usage: novelforge-agent install|start|list|status|next|submit|context|review|revise|cross-review|retrieve');
+    if (command === 'amend-bible') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        const file = valueAfter(argv, '--file');
+        const reason = valueAfter(argv, '--reason');
+        if (!file)
+            throw new Error('Missing --file with new bible Markdown');
+        const content = await readFile(file, 'utf8');
+        console.log(JSON.stringify(await amendStoryBible({ projectPath, content, reason }), null, 2));
+        return;
+    }
+    if (command === 'threads') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        const status = valueAfter(argv, '--status');
+        const all = await loadThreads(projectPath);
+        const filtered = status ? all.filter((t) => t.status === status) : all;
+        console.log(JSON.stringify(filtered, null, 2));
+        return;
+    }
+    if (command === 'update-thread') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        const id = valueAfter(argv, '--id');
+        if (!id)
+            throw new Error('Missing --id');
+        const status = valueAfter(argv, '--status');
+        const plannedPayoffAt = valueAfter(argv, '--planned-payoff');
+        const description = valueAfter(argv, '--description');
+        const notes = valueAfter(argv, '--notes');
+        const updated = await updateThread(projectPath, id, {
+            status,
+            plannedPayoffAt: plannedPayoffAt ? Number(plannedPayoffAt) : undefined,
+            description,
+            notes,
+        });
+        console.log(JSON.stringify(updated, null, 2));
+        return;
+    }
+    if (command === 'fork') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        const label = valueAfter(argv, '--label');
+        console.log(JSON.stringify(await forkProject({ sourceProjectPath: projectPath, label }), null, 2));
+        return;
+    }
+    if (command === 'delete-chapter') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        const chapter = valueAfter(argv, '--chapter');
+        if (!chapter)
+            throw new Error('Missing --chapter');
+        console.log(JSON.stringify(await deleteChapter({ projectPath, chapterNumber: Number(chapter) }), null, 2));
+        return;
+    }
+    if (command === 'redo') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        const step = valueAfter(argv, '--step');
+        if (!step)
+            throw new Error('Missing --step');
+        const chapter = valueAfter(argv, '--chapter');
+        console.log(JSON.stringify(await redoStep({
+            projectPath,
+            step,
+            chapterNumber: chapter ? Number(chapter) : undefined,
+        }), null, 2));
+        return;
+    }
+    throw new Error('Usage: novelforge-agent install|start|list|status|next|submit|context|review|revise|cross-review|retrieve|amend-bible|threads|update-thread|fork|delete-chapter|redo');
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
     runCli().catch((error) => {

package/dist/src/core/bibleStore.js

@@ -0,0 +1,36 @@
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { archiveStoryBible, loadState, saveMarkdownFile, saveState, } from './projectStore.js';
+import { storyBibleVersionFileName } from './fileNames.js';
+import { indexStoryBible } from './retrieval/index.js';
+function isEmpty(content) {
+    return !content || !content.trim();
+}
+export async function amendStoryBible(input) {
+    if (isEmpty(input.content))
+        throw new Error('Amended story bible content is empty');
+    const state = await loadState(input.projectPath);
+    // Archive current
+    const archived = await archiveStoryBible(state.projectPath, join('story-bible-versions', storyBibleVersionFileName(new Date().toISOString())));
+    // Save new
+    const savedPath = await saveMarkdownFile(state.projectPath, 'story-bible.md', input.content);
+    // Re-index
+    await indexStoryBible(state.projectPath, input.content);
+    // Track in state
+    const bibleVersion = (state.completedSteps.filter((s) => s === 'story_bible_amend').length ?? 0) + 1;
+    await saveState({
+        ...state,
+        completedSteps: [...state.completedSteps, 'story_bible_amend'],
+        files: { ...state.files, storyBible: 'story-bible.md' },
+    });
+    return { archivedPath: archived, bibleVersion, savedPath };
+}
+export async function listStoryBibleVersions(projectPath) {
+    try {
+        const items = await readdir(join(projectPath, 'story-bible-versions'));
+        return items.filter((f) => f.endsWith('.md')).sort();
+    }
+    catch {
+        return [];
+    }
+}

package/dist/src/core/characterStore.js

@@ -0,0 +1,74 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const CHARACTERS_FILE = 'characters.json';
+function emptyState(member, chapterNumber = 0) {
+    return {
+        name: member.name,
+        role: member.role,
+        goal: '未确认',
+        belief: '未确认',
+        relationships: [],
+        abilities: [],
+        secrets: [],
+        emotionalState: member.description,
+        lastUpdatedAt: chapterNumber,
+    };
+}
+export async function loadCharacterStates(projectPath) {
+    try {
+        const raw = await readFile(join(projectPath, CHARACTERS_FILE), 'utf8');
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed.characters) ? parsed.characters : [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveCharacterStates(projectPath, characters) {
+    const fullPath = join(projectPath, CHARACTERS_FILE);
+    await writeFile(fullPath, `${JSON.stringify({ characters }, null, 2)}\n`, 'utf8');
+    return fullPath;
+}
+export async function initializeCharacterStates(projectPath, coreCast) {
+    const existing = await loadCharacterStates(projectPath);
+    const byName = new Map(existing.map((c) => [c.name, c]));
+    for (const member of coreCast) {
+        if (!byName.has(member.name)) {
+            byName.set(member.name, emptyState(member));
+        }
+    }
+    return saveCharacterStates(projectPath, Array.from(byName.values()));
+}
+export async function applyCharacterUpdates(projectPath, chapterNumber, updates) {
+    const existing = await loadCharacterStates(projectPath);
+    if (!updates || !updates.length)
+        return existing;
+    const byName = new Map(existing.map((c) => [c.name, { ...c }]));
+    for (const update of updates) {
+        const current = byName.get(update.name) ?? {
+            name: update.name,
+            role: update.role,
+            goal: '未确认',
+            belief: '未确认',
+            relationships: [],
+            abilities: [],
+            secrets: [],
+            emotionalState: '未确认',
+            lastUpdatedAt: chapterNumber,
+        };
+        byName.set(update.name, {
+            ...current,
+            role: update.role ?? current.role,
+            goal: update.goal ?? current.goal,
+            belief: update.belief ?? current.belief,
+            relationships: update.relationships ?? current.relationships,
+            abilities: update.abilities ?? current.abilities,
+            secrets: update.secrets ?? current.secrets,
+            emotionalState: update.emotionalState ?? current.emotionalState,
+            lastUpdatedAt: chapterNumber,
+        });
+    }
+    const next = Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+    await saveCharacterStates(projectPath, next);
+    return next;
+}

package/dist/src/core/contextBuilder.js

@@ -2,6 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { chapterFileName, chapterReviewFileName, memoryFileName } from './fileNames.js';
 import { formatHits, retrieve } from './retrieval/index.js';
+import { activeThreads, loadThreads } from './threadStore.js';
 async function readOptional(path) {
     try {
         return await readFile(path, 'utf8');
@@ -15,10 +16,26 @@ export async function buildContext(input) {
     const metadata = await readOptional(join(input.projectPath, 'novel.json'));
     const storyBible = await readOptional(join(input.projectPath, 'story-bible.md'));
     const chaptersJson = await readOptional(join(input.projectPath, 'architecture/chapters.json'));
+    const charactersJson = await readOptional(join(input.projectPath, 'characters.json'));
+    const volumePacingJson = await readOptional(join(input.projectPath, 'architecture/volume-pacing.json'));
     if (metadata)
         parts.push(`## Novel Metadata\n${metadata}`);
     if (storyBible)
         parts.push(`## Story Bible\n${storyBible.slice(0, 4000)}`);
+    if (charactersJson)
+        parts.push(`## Character State Table\n${charactersJson}`);
+    function addVolumePacing(volumeId) {
+        if (!volumePacingJson)
+            return;
+        try {
+            const boards = JSON.parse(volumePacingJson);
+            const board = volumeId ? boards.find((item) => item.volumeId === volumeId) : undefined;
+            parts.push(`## Volume Pacing Board\n${JSON.stringify(board ?? boards, null, 2)}`);
+        }
+        catch {
+            parts.push(`## Volume Pacing Board\n${volumePacingJson}`);
+        }
+    }
     if (input.purpose === 'chapter_generation' && input.chapterNumber) {
         let currentArchitectureForQuery;
         if (chaptersJson) {
@@ -27,6 +44,7 @@ export async function buildContext(input) {
             if (chapter) {
                 currentArchitectureForQuery = chapter;
                 parts.push(`## Current Chapter Architecture\n${JSON.stringify(chapter, null, 2)}`);
+                addVolumePacing(chapter.volumeId);
             }
         }
         if (input.chapterNumber > 1) {
@@ -54,6 +72,19 @@ export async function buildContext(input) {
                 if (formatted)
                     parts.push(`## Retrieved Relevant Snippets (lexical, BM25-style)\n${formatted}`);
             }
+            const allThreads = await loadThreads(input.projectPath);
+            const active = activeThreads(allThreads);
+            if (active.length) {
+                const lines = active.map((t) => {
+                    const flags = [`#${t.id}`, `status=${t.status}`, `planted=ch${t.plantedAt}`];
+                    if (t.plannedPayoffAt)
+                        flags.push(`payoff=ch${t.plannedPayoffAt}`);
+                    if (t.lastTouchedAt !== t.plantedAt)
+                        flags.push(`touched=ch${t.lastTouchedAt}`);
+                    return `- ${t.description}  (${flags.join(', ')})`;
+                });
+                parts.push(`## Active Foreshadow Threads (do not silently drop or contradict)\n${lines.join('\n')}`);
+            }
         }
     }
     if (input.purpose === 'memory_extraction' && input.chapterNumber) {
@@ -77,8 +108,10 @@ export async function buildContext(input) {
         if (chaptersJson) {
             const chapters = JSON.parse(chaptersJson);
             const arch = chapters.find((item) => item.chapterNumber === input.chapterNumber);
-            if (arch)
+            if (arch) {
                 parts.push(`## Target Chapter Architecture\n${JSON.stringify(arch, null, 2)}`);
+                addVolumePacing(arch.volumeId);
+            }
         }
         const chapter = await readOptional(join(input.projectPath, 'chapters', chapterFileName(input.chapterNumber)));
         if (chapter)
@@ -93,6 +126,16 @@ export async function buildContext(input) {
         const chapter = await readOptional(join(input.projectPath, 'chapters', chapterFileName(input.chapterNumber)));
         if (chapter)
             parts.push(`## Current Chapter Text\n${chapter}`);
+        if (chaptersJson) {
+            try {
+                const chapters = JSON.parse(chaptersJson);
+                const arch = chapters.find((item) => item.chapterNumber === input.chapterNumber);
+                addVolumePacing(arch?.volumeId);
+            }
+            catch {
+                // ignore malformed architecture here; review feedback is still useful
+            }
+        }
         const review = await readOptional(join(input.projectPath, 'reviews/chapter', chapterReviewFileName(input.chapterNumber)));
         if (review)
             parts.push(`## Editor Review\n${review}`);

package/dist/src/core/fileNames.js

@@ -39,3 +39,7 @@ export function chapterVersionFileName(chapterNumber, timestamp) {
     const safeTs = timestamp.replace(/[:.]/g, '-');
     return `${padChapterNumber(chapterNumber)}.${safeTs}.md`;
 }
+export function storyBibleVersionFileName(timestamp) {
+    const safeTs = timestamp.replace(/[:.]/g, '-');
+    return `story-bible.${safeTs}.md`;
+}

package/dist/src/core/index.js

@@ -7,3 +7,7 @@ export * from './contextBuilder.js';
 export * from './prompts.js';
 export * from './retrieval/index.js';
 export * from './projectDiscovery.js';
+export * from './threadStore.js';
+export * from './bibleStore.js';
+export * from './projectOps.js';
+export * from './characterStore.js';

package/dist/src/core/projectOps.js

@@ -0,0 +1,187 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+import { cp, readdir, unlink, writeFile } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { loadState, saveState } from './projectStore.js';
+import { removeChapterFromIndex, removeMemoryCardFromIndex } from './retrieval/index.js';
+import { chapterFileName, memoryFileName } from './fileNames.js';
+export async function forkProject(input) {
+    const source = resolve(input.sourceProjectPath);
+    const state = await loadState(source);
+    const suffix = randomBytes(3).toString('hex');
+    const label = (input.label ?? 'fork').replace(/[^a-z0-9-]+/gi, '-').replace(/^-+|-+$/g, '').toLowerCase() || 'fork';
+    const targetName = `${basename(source)}-${label}-${suffix}`;
+    const target = join(dirname(source), targetName);
+    await cp(source, target, { recursive: true });
+    const forkedState = {
+        ...state,
+        projectId: randomUUID(),
+        projectPath: target,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+    await saveState(forkedState);
+    return { newProjectPath: target, newProjectId: forkedState.projectId };
+}
+async function tryUnlink(path) {
+    try {
+        await unlink(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function tryRmDirEntry(dirPath, prefix) {
+    const removed = [];
+    try {
+        const items = await readdir(dirPath);
+        for (const item of items) {
+            if (item.startsWith(prefix)) {
+                const full = join(dirPath, item);
+                try {
+                    await unlink(full);
+                    removed.push(full);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    catch {
+        // dir absent
+    }
+    return removed;
+}
+export async function deleteChapter(input) {
+    const state = await loadState(input.projectPath);
+    const n = input.chapterNumber;
+    if (n < 1)
+        throw new Error('chapterNumber must be >= 1');
+    const removed = [];
+    const chapterRel = join('chapters', chapterFileName(n));
+    if (await tryUnlink(join(state.projectPath, chapterRel)))
+        removed.push(chapterRel);
+    const memoryRel = join('memory', memoryFileName(n));
+    if (await tryUnlink(join(state.projectPath, memoryRel)))
+        removed.push(memoryRel);
+    // Versions of this chapter
+    const versionsRemoved = await tryRmDirEntry(join(state.projectPath, 'chapters/.versions'), `${chapterFileName(n).replace(/\.md$/, '')}.`);
+    removed.push(...versionsRemoved);
+    // Per-chapter review
+    const reviewName = `chapter-${String(n).padStart(3, '0')}.json`;
+    if (await tryUnlink(join(state.projectPath, 'reviews/chapter', reviewName))) {
+        removed.push(`reviews/chapter/${reviewName}`);
+    }
+    // Update state.files
+    const nextFiles = { ...state.files };
+    delete nextFiles[`chapter-${n}`];
+    delete nextFiles[`memory-${n}`];
+    delete nextFiles[`review-chapter-${n}`];
+    // Remove this chapter and its memory card from the lexical index
+    await removeChapterFromIndex(state.projectPath, n);
+    await removeMemoryCardFromIndex(state.projectPath, n);
+    // Adjust state.currentChapter & currentStep if needed
+    let newCurrentChapter = state.currentChapter;
+    let newCurrentStep = state.currentStep;
+    if (state.currentChapter > n) {
+        // user deleted an earlier chapter; current pointer becomes the deleted one to be regenerated
+        newCurrentChapter = n;
+        newCurrentStep = 'chapter';
+    }
+    else if (state.currentChapter === n + 1 && (state.currentStep === 'chapter' || state.currentStep === 'memory_card')) {
+        // we just finished chapter n and were about to do n+1; step back
+        newCurrentChapter = n;
+        newCurrentStep = 'chapter';
+    }
+    const nextState = {
+        ...state,
+        files: nextFiles,
+        currentChapter: newCurrentChapter,
+        currentStep: newCurrentStep,
+        pendingAction: undefined,
+    };
+    await saveState(nextState);
+    return { removed, newCurrentChapter, newCurrentStep };
+}
+const STEP_FILE_KEYS = {
+    novel_metadata: ['novel'],
+    story_bible: ['storyBible'],
+    architecture: ['architecture'],
+    continuity_review: ['continuityReview'],
+};
+const STEP_FILE_PATHS = {
+    novel_metadata: ['novel.json'],
+    story_bible: ['story-bible.md'],
+    architecture: ['architecture/full.md', 'architecture/volumes.json', 'architecture/chapters.json'],
+};
+export async function redoStep(input) {
+    const state = await loadState(input.projectPath);
+    const removed = [];
+    if (input.step === 'chapter' || input.step === 'memory_card') {
+        const chapter = input.chapterNumber ?? state.currentChapter;
+        if (input.step === 'memory_card') {
+            const rel = join('memory', memoryFileName(chapter));
+            if (await tryUnlink(join(state.projectPath, rel)))
+                removed.push(rel);
+            delete state.files[`memory-${chapter}`];
+        }
+        else {
+            // chapter: also remove its memory + per-chapter review since they depend on it
+            const cRel = join('chapters', chapterFileName(chapter));
+            if (await tryUnlink(join(state.projectPath, cRel)))
+                removed.push(cRel);
+            const mRel = join('memory', memoryFileName(chapter));
+            if (await tryUnlink(join(state.projectPath, mRel)))
+                removed.push(mRel);
+            delete state.files[`chapter-${chapter}`];
+            delete state.files[`memory-${chapter}`];
+            await removeChapterFromIndex(state.projectPath, chapter);
+            await removeMemoryCardFromIndex(state.projectPath, chapter);
+        }
+        state.currentChapter = chapter;
+        state.currentStep = input.step;
+        state.pendingAction = undefined;
+    }
+    else if (input.step === 'novel_metadata' || input.step === 'story_bible' || input.step === 'architecture' || input.step === 'continuity_review') {
+        const paths = STEP_FILE_PATHS[input.step] ?? [];
+        for (const p of paths) {
+            if (await tryUnlink(join(state.projectPath, p)))
+                removed.push(p);
+        }
+        const keys = STEP_FILE_KEYS[input.step] ?? [];
+        for (const k of keys) {
+            delete state.files[k];
+        }
+        state.currentStep = input.step;
+        state.pendingAction = undefined;
+        if (input.step === 'novel_metadata')
+            state.currentChapter = 1;
+    }
+    else {
+        throw new Error(`redo_step does not support step: ${input.step}`);
+    }
+    // Trim completedSteps after the redo target
+    const idx = state.completedSteps.lastIndexOf(input.step);
+    if (idx >= 0)
+        state.completedSteps = state.completedSteps.slice(0, idx);
+    await saveState(state);
+    return {
+        removed,
+        currentStep: state.currentStep,
+        currentChapter: state.currentChapter,
+    };
+}
+// =============================================================================
+// guards
+// =============================================================================
+export function assertProjectPath(workspaceRoot, projectPath) {
+    const root = resolve(workspaceRoot);
+    const target = resolve(projectPath);
+    const rel = relative(root, target);
+    if (rel.startsWith('..') || isAbsolute(rel)) {
+        throw new Error(`Refusing to operate outside workspace: ${target}`);
+    }
+}
+// keep tsc happy if no other refs
+void writeFile;

package/dist/src/core/projectStore.js

@@ -15,6 +15,7 @@ export async function ensureProjectDirectories(projectPath) {
     await mkdir(join(projectPath, 'architecture'), { recursive: true });
     await mkdir(join(projectPath, 'chapters'), { recursive: true });
     await mkdir(join(projectPath, 'chapters/.versions'), { recursive: true });
+    await mkdir(join(projectPath, 'story-bible-versions'), { recursive: true });
     await mkdir(join(projectPath, 'memory'), { recursive: true });
     await mkdir(join(projectPath, 'reviews'), { recursive: true });
     await mkdir(join(projectPath, 'reviews/chapter'), { recursive: true });
@@ -31,6 +32,16 @@ export async function archiveChapterVersion(projectPath, chapterRelative, versio
         return undefined;
     }
 }
+export async function archiveStoryBible(projectPath, versionRelative) {
+    const sourcePath = join(projectPath, 'story-bible.md');
+    try {
+        const existing = await readFile(sourcePath, 'utf8');
+        return saveMarkdownFile(projectPath, versionRelative, existing);
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function createProject(input) {
     const workspaceRoot = resolve(input.workspaceRoot);
     const baseDir = input.outputDir || 'novels';