@hanna84/mcp-writing 2.9.6 → 2.9.8

package/index.js

@@ -10,37 +10,19 @@ import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import matter from "gray-matter";
 import yaml from "js-yaml";
-import { z } from "zod";
 import { openDb } from "./db.js";
-import { syncAll, isSyncDirWritable, getSyncOwnershipDiagnostics, getFileWriteDiagnostics, readMeta, indexSceneFile, sidecarPath, isStructuralProjectId } from "./sync.js";
-import { isGitAvailable, isGitRepository, initGitRepository, createSnapshot, listSnapshots, getSceneProseAtCommit } from "./git.js";
+import { syncAll, isSyncDirWritable, getSyncOwnershipDiagnostics, sidecarPath, isStructuralProjectId } from "./sync.js";
+import { isGitAvailable, isGitRepository, initGitRepository, getSceneProseAtCommit } from "./git.js";
 import { renderCharacterArcTemplate, renderCharacterSheetTemplate, renderPlaceSheetTemplate, slugifyEntityName } from "./world-entity-templates.js";
-import { validateProjectId } from "./importer.js";
 import { ASYNC_PROGRESS_PREFIX } from "./async-progress.js";
-import {
-  STYLEGUIDE_CONFIG_BASENAME,
-  STYLEGUIDE_ENUMS,
-  buildStyleguideConfigDraft,
-  previewStyleguideConfigUpdate,
-  resolveStyleguideConfig,
-  summarizeStyleguideConfig,
-  updateStyleguideConfig,
-} from "./prose-styleguide.js";
-import {
-  detectStyleguideSignals,
-  analyzeSceneStyleguideDrift,
-  suggestStyleguideUpdatesFromScenes,
-} from "./prose-styleguide-drift.js";
-import {
-  PROSE_STYLEGUIDE_SKILL_BASENAME,
-  PROSE_STYLEGUIDE_SKILL_DIRNAME,
-  buildProseStyleguideSkill,
-} from "./prose-styleguide-skill.js";
+import { STYLEGUIDE_CONFIG_BASENAME } from "./prose-styleguide.js";
 import { ReviewBundlePlanError } from "./review-bundles.js";
 import { registerSyncTools } from "./tools/sync.js";
 import { registerSearchTools } from "./tools/search.js";
 import { registerMetadataTools } from "./tools/metadata.js";
 import { registerReviewBundleTools } from "./tools/review-bundles.js";
+import { registerStyleguideTools } from "./tools/styleguide.js";
+import { registerEditingTools } from "./tools/editing.js";
 
 const SYNC_DIR = process.env.WRITING_SYNC_DIR ?? "./sync";
 const DB_PATH = process.env.DB_PATH ?? "./writing.db";
@@ -1039,11 +1021,16 @@ function createMcpServer() {
     readEntityMetadata,
     createCanonicalWorldEntity,
     resolveOutputDirWithinSync,
+    isPathCandidateInsideSyncDir,
+    pendingProposals,
+    generateProposalId,
   };
   registerSyncTools(s, toolContext);
   registerSearchTools(s, toolContext);
   registerMetadataTools(s, toolContext);
   registerReviewBundleTools(s, toolContext);
