novelforge-agent 0.1.1 → 0.2.0

package/dist/src/core/steps/memoryCard.js

@@ -3,12 +3,16 @@ import { MemoryCardSchema } from '../schemas.js';
 import { saveJsonFile } from '../projectStore.js';
 import { memoryFileName } from '../fileNames.js';
 import { indexMemoryCard } from '../retrieval/index.js';
+import { ingestMemoryCardThreads } from '../threadStore.js';
+import { applyCharacterUpdates } from '../characterStore.js';
 import { parseJson } from './types.js';
 export const memoryCardHandler = async (state, content) => {
     const parsed = MemoryCardSchema.parse(parseJson(content));
     const relative = join('memory', memoryFileName(state.currentChapter));
     const path = await saveJsonFile(state.projectPath, relative, parsed);
     await indexMemoryCard(state.projectPath, state.currentChapter, parsed);
+    await ingestMemoryCardThreads(state.projectPath, state.currentChapter, parsed.threadActions);
+    await applyCharacterUpdates(state.projectPath, state.currentChapter, parsed.characterUpdates);
     const nextChapter = state.currentChapter + 1;
     return {
         savedPaths: [path],

package/dist/src/core/steps/novelMetadata.js

@@ -1,12 +1,14 @@
 import { NovelMetadataSchema } from '../schemas.js';
 import { saveJsonFile } from '../projectStore.js';
+import { initializeCharacterStates } from '../characterStore.js';
 import { parseJson } from './types.js';
 export const novelMetadataHandler = async (state, content) => {
     const parsed = NovelMetadataSchema.parse(parseJson(content));
     const path = await saveJsonFile(state.projectPath, 'novel.json', parsed);
+    const charactersPath = await initializeCharacterStates(state.projectPath, parsed.coreCast);
     return {
-        savedPaths: [path],
-        fileEntries: { novel: 'novel.json' },
+        savedPaths: [path, charactersPath],
+        fileEntries: { novel: 'novel.json', characters: 'characters.json' },
         next: { kind: 'linear', nextStep: 'story_bible' },
     };
 };

package/dist/src/core/threadStore.js

@@ -0,0 +1,150 @@
+import { randomBytes } from 'node:crypto';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const THREADS_FILE = 'threads.json';
+export async function loadThreads(projectPath) {
+    try {
+        const raw = await readFile(join(projectPath, THREADS_FILE), 'utf8');
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed.threads) ? parsed.threads : [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveThreads(projectPath, threads) {
+    const fullPath = join(projectPath, THREADS_FILE);
+    const bundle = { threads };
+    await writeFile(fullPath, `${JSON.stringify(bundle, null, 2)}\n`, 'utf8');
+    return fullPath;
+}
+function newThreadId(existing) {
+    let candidate = `t_${randomBytes(3).toString('hex')}`;
+    while (existing.has(candidate)) {
+        candidate = `t_${randomBytes(3).toString('hex')}`;
+    }
+    return candidate;
+}
+function findByDescription(threads, description) {
+    const target = description.trim();
+    return threads.find((t) => t.description.trim() === target);
+}
+/**
+ * Apply the threadActions emitted by a memory_card for chapter `chapterNumber`.
+ * Behavior:
+ *  - 'plant'   → create new thread (or reuse if identical description already planted)
+ *  - 'build'   → mark existing thread status = 'building', bump lastTouchedAt
+ *  - 'pay'     → mark existing thread status = 'paid', set paidOffAt
+ *  - 'drop'    → mark existing thread status = 'dropped', set droppedAt
+ *  Unknown threadIds for non-plant actions are tolerated (a new thread is created and marked appropriately, so we never lose user intent).
+ */
+export function applyThreadActions(existing, chapterNumber, actions) {
+    if (!actions || !actions.length)
+        return existing;
+    const next = existing.map((t) => ({ ...t }));
+    const byId = new Map(next.map((t) => [t.id, t]));
+    const usedIds = new Set(next.map((t) => t.id));
+    for (const action of actions) {
+        if (action.kind === 'plant') {
+            const dup = findByDescription(next, action.description);
+            if (dup) {
+                dup.lastTouchedAt = Math.max(dup.lastTouchedAt, chapterNumber);
+                continue;
+            }
+            const id = action.threadId && !usedIds.has(action.threadId)
+                ? action.threadId
+                : newThreadId(usedIds);
+            usedIds.add(id);
+            const planted = {
+                id,
+                description: action.description.trim(),
+                status: 'planted',
+                plantedAt: chapterNumber,
+                lastTouchedAt: chapterNumber,
+            };
+            next.push(planted);
+            byId.set(id, planted);
+            continue;
+        }
+        // build / pay / drop need an existing thread
+        let target = action.threadId ? byId.get(action.threadId) : undefined;
+        if (!target) {
+            target = findByDescription(next, action.description);
+        }
+        if (!target) {
+            // Create a placeholder so the user intent is captured; mark planted+touched on this chapter
+            const id = newThreadId(usedIds);
+            usedIds.add(id);
+            target = {
+                id,
+                description: action.description.trim(),
+                status: 'planted',
+                plantedAt: chapterNumber,
+                lastTouchedAt: chapterNumber,
+                notes: `Auto-created from a ${action.kind} action without a known threadId.`,
+            };
+            next.push(target);
+            byId.set(id, target);
+        }
+        target.lastTouchedAt = chapterNumber;
+        if (action.kind === 'build') {
+            target.status = 'building';
+        }
+        else if (action.kind === 'pay') {
+            target.status = 'paid';
+            target.paidOffAt = chapterNumber;
+        }
+        else if (action.kind === 'drop') {
+            target.status = 'dropped';
+            target.droppedAt = chapterNumber;
+        }
+    }
+    return next;
+}
+export function activeThreads(threads) {
+    return threads.filter((t) => t.status === 'planted' || t.status === 'building');
+}
+export async function ingestMemoryCardThreads(projectPath, chapterNumber, actions) {
+    if (!actions || !actions.length)
+        return loadThreads(projectPath);
+    const existing = await loadThreads(projectPath);
+    const next = applyThreadActions(existing, chapterNumber, actions);
+    await saveThreads(projectPath, next);
+    return next;
+}
+export async function updateThread(projectPath, id, patch) {
+    const existing = await loadThreads(projectPath);
+    const target = existing.find((t) => t.id === id);
+    if (!target)
+        throw new Error(`Thread not found: ${id}`);
+    if (patch.status)
+        target.status = patch.status;
+    if (patch.description)
+        target.description = patch.description.trim();
+    if (Object.prototype.hasOwnProperty.call(patch, 'plannedPayoffAt')) {
+        if (patch.plannedPayoffAt === null)
+            delete target.plannedPayoffAt;
+        else if (typeof patch.plannedPayoffAt === 'number')
+            target.plannedPayoffAt = patch.plannedPayoffAt;
+    }
+    if (Object.prototype.hasOwnProperty.call(patch, 'paidOffAt')) {
+        if (patch.paidOffAt === null)
+            delete target.paidOffAt;
+        else if (typeof patch.paidOffAt === 'number')
+            target.paidOffAt = patch.paidOffAt;
+    }
+    if (Object.prototype.hasOwnProperty.call(patch, 'droppedAt')) {
+        if (patch.droppedAt === null)
+            delete target.droppedAt;
+        else if (typeof patch.droppedAt === 'number')
+            target.droppedAt = patch.droppedAt;
+    }
+    if (Object.prototype.hasOwnProperty.call(patch, 'notes')) {
+        if (patch.notes === null)
+            delete target.notes;
+        else if (typeof patch.notes === 'string')
+            target.notes = patch.notes;
+    }
+    await saveThreads(projectPath, existing);
+    return target;
+}

package/dist/src/core/workflow.js

@@ -83,19 +83,19 @@ function buildPendingAction(state, input) {
         case 'chapter_review': {
             if (!input.chapterNumber)
                 throw new Error('chapter_review requires chapterNumber');
-            return { step: 'chapter_review', chapterNumber: input.chapterNumber };
+            return { step: 'chapter_review', mode: 'side_track', chapterNumber: input.chapterNumber };
         }
         case 'chapter_revision': {
             if (!input.chapterNumber)
                 throw new Error('chapter_revision requires chapterNumber');
-            return { step: 'chapter_revision', chapterNumber: input.chapterNumber, feedback: input.feedback };
+            return { step: 'chapter_revision', mode: 'side_track', chapterNumber: input.chapterNumber, feedback: input.feedback };
         }
         case 'cross_chapter_review': {
             const max = maxExistingChapter(state);
             const range = input.range ?? { start: 1, end: max || state.currentChapter };
             if (range.start < 1 || range.end < range.start)
                 throw new Error('Invalid range');
-            return { step: 'cross_chapter_review', range };
+            return { step: 'cross_chapter_review', mode: 'side_track', range };
         }
         default:
             throw new Error(`Unknown side-track step: ${input.step}`);

package/dist/src/mcp/tools.js

@@ -1,6 +1,8 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import { buildContext, chapterFileName, createProject, getNextStep, getProjectStatus, listProjects, requestSideTrack, retrieve, saveMarkdownFile, submitStepResult, } from '../core/index.js';
+import { resolve } from 'node:path';
+import { amendStoryBible, assertProjectPath, buildContext, createProject, deleteChapter, forkProject, getNextStep, getProjectStatus, listProjects, listStoryBibleVersions, loadState, loadThreads, redoStep, requestSideTrack, retrieve, submitStepResult, updateThread, } from '../core/index.js';
+const MCP_SERVER_VERSION = '0.2.0';
 function textResult(value) {
     return {
         content: [{
@@ -10,9 +12,17 @@ function textResult(value) {
     };
 }
 export function createNovelAgentServer(options) {
+    function checkedProjectPath(projectPath) {
+        assertProjectPath(options.workspaceRoot, projectPath);
+        return projectPath;
+    }
+    function checkedOutputDir(outputDir) {
+        assertProjectPath(options.workspaceRoot, resolve(options.workspaceRoot, outputDir));
+        return outputDir;
+    }
     const server = new McpServer({
         name: 'novelforge-agent',
-        version: '0.1.0',
+        version: MCP_SERVER_VERSION,
     });
     server.tool('start_novel_project', 'Create a local novel project and return the first generation instruction.', {
         prompt: z.string().min(1),
@@ -31,9 +41,9 @@ export function createNovelAgentServer(options) {
     });
     server.tool('list_projects', 'List all NovelForge projects under the workspace, sorted by most recently updated. Use this to find an existing projectPath instead of asking the user.', {
         outputDir: z.string().default('novels'),
-    }, async ({ outputDir }) => textResult(await listProjects({ workspaceRoot: options.workspaceRoot, outputDir })));
-    server.tool('get_project_status', 'Return a compact, one-screen summary of a project: current step, chapters written, open threads, latest review verdict, completion state.', { projectPath: z.string().min(1) }, async ({ projectPath }) => textResult(await getProjectStatus(projectPath)));
-    server.tool('get_next_step', 'Return the next required generation step for a novel project.', { projectPath: z.string().min(1) }, async ({ projectPath }) => textResult(await getNextStep(projectPath)));
+    }, async ({ outputDir }) => textResult(await listProjects({ workspaceRoot: options.workspaceRoot, outputDir: checkedOutputDir(outputDir) })));
+    server.tool('get_project_status', 'Return a compact, one-screen summary of a project: current step, chapters written, open threads, latest review verdict, completion state.', { projectPath: z.string().min(1) }, async ({ projectPath }) => textResult(await getProjectStatus(checkedProjectPath(projectPath))));
+    server.tool('get_next_step', 'Return the next required generation step for a novel project.', { projectPath: z.string().min(1) }, async ({ projectPath }) => textResult(await getNextStep(checkedProjectPath(projectPath))));
     server.tool('submit_step_result', 'Submit host-generated content for validation, saving, and workflow advancement.', {
         projectPath: z.string().min(1),
         step: z.enum([
@@ -49,7 +59,7 @@ export function createNovelAgentServer(options) {
             'complete',
         ]),
         content: z.string(),
-    }, async ({ projectPath, step, content }) => textResult(await submitStepResult({ projectPath, step, content })));
+    }, async ({ projectPath, step, content }) => textResult(await submitStepResult({ projectPath: checkedProjectPath(projectPath), step, content })));
     server.tool('get_context', 'Build purpose-specific context for generation, memory extraction, review, or revision.', {
         projectPath: z.string().min(1),
         purpose: z.enum([
@@ -64,44 +74,51 @@ export function createNovelAgentServer(options) {
         start: z.number().int().positive().optional(),
         end: z.number().int().positive().optional(),
     }, async ({ projectPath, purpose, chapterNumber, start, end }) => textResult(await buildContext({
-        projectPath,
+        projectPath: checkedProjectPath(projectPath),
         purpose,
         chapterNumber,
         range: start && end ? { start, end } : undefined,
     })));
-    server.tool('save_chapter', 'Save a generated chapter directly as Markdown.', {
+    server.tool('save_chapter', 'Submit a generated chapter Markdown draft through the workflow state machine. This requires currentStep="chapter" and advances to chapter_review.', {
         projectPath: z.string().min(1),
         chapterNumber: z.number().int().positive(),
         title: z.string().min(1),
         content: z.string().min(1),
     }, async ({ projectPath, chapterNumber, title, content }) => {
-        const fileName = `chapters/${chapterFileName(chapterNumber)}`;
-        const savedPath = await saveMarkdownFile(projectPath, fileName, `# ${title}\n\n${content}`);
-        return textResult({ savedPath, suggestedNextStep: 'memory_card' });
+        const checked = checkedProjectPath(projectPath);
+        const state = await loadState(checked);
+        if (state.currentStep !== 'chapter' || state.currentChapter !== chapterNumber) {
+            throw new Error(`save_chapter requires currentStep="chapter" and currentChapter=${chapterNumber}; got currentStep="${state.currentStep}", currentChapter=${state.currentChapter}`);
+        }
+        return textResult(await submitStepResult({
+            projectPath: checked,
+            step: 'chapter',
+            content: `# ${title}\n\n${content}`,
+        }));
     });
     server.tool('generate_chapter', 'Build the chapter-generation context and instruction for a specific chapter without changing workflow state.', {
         projectPath: z.string().min(1),
         chapterNumber: z.number().int().positive(),
     }, async ({ projectPath, chapterNumber }) => textResult({
-        context: await buildContext({ projectPath, purpose: 'chapter_generation', chapterNumber }),
-        hint: 'Persist the result via save_chapter or submit_step_result(step="chapter") when the workflow currentStep is "chapter".',
+        context: await buildContext({ projectPath: checkedProjectPath(projectPath), purpose: 'chapter_generation', chapterNumber }),
+        hint: 'Persist the result via submit_step_result(step="chapter") when the workflow currentStep is "chapter"; the workflow then requires chapter_review before memory_card.',
     }));
     server.tool('extract_memory_card', 'Build the memory-extraction context for a specific chapter without changing workflow state.', {
         projectPath: z.string().min(1),
         chapterNumber: z.number().int().positive(),
     }, async ({ projectPath, chapterNumber }) => textResult({
-        context: await buildContext({ projectPath, purpose: 'memory_extraction', chapterNumber }),
+        context: await buildContext({ projectPath: checkedProjectPath(projectPath), purpose: 'memory_extraction', chapterNumber }),
         hint: 'Submit the extracted memory card via submit_step_result with step="memory_card" when the workflow currentStep matches.',
     }));
     server.tool('review_chapter', 'Ask the host to review a specific chapter. Switches the workflow into chapter_review side-track and returns the review prompt + packed context. Resume original step after submit_step_result(step="chapter_review").', {
         projectPath: z.string().min(1),
         chapterNumber: z.number().int().positive(),
-    }, async ({ projectPath, chapterNumber }) => textResult(await requestSideTrack({ projectPath, step: 'chapter_review', chapterNumber })));
+    }, async ({ projectPath, chapterNumber }) => textResult(await requestSideTrack({ projectPath: checkedProjectPath(projectPath), step: 'chapter_review', chapterNumber })));
     server.tool('revise_chapter', 'Ask the host to rewrite a specific chapter based on prior review feedback and optional extra instructions. Previous version is archived under chapters/.versions/.', {
         projectPath: z.string().min(1),
         chapterNumber: z.number().int().positive(),
         feedback: z.string().optional(),
-    }, async ({ projectPath, chapterNumber, feedback }) => textResult(await requestSideTrack({ projectPath, step: 'chapter_revision', chapterNumber, feedback })));
+    }, async ({ projectPath, chapterNumber, feedback }) => textResult(await requestSideTrack({ projectPath: checkedProjectPath(projectPath), step: 'chapter_revision', chapterNumber, feedback })));
     server.tool('retrieve', 'Lexical BM25-style retrieval over indexed chapter paragraphs, story-bible sections, and memory cards. Returns ranked snippets with chapter attribution.', {
         projectPath: z.string().min(1),
         query: z.string().min(1),
@@ -111,7 +128,7 @@ export function createNovelAgentServer(options) {
         chapterEnd: z.number().int().positive().optional(),
     }, async ({ projectPath, query, topK, types, chapterStart, chapterEnd }) => {
         const chapterRange = chapterStart && chapterEnd ? { start: chapterStart, end: chapterEnd } : undefined;
-        const hits = await retrieve(projectPath, query, { topK, types, chapterRange });
+        const hits = await retrieve(checkedProjectPath(projectPath), query, { topK, types, chapterRange });
         return textResult({ query, hits });
     });
     server.tool('cross_chapter_review', 'Ask the host to review a chapter range for cross-chapter continuity conflicts. Defaults to all generated chapters.', {
@@ -120,7 +137,170 @@ export function createNovelAgentServer(options) {
         end: z.number().int().positive().optional(),
     }, async ({ projectPath, start, end }) => {
         const range = start && end ? { start, end } : undefined;
-        return textResult(await requestSideTrack({ projectPath, step: 'cross_chapter_review', range }));
+        return textResult(await requestSideTrack({ projectPath: checkedProjectPath(projectPath), step: 'cross_chapter_review', range }));
     });
+    // ----- v0.2 tools -----
+    server.tool('amend_story_bible', 'Replace the story bible with a revised version. Old version is auto-archived under story-bible-versions/ and the lexical index is rebuilt for the new content.', {
+        projectPath: z.string().min(1),
+        content: z.string().min(1),
+        reason: z.string().optional(),
+    }, async ({ projectPath, content, reason }) => textResult(await amendStoryBible({ projectPath: checkedProjectPath(projectPath), content, reason })));
+    server.tool('list_bible_versions', 'List archived story-bible versions for a project (filenames sorted oldest first).', { projectPath: z.string().min(1) }, async ({ projectPath }) => textResult({ versions: await listStoryBibleVersions(checkedProjectPath(projectPath)) }));
+    server.tool('list_threads', 'List foreshadow threads for a project, optionally filtered by status. Threads are aggregated from memory_card.threadActions.', {
+        projectPath: z.string().min(1),
+        status: z.enum(['planted', 'building', 'paid', 'dropped']).optional(),
+    }, async ({ projectPath, status }) => {
+        const all = await loadThreads(checkedProjectPath(projectPath));
+        const filtered = status ? all.filter((t) => t.status === status) : all;
+        return textResult({ threads: filtered });
+    });
+    server.tool('update_thread', 'Update a single foreshadow thread (override status, plannedPayoffAt, paidOffAt, droppedAt, description, notes).', {
+        projectPath: z.string().min(1),
+        id: z.string().min(1),
+        status: z.enum(['planted', 'building', 'paid', 'dropped']).optional(),
+        plannedPayoffAt: z.number().int().positive().nullable().optional(),
+        paidOffAt: z.number().int().positive().nullable().optional(),
+        droppedAt: z.number().int().positive().nullable().optional(),
+        description: z.string().min(1).optional(),
+        notes: z.string().nullable().optional(),
+    }, async ({ projectPath, id, ...patch }) => textResult(await updateThread(checkedProjectPath(projectPath), id, patch)));
+    server.tool('fork_project', 'Copy an existing project to a new sibling directory with a new projectId. Use to try alternate plot branches without losing the original.', {
+        sourceProjectPath: z.string().min(1),
+        label: z.string().optional(),
+    }, async ({ sourceProjectPath, label }) => textResult(await forkProject({ sourceProjectPath: checkedProjectPath(sourceProjectPath), label })));
+    server.tool('delete_chapter', 'Delete a chapter, its memory card, its single-chapter review, and all archived versions. Removes the chapter from the lexical index and rewinds the workflow if needed.', {
+        projectPath: z.string().min(1),
+        chapterNumber: z.number().int().positive(),
+    }, async ({ projectPath, chapterNumber }) => textResult(await deleteChapter({ projectPath: checkedProjectPath(projectPath), chapterNumber })));
+    server.tool('redo_step', 'Roll the workflow back to a specific step. Files produced by that step (and dependent chapter content for chapter/memory_card steps) are removed; the host must regenerate.', {
+        projectPath: z.string().min(1),
+        step: z.enum([
+            'novel_metadata',
+            'story_bible',
+            'architecture',
+            'chapter',
+            'memory_card',
+            'continuity_review',
+        ]),
+        chapterNumber: z.number().int().positive().optional(),
+    }, async ({ projectPath, step, chapterNumber }) => textResult(await redoStep({ projectPath: checkedProjectPath(projectPath), step, chapterNumber })));
+    // ===== MCP Prompts (slash commands) =====
+    server.prompt('nf-start', 'Start a brand new novel project under the configured workspace.', {
+        prompt: z.string().describe('User idea / premise / genre, in any language.'),
+        chapters: z.string().optional().describe('Target number of chapters as a string. Defaults to 5.'),
+    }, ({ prompt, chapters }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Use the novelforge MCP server. Call start_novel_project with prompt="${prompt}", targetChapters=${chapters ?? '5'}, then enter the autonomous loop: read next.instruction, generate the requested content, call submit_step_result, repeat until currentStep is "complete". Show me the projectPath after start_novel_project returns.`,
+                },
+            }],
+    }));
+    server.prompt('nf-next', 'Continue the current novelforge workflow by one step.', {
+        projectPath: z.string().describe('Absolute path to the project.'),
+    }, ({ projectPath }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Use the novelforge MCP server. Call get_next_step with projectPath="${projectPath}". Read the returned instruction + context and produce the requested artifact, then call submit_step_result. Show me what step was advanced.`,
+                },
+            }],
+    }));
+    server.prompt('nf-list', 'List all novelforge projects in the workspace.', {}, () => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: 'Use the novelforge MCP server: call list_projects with no arguments. Show me the result in a compact table (title, currentStep, chaptersWritten/targetChapters, updatedAt, projectPath).',
+                },
+            }],
+    }));
+    server.prompt('nf-status', 'Show a one-screen status for a novelforge project.', {
+        projectPath: z.string(),
+    }, ({ projectPath }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Use the novelforge MCP server: call get_project_status with projectPath="${projectPath}". Summarize: title, current step, chapters written, open threads count, latest review verdict.`,
+                },
+            }],
+    }));
+    server.prompt('nf-review-chapter', 'Run a single-chapter editorial review.', {
+        projectPath: z.string(),
+        chapterNumber: z.string(),
+    }, ({ projectPath, chapterNumber }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Use the novelforge MCP server: call review_chapter with projectPath="${projectPath}", chapterNumber=${chapterNumber}. Read the returned instruction + context, produce the JSON chapter review, then call submit_step_result with step="chapter_review". Summarize the findings for me.`,
+                },
+            }],
+    }));
+    server.prompt('nf-revise-chapter', 'Revise a chapter based on review feedback or new instructions.', {
+        projectPath: z.string(),
+        chapterNumber: z.string(),
+        feedback: z.string().optional(),
+    }, ({ projectPath, chapterNumber, feedback }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Use the novelforge MCP server: call revise_chapter with projectPath="${projectPath}", chapterNumber=${chapterNumber}${feedback ? `, feedback=${JSON.stringify(feedback)}` : ''}. Read the returned instruction + context, produce the revised Markdown chapter, then call submit_step_result with step="chapter_revision". Confirm the previous version was archived.`,
+                },
+            }],
+    }));
+    server.prompt('nf-cross-review', 'Cross-chapter continuity review over a range.', {
+        projectPath: z.string(),
+        start: z.string().optional(),
+        end: z.string().optional(),
+    }, ({ projectPath, start, end }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Use the novelforge MCP server: call cross_chapter_review with projectPath="${projectPath}"${start && end ? `, start=${start}, end=${end}` : ''}. Read the returned instruction + context, produce the JSON cross-chapter review, then call submit_step_result with step="cross_chapter_review". Summarize verdict and any issues.`,
+                },
+            }],
+    }));
+    server.prompt('nf-retrieve', 'Lexical retrieval over a project (BM25-style).', {
+        projectPath: z.string(),
+        query: z.string(),
+    }, ({ projectPath, query }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Use the novelforge MCP server: call retrieve with projectPath="${projectPath}", query=${JSON.stringify(query)}, topK=8. List the hits with chapter attribution and short excerpts.`,
+                },
+            }],
+    }));
+    server.prompt('nf-amend-bible', 'Amend the story bible with new content (previous version auto-archived).', {
+        projectPath: z.string(),
+        reason: z.string().optional(),
+    }, ({ projectPath, reason }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Use the novelforge MCP server. First call get_project_status with projectPath="${projectPath}" to confirm the project exists, then read the current story-bible.md (you may use the host's filesystem tools). Apply the following amendment intent and produce a complete revised story bible Markdown:\n\n${reason ?? '(no specific reason supplied — ask the user what to change)'}\n\nThen call amend_story_bible with projectPath="${projectPath}" and the new content. Confirm the archived version path.`,
+                },
+            }],
+    }));
+    server.prompt('nf-threads', 'Show active foreshadow threads for a project.', {
+        projectPath: z.string(),
+        status: z.enum(['planted', 'building', 'paid', 'dropped']).optional(),
+    }, ({ projectPath, status }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Use the novelforge MCP server: call list_threads with projectPath="${projectPath}"${status ? `, status="${status}"` : ''}. Show me the threads as a compact list: id, status, plantedAt, plannedPayoffAt (if set), description.`,
+                },
+            }],
+    }));
     return server;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "novelforge-agent",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Local-first long-form novel workflow engine for any MCP host (Claude Code, Codex CLI, …) or CLI. State machine + zod schemas + BM25 retrieval + persistent project state. No LLM dependency.",
   "keywords": [
     "mcp",
@@ -43,6 +43,10 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "test": "npm run build && node --test dist/test/*.test.js",
+    "test:e2e": "npm run build && bash scripts/e2e.sh",
+    "inspect": "npm run build && npx -y @modelcontextprotocol/inspector node dist/src/mcp/server.js",
+    "inspect:tools": "npm run build && npx -y @modelcontextprotocol/inspector --cli node dist/src/mcp/server.js --method tools/list",
+    "inspect:prompts": "npm run build && npx -y @modelcontextprotocol/inspector --cli node dist/src/mcp/server.js --method prompts/list",
     "dev:mcp": "tsx src/mcp/server.ts",
     "dev:cli": "tsx src/cli/index.ts",
     "prepublishOnly": "npm run build && npm test",

package/src/cli/index.ts

@@ -1,14 +1,20 @@
 #!/usr/bin/env node
 import { readFile } from 'node:fs/promises';
 import {
+  amendStoryBible,
   buildContext,
   createProject,
+  deleteChapter,
+  forkProject,
   getNextStep,
   getProjectStatus,
   listProjects,
+  loadThreads,
+  redoStep,
   requestSideTrack,
   retrieve,
   submitStepResult,
+  updateThread,
 } from '../core/index.js';
 import { formatInstallResult, runInstall, InstallHost } from './install.js';
 
@@ -156,7 +162,74 @@ export async function runCli(argv = process.argv.slice(2), cwd = process.cwd()):
     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') as 'planted' | 'building' | 'paid' | 'dropped' | undefined;
+    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') as 'planted' | 'building' | 'paid' | 'dropped' | undefined;
+    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') as
+      | 'novel_metadata' | 'story_bible' | 'architecture' | 'chapter' | 'memory_card' | 'continuity_review'
+      | undefined;
+    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]}`) {