@hanna84/mcp-writing 1.0.0 → 1.1.1

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+## [1.1.1](https://github.com/hannasdev/mcp-writing/compare/v1.1.0...v1.1.1) (2026-04-16)
+
+
+### Bug Fixes
+
+* use dedicated token for release-please workflow ([#10](https://github.com/hannasdev/mcp-writing/issues/10)) ([6167a59](https://github.com/hannasdev/mcp-writing/commit/6167a598999c173ba04bcdc61223259449e1cf24))
+
+
+### Miscellaneous Chores
+
+* fix lint in MCP validation scripts ([2b2385e](https://github.com/hannasdev/mcp-writing/commit/2b2385e3eddd8fd30716d0f72dfa6346ec2d6e5f))
+* include chore commits in release automation ([5a28f27](https://github.com/hannasdev/mcp-writing/commit/5a28f277d1551e35c7fd717836c259badbf8a1d9))
+* include chore commits in release-please ([c437850](https://github.com/hannasdev/mcp-writing/commit/c4378501ee7dc29d582ce78bc1d227927e719810))
+* keep reusable MCP validation scripts ([65f44cb](https://github.com/hannasdev/mcp-writing/commit/65f44cb730176aa4b340c42685dccda05a6725e6))
+* keep reusable MCP validation scripts ([9d4181e](https://github.com/hannasdev/mcp-writing/commit/9d4181e32d6ba9a76a33659c5cfedfe9cf296619))
+* trigger CI for release-please branches ([09e599a](https://github.com/hannasdev/mcp-writing/commit/09e599a399e6b9e039ef2670cfa51a88518dbd56))
+
+## [1.1.0](https://github.com/hannasdev/mcp-writing/compare/v1.0.0...v1.1.0) (2026-04-16)
+
+
+### Features
+
+* reconcile Scrivener reorders via stable external IDs ([977a1c3](https://github.com/hannasdev/mcp-writing/commit/977a1c3770861b5f8b0dd9ec8bcdcb00ff39d18a))
+* stable Scrivener identity and reorder reconciliation ([14c165f](https://github.com/hannasdev/mcp-writing/commit/14c165fd80050c59e162fd35bd84cbd39b767cee))

package/index.js

@@ -2,7 +2,6 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import http from "node:http";
 import fs from "node:fs";
-import path from "node:path";
 import matter from "gray-matter";
 import { z } from "zod";
 import { openDb } from "./db.js";
@@ -371,7 +370,7 @@ function createMcpServer() {
           const raw = fs.readFileSync(character.file_path, "utf8");
           const { content } = matter(raw);
           notes = content.trim();
-        } catch {}
+        } catch { /* empty */ }
       }
 
       const result = { ...character, traits, notes: notes || undefined };
@@ -779,7 +778,7 @@ function createMcpServer() {
     {
       scene_id:   z.string().describe("The scene_id to flag (e.g. 'sc-012-open-to-anyone')."),
       project_id: z.string().describe("Project the scene belongs to (e.g. 'the-lamb')."),
-      note:       z.string().describe("The flag note (e.g. 'Victor knows Mira\'s name here, but they haven\'t been introduced yet — contradicts sc-006')."),
+      note:       z.string().describe("The flag note (e.g. 'Victor knows Mira\u2019s name here, but they haven\u2019t been introduced yet \u2014 contradicts sc-006')."),
     },
     async ({ scene_id, project_id, note }) => {
       if (!SYNC_DIR_WRITABLE) {
@@ -850,8 +849,8 @@ const httpServer = http.createServer(async (req, res) => {
 
     const existing = activeSessions.get(sessionId);
     if (existing) {
-      try { await existing.transport.close(); } catch {}
-      try { await existing.server.close(); } catch {}
+      try { await existing.transport.close(); } catch { /* empty */ }
+      try { await existing.server.close(); } catch { /* empty */ }
       activeSessions.delete(sessionId);
     }
 

package/metadata-lint.js

@@ -17,6 +17,8 @@ const threadLinkSchema = z.object({
 
 const sceneSchema = z.object({
   scene_id: z.string().min(1),
+  external_source: z.string().min(1).optional(),
+  external_id: z.string().min(1).optional(),
   title: z.string().min(1).optional(),
   part: z.number().int().positive().optional(),
   chapter: z.number().int().positive().optional(),
@@ -284,7 +286,7 @@ export function lintMetadataInSyncDir(syncDir) {
         arr.push(sidecar);
         sceneIdToFiles.set(meta.scene_id, arr);
       }
-    } catch {}
+    } catch { /* empty */ }
   }
   for (const file of files) {
     if (fs.existsSync(sidecarPath(file))) continue; // already counted via sidecar
@@ -295,7 +297,7 @@ export function lintMetadataInSyncDir(syncDir) {
         arr.push(file);
         sceneIdToFiles.set(data.scene_id, arr);
       }
-    } catch {}
+    } catch { /* empty */ }
   }
 
   for (const [sceneId, dupeFiles] of sceneIdToFiles) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanna84/mcp-writing",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "MCP service for AI-assisted reasoning and editing on long-form fiction projects",
   "type": "module",
   "main": "index.js",
@@ -10,13 +10,15 @@
     "sync.js",
     "metadata-lint.js",
     "scripts/",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "start": "node --experimental-sqlite index.js",
+    "lint": "eslint index.js db.js sync.js metadata-lint.js scripts/",
     "lint:metadata": "node scripts/lint-metadata.mjs",
     "lint:metadata:test": "node scripts/lint-metadata.mjs --sync-dir ./test-sync",
     "test:unit": "node --experimental-sqlite --test test/unit.test.mjs",
@@ -38,5 +40,10 @@
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.1",
     "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.2.0",
+    "globals": "^17.5.0"
   }
 }

package/scripts/import.js

@@ -14,12 +14,13 @@
  *   --dry-run         Show what would be created without writing anything
  *
  * What it does (Draft folder):
- *   - Walks the Draft dir in filename order (NNN prefix = binder sequence)
+ *   - Walks the Draft dir in filename order (NNN prefix = current binder sequence)
  *   - Skips empty files (non-compilation title cards) and Epigraphs
  *   - Detects Save the Cat beat markers ("-Beat Name-" empty files) and carries
  *     the beat name forward to the next prose scene's sidecar
  *   - Creates mcp-sync-dir/projects/<project>/scenes/ structure
- *   - Writes a .meta.yaml sidecar for each scene (skips files that already have one)
+ *   - Reconciles existing imports by stable Scrivener binder ID (`[123]` in the filename)
+ *   - Writes a .meta.yaml sidecar for each scene while preserving existing editorial metadata
  *
  * What it does (Notes folder):
  *   - Tracks section mode via empty top-level folder markers (Characters, Places, World...)
@@ -62,11 +63,16 @@ const placesDir = path.join(mcpSyncDir, "projects", projectId, "world", "places"
 // Helpers
 // ---------------------------------------------------------------------------
 
-// Parse "NNN Title [binder_id].txt" → { seq, rawTitle } or null
+// Parse "NNN Title [binder_id].txt" → { seq, rawTitle, binderId, ext } or null
 function parseFilename(filename) {
-  const m = filename.match(/^(\d+)\s+(.+?)\s*\[\d+\]\.(txt|md)$/);
+  const m = filename.match(/^(\d+)\s+(.+?)\s*\[(\d+)\]\.(txt|md)$/);
   if (!m) return null;
-  return { seq: parseInt(m[1], 10), rawTitle: m[2].trim() };
+  return {
+    seq: parseInt(m[1], 10),
+    rawTitle: m[2].trim(),
+    binderId: m[3],
+    ext: m[4],
+  };
 }
 
 function isBeatMarker(rawTitle) {
@@ -94,8 +100,8 @@ function slugify(str) {
     .slice(0, 50);
 }
 
-function makeSceneId(seq, title) {
-  return `sc-${String(seq).padStart(3, "0")}-${slugify(title).slice(0, 40)}`;
+function makeSceneId(binderId, title) {
+  return `sc-${String(binderId).padStart(3, "0")}-${slugify(title).slice(0, 40)}`;
 }
 
 function makeCharacterId(rawTitle) {
@@ -137,6 +143,51 @@ function walkSorted(dir) {
   return files.sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
 }
 
+function loadYamlFile(filePath) {
+  try {
+    return yaml.load(fs.readFileSync(filePath, "utf8")) ?? {};
+  } catch {
+    return {};
+  }
+}
+
+function buildExistingSceneIndex(dir) {
+  const byBinderId = new Map();
+  if (!fs.existsSync(dir)) return byBinderId;
+
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".meta.yaml")) continue;
+
+    const sidecarPath = path.join(dir, entry.name);
+    const proseCandidates = [
+      sidecarPath.replace(/\.meta\.yaml$/, ".txt"),
+      sidecarPath.replace(/\.meta\.yaml$/, ".md"),
+    ];
+    const prosePath = proseCandidates.find(candidate => fs.existsSync(candidate)) ?? null;
+    const proseName = prosePath ? path.basename(prosePath) : entry.name.replace(/\.meta\.yaml$/, ".txt");
+    const parsedName = parseFilename(proseName);
+    const meta = loadYamlFile(sidecarPath);
+    const binderId = meta.external_source === "scrivener" && meta.external_id
+      ? String(meta.external_id)
+      : parsedName?.binderId ?? null;
+
+    if (!binderId) continue;
+
+    byBinderId.set(String(binderId), {
+      binderId: String(binderId),
+      prosePath,
+      sidecarPath,
+      meta,
+    });
+  }
+
+  return byBinderId;
+}
+
+function removeIfExists(filePath) {
+  if (filePath && fs.existsSync(filePath)) fs.unlinkSync(filePath);
+}
+
 // ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
@@ -149,6 +200,7 @@ const hasNotes = fs.existsSync(notesDir);
 const draftRoot = hasDraft ? draftDir : scrivenerDir;
 
 const files = walkSorted(draftRoot);
+const existingScenes = buildExistingSceneIndex(scenesDir);
 let created = 0;
 let skipped = 0;
 let alreadyDone = 0;
@@ -172,7 +224,7 @@ for (const file of files) {
     continue;
   }
 
-  const { seq, rawTitle } = parsed;
+  const { seq, rawTitle, binderId, ext } = parsed;
   const isEmpty = fs.statSync(file).size === 0;
 
   // Beat markers: always empty, carry beat name forward
@@ -197,20 +249,17 @@ for (const file of files) {
   }
 
   // Scene file — create sidecar
-  const title    = cleanTitle(rawTitle);
-  const sceneId  = makeSceneId(seq, title);
-  const destFile = path.join(scenesDir, filename);
-  const sidecar  = destFile.replace(/\.(txt|md)$/, ".meta.yaml");
-
-  if (fs.existsSync(sidecar)) {
-    console.log(`  SKIP  (sidecar exists) ${filename}`);
-    alreadyDone++;
-    beatCarry = null; // beat was consumed by an existing scene
-    continue;
-  }
+  const title = cleanTitle(rawTitle);
+  const existing = existingScenes.get(String(binderId)) ?? null;
+  const sceneId = existing?.meta?.scene_id ?? makeSceneId(binderId, title);
+  const destFile = path.join(scenesDir, `${seq.toString().padStart(3, "0")} ${rawTitle} [${binderId}].${ext}`);
+  const sidecar = destFile.replace(/\.(txt|md)$/, ".meta.yaml");
 
   const meta = {
+    ...(existing?.meta ?? {}),
     scene_id: sceneId,
+    external_source: "scrivener",
+    external_id: String(binderId),
     title,
     timeline_position: seq,
     ...(beatCarry ? { save_the_cat_beat: beatCarry } : {}),
@@ -224,20 +273,34 @@ for (const file of files) {
     // tags: [],
   };
 
+  if (!beatCarry && existing?.meta && Object.hasOwn(existing.meta, "save_the_cat_beat")) {
+    delete meta.save_the_cat_beat;
+  }
+
   if (dryRun) {
     console.log(`  DRY   ${path.basename(sidecar)}`);
+    if (existing) {
+      console.log(`        reconcile: binder ${binderId} -> existing scene_id ${sceneId}`);
+    }
     console.log(`        scene_id: ${sceneId}, beat: ${beatCarry ?? "(none)"}`);
   } else {
-    // Copy prose file into mcp-sync-dir scenes folder
-    if (!fs.existsSync(destFile)) {
-      fs.copyFileSync(file, destFile);
-    }
+    // Copy/update prose file in mcp-sync-dir scenes folder
+    fs.copyFileSync(file, destFile);
     fs.writeFileSync(sidecar, yaml.dump(meta, { lineWidth: 120 }), "utf8");
-    console.log(`  OK    ${path.basename(sidecar)}  [beat: ${beatCarry ?? "—"}]`);
+
+    if (existing) {
+      if (existing.prosePath && existing.prosePath !== destFile) removeIfExists(existing.prosePath);
+      if (existing.sidecarPath && existing.sidecarPath !== sidecar) removeIfExists(existing.sidecarPath);
+      console.log(`  OK    ${path.basename(sidecar)}  [reconciled binder ${binderId}, beat: ${beatCarry ?? "—"}]`);
+    } else {
+      console.log(`  OK    ${path.basename(sidecar)}  [beat: ${beatCarry ?? "—"}]`);
+    }
+    existingScenes.set(String(binderId), { binderId: String(binderId), prosePath: destFile, sidecarPath: sidecar, meta });
   }
 
   beatCarry = null; // consumed
-  created++;
+  if (existing) alreadyDone++;
+  else created++;
 }
 
 console.log(`\n${"─".repeat(50)}`);

package/scripts/manual-validation.mjs

@@ -0,0 +1,273 @@
+/**
+ * MCP Manual Validation Script - Fixed Version
+ */
+import { spawn } from "node:child_process";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { URL as NodeURL } from "node:url";
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+
+const ROOT = process.cwd();
+
+async function waitForServer(url, retries = 30, delayMs = 300) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      const res = await fetch(`${url}/healthz`);
+      if (res.ok) return true;
+    } catch { /* empty */ }
+    await new Promise(r => setTimeout(r, delayMs));
+  }
+  throw new Error(`Server did not become ready`);
+}
+
+function spawnServer(port, syncDir) {
+  const proc = spawn(process.execPath, ["--experimental-sqlite", `${ROOT}/index.js`], {
+    env: { ...process.env, WRITING_SYNC_DIR: syncDir, DB_PATH: ":memory:", HTTP_PORT: String(port) },
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  return proc;
+}
+
+async function connectClient(url) {
+  const c = new Client({ name: "manual-validation-client", version: "1.0.0" });
+  const transport = new SSEClientTransport(new NodeURL(`${url}/sse`));
+  await c.connect(transport);
+  return c;
+}
+
+async function callTool(client, name, args = {}) {
+  try {
+    return await client.callTool({ name, arguments: args });
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+function parseResponse(result) {
+  if (result.error) return { error: result.error };
+  try {
+    const text = result.content?.[0]?.text;
+    if (!text) return { raw: result };
+    // Try to parse as JSON
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { text };
+    }
+  } catch {
+    return { raw: result };
+  }
+}
+
+// ======================== PHASE A ========================
+async function runPhaseA() {
+  console.log("\n========== PHASE A: Raw Export (./txt) ==========\n");
+  const PORT = 3110;
+  const BASE = `http://localhost:${PORT}`;
+  
+  const proc = spawnServer(PORT, `${ROOT}/txt`);
+  const results = { errors: [] };
+  
+  try {
+    await waitForServer(BASE);
+    console.log("✓ Server started on port", PORT);
+    
+    const client = await connectClient(BASE);
+    console.log("✓ MCP Client connected\n");
+    
+    // sync
+    const syncRes = await callTool(client, "sync");
+    const syncText = syncRes.content?.[0]?.text || JSON.stringify(syncRes);
+    results.syncMessage = syncText;
+    console.log("sync:", syncText.slice(0, 200));
+    
+    // find_scenes
+    const scenesRes = await callTool(client, "find_scenes", {});
+    const scenesData = parseResponse(scenesRes);
+    results.sceneCount = scenesData.total_count ?? scenesData.results?.length ?? "N/A";
+    console.log("find_scenes count:", results.sceneCount);
+    
+    // list_characters
+    const charsRes = await callTool(client, "list_characters", {});
+    const charsData = parseResponse(charsRes);
+    results.characterCount = charsData.total_count ?? charsData.characters?.length ?? "N/A";
+    console.log("list_characters count:", results.characterCount);
+    
+    // list_places
+    const placesRes = await callTool(client, "list_places", {});
+    const placesData = parseResponse(placesRes);
+    results.placeCount = placesData.total_count ?? placesData.places?.length ?? "N/A";
+    console.log("list_places count:", results.placeCount);
+    
+    // search_metadata
+    const searchRes = await callTool(client, "search_metadata", { query: "airport" });
+    const searchData = parseResponse(searchRes);
+    results.airportSearchCount = searchData.total_count ?? searchData.results?.length ?? "N/A";
+    console.log("search_metadata(airport) count:", results.airportSearchCount);
+    
+    await client.close();
+    console.log("✓ Client closed");
+  } catch (e) {
+    results.errors.push(`Phase A error: ${e.message}`);
+    console.error("Phase A error:", e.message);
+  } finally {
+    proc.kill();
+    console.log("✓ Server killed");
+  }
+  
+  return results;
+}
+
+// ======================== PHASE B ========================
+async function runPhaseB() {
+  console.log("\n========== PHASE B: Imported Format ==========\n");
+  const PORT = 3111;
+  const BASE = `http://localhost:${PORT}`;
+  const IMPORT_DIR = "/tmp/mcp-writing-manual";
+  
+  const results = { errors: [], warnings: [] };
+  
+  // Cleanup
+  try {
+    fs.rmSync(IMPORT_DIR, { recursive: true, force: true });
+    console.log("✓ Cleaned up", IMPORT_DIR);
+  } catch { /* empty */ }
+  
+  // Import
+  try {
+    const importOutput = execSync(
+      `node scripts/import.js ./txt ${IMPORT_DIR} --project scrivener-export`,
+      { cwd: ROOT, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    console.log("✓ Import completed");
+    results.importOutput = importOutput.slice(0, 500);
+  } catch (e) {
+    results.errors.push(`Import error: ${e.message}`);
+    console.error("Import error:", e.message);
+    return results;
+  }
+  
+  // Lint
+  try {
+    const lintOutput = execSync(
+      `node scripts/lint-metadata.mjs --sync-dir ${IMPORT_DIR}`,
+      { cwd: ROOT, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    results.lintOutput = lintOutput;
+    console.log("✓ Lint completed");
+    console.log("Lint output:\n", lintOutput.slice(0, 400));
+  } catch (e) {
+    results.lintOutput = e.stdout || e.stderr || e.message;
+    results.warnings.push(`Lint warnings: ${results.lintOutput.slice(0, 500)}`);
+    console.log("Lint output (non-zero):\n", results.lintOutput.slice(0, 400));
+  }
+  
+  // Start server
+  const proc = spawnServer(PORT, IMPORT_DIR);
+  
+  try {
+    await waitForServer(BASE);
+    console.log("✓ Server started on port", PORT);
+    
+    const client = await connectClient(BASE);
+    console.log("✓ MCP Client connected\n");
+    
+    // sync
+    const syncRes = await callTool(client, "sync");
+    const syncText = syncRes.content?.[0]?.text || JSON.stringify(syncRes);
+    results.syncMessage = syncText;
+    console.log("sync:", syncText.slice(0, 200));
+    
+    // find_scenes with project filter
+    const scenesRes = await callTool(client, "find_scenes", { 
+      project_id: "scrivener-export", 
+      page_size: 5, 
+      page: 1 
+    });
+    const scenesData = parseResponse(scenesRes);
+    results.sceneCount = scenesData.total_count ?? scenesData.results?.length ?? "N/A";
+    results.firstSceneId = scenesData.results?.[0]?.scene_id || null;
+    console.log("find_scenes count:", results.sceneCount);
+    if (results.firstSceneId) console.log("First scene_id:", results.firstSceneId);
+    
+    // list_characters with project filter
+    const charsRes = await callTool(client, "list_characters", { project_id: "scrivener-export" });
+    const charsData = parseResponse(charsRes);
+    results.characterCount = charsData.total_count ?? charsData.characters?.length ?? "N/A";
+    console.log("list_characters count:", results.characterCount);
+    
+    // list_places with project filter
+    const placesRes = await callTool(client, "list_places", { project_id: "scrivener-export" });
+    const placesData = parseResponse(placesRes);
+    results.placeCount = placesData.total_count ?? placesData.places?.length ?? "N/A";
+    console.log("list_places count:", results.placeCount);
+    
+    // search_metadata
+    const searchRes = await callTool(client, "search_metadata", { 
+      query: "airport", 
+      page_size: 5, 
+      page: 1 
+    });
+    const searchData = parseResponse(searchRes);
+    results.airportSearchCount = searchData.total_count ?? searchData.results?.length ?? "N/A";
+    console.log("search_metadata(airport) count:", results.airportSearchCount);
+    
+    // get_scene_prose if we have a scene ID
+    if (results.firstSceneId) {
+      const proseRes = await callTool(client, "get_scene_prose", { scene_id: results.firstSceneId });
+      const proseData = parseResponse(proseRes);
+      results.proseExcerpt = proseData.prose?.slice(0, 200) || proseData.text?.slice(0, 200) || proseRes.content?.[0]?.text?.slice(0, 200) || "(no prose)";
+      console.log("get_scene_prose excerpt:", results.proseExcerpt.slice(0, 150) + "...");
+    } else {
+      results.proseExcerpt = "(no scene_id available)";
+    }
+    
+    await client.close();
+    console.log("✓ Client closed");
+  } catch (e) {
+    results.errors.push(`Phase B error: ${e.message}`);
+    console.error("Phase B error:", e.message);
+  } finally {
+    proc.kill();
+    console.log("✓ Server killed");
+  }
+  
+  return results;
+}
+
+// ======================== MAIN ========================
+async function main() {
+  console.log("Starting MCP Manual Validation...\n");
+  
+  const phaseA = await runPhaseA();
+  const phaseB = await runPhaseB();
+  
+  console.log("\n========== FINAL SUMMARY ==========\n");
+  
+  console.log("PHASE A (Raw Export ./txt):");
+  console.log("  Sync message:", phaseA.syncMessage?.slice(0, 150) || "N/A");
+  console.log("  Scene count:", phaseA.sceneCount);
+  console.log("  Character count:", phaseA.characterCount);
+  console.log("  Place count:", phaseA.placeCount);
+  console.log("  Airport search count:", phaseA.airportSearchCount);
+  if (phaseA.errors.length) console.log("  Errors:", phaseA.errors);
+  
+  console.log("\nPHASE B (Imported /tmp/mcp-writing-manual):");
+  console.log("  Sync message:", phaseB.syncMessage?.slice(0, 150) || "N/A");
+  console.log("  Scene count:", phaseB.sceneCount);
+  console.log("  Character count:", phaseB.characterCount);
+  console.log("  Place count:", phaseB.placeCount);
+  console.log("  Airport search count:", phaseB.airportSearchCount);
+  console.log("  First scene_id:", phaseB.firstSceneId || "N/A");
+  console.log("  Prose excerpt (200 chars):", phaseB.proseExcerpt?.slice(0, 200) || "N/A");
+  if (phaseB.warnings.length) console.log("  Lint warnings:", phaseB.warnings.length > 0 ? "Yes (see above)" : "None");
+  if (phaseB.errors.length) console.log("  Errors:", phaseB.errors);
+  
+  console.log("\n========== VALIDATION COMPLETE ==========\n");
+}
+
+main().catch(e => {
+  console.error("Fatal error:", e);
+  process.exit(1);
+});

package/scripts/mcp-debug-client.mjs

@@ -0,0 +1,43 @@
+import { spawn } from "node:child_process";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { URL as NodeURL } from "node:url";
+
+const ROOT = process.cwd();
+
+async function waitForServer(url, retries = 30, delayMs = 300) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      const res = await fetch(`${url}/healthz`);
+      if (res.ok) return true;
+    } catch { /* empty */ }
+    await new Promise(r => setTimeout(r, delayMs));
+  }
+  throw new Error(`Server did not become ready`);
+}
+
+const PORT = 3112;
+const BASE = `http://localhost:${PORT}`;
+const IMPORT_DIR = "/tmp/mcp-writing-manual";
+
+const proc = spawn(process.execPath, ["--experimental-sqlite", `${ROOT}/index.js`], {
+  env: { ...process.env, WRITING_SYNC_DIR: IMPORT_DIR, DB_PATH: ":memory:", HTTP_PORT: String(PORT) },
+  stdio: ["ignore", "pipe", "pipe"],
+});
+
+try {
+  await waitForServer(BASE);
+  const client = new Client({ name: "debug-client", version: "1.0.0" });
+  const transport = new SSEClientTransport(new NodeURL(`${BASE}/sse`));
+  await client.connect(transport);
+  
+  await client.callTool({ name: "sync", arguments: {} });
+  
+  const scenes = await client.callTool({ name: "find_scenes", arguments: { project_id: "scrivener-export", page_size: 3, page: 1 } });
+  console.log("=== find_scenes raw response ===");
+  console.log(JSON.stringify(scenes, null, 2));
+  
+  await client.close();
+} finally {
+  proc.kill();
+}

package/sync.js

@@ -141,7 +141,7 @@ export function readMeta(filePath, syncDir, { writable = false } = {}) {
     try {
       fs.writeFileSync(sidecar, stringifyYaml(normalized.meta), "utf8");
       return { ...normalized, sourceMeta: frontmatter, sidecarGenerated: true };
-    } catch {}
+    } catch { /* empty */ }
   }
 
   return { ...normalized, sourceMeta: frontmatter, sidecarGenerated: false };
@@ -402,7 +402,7 @@ export function syncAll(db, syncDir, { quiet = false, writable = false } = {}) {
       try {
         const raw = fs.readFileSync(sidecar, "utf8");
         orphanedSceneId = (parseYaml(raw) ?? {}).scene_id ?? null;
-      } catch {}
+      } catch { /* empty */ }
 
       if (orphanedSceneId && indexedSceneIds.has(orphanedSceneId)) {
         warnings.push(