+  registerStyleguideTools(s, toolContext);
+  registerEditingTools(s, toolContext);
 
   // ---- get_runtime_config --------------------------------------------------
   s.tool(
@@ -1068,946 +1055,6 @@ function createMcpServer() {
   );
 
   // ---- prose styleguide ---------------------------------------------------
-  s.tool(
-    "setup_prose_styleguide_config",
-    "Create prose-styleguide.config.yaml at sync root or project root using language defaults plus optional explicit overrides.",
-    {
-      scope: z.enum(["sync_root", "project_root"]).optional().describe("Config write target scope. Defaults to project_root when project_id is supplied, otherwise sync_root."),
-      project_id: z.string().optional().describe("Project ID when writing project_root config (e.g. 'the-lamb' or 'universe-1/book-1')."),
-      language: z.enum(STYLEGUIDE_ENUMS.language).describe("Primary writing language. Seeds language-specific defaults."),
-      overrides: z.object({
-        spelling: z.enum(STYLEGUIDE_ENUMS.spelling).optional(),
-        quotation_style: z.enum(STYLEGUIDE_ENUMS.quotation_style).optional(),
-        quotation_style_nested: z.enum(STYLEGUIDE_ENUMS.quotation_style_nested).optional(),
-        em_dash_spacing: z.enum(STYLEGUIDE_ENUMS.em_dash_spacing).optional(),
-        ellipsis_style: z.enum(STYLEGUIDE_ENUMS.ellipsis_style).optional(),
-        abbreviation_periods: z.enum(STYLEGUIDE_ENUMS.abbreviation_periods).optional(),
-        oxford_comma: z.enum(STYLEGUIDE_ENUMS.oxford_comma).optional(),
-        numbers: z.enum(STYLEGUIDE_ENUMS.numbers).optional(),
-        date_format: z.enum(STYLEGUIDE_ENUMS.date_format).optional(),
-        time_format: z.enum(STYLEGUIDE_ENUMS.time_format).optional(),
-        tense: z.string().optional(),
-        pov: z.enum(STYLEGUIDE_ENUMS.pov).optional(),
-        dialogue_tags: z.enum(STYLEGUIDE_ENUMS.dialogue_tags).optional(),
-        sentence_fragments: z.enum(STYLEGUIDE_ENUMS.sentence_fragments).optional(),
-      }).optional().describe("Optional overrides layered on top of language defaults."),
-      voice_notes: z.string().optional().describe("Optional freeform voice notes to include in config."),
-      overwrite: z.boolean().optional().describe("If true, replaces an existing config file at the target location."),
-    },
-    async ({ scope, project_id, language, overrides = {}, voice_notes, overwrite = false }) => {
-      const resolvedScope = scope ?? (project_id ? "project_root" : "sync_root");
-
-      if (project_id !== undefined) {
-        const projectIdCheck = validateProjectId(project_id);
-        if (!projectIdCheck.ok) {
-          return errorResponse("INVALID_PROJECT_ID", projectIdCheck.reason, { project_id });
-        }
-      }
-
-      if (resolvedScope === "project_root" && !project_id) {
-        return errorResponse(
-          "PROJECT_ID_REQUIRED",
-          "project_id is required when scope=project_root."
-        );
-      }
-
-      if (!SYNC_DIR_WRITABLE) {
-        return errorResponse(
-          "SYNC_DIR_NOT_WRITABLE",
-          "Cannot write styleguide config because WRITING_SYNC_DIR is not writable in this runtime.",
-          { sync_dir: SYNC_DIR_ABS }
-        );
-      }
-
-      const targetPath = resolvedScope === "sync_root"
-        ? path.join(SYNC_DIR, STYLEGUIDE_CONFIG_BASENAME)
-        : path.join(resolveProjectRoot(project_id), STYLEGUIDE_CONFIG_BASENAME);
-
-      if (!isPathCandidateInsideSyncDir(targetPath)) {
-        return errorResponse(
-          "INVALID_CONFIG_PATH",
-          "Resolved styleguide config path must be inside WRITING_SYNC_DIR.",
-          { target_path: path.resolve(targetPath), sync_dir: SYNC_DIR_ABS }
-        );
-      }
-
-      if (fs.existsSync(targetPath) && !overwrite) {
-        return errorResponse(
-          "STYLEGUIDE_CONFIG_EXISTS",
-          "Styleguide config already exists at target path. Set overwrite=true to replace it.",
-          { target_path: path.resolve(targetPath) }
-        );
-      }
-
-      const draft = buildStyleguideConfigDraft({
-        language,
-        overrides,
-        voice_notes,
-      });
-      if (!draft.ok) {
-        return errorResponse(
-          draft.error.code,
-          draft.error.message,
-          draft.error.details
-        );
-      }
-
-      fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-      fs.writeFileSync(targetPath, yaml.dump(draft.config, { lineWidth: 120 }), "utf8");
-
-      return jsonResponse({
-        ok: true,
-        scope: resolvedScope,
-        file_path: path.resolve(targetPath),
-        config: draft.config,
-        inferred_defaults: draft.inferred_defaults,
-        warnings: draft.warnings,
-        next_step: "Config created. Call update_prose_styleguide_config to apply field updates.",
-      });
-    }
-  );
-
-  s.tool(
-    "get_prose_styleguide_config",
-    "Resolve prose-styleguide.config.yaml with cascading precedence (sync root, then universe root, then project root). Applies language-derived defaults and nested quotation defaults when omitted.",
-    {
-      project_id: z.string().optional().describe("Optional project ID for project-scoped resolution (e.g. 'the-lamb' or 'universe-1/book-1')."),
-    },
-    async ({ project_id }) => {
-      if (project_id !== undefined) {
-        const projectIdCheck = validateProjectId(project_id);
-        if (!projectIdCheck.ok) {
-          return errorResponse("INVALID_PROJECT_ID", projectIdCheck.reason, { project_id });
-        }
-      }
-
-      const resolved = resolveStyleguideConfig({
-        syncDir: SYNC_DIR,
-        projectId: project_id,
-      });
-
-      if (!resolved.ok) {
-        return errorResponse(
-          resolved.error.code,
-          resolved.error.message,
-          resolved.error.details
-        );
-      }
-
-      return jsonResponse({
-        ok: true,
-        styleguide: resolved,
-        next_step: resolved.setup_required
-          ? "No prose-styleguide.config.yaml was found. Call setup_prose_styleguide_config (with language e.g. 'en') to create one at sync root or project root."
-          : "Config resolved successfully.",
-      });
-    }
-  );
-
-  s.tool(
-    "summarize_prose_styleguide_config",
-    "Summarize the currently resolved prose styleguide config in plain language for review or confirmation.",
-    {
-      project_id: z.string().optional().describe("Optional project ID for project-scoped resolution (e.g. 'the-lamb' or 'universe-1/book-1')."),
-    },
-    async ({ project_id }) => {
-      if (project_id !== undefined) {
-        const projectIdCheck = validateProjectId(project_id);
-        if (!projectIdCheck.ok) {
-          return errorResponse("INVALID_PROJECT_ID", projectIdCheck.reason, { project_id });
-        }
-      }
-
-      const resolved = resolveStyleguideConfig({
-        syncDir: SYNC_DIR,
-        projectId: project_id,
-      });
-      if (!resolved.ok) {
-        return errorResponse(
-          resolved.error.code,
-          resolved.error.message,
-          resolved.error.details
-        );
-      }
-      if (resolved.setup_required || !resolved.resolved_config) {
-        return errorResponse(
-          "STYLEGUIDE_CONFIG_REQUIRED",
-          "Cannot summarize prose styleguide config before prose-styleguide.config.yaml is set up.",
-          {
-            project_id: project_id ?? null,
-            next_step: "Run setup_prose_styleguide_config or bootstrap_prose_styleguide_config.",
-          }
-        );
-      }
-
-      const summary = summarizeStyleguideConfig({
-        resolvedConfig: resolved.resolved_config,
-        inferredDefaults: resolved.inferred_defaults,
-      });
-      if (!summary.ok) {
-        return errorResponse(summary.error.code, summary.error.message);
-      }
-
-      return jsonResponse({
-        ok: true,
-        project_id: project_id ?? null,
-        summary_text: summary.summary_text,
-        summary_lines: summary.summary_lines,
-        styleguide: resolved,
-      });
-    }
-  );
-
-  s.tool(
-    "bootstrap_prose_styleguide_config",
-    "Detect dominant prose conventions from existing scenes and suggest initial prose-styleguide config values.",
-    {
-      project_id: z.string().describe("Project ID to analyze (e.g. 'the-lamb' or 'universe-1/book-1')."),
-      scene_ids: z.array(z.string()).optional().describe("Optional scene_id allowlist to analyze."),
-      part: z.number().int().optional().describe("Optional part filter."),
-      chapter: z.number().int().optional().describe("Optional chapter filter."),
-      max_scenes: z.number().int().positive().optional().describe("Maximum number of scenes to analyze (default: 50)."),
-      min_agreement: z.number().min(0).max(1).optional().describe("Minimum agreement ratio for suggested fields (default: 0.6)."),
-      min_evidence: z.number().int().positive().optional().describe("Minimum number of observed scenes per field before suggesting it (default: 3)."),
-      include_scene_signals: z.boolean().optional().describe("If true, include per-scene detected signals in the response."),
-    },
-    async ({
-      project_id,
-      scene_ids,
-      part,
-      chapter,
-      max_scenes = 50,
-      min_agreement = 0.6,
-      min_evidence = 3,
-      include_scene_signals = false,
-    }) => {
-      const projectIdCheck = validateProjectId(project_id);
-      if (!projectIdCheck.ok) {
-        return errorResponse("INVALID_PROJECT_ID", projectIdCheck.reason, { project_id });
-      }
-
-      const targetResolution = resolveBatchTargetScenes(db, {
-        projectId: project_id,
-        sceneIds: scene_ids,
-        part,
-        chapter,
-        onlyStale: false,
-      });
-      if (!targetResolution.ok) {
-        return errorResponse(targetResolution.code, targetResolution.message, targetResolution.details);
-      }
-
-      const targetScenes = targetResolution.rows;
-      if (targetScenes.length === 0) {
-        return errorResponse(
-          "NOT_FOUND",
-          `No scenes were found for project '${project_id}' with the requested filters.`,
-          { project_id, scene_ids: scene_ids ?? null, part: part ?? null, chapter: chapter ?? null }
-        );
-      }
-
-      if (targetScenes.length > max_scenes) {
-        return errorResponse(
-          "VALIDATION_ERROR",
-          `Matched ${targetScenes.length} scenes, which exceeds max_scenes=${max_scenes}.`,
-          {
-            matched_scenes: targetScenes.length,
-            max_scenes,
-            project_id,
-            next_step: maxScenesNextStep(targetScenes.length),
-          }
-        );
-      }
-
-      const sceneSignals = [];
-      let unreadableScenes = 0;
-
-      for (const scene of targetScenes) {
-        try {
-          const raw = fs.readFileSync(scene.file_path, "utf8");
-          const prose = matter(raw).content;
-          sceneSignals.push({
-            scene_id: scene.scene_id,
-            observed: detectStyleguideSignals(prose),
-          });
-        } catch {
-          unreadableScenes += 1;
-          sceneSignals.push({
-            scene_id: scene.scene_id,
-            observed: {},
-          });
-        }
-      }
-
-      const suggestedConfig = suggestStyleguideUpdatesFromScenes({
-        sceneAnalyses: sceneSignals,
-        resolvedConfig: null,
-        minAgreement: min_agreement,
-        minEvidence: min_evidence,
-      });
-
-      return jsonResponse({
-        ok: true,
-        project_id,
-        checked_scenes: sceneSignals.length,
-        unreadable_scenes: unreadableScenes,
-        suggested_config: suggestedConfig,
-        next_step: `To apply: (1) If no project-scoped config exists yet, call setup_prose_styleguide_config first with scope=project_root, project_id=${project_id}, and language (e.g. 'en'). (2) Then call update_prose_styleguide_config with the fields from suggested_config you want to apply.`,
-        scene_signals: include_scene_signals ? sceneSignals : undefined,
-      });
-    }
-  );
-
-  s.tool(
-    "update_prose_styleguide_config",
-    "Update an existing prose-styleguide.config.yaml at sync-root or project-root scope by writing only explicit field changes.",
-    {
-      scope: z.enum(["sync_root", "project_root"]).describe("Config scope to update."),
-      project_id: z.string().optional().describe("Project ID when updating project_root config (e.g. 'the-lamb' or 'universe-1/book-1')."),
-      updates: z.object({
-        language: z.enum(STYLEGUIDE_ENUMS.language).optional(),
-        spelling: z.enum(STYLEGUIDE_ENUMS.spelling).optional(),
-        quotation_style: z.enum(STYLEGUIDE_ENUMS.quotation_style).optional(),
-        quotation_style_nested: z.enum(STYLEGUIDE_ENUMS.quotation_style_nested).optional(),
-        em_dash_spacing: z.enum(STYLEGUIDE_ENUMS.em_dash_spacing).optional(),
-        ellipsis_style: z.enum(STYLEGUIDE_ENUMS.ellipsis_style).optional(),
-        abbreviation_periods: z.enum(STYLEGUIDE_ENUMS.abbreviation_periods).optional(),
-        oxford_comma: z.enum(STYLEGUIDE_ENUMS.oxford_comma).optional(),
-        numbers: z.enum(STYLEGUIDE_ENUMS.numbers).optional(),
-        date_format: z.enum(STYLEGUIDE_ENUMS.date_format).optional(),
-        time_format: z.enum(STYLEGUIDE_ENUMS.time_format).optional(),
-        tense: z.string().optional(),
-        pov: z.enum(STYLEGUIDE_ENUMS.pov).optional(),
-        dialogue_tags: z.enum(STYLEGUIDE_ENUMS.dialogue_tags).optional(),
-        sentence_fragments: z.enum(STYLEGUIDE_ENUMS.sentence_fragments).optional(),
-        voice_notes: z.string().optional(),
-      }).strict().describe("Explicit config field changes to write at the selected scope."),
-    },
-    async ({ scope, project_id, updates }) => {
-      if (project_id !== undefined) {
-        const projectIdCheck = validateProjectId(project_id);
-        if (!projectIdCheck.ok) {
-          return errorResponse("INVALID_PROJECT_ID", projectIdCheck.reason, { project_id });
-        }
-      }
-
-      if (scope === "project_root" && !project_id) {
-        return errorResponse(
-          "PROJECT_ID_REQUIRED",
-          "project_id is required when scope=project_root."
-        );
-      }
-
-      if (!SYNC_DIR_WRITABLE) {
-        return errorResponse(
-          "SYNC_DIR_NOT_WRITABLE",
-          "Cannot update styleguide config because WRITING_SYNC_DIR is not writable in this runtime.",
-          { sync_dir: SYNC_DIR_ABS }
-        );
-      }
-
-      const updated = updateStyleguideConfig({
-        syncDir: SYNC_DIR,
-        scope,
-        projectId: project_id,
-        updates,
-      });
-      if (!updated.ok) {
-        return errorResponse(
-          updated.error.code,
-          updated.error.message,
-          updated.error.details
-        );
-      }
-
-      return jsonResponse({
-        ok: true,
-        scope: updated.scope,
-        project_id: updated.project_id,
-        file_path: path.resolve(updated.file_path),
-        config: updated.config,
-        changed_fields: updated.changed_fields,
-        noop: Boolean(updated.noop),
-        message: updated.message,
-        warnings: updated.warnings,
-      });
-    }
-  );
-
-  s.tool(
-    "preview_prose_styleguide_config_update",
-    "Preview how explicit updates would change an existing prose-styleguide.config.yaml without writing any files.",
-    {
-      scope: z.enum(["sync_root", "project_root"]).describe("Config scope to preview updates for."),
-      project_id: z.string().optional().describe("Project ID when previewing project_root config updates (e.g. 'the-lamb' or 'universe-1/book-1')."),
-      updates: z.object({
-        language: z.enum(STYLEGUIDE_ENUMS.language).optional(),
-        spelling: z.enum(STYLEGUIDE_ENUMS.spelling).optional(),
-        quotation_style: z.enum(STYLEGUIDE_ENUMS.quotation_style).optional(),
-        quotation_style_nested: z.enum(STYLEGUIDE_ENUMS.quotation_style_nested).optional(),
-        em_dash_spacing: z.enum(STYLEGUIDE_ENUMS.em_dash_spacing).optional(),
-        ellipsis_style: z.enum(STYLEGUIDE_ENUMS.ellipsis_style).optional(),
-        abbreviation_periods: z.enum(STYLEGUIDE_ENUMS.abbreviation_periods).optional(),
-        oxford_comma: z.enum(STYLEGUIDE_ENUMS.oxford_comma).optional(),
-        numbers: z.enum(STYLEGUIDE_ENUMS.numbers).optional(),
-        date_format: z.enum(STYLEGUIDE_ENUMS.date_format).optional(),
-        time_format: z.enum(STYLEGUIDE_ENUMS.time_format).optional(),
-        tense: z.string().optional(),
-        pov: z.enum(STYLEGUIDE_ENUMS.pov).optional(),
-        dialogue_tags: z.enum(STYLEGUIDE_ENUMS.dialogue_tags).optional(),
-        sentence_fragments: z.enum(STYLEGUIDE_ENUMS.sentence_fragments).optional(),
-        voice_notes: z.string().optional(),
-      }).strict().describe("Explicit config field changes to preview at the selected scope."),
-    },
-    async ({ scope, project_id, updates }) => {
-      if (project_id !== undefined) {
-        const projectIdCheck = validateProjectId(project_id);
-        if (!projectIdCheck.ok) {
-          return errorResponse("INVALID_PROJECT_ID", projectIdCheck.reason, { project_id });
-        }
-      }
-
-      if (scope === "project_root" && !project_id) {
-        return errorResponse(
-          "PROJECT_ID_REQUIRED",
-          "project_id is required when scope=project_root."
-        );
-      }
-
-      const preview = previewStyleguideConfigUpdate({
-        syncDir: SYNC_DIR,
-        scope,
-        projectId: project_id,
-        updates,
-      });
-      if (!preview.ok) {
-        return errorResponse(
-          preview.error.code,
-          preview.error.message,
-          preview.error.details
-        );
-      }
-
-      return jsonResponse({
-        ok: true,
-        scope: preview.scope,
-        project_id: preview.project_id,
-        file_path: path.resolve(preview.file_path),
-        current_config: preview.current_config,
-        next_config: preview.config,
-        changed_fields: preview.changed_fields,
-        noop: preview.changed_fields.length === 0,
-        message: preview.changed_fields.length === 0
-          ? "No changes detected for requested styleguide updates."
-          : "Preview generated.",
-        warnings: preview.warnings,
-      });
-    }
-  );
-
-  s.tool(
-    "check_prose_styleguide_drift",
-    "Detect styleguide drift by comparing declared config conventions against observed signals in scene prose.",
-    {
-      project_id: z.string().describe("Project ID to analyze (e.g. 'the-lamb' or 'universe-1/book-1')."),
-      scene_ids: z.array(z.string()).optional().describe("Optional scene_id allowlist to analyze."),
-      part: z.number().int().optional().describe("Optional part filter."),
-      chapter: z.number().int().optional().describe("Optional chapter filter."),
-      max_scenes: z.number().int().positive().optional().describe("Maximum number of scenes to analyze (default: 50)."),
-      min_agreement: z.number().min(0).max(1).optional().describe("Minimum agreement ratio for suggested updates (default: 0.6)."),
-      include_clean_scenes: z.boolean().optional().describe("If true, include scenes with no detected drift in scene_results."),
-    },
-    async ({
-      project_id,
-      scene_ids,
-      part,
-      chapter,
-      max_scenes = 50,
-      min_agreement = 0.6,
-      include_clean_scenes = false,
-    }) => {
-      const projectIdCheck = validateProjectId(project_id);
-      if (!projectIdCheck.ok) {
-        return errorResponse("INVALID_PROJECT_ID", projectIdCheck.reason, { project_id });
-      }
-
-      const resolved = resolveStyleguideConfig({
-        syncDir: SYNC_DIR,
-        projectId: project_id,
-      });
-      if (!resolved.ok) {
-        return errorResponse(
-          resolved.error.code,
-          resolved.error.message,
-          resolved.error.details
-        );
-      }
-      if (resolved.setup_required || !resolved.resolved_config) {
-        return errorResponse(
-          "STYLEGUIDE_CONFIG_REQUIRED",
-          "Cannot check prose styleguide drift before prose-styleguide.config.yaml is set up.",
-          {
-            project_id,
-            next_step: "Run setup_prose_styleguide_config or bootstrap_prose_styleguide_config.",
-          }
-        );
-      }
-
-      const targetResolution = resolveBatchTargetScenes(db, {
-        projectId: project_id,
-        sceneIds: scene_ids,
-        part,
-        chapter,
-        onlyStale: false,
-      });
-      if (!targetResolution.ok) {
-        return errorResponse(targetResolution.code, targetResolution.message, targetResolution.details);
-      }
-
-      const targetScenes = targetResolution.rows;
-      if (targetScenes.length > max_scenes) {
-        return errorResponse(
-          "VALIDATION_ERROR",
-          `Matched ${targetScenes.length} scenes, which exceeds max_scenes=${max_scenes}.`,
-          {
-            matched_scenes: targetScenes.length,
-            max_scenes,
-            project_id,
-            next_step: maxScenesNextStep(targetScenes.length),
-          }
-        );
-      }
-
-      const sceneAnalyses = [];
-      for (const scene of targetScenes) {
-        let prose;
-        try {
-          const raw = fs.readFileSync(scene.file_path, "utf8");
-          prose = matter(raw).content;
-        } catch {
-          sceneAnalyses.push({
-            scene_id: scene.scene_id,
-            observed: {},
-            drift: [{ field: "scene_file", declared: "readable", observed: "unreadable" }],
-          });
-          continue;
-        }
-
-        const analysis = analyzeSceneStyleguideDrift({
-          prose,
-          resolvedConfig: resolved.resolved_config,
-        });
-        sceneAnalyses.push({
-          scene_id: scene.scene_id,
-          observed: analysis.observed,
-          drift: analysis.drift,
-        });
-      }
-
-      const suggestedUpdates = suggestStyleguideUpdatesFromScenes({
-        sceneAnalyses,
-        resolvedConfig: resolved.resolved_config,
-        minAgreement: min_agreement,
-      });
-
-      const filteredScenes = include_clean_scenes
-        ? sceneAnalyses
-        : sceneAnalyses.filter((scene) => scene.drift.length > 0);
-
-      const driftByField = {};
-      for (const scene of sceneAnalyses) {
-        for (const entry of scene.drift) {
-          driftByField[entry.field] = (driftByField[entry.field] ?? 0) + 1;
-        }
-      }
-
-      return jsonResponse({
-        ok: true,
-        project_id,
-        checked_scenes: sceneAnalyses.length,
-        scenes_with_drift: sceneAnalyses.filter((scene) => scene.drift.length > 0).length,
-        drift_by_field: driftByField,
-        scene_results: filteredScenes,
-        suggested_updates: suggestedUpdates,
-      });
-    }
-  );
-
-  s.tool(
-    "setup_prose_styleguide_skill",
-    "Generate skills/prose-styleguide.md from the resolved prose styleguide config and universal craft rules.",
-    {
-      project_id: z.string().optional().describe("Optional project ID for scoped config resolution (e.g. 'the-lamb' or 'universe-1/book-1')."),
-      overwrite: z.boolean().optional().describe("If true, replaces an existing skills/prose-styleguide.md file."),
-    },
-    async ({ project_id, overwrite = false }) => {
-      if (project_id !== undefined) {
-        const projectIdCheck = validateProjectId(project_id);
-        if (!projectIdCheck.ok) {
-          return errorResponse("INVALID_PROJECT_ID", projectIdCheck.reason, { project_id });
-        }
-      }
-
-      if (!SYNC_DIR_WRITABLE) {
-        return errorResponse(
-          "SYNC_DIR_NOT_WRITABLE",
-          "Cannot write prose styleguide skill because WRITING_SYNC_DIR is not writable in this runtime.",
-          { sync_dir: SYNC_DIR_ABS }
-        );
-      }
-
-      const resolved = resolveStyleguideConfig({
-        syncDir: SYNC_DIR,
-        projectId: project_id,
-      });
-      if (!resolved.ok) {
-        return errorResponse(
-          resolved.error.code,
-          resolved.error.message,
-          resolved.error.details
-        );
-      }
-      if (resolved.setup_required || !resolved.resolved_config) {
-        return errorResponse(
-          "STYLEGUIDE_CONFIG_REQUIRED",
-          "Cannot generate prose-styleguide.md before prose-styleguide.config.yaml is set up.",
-          {
-            project_id: project_id ?? null,
-            next_step: "Run setup_prose_styleguide_config or bootstrap_prose_styleguide_config first.",
-          }
-        );
-      }
-
-      const skillPath = path.join(SYNC_DIR, PROSE_STYLEGUIDE_SKILL_DIRNAME, PROSE_STYLEGUIDE_SKILL_BASENAME);
-      if (!isPathCandidateInsideSyncDir(skillPath)) {
-        return errorResponse(
-          "INVALID_SKILL_PATH",
-          "Resolved prose styleguide skill path must be inside WRITING_SYNC_DIR.",
-          { target_path: path.resolve(skillPath), sync_dir: SYNC_DIR_ABS }
-        );
-      }
-
-      if (fs.existsSync(skillPath) && !overwrite) {
-        return errorResponse(
-          "STYLEGUIDE_SKILL_EXISTS",
-          "skills/prose-styleguide.md already exists. Set overwrite=true to replace it.",
-          { target_path: path.resolve(skillPath) }
-        );
-      }
-
-      const generated = buildProseStyleguideSkill({
-        resolvedConfig: resolved.resolved_config,
-        sources: resolved.sources,
-        projectId: project_id ?? null,
-      });
-      if (!generated.ok) {
-        return errorResponse(generated.error.code, generated.error.message);
-      }
-
-      fs.mkdirSync(path.dirname(skillPath), { recursive: true });
-      fs.writeFileSync(skillPath, generated.markdown, "utf8");
-
-      return jsonResponse({
-        ok: true,
-        file_path: path.resolve(skillPath),
-        project_id: project_id ?? null,
-        injected_rules: generated.injected_rules,
-        source_count: resolved.sources.length,
-      });
-    }
-  );
-
-  // ---- PHASE 3: Prose Editing (git-backed) --------------------------------
-
-  // ---- propose_edit --------------------------------------------------------
-  s.tool(
-    "propose_edit",
-    "Generate a proposed revision for a scene. Returns a proposal_id and a diff preview. Nothing is written yet — you must call commit_edit to apply the change. This tool requires git to be available.",
-    {
-      scene_id: z.string().describe("The scene_id to revise (e.g. 'sc-011-sebastian')."),
-      instruction: z.string().describe("A brief instruction for the edit (e.g. 'Tighten the opening paragraph'). Used in the git commit message."),
-      revised_prose: z.string().describe("The complete revised prose text for the scene."),
-    },
-    async ({ scene_id, instruction, revised_prose }) => {
-      if (!GIT_ENABLED) {
-        return errorResponse("GIT_UNAVAILABLE", "Git is not available — prose editing is not supported. Ensure git is installed and the sync directory is writable.");
-      }
-
-      const scene = db.prepare(`SELECT file_path FROM scenes WHERE scene_id = ?`).get(scene_id);
-      if (!scene) {
-        return errorResponse("NOT_FOUND", `Scene '${scene_id}' not found. Hint: call find_scenes to get valid scene IDs.`);
-      }
-
-      try {
-        // Read current prose
-        const raw = fs.readFileSync(scene.file_path, "utf8");
-        const { data: metadata, content: currentProse } = matter(raw);
-
-        // Generate a simple diff representation
-        const currentLines = currentProse.trim().split("\n");
-        const revisedLines = revised_prose.trim().split("\n");
-        const diffLines = [];
-        const maxLines = Math.max(currentLines.length, revisedLines.length);
-
-        // Simple line-by-line diff
-        for (let i = 0; i < Math.min(3, maxLines); i++) {
-          const curr = currentLines[i] || "(removed)";
-          const rev = revisedLines[i] || "(removed)";
-          if (curr !== rev) {
-            diffLines.push(`- ${curr.substring(0, 80)}`);
-            diffLines.push(`+ ${rev.substring(0, 80)}`);
-          }
-        }
-        if (maxLines > 3) {
-          diffLines.push(`... (${maxLines - 3} more lines)`);
-        }
-
-        const proposalId = generateProposalId();
-        pendingProposals.set(proposalId, {
-          scene_id,
-          scene_file_path: scene.file_path,
-          instruction,
-          revised_prose,
-          original_prose: currentProse,
-          metadata,
-          created_at: new Date().toISOString(),
-        });
-
-        const summary = {
-          proposal_id: proposalId,
-          scene_id,
-          instruction,
-          diff_preview: diffLines.join("\n"),
-          note: "Review the diff above. Call commit_edit with this proposal_id to apply the change.",
-        };
-
-        return jsonResponse(summary);
-      } catch (err) {
-        if (err.code === "ENOENT") {
-          return errorResponse("STALE_PATH", `Prose file for scene '${scene_id}' not found at indexed path.`, { indexed_path: scene.file_path });
-        }
-        return errorResponse("IO_ERROR", `Failed to read scene file: ${err.message}`);
-      }
-    }
-  );
-
-  // ---- commit_edit ---------------------------------------------------------
-  s.tool(
-    "commit_edit",
-    "Apply a proposed edit and commit it to git. First creates a pre-edit snapshot, then writes the revised prose and metadata back to disk. The scene metadata stale flag is cleared.",
-    {
-      scene_id: z.string().describe("The scene_id being revised."),
-      proposal_id: z.string().describe("The proposal_id returned by propose_edit."),
-    },
-    async ({ scene_id, proposal_id }) => {
-      if (!GIT_ENABLED) {
-        return errorResponse("GIT_UNAVAILABLE", "Git is not available — prose editing is not supported.");
-      }
-
-      const proposal = pendingProposals.get(proposal_id);
-      if (!proposal) {
-        return errorResponse("PROPOSAL_NOT_FOUND", `Proposal '${proposal_id}' not found or has expired. Hint: call propose_edit again to create a fresh proposal_id.`);
-      }
-
-      if (proposal.scene_id !== scene_id) {
-        return errorResponse("INVALID_EDIT", `Proposal '${proposal_id}' is for scene '${proposal.scene_id}', not '${scene_id}'.`);
-      }
-
-      try {
-        const proseWriteDiagnostics = getFileWriteDiagnostics(proposal.scene_file_path);
-        if (proseWriteDiagnostics.stat_error_code === "EACCES" || proseWriteDiagnostics.stat_error_code === "EPERM") {
-          return errorResponse(
-            "PROSE_FILE_NOT_WRITABLE",
-            "Scene prose file cannot be accessed by the current runtime user.",
-            {
-              indexed_path: proposal.scene_file_path,
-              prose_write_diagnostics: proseWriteDiagnostics,
-            }
-          );
-        }
-
-        if (proseWriteDiagnostics.stat_error_code && proseWriteDiagnostics.stat_error_code !== "ENOENT" && proseWriteDiagnostics.stat_error_code !== "ENOTDIR") {
-          return errorResponse(
-            "IO_ERROR",
-            "Failed to inspect scene prose path before writing.",
-            {
-              indexed_path: proposal.scene_file_path,
-              prose_write_diagnostics: proseWriteDiagnostics,
-            }
-          );
-        }
-
-        if (!proseWriteDiagnostics.exists) {
-          return errorResponse("STALE_PATH", "Prose file not found at indexed path.", {
-            indexed_path: proposal.scene_file_path,
-            prose_write_diagnostics: proseWriteDiagnostics,
-          });
-        }
-
-        if (!proseWriteDiagnostics.is_file) {
-          return errorResponse("INVALID_PROSE_PATH", "Indexed prose path is not a regular file.", {
-            indexed_path: proposal.scene_file_path,
-            prose_write_diagnostics: proseWriteDiagnostics,
-          });
-        }
-
-        if (!proseWriteDiagnostics.writable) {
-          return errorResponse(
-            "PROSE_FILE_NOT_WRITABLE",
-            "Scene prose file is not writable by the current runtime user.",
-            {
-              indexed_path: proposal.scene_file_path,
-              prose_write_diagnostics: proseWriteDiagnostics,
-            }
-          );
-        }
-
-        // Reconstruct file content, preserving frontmatter only if the original had it
-        const hasFrontmatter = proposal.metadata && Object.keys(proposal.metadata).length > 0;
-        const content = hasFrontmatter
-          ? `---\n${yaml.dump(proposal.metadata)}---\n\n${proposal.revised_prose}\n`
-          : `${proposal.revised_prose}\n`;
-
-        // Create pre-edit snapshot (commits current state before overwriting)
-        const snapshot = createSnapshot(SYNC_DIR, proposal.scene_file_path, scene_id, proposal.instruction);
-
-        // Write the revised prose to disk
-        fs.writeFileSync(proposal.scene_file_path, content, "utf8");
-
-        // Re-index using canonical metadata (sidecar takes precedence over inline frontmatter)
-        const { meta: canonicalMeta } = readMeta(proposal.scene_file_path, SYNC_DIR, { writable: false });
-        const { content: newProse } = matter(content);
-        indexSceneFile(db, SYNC_DIR, proposal.scene_file_path, canonicalMeta, newProse);
-
-        // Clean up the proposal
-        pendingProposals.delete(proposal_id);
-
-        const result = {
-          ok: true,
-          scene_id,
-          proposal_id,
-          snapshot_commit: snapshot.commit_hash,
-          message: `Committed edit for scene '${scene_id}'${snapshot.commit_hash ? ` (snapshot: ${snapshot.commit_hash.substring(0, 7)})` : " (no changes to snapshot)"}`,
-        };
-
-        return jsonResponse(result);
-      } catch (err) {
-        if (err.code === "ENOENT") {
-          return errorResponse("STALE_PATH", `Prose file not found at indexed path.`, { indexed_path: proposal.scene_file_path });
-        }
-        return errorResponse("IO_ERROR", `Failed to commit edit: ${err.message}`);
-      }
-    }
-  );
-
-  // ---- discard_edit --------------------------------------------------------
-  s.tool(
-    "discard_edit",
-    "Discard a pending proposal without applying it. The proposal is deleted and the prose remains unchanged.",
-    {
-      proposal_id: z.string().describe("The proposal_id to discard (from propose_edit)."),
-    },
-    async ({ proposal_id }) => {
-      const proposal = pendingProposals.get(proposal_id);
-      if (!proposal) {
-        return errorResponse("PROPOSAL_NOT_FOUND", `Proposal '${proposal_id}' not found or has already been discarded.`);
-      }
-
-      pendingProposals.delete(proposal_id);
-      return jsonResponse({
-        ok: true,
-        proposal_id,
-        message: `Discarded proposal '${proposal_id}' for scene '${proposal.scene_id}'.`,
-      });
-    }
-  );
-
-  // ---- snapshot_scene -------------------------------------------------------
-  s.tool(
-    "snapshot_scene",
-    "Manually create a git commit (snapshot) for the current state of a scene. Use this to mark important editing checkpoints outside of the propose/commit workflow.",
-    {
-      scene_id: z.string().describe("The scene_id to snapshot."),
-      project_id: z.string().describe("Project the scene belongs to."),
-      reason: z.string().describe("A brief reason for the snapshot (e.g. 'Character arc milestone reached')."),
-    },
-    async ({ scene_id, project_id, reason }) => {
-      if (!GIT_ENABLED) {
-        return errorResponse("GIT_UNAVAILABLE", "Git is not available — snapshots cannot be created.");
-      }
-
-      const scene = db.prepare(`SELECT file_path FROM scenes WHERE scene_id = ? AND project_id = ?`)
-        .get(scene_id, project_id);
-      if (!scene) {
-        return errorResponse("NOT_FOUND", `Scene '${scene_id}' not found in project '${project_id}'.`);
-      }
-
-      try {
-        const snapshot = createSnapshot(SYNC_DIR, scene.file_path, scene_id, reason);
-        if (!snapshot.commit_hash) {
-          return jsonResponse({
-            ok: true,
-            scene_id,
-            reason,
-            message: "No changes to snapshot.",
-          });
-        }
-
-        return jsonResponse({
-          ok: true,
-          scene_id,
-          reason,
-          commit_hash: snapshot.commit_hash,
-          message: `Created snapshot for scene '${scene_id}': ${reason}`,
-        });
-      } catch (err) {
-        if (err.code === "ENOENT") {
-          return errorResponse("STALE_PATH", `Prose file not found at indexed path.`, { indexed_path: scene.file_path });
-        }
-        return errorResponse("IO_ERROR", `Failed to create snapshot: ${err.message}`);
-      }
-    }
-  );
-
-  // ---- list_snapshots -------------------------------------------------------
-  s.tool(
-    "list_snapshots",
-    "List git commit history for a scene, with timestamps and commit messages. Use this to find commit hashes for get_scene_prose historical retrieval.",
-    {
-      scene_id: z.string().describe("The scene_id to list snapshots for."),
-    },
-    async ({ scene_id }) => {
-      if (!GIT_ENABLED) {
-        return errorResponse("GIT_UNAVAILABLE", "Git is not available — snapshots cannot be retrieved.");
-      }
-
-      const scene = db.prepare(`SELECT file_path FROM scenes WHERE scene_id = ?`).get(scene_id);
-      if (!scene) {
-        return errorResponse("NOT_FOUND", `Scene '${scene_id}' not found.`);
-      }
-
-      try {
-        const snapshots = listSnapshots(SYNC_DIR, scene.file_path);
-        if (!snapshots || snapshots.length === 0) {
-          return errorResponse("NO_RESULTS", `No snapshots found for scene '${scene_id}'. Try editing and committing the scene first.`);
-        }
-
-        return jsonResponse({
-          scene_id,
-          snapshots: snapshots.map(s => ({
-            commit_hash: s.commit_hash,
-            short_hash: s.commit_hash.substring(0, 7),
-            timestamp: s.timestamp,
-            message: s.message,
-          })),
-          note: "Use the commit_hash values with get_scene_prose(scene_id, commit) to retrieve a past version.",
-        });
-      } catch (err) {
-        return errorResponse("IO_ERROR", `Failed to list snapshots: ${err.message}`);
-      }
-    }
-  );
-
   return s;
 }