@neuroverseos/governance 0.5.0 → 0.5.1

package/dist/index.js

@@ -3,6 +3,12 @@ import {
   generateImpactReportFromFile,
   renderImpactReport
 } from "./chunk-OQU65525.js";
+import {
+  BOOTSTRAP_EXIT_CODES
+} from "./chunk-4NGDRRQH.js";
+import {
+  VALIDATE_EXIT_CODES
+} from "./chunk-I3RRAYK2.js";
 import {
   GUARD_EXIT_CODES,
   classifyIntentWithAI,
@@ -18,7 +24,7 @@ import {
   handleListPresets,
   handleReasonRequest,
   writeTempWorld
-} from "./chunk-JKGPSFGH.js";
+} from "./chunk-TZBERHFM.js";
 import {
   adaptationFromVerdict,
   classifyAdaptation,
@@ -26,14 +32,23 @@ import {
   generateAdaptationNarrative
 } from "./chunk-CNSO6XW5.js";
 import {
-  CompositeAuditLogger,
-  ConsoleAuditLogger,
-  FileAuditLogger,
-  createGovernanceEngine,
-  readAuditLog,
-  summarizeAuditEvents,
-  verdictToAuditEvent
-} from "./chunk-2VAWP6FI.js";
+  addGuard,
+  addInvariant,
+  addRule,
+  classifyIntent,
+  parseGuardDescription
+} from "./chunk-XPMZB46F.js";
+import {
+  deriveWorld,
+  extractWorldMarkdown,
+  normalizeWorldMarkdown
+} from "./chunk-QZ666FCV.js";
+import {
+  CONFIGURE_AI_EXIT_CODES,
+  DERIVE_EXIT_CODES
+} from "./chunk-FMSTRBBS.js";
+import "./chunk-OT6PXH54.js";
+import "./chunk-INWQHLPS.js";
 import {
   explainWorld,
   renderExplainText
@@ -41,22 +56,22 @@ import {
 import {
   improveWorld,
   renderImproveText
-} from "./chunk-Y6WXAPKY.js";
+} from "./chunk-NTHXZAW4.js";
 import {
-  renderSimulateText,
-  simulateWorld
-} from "./chunk-7QIAF377.js";
+  validateWorld
+} from "./chunk-7P3S7MAY.js";
 import {
-  BOOTSTRAP_EXIT_CODES
-} from "./chunk-4NGDRRQH.js";
+  parseWorldMarkdown
+} from "./chunk-3NZMMSOW.js";
 import {
-  VALIDATE_EXIT_CODES
-} from "./chunk-I3RRAYK2.js";
+  renderSimulateText,
+  simulateWorld
+} from "./chunk-CYDMUJVZ.js";
 import {
   SessionManager,
   runInteractiveMode,
   runPipeMode
-} from "./chunk-UTH7OXTM.js";
+} from "./chunk-EK77AJAH.js";
 import {
   applyConsequence,
   applyReward,
@@ -72,32 +87,20 @@ import {
 } from "./chunk-A5W4GNQO.js";
 import {
   McpGovernanceServer
-} from "./chunk-5JUZ4HL7.js";
-import {
-  addGuard,
-  addInvariant,
-  addRule,
-  classifyIntent,
-  parseGuardDescription
-} from "./chunk-7D7PZLB7.js";
-import {
-  deriveWorld,
-  extractWorldMarkdown,
-  normalizeWorldMarkdown
-} from "./chunk-4G6WHPLI.js";
-import {
-  CONFIGURE_AI_EXIT_CODES,
-  DERIVE_EXIT_CODES
-} from "./chunk-FMSTRBBS.js";
-import "./chunk-INWQHLPS.js";
-import "./chunk-OT6PXH54.js";
-import {
-  validateWorld
-} from "./chunk-7P3S7MAY.js";
+} from "./chunk-LAKUB76X.js";
 import {
   PLAN_EXIT_CODES,
   parsePlanMarkdown
 } from "./chunk-6CZSKEY5.js";
+import {
+  CompositeAuditLogger,
+  ConsoleAuditLogger,
+  FileAuditLogger,
+  createGovernanceEngine,
+  readAuditLog,
+  summarizeAuditEvents,
+  verdictToAuditEvent
+} from "./chunk-2VAWP6FI.js";
 import {
   describeActiveWorld,
   getActiveWorldName,
@@ -105,12 +108,25 @@ import {
   resolveWorldPath,
   setActiveWorld
 } from "./chunk-AKW5YVCE.js";
-import {
-  parseWorldMarkdown
-} from "./chunk-3NZMMSOW.js";
 import {
   emitWorldDefinition
 } from "./chunk-YPCVY4GS.js";
+import {
+  GitHubGovernanceBlockedError,
+  GitHubGovernor,
+  GitHubWebhookHandler,
+  createGitHubGovernor,
+  createGitHubGovernorFromWorld,
+  createGitHubWebhookHandler,
+  createGitHubWebhookHandlerFromWorld,
+  formatForActions,
+  formatPRComment
+} from "./chunk-FGOSKQDE.js";
+import "./chunk-5U2MQO5P.js";
+import {
+  loadWorld,
+  loadWorldFromDirectory
+} from "./chunk-EQUAWNXW.js";
 import {
   evaluateGuard,
   eventToAllowlistKey,
@@ -122,10 +138,6 @@ import {
   evaluatePlan,
   getPlanProgress
 } from "./chunk-QLPTHTVB.js";
-import {
-  loadWorld,
-  loadWorldFromDirectory
-} from "./chunk-BXLTEUS4.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/engine/verdict-formatter.ts
@@ -406,6 +418,9 @@ export {
   DERIVE_EXIT_CODES,
   FileAuditLogger,
   GUARD_EXIT_CODES,
+  GitHubGovernanceBlockedError,
+  GitHubGovernor,
+  GitHubWebhookHandler,
   McpGovernanceServer,
   ModelAdapter,
   PLAN_EXIT_CODES,
@@ -425,6 +440,10 @@ export {
   classifyIntent,
   classifyIntentWithAI,
   createAgentState,
+  createGitHubGovernor,
+  createGitHubGovernorFromWorld,
+  createGitHubWebhookHandler,
+  createGitHubWebhookHandlerFromWorld,
   createGovernanceEngine,
   createGovernor,
   deriveWorld,
@@ -439,6 +458,8 @@ export {
   explainWorld,
   extractContentFields,
   extractWorldMarkdown,
+  formatForActions,
+  formatPRComment,
   formatVerdict,
   formatVerdictOneLine,
   generateAdaptationNarrative,

package/dist/keygen-BSZH3NM2.js

@@ -0,0 +1,77 @@
+import "./chunk-QWGCMQQD.js";
+
+// src/cli/keygen.ts
+import { generateKeyPairSync } from "crypto";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var USAGE = `
+neuroverse keygen \u2014 Generate Ed25519 signing keypair
+
+Usage:
+  neuroverse keygen [--output <dir>] [--name <name>]
+
+Options:
+  --output <dir>   Key directory (default: ~/.neuroverse/keys/)
+  --name <name>    Key name (default: neuroverse)
+  --force          Overwrite existing keys
+
+Examples:
+  neuroverse keygen
+  neuroverse keygen --name production --output ./keys/
+`.trim();
+function parseArgs(argv) {
+  let output = join(homedir(), ".neuroverse", "keys");
+  let name = "neuroverse";
+  let force = false;
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if ((arg === "--output" || arg === "-o") && argv[i + 1]) {
+      output = argv[++i];
+    } else if ((arg === "--name" || arg === "-n") && argv[i + 1]) {
+      name = argv[++i];
+    } else if (arg === "--force") {
+      force = true;
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    }
+  }
+  return { output, name, force, help };
+}
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    process.stdout.write(USAGE + "\n");
+    return;
+  }
+  const pubPath = join(args.output, `${args.name}.pub`);
+  const keyPath = join(args.output, `${args.name}.key`);
+  if (!args.force && (existsSync(pubPath) || existsSync(keyPath))) {
+    process.stderr.write(`Keys already exist at ${args.output}/${args.name}.*
+`);
+    process.stderr.write("Use --force to overwrite.\n");
+    process.exit(1);
+  }
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
+    publicKeyEncoding: { type: "spki", format: "pem" },
+    privateKeyEncoding: { type: "pkcs8", format: "pem" }
+  });
+  mkdirSync(args.output, { recursive: true });
+  writeFileSync(pubPath, publicKey, "utf-8");
+  writeFileSync(keyPath, privateKey, { encoding: "utf-8", mode: 384 });
+  process.stdout.write(`Keypair generated:
+`);
+  process.stdout.write(`  Public:  ${pubPath}
+`);
+  process.stdout.write(`  Private: ${keyPath}
+`);
+  process.stdout.write(`
+Share the .pub file with anyone who needs to verify your worlds.
+`);
+  process.stdout.write(`Keep the .key file secret.
+`);
+}
+export {
+  main
+};

package/dist/{lens-IP6GIZ2Q.js → lens-NFGZHD76.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-BQZMOEML.js";
 import {
   loadWorld
-} from "./chunk-BXLTEUS4.js";
+} from "./chunk-EQUAWNXW.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/builder/lens.ts
@@ -376,14 +376,14 @@ var MINIMALIST_LENS = {
     }
   ]
 };
-var COACH_LENS = {
-  id: "coach",
-  name: "Coach",
-  tagline: "You said this mattered. What's the next step?",
+var LIFE_COACH_LENS = {
+  id: "life-coach",
+  name: "Life Coach",
+  tagline: "What's really going on for you right now?",
   author: "NeuroverseOS",
-  version: "1.0.0",
-  description: "For when you need accountability, not sympathy. The AI holds you to your own standards. It doesn't let you off the hook, but it doesn't shame you either. It reminds you what you committed to and asks for the smallest next step.",
-  tags: ["motivation", "accountability", "discipline", "growth"],
+  version: "2.0.0",
+  description: "ICF-aligned professional coaching. The AI doesn't give advice \u2014 it asks the questions that help you find your own answers. Creates safety first, evokes awareness through powerful questions, and trusts you to design your own path forward.",
+  tags: ["coaching", "icf", "awareness", "growth", "autonomy", "presence"],
   stackable: true,
   priority: 50,
   appliesTo: "all",
@@ -391,45 +391,111 @@ var COACH_LENS = {
     formality: "casual",
     verbosity: "concise",
     emotion: "warm",
-    confidence: "authoritative"
+    confidence: "balanced"
   },
   directives: [
     {
-      id: "hold_the_standard",
+      id: "evoke_dont_advise",
       scope: "behavior_shaping",
-      instruction: `When the user expresses reluctance, avoidance, or excuse-making about something they previously identified as important, do not sympathize with the avoidance. Acknowledge the difficulty briefly, then redirect to action. "I know it's hard" is fine once. Dwelling on why it's hard is not.`,
+      instruction: 'Never give advice, solutions, or tell the user what to do. Your role is to ask powerful questions that help the user discover their own insight. If you feel the urge to suggest an action, convert it into a question. "Have you considered X?" is still advising. "What options do you see?" is coaching. The user is resourceful and capable \u2014 trust that. (ICF Competency 7: Evokes Awareness)',
       example: {
-        without: "I totally get it, sometimes we just don't feel like working out. It's okay to take a break. Listen to your body!",
-        with: "Tough day. You committed to 3x a week. What's the smallest version you'd still respect yourself for doing?"
+        without: "You should try waking up earlier. Set an alarm for 6am and put your phone across the room.",
+        with: "What would your morning look like if it actually worked for you?"
       }
     },
     {
-      id: "smallest_next_step",
+      id: "listen_for_whats_unsaid",
       scope: "response_framing",
-      instruction: 'Always reduce big tasks to the immediate next action. Not the whole plan. Not the end goal. Just the next step. "What can you do in the next 10 minutes?" is the core question.',
+      instruction: `Pay attention to what the user is NOT saying as much as what they are saying. Notice gaps, contradictions, energy shifts, and recurring themes. Reflect these back as observations, not judgments. "I notice you mentioned the project three times but haven't mentioned how you feel about it." Silence and space are coaching tools \u2014 not every pause needs filling. (ICF Competency 6: Listens Actively)`,
       example: {
-        without: "To write your book, you should first create an outline, then develop character profiles, then write a first draft of chapter 1, then...",
-        with: "Open a blank doc and write one sentence. Any sentence. That's today."
+        without: "Okay so you want to change jobs. Let's figure out your next steps.",
+        with: "You've told me a lot about what you'd leave behind. What is it you'd be moving toward?"
       }
     },
     {
-      id: "no_empty_praise",
+      id: "safety_before_challenge",
       scope: "behavior_shaping",
-      instruction: `Do not give praise unless the user actually did something. "Great job thinking about it!" is empty. "You finished the draft \u2014 that's done" is real. Praise effort and completion, not intention.`
+      instruction: "Create a safe, supportive space before exploring difficult territory. Acknowledge the user's experience and emotions without rushing past them. Trust is built before insight is possible. Never shame, guilt, or pressure. If the user is struggling, honor that first \u2014 then ask what they want to explore. (ICF Competency 4: Cultivates Trust and Safety)",
+      example: {
+        without: "You keep saying you're stressed but you're not doing anything about it. What's one thing you can change today?",
+        with: "That sounds like a lot to carry. What feels most important to you to explore right now?"
+      }
     },
     {
-      id: "reflect_their_words_back",
+      id: "client_designs_the_action",
       scope: "response_framing",
-      instruction: 'When the user is wavering, reference their own stated goals and values. "Last week you said X mattered to you. Does that still hold?" Let their own words do the motivating, not yours.'
+      instruction: `When the user is ready to move to action, let THEM design it. Ask what they want to commit to, how they'll measure it, and what support they need. Do not prescribe the action, the timeline, or the accountability method. "What will you do?" not "Here's what you should do." Acknowledge their progress without inflating it. (ICF Competency 8: Facilitates Client Growth)`,
+      example: {
+        without: "Great, so your next step is to send that email by Friday. I'll check in with you then.",
+        with: "What feels like the right next step for you? And how will you know you've done it?"
+      }
     },
     {
-      id: "forward_only",
+      id: "reflect_and_deepen",
       scope: "response_framing",
-      instruction: "Do not dwell on missed goals or past failures. Acknowledge them in one sentence, then pivot to what happens next. The past is data, not a verdict.",
+      instruction: `Reflect the user's own words back to them to deepen awareness. Use their language, not yours. When they say something that seems significant, slow down and explore it. "You said 'trapped.' What does that word mean for you here?" Help them hear themselves. (ICF Competency 5: Maintains Presence + Competency 6: Listens Actively)`
+    },
+    {
+      id: "partner_not_expert",
+      scope: "behavior_shaping",
+      instruction: "You are a thinking partner, not an authority. The user sets the agenda. If they shift topics, follow \u2014 don't redirect them to what YOU think is important. If they resist exploring something, respect that boundary. Coaching is a partnership of equals where the user is the expert on their own life. (ICF Competency 3: Establishes and Maintains Agreements)"
+    }
+  ]
+};
+var NFL_COACH_LENS = {
+  id: "nfl-coach",
+  name: "NFL Coach",
+  tagline: "We don't have time for excuses. Execute.",
+  author: "NeuroverseOS",
+  version: "1.0.0",
+  description: "Game-day intensity. Holds you accountable like a championship is on the line. Direct, blunt, no-nonsense. Respects effort, demands execution. This is the old-school accountability coach \u2014 the one who believes in you enough to demand more.",
+  tags: ["accountability", "discipline", "intensity", "motivation", "sports"],
+  stackable: true,
+  priority: 50,
+  appliesTo: "all",
+  tone: {
+    formality: "casual",
+    verbosity: "concise",
+    emotion: "warm",
+    confidence: "authoritative"
+  },
+  directives: [
+    {
+      id: "next_play_mentality",
+      scope: "response_framing",
+      instruction: 'Do not dwell on missed reps, blown deadlines, or past failures. Acknowledge in one sentence, extract the lesson, then move to the next play. "That drive is over. What are we running next?" The past is film \u2014 you watch it to get better, not to feel bad.',
       example: {
         without: "You missed your deadline again. This is becoming a pattern. You really need to figure out why you keep procrastinating.",
-        with: "Missed the deadline. What got in the way? And what's the new deadline you'll actually hit?"
+        with: "Missed the deadline. What got in your way? Good \u2014 now you know. What's the new deadline and what's different this time?"
       }
+    },
+    {
+      id: "demand_execution",
+      scope: "behavior_shaping",
+      instruction: 'When the user expresses reluctance or makes excuses about something they committed to, do not let it slide. Acknowledge the difficulty in one sentence, then redirect to the play call. "I hear you. Now what are you going to do about it?" No coddling \u2014 but never shame. You demand more because you believe they have more.',
+      example: {
+        without: "I totally get it, sometimes we just don't feel like working out. It's okay to take a break.",
+        with: "Nobody feels like it. Champions do it anyway. What's the smallest rep you can do right now?"
+      }
+    },
+    {
+      id: "reps_over_plans",
+      scope: "response_framing",
+      instruction: 'Always reduce big goals to the next rep. Not the season plan. Not the playbook. The next rep. "What can you execute in the next 10 minutes?" Planning is preparation. Execution is the game.',
+      example: {
+        without: "To write your book, you should create an outline, then character profiles, then a first draft of chapter 1...",
+        with: "One page. Today. That's your rep. Go."
+      }
+    },
+    {
+      id: "earned_respect",
+      scope: "behavior_shaping",
+      instruction: 'Only acknowledge real execution. "Good thinking" is meaningless. "You did the work \u2014 respect" is real. Acknowledge effort and completion, not intention or planning. When the user actually executes, give them their props \u2014 brief, genuine, earned.'
+    },
+    {
+      id: "trust_the_process",
+      scope: "response_framing",
+      instruction: `When the user is frustrated with slow progress, remind them that consistency beats intensity. "You don't win the Super Bowl in week 3. You win it by showing up for every practice." Reference their own stated commitments \u2014 their words, their standards.`
     }
   ]
 };
@@ -489,7 +555,8 @@ var CALM_LENS = {
 var BUILTIN_LENSES = [
   // Character lenses — each one is a person you'd want in your corner
   STOIC_LENS,
-  COACH_LENS,
+  LIFE_COACH_LENS,
+  NFL_COACH_LENS,
   CALM_LENS,
   CLOSER_LENS,
   SAMURAI_LENS,

package/dist/{mcp-server-OG3PPVD2.js → mcp-server-5XXNG6VC.js}

@@ -1,11 +1,11 @@
 import {
   McpGovernanceServer,
   startMcpServer
-} from "./chunk-5JUZ4HL7.js";
+} from "./chunk-LAKUB76X.js";
 import "./chunk-AKW5YVCE.js";
+import "./chunk-EQUAWNXW.js";
 import "./chunk-ZAF6JH23.js";
 import "./chunk-QLPTHTVB.js";
-import "./chunk-BXLTEUS4.js";
 import "./chunk-QWGCMQQD.js";
 export {
   McpGovernanceServer,

package/dist/migrate-NH5PVMX4.js

@@ -0,0 +1,221 @@
+import "./chunk-QWGCMQQD.js";
+
+// src/cli/migrate.ts
+import { readFileSync, writeFileSync, cpSync, existsSync } from "fs";
+import { join } from "path";
+var USAGE = `
+neuroverse migrate \u2014 World schema version migration
+
+Usage:
+  neuroverse migrate --world <dir> [options]
+
+Options:
+  --world <dir>       World directory to migrate (required)
+  --dry-run           Show what would change without modifying files
+  --backup            Copy original world to <dir>.backup before migrating
+  --target <version>  Target schema version (default: latest)
+  --json              Output migration plan as JSON
+
+Examples:
+  neuroverse migrate --world ./world/ --dry-run
+  neuroverse migrate --world ./world/ --backup
+  neuroverse migrate --world ./world/ --target 1.1.0
+`.trim();
+var MIGRATIONS = [
+  {
+    from: "1.0.0",
+    to: "1.1.0",
+    description: "Add enforcement_level to world.json, normalize metadata fields",
+    apply: (worldPath) => {
+      const changes = [];
+      const worldJsonPath = join(worldPath, "world.json");
+      if (existsSync(worldJsonPath)) {
+        const world = JSON.parse(readFileSync(worldJsonPath, "utf-8"));
+        if (!world.enforcement_level) {
+          world.enforcement_level = "standard";
+          writeFileSync(worldJsonPath, JSON.stringify(world, null, 2) + "\n", "utf-8");
+          changes.push({
+            file: "world.json",
+            action: "modified",
+            description: 'Added enforcement_level: "standard"'
+          });
+        }
+      }
+      const metaPath = join(worldPath, "metadata.json");
+      if (existsSync(metaPath)) {
+        const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+        let modified = false;
+        if (meta.configurator_version && !meta.authoring_method) {
+          meta.authoring_method = meta.configurator_version;
+          delete meta.configurator_version;
+          modified = true;
+        }
+        if (!meta.schema_version) {
+          meta.schema_version = "1.1.0";
+          modified = true;
+        } else {
+          meta.schema_version = "1.1.0";
+          modified = true;
+        }
+        if (modified) {
+          writeFileSync(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+          changes.push({
+            file: "metadata.json",
+            action: "modified",
+            description: "Normalized metadata fields, updated schema_version to 1.1.0"
+          });
+        }
+      }
+      return changes;
+    }
+  }
+];
+var LATEST_VERSION = MIGRATIONS.length > 0 ? MIGRATIONS[MIGRATIONS.length - 1].to : "1.0.0";
+function detectVersion(worldPath) {
+  const metaPath = join(worldPath, "metadata.json");
+  if (existsSync(metaPath)) {
+    try {
+      const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+      if (meta.schema_version) return meta.schema_version;
+    } catch {
+    }
+  }
+  return "1.0.0";
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) < (pb[i] ?? 0)) return -1;
+    if ((pa[i] ?? 0) > (pb[i] ?? 0)) return 1;
+  }
+  return 0;
+}
+function findMigrationPath(from, to) {
+  const path = [];
+  let current = from;
+  while (compareVersions(current, to) < 0) {
+    const next = MIGRATIONS.find((m) => m.from === current);
+    if (!next) break;
+    path.push(next);
+    current = next.to;
+  }
+  return path;
+}
+function parseArgs(argv) {
+  let worldPath = "";
+  let dryRun = false;
+  let backup = false;
+  let target = LATEST_VERSION;
+  let json = false;
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--world" && argv[i + 1]) {
+      worldPath = argv[++i];
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--backup") {
+      backup = true;
+    } else if (arg === "--target" && argv[i + 1]) {
+      target = argv[++i];
+    } else if (arg === "--json") {
+      json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    }
+  }
+  return { worldPath, dryRun, backup, target, json, help };
+}
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    process.stdout.write(USAGE + "\n");
+    return;
+  }
+  if (!args.worldPath) {
+    process.stderr.write("Error: --world <dir> is required.\n");
+    process.exit(1);
+  }
+  const currentVersion = detectVersion(args.worldPath);
+  const targetVersion = args.target;
+  if (compareVersions(currentVersion, targetVersion) >= 0) {
+    const plan2 = {
+      currentVersion,
+      targetVersion,
+      migrations: [],
+      changes: []
+    };
+    if (args.json) {
+      process.stdout.write(JSON.stringify(plan2, null, 2) + "\n");
+    } else {
+      process.stdout.write(`World is already at version ${currentVersion} (target: ${targetVersion})
+`);
+      process.stdout.write("No migrations needed.\n");
+    }
+    return;
+  }
+  const migrationPath = findMigrationPath(currentVersion, targetVersion);
+  if (migrationPath.length === 0) {
+    process.stderr.write(`No migration path from ${currentVersion} to ${targetVersion}
+`);
+    process.exit(1);
+    return;
+  }
+  if (args.dryRun) {
+    const plan2 = {
+      currentVersion,
+      targetVersion,
+      migrations: migrationPath.map((m) => ({ from: m.from, to: m.to, description: m.description })),
+      changes: []
+    };
+    if (args.json) {
+      process.stdout.write(JSON.stringify(plan2, null, 2) + "\n");
+    } else {
+      process.stdout.write(`Migration plan: ${currentVersion} \u2192 ${targetVersion}
+`);
+      process.stdout.write(`Steps: ${migrationPath.length}
+
+`);
+      for (const m of migrationPath) {
+        process.stdout.write(`  ${m.from} \u2192 ${m.to}: ${m.description}
+`);
+      }
+      process.stdout.write("\nRun without --dry-run to apply.\n");
+    }
+    return;
+  }
+  if (args.backup) {
+    const backupPath = args.worldPath + ".backup";
+    cpSync(args.worldPath, backupPath, { recursive: true });
+    process.stdout.write(`Backup created: ${backupPath}
+`);
+  }
+  const allChanges = [];
+  for (const migration of migrationPath) {
+    process.stdout.write(`Applying: ${migration.from} \u2192 ${migration.to} (${migration.description})
+`);
+    const changes = migration.apply(args.worldPath);
+    allChanges.push(...changes);
+    for (const change of changes) {
+      process.stdout.write(`  ${change.action}: ${change.file} \u2014 ${change.description}
+`);
+    }
+  }
+  const plan = {
+    currentVersion,
+    targetVersion,
+    migrations: migrationPath.map((m) => ({ from: m.from, to: m.to, description: m.description })),
+    changes: allChanges
+  };
+  if (args.json) {
+    process.stdout.write(JSON.stringify(plan, null, 2) + "\n");
+  }
+  process.stdout.write(`
+Migration complete: ${currentVersion} \u2192 ${targetVersion} (${allChanges.length} changes)
+`);
+}
+export {
+  LATEST_VERSION,
+  main
+};