@nikelyh/metamorph 2.0.11 → 2.1.1

package/dist/index.js

@@ -1,4 +1,22 @@
 #!/usr/bin/env node
+import {
+  MigrationIntegrator,
+  SQLiteStateStore,
+  ShadowWorkspace,
+  createApiServer,
+  createCheckProjectDiagnosticsTool,
+  createCreateFileTool,
+  createDeleteFileTool,
+  createListDirectoryTool,
+  createReadFileTool,
+  createRenameFileTool,
+  createRunBuildTool,
+  createWriteFileTool
+} from "./chunk-L7B6KUCW.js";
+import {
+  formatCatalogRules,
+  resolveMigrationCatalog
+} from "./chunk-VEAYUIOZ.js";
 import {
   detectTechnologies
 } from "./chunk-3QN2Q75J.js";
@@ -10,1267 +28,325 @@ import {
   resolveRuntime,
   runLoop,
   sendEvent
-} from "./chunk-GNWRSZXT.js";
+} from "./chunk-GKRBTA6E.js";
+import {
+  collectFileHints,
+  registerMigrationPlugin
+} from "./chunk-O2QLEES3.js";
+import {
+  analyzeReactToNextStructure,
+  findShadowRoot,
+  hasNextAppRoutes,
+  isFsdPageComponent,
+  isSpaPagesTreeFile,
+  isSpaRootComponent,
+  listAppRouterFiles,
+  nextMigrationFileHint
+} from "./chunk-H2LZEPNI.js";
 
 // src/index.ts
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
 import "dotenv/config";
+import * as path11 from "path";
 
-// ../infrastructure/src/db/SQLiteStateStore.ts
-import { DatabaseSync } from "node:sqlite";
-import { join as join2 } from "path";
-import { mkdirSync } from "fs";
-var SQLiteStateStore = class {
-  db;
-  constructor(storageDir = ".metamorph") {
-    try {
-      mkdirSync(storageDir, { recursive: true });
-    } catch (e) {
-    }
-    const dbPath = join2(storageDir, "history.db");
-    this.db = new DatabaseSync(dbPath);
-    this.initTables();
-  }
-  /**
-   * Creates the necessary tables if they do not exist.
-   */
-  initTables() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS plans (
-        id TEXT PRIMARY KEY,
-        run_id TEXT,
-        target_path TEXT,
-        source_framework TEXT,
-        target_framework TEXT,
-        rules_json TEXT,
-        created_at TEXT
-      );
-    `);
-    try {
-      this.db.exec("ALTER TABLE plans ADD COLUMN run_id TEXT");
-    } catch (e) {
-    }
-    try {
-      this.db.exec("ALTER TABLE plans ADD COLUMN target_path TEXT");
-    } catch (e) {
-    }
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS tasks (
-        plan_id TEXT,
-        file_path TEXT,
-        status TEXT,
-        dependencies_json TEXT,
-        error TEXT,
-        PRIMARY KEY (plan_id, file_path),
-        FOREIGN KEY (plan_id) REFERENCES plans(id)
-      );
-    `);
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        event_name TEXT,
-        payload_json TEXT,
-        timestamp TEXT
-      );
-    `);
-  }
-  async savePlan(plan) {
-    const stmtPlan = this.db.prepare(`
-      INSERT OR REPLACE INTO plans (id, run_id, target_path, source_framework, target_framework, rules_json, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-    stmtPlan.run(
-      plan.id,
-      plan.runId,
-      plan.targetPath || "",
-      plan.profile.source,
-      plan.profile.target,
-      JSON.stringify(plan.profile.rules || []),
-      plan.createdAt.toISOString()
-    );
-    const stmtTask = this.db.prepare(`
-      INSERT OR REPLACE INTO tasks (plan_id, file_path, status, dependencies_json, error)
-      VALUES (?, ?, ?, ?, ?)
-    `);
-    for (const task of plan.tasks) {
-      stmtTask.run(
-        plan.id,
-        task.filePath,
-        task.status,
-        JSON.stringify(task.dependencies || []),
-        task.error || null
-      );
-    }
+// ../application/src/agents/MapperAgent.ts
+import * as fs from "fs";
+import * as path from "path";
+import {
+  createAgent,
+  SituationSpecification
+} from "@mozaik-ai/core";
+var WhenMigrationStarts = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "migration.started" /* MIGRATION_STARTED */;
   }
-  async getPlan(id) {
-    const stmtPlan = this.db.prepare(`SELECT * FROM plans WHERE id = ?`);
-    const planRow = stmtPlan.get(id);
-    if (!planRow) {
-      return null;
+};
+var mapFilesProcessor = {
+  async apply({ event, participant }) {
+    const payload = event.payload;
+    console.log(`[MapperAgent] Migration started for Plan: ${payload.planId}`);
+    const shadowDir = payload.shadowWorkspacePath || "";
+    if (!shadowDir) {
+      console.warn("[MapperAgent] No shadow workspace provided. Skipping.");
+      return;
     }
-    const stmtTasks = this.db.prepare(`SELECT * FROM tasks WHERE plan_id = ?`);
-    const taskRows = stmtTasks.all(id);
-    return {
-      id: planRow.id,
-      runId: planRow.run_id,
-      targetPath: planRow.target_path,
-      profile: {
-        source: planRow.source_framework,
-        target: planRow.target_framework,
-        rules: JSON.parse(planRow.rules_json)
-      },
-      createdAt: new Date(planRow.created_at),
-      tasks: taskRows.map((row) => ({
-        filePath: row.file_path,
-        status: row.status,
-        dependencies: JSON.parse(row.dependencies_json),
-        error: row.error || void 0
-      }))
+    const filesToMigrate = [];
+    const scanDir = (dir) => {
+      if (!fs.existsSync(dir)) return;
+      const files = fs.readdirSync(dir);
+      const ignoredDirs = ["node_modules", "dist", "build", "out", "coverage", ".next"];
+      for (const file of files) {
+        if (ignoredDirs.includes(file) || file.startsWith(".")) continue;
+        const fullPath = path.join(dir, file);
+        if (fs.statSync(fullPath).isDirectory()) {
+          scanDir(fullPath);
+        } else if (/\.(ts|js|tsx|jsx|vue|svelte)$/.test(file) || file.endsWith(".html") && file !== "index.html") {
+          filesToMigrate.push(fullPath);
+        }
+      }
     };
-  }
-  async updateTaskStatus(planId, filePath, status, error) {
-    const stmt = this.db.prepare(`
-      INSERT INTO tasks (plan_id, file_path, status, error, dependencies_json)
-      VALUES (?, ?, ?, ?, '[]')
-      ON CONFLICT(plan_id, file_path) DO UPDATE 
-      SET status = excluded.status, error = excluded.error
-    `);
-    stmt.run(planId, filePath, status, error || null);
-  }
-  async logEvent(eventName, payload) {
-    const stmt = this.db.prepare(`
-      INSERT INTO events (event_name, payload_json, timestamp)
-      VALUES (?, ?, ?)
-    `);
-    stmt.run(eventName, JSON.stringify(payload), (/* @__PURE__ */ new Date()).toISOString());
-  }
-  async getAllPlans() {
-    const stmtPlans = this.db.prepare(`SELECT * FROM plans ORDER BY created_at DESC`);
-    const planRows = stmtPlans.all();
-    const stmtTasks = this.db.prepare(`SELECT * FROM tasks`);
-    const taskRows = stmtTasks.all();
-    return planRows.map((planRow) => {
-      const planTasks = taskRows.filter((t) => t.plan_id === planRow.id);
-      return {
-        id: planRow.id,
-        runId: planRow.run_id,
-        targetPath: planRow.target_path,
-        profile: {
-          source: planRow.source_framework,
-          target: planRow.target_framework,
-          rules: JSON.parse(planRow.rules_json)
+    scanDir(shadowDir);
+    const runtime = resolveRuntime();
+    const repository = runtime.state.repository;
+    for (const discoveredFile of filesToMigrate) {
+      console.log(`[MapperAgent] Discovered file: ${discoveredFile}`);
+      await repository.updateTaskStatus(payload.planId, discoveredFile, "pending");
+      sendEvent(
+        {
+          type: "file.discovered" /* FILE_DISCOVERED */,
+          producerId: participant.getId(),
+          occurredAt: /* @__PURE__ */ new Date(),
+          payload: {
+            planId: payload.planId,
+            filePath: discoveredFile
+          }
         },
-        createdAt: new Date(planRow.created_at),
-        tasks: planTasks.map((row) => ({
-          filePath: row.file_path,
-          status: row.status,
-          dependencies: JSON.parse(row.dependencies_json),
-          error: row.error || void 0
-        }))
-      };
-    });
-  }
-  async getEvents() {
-    const stmt = this.db.prepare(`SELECT * FROM events ORDER BY id DESC LIMIT 100`);
-    const rows = stmt.all();
-    return rows.map((row) => ({
-      id: row.id,
-      eventName: row.event_name,
-      payload: JSON.parse(row.payload_json),
-      timestamp: new Date(row.timestamp)
-    }));
-  }
-  async reset() {
-    this.db.exec(`DELETE FROM tasks`);
-    this.db.exec(`DELETE FROM plans`);
-    this.db.exec(`DELETE FROM events`);
+        participant.getId()
+      );
+    }
   }
 };
-
-// ../infrastructure/src/tools/AstTools.ts
-import { Project } from "ts-morph";
-import { existsSync } from "fs";
-var project = new Project();
-function createReadFileTool() {
-  return {
-    type: "function",
-    name: "read_file",
-    description: "Reads the content of a source file using ts-morph.",
-    parameters: {
-      type: "object",
-      properties: {
-        filePath: { type: "string", description: "The relative path to the file to read." }
-      },
-      required: ["filePath"],
-      additionalProperties: false
-    },
-    strict: true,
-    invoke: async ({ filePath }) => {
-      if (!existsSync(filePath)) {
-        return { error: `File not found: ${filePath}` };
-      }
-      let sourceFile = project.getSourceFile(filePath);
-      if (!sourceFile) {
-        project.addSourceFileAtPath(filePath);
-        sourceFile = project.getSourceFileOrThrow(filePath);
-      } else {
-        await sourceFile.refreshFromFileSystem();
-      }
-      return {
-        filePath,
-        content: sourceFile.getFullText()
-      };
-    }
-  };
+var mapFilesHandler = {
+  specification: new WhenMigrationStarts(),
+  processor: mapFilesProcessor
+};
+function createMapperAgent() {
+  return createAgent({
+    name: "Mapper",
+    capabilities: ["code_analysis"],
+    instruction: "You are the Architect Mapper. Your job is to analyze the source code and discover files that need migration.",
+    tools: [],
+    // AST scanning tools will go here later
+    handlers: [mapFilesHandler]
+  });
 }
-function createWriteFileTool() {
-  return {
-    type: "function",
-    name: "write_file",
-    description: "Overwrites the content of a source file with the provided refactored code using ts-morph.",
-    parameters: {
-      type: "object",
-      properties: {
-        filePath: { type: "string", description: "The relative path to the file to modify." },
-        newContent: { type: "string", description: "The entire new source code to write to the file." }
-      },
-      required: ["filePath", "newContent"],
-      additionalProperties: false
-    },
-    strict: true,
-    invoke: async ({ filePath, newContent }) => {
-      let sourceFile = project.getSourceFile(filePath);
-      if (!sourceFile) {
-        if (existsSync(filePath)) {
-          project.addSourceFileAtPath(filePath);
-          sourceFile = project.getSourceFileOrThrow(filePath);
-        } else {
-          sourceFile = project.createSourceFile(filePath, "");
-        }
-      }
-      sourceFile.replaceWithText(newContent);
-      await sourceFile.save();
-      return {
-        success: true,
-        message: `File ${filePath} successfully updated.`
-      };
+
+// ../application/src/agents/WorkerAgent.ts
+import {
+  createAgent as createAgent2,
+  SituationSpecification as SituationSpecification2
+} from "@mozaik-ai/core";
+import * as fs3 from "fs";
+
+// ../application/src/utils/FileTreeBuilder.ts
+import * as path2 from "path";
+function getCommonBaseDir(filePaths) {
+  if (!filePaths || filePaths.length === 0) return "";
+  if (filePaths.length === 1) return path2.dirname(filePaths[0]);
+  const splitPaths = filePaths.map((p) => path2.normalize(p).split(path2.sep));
+  let commonPath = "";
+  for (let i = 0; i < splitPaths[0].length; i++) {
+    const part = splitPaths[0][i];
+    const isCommon = splitPaths.every((parts) => parts[i] === part);
+    if (isCommon) {
+      commonPath = commonPath === "" ? part : commonPath + path2.sep + part;
+    } else {
+      break;
     }
-  };
+  }
+  return commonPath;
 }
-function createRenameFileTool() {
-  return {
-    type: "function",
-    name: "rename_file",
-    description: "Renames a file in the project.",
-    parameters: {
-      type: "object",
-      properties: {
-        oldPath: { type: "string", description: "Current relative path of the file." },
-        newPath: { type: "string", description: "New relative path for the file." }
-      },
-      required: ["oldPath", "newPath"],
-      additionalProperties: false
-    },
-    strict: true,
-    invoke: async ({ oldPath, newPath }) => {
-      const { renameSync, existsSync: existsSync5 } = await import("fs");
-      if (!existsSync5(oldPath)) {
-        return { error: `File not found: ${oldPath}` };
-      }
-      renameSync(oldPath, newPath);
-      const sourceFile = project.getSourceFile(oldPath);
-      if (sourceFile) {
-        project.removeSourceFile(sourceFile);
-        if (existsSync5(newPath)) {
-          project.addSourceFileAtPath(newPath);
-        }
+function buildFileTree(filePaths) {
+  if (!filePaths || filePaths.length === 0) return "No files found.";
+  const baseDir = getCommonBaseDir(filePaths);
+  const relativePaths = filePaths.map((p) => path2.relative(baseDir, p)).filter((p) => p.length > 0).sort();
+  if (relativePaths.length === 0) return "No files found.";
+  const tree = {};
+  for (const relPath of relativePaths) {
+    const parts = relPath.split(path2.sep);
+    let current = tree;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (i === parts.length - 1) {
+        current[part] = null;
+      } else {
+        current[part] = current[part] || {};
+        current = current[part];
       }
-      return { success: true, message: `File renamed from ${oldPath} to ${newPath}.` };
     }
-  };
-}
-function createCreateFileTool() {
-  return {
-    type: "function",
-    name: "create_file",
-    description: "Creates a new file with the specified content.",
-    parameters: {
-      type: "object",
-      properties: {
-        filePath: { type: "string", description: "Relative path of the new file to create." },
-        content: { type: "string", description: "The content of the new file." }
-      },
-      required: ["filePath", "content"],
-      additionalProperties: false
-    },
-    strict: true,
-    invoke: async ({ filePath, content }) => {
-      const { writeFileSync: writeFileSync2, mkdirSync: mkdirSync2 } = await import("fs");
-      const { dirname: dirname2 } = await import("path");
-      mkdirSync2(dirname2(filePath), { recursive: true });
-      writeFileSync2(filePath, content, "utf-8");
-      project.addSourceFileAtPath(filePath);
-      return { success: true, message: `File created at ${filePath}.` };
-    }
-  };
-}
-function createDeleteFileTool() {
-  return {
-    type: "function",
-    name: "delete_file",
-    description: "Deletes a file from the project.",
-    parameters: {
-      type: "object",
-      properties: {
-        filePath: { type: "string", description: "Relative path of the file to delete." }
-      },
-      required: ["filePath"],
-      additionalProperties: false
-    },
-    strict: true,
-    invoke: async ({ filePath }) => {
-      const { renameSync, existsSync: existsSync5 } = await import("fs");
-      if (!existsSync5(filePath)) {
-        return { error: `File not found: ${filePath}` };
-      }
-      const obsoletePath = `${filePath}.obsolete`;
-      renameSync(filePath, obsoletePath);
-      const sourceFile = project.getSourceFile(filePath);
-      if (sourceFile) {
-        project.removeSourceFile(sourceFile);
+  }
+  let output = `/
+`;
+  function renderTree(node, prefix = "") {
+    if (node === null) return;
+    const keys = Object.keys(node);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const isLast = i === keys.length - 1;
+      const isFile = node[key] === null;
+      const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      output += `${prefix}${connector}${key}
+`;
+      if (!isFile) {
+        const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
+        renderTree(node[key], nextPrefix);
       }
-      return { success: true, message: `File marked as obsolete at ${obsoletePath} instead of deleting.` };
     }
-  };
+  }
+  renderTree(tree);
+  return output.trim();
 }
 
-// ../infrastructure/src/workspace/ShadowWorkspace.ts
-import fs from "fs-extra";
-import { join as join3, resolve } from "path";
-var ShadowWorkspace = class {
-  baseDir;
-  constructor(basePath = ".metamorph/shadow") {
-    this.baseDir = resolve(process.cwd(), basePath);
+// ../application/src/utils/NeighborContext.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+var MAX_FILES = 8;
+var MAX_FILE_CHARS = 4e3;
+var MAX_TOTAL_CHARS = 24e3;
+function readTruncated(filePath) {
+  try {
+    if (!fs2.existsSync(filePath) || !fs2.statSync(filePath).isFile()) return null;
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    if (raw.length <= MAX_FILE_CHARS) return raw;
+    return `${raw.slice(0, MAX_FILE_CHARS)}
+
+/* \u2026 truncated (${raw.length} chars) */`;
+  } catch {
+    return null;
   }
-  /**
-   * Clones a target directory into the shadow workspace.
-   * @param targetPath The absolute or relative path to the directory to clone.
-   * @param runId A unique identifier for this run (e.g. timestamp).
-   * @returns The absolute path to the cloned directory inside the shadow workspace.
-   */
-  cloneDirectory(targetPath, runId) {
-    const sourceDir = resolve(process.cwd(), targetPath);
-    if (!fs.existsSync(sourceDir)) {
-      throw new Error(`Target directory does not exist: ${sourceDir}`);
-    }
-    const shadowDir = join3(this.baseDir, runId);
-    if (fs.existsSync(shadowDir)) {
-      fs.emptyDirSync(shadowDir);
-    }
-    const ignoredDirs = ["node_modules", ".git", ".metamorph", "dist", "build", "out", "coverage", ".next"];
-    const items = fs.readdirSync(sourceDir);
-    for (const item of items) {
-      if (ignoredDirs.includes(item)) {
-        continue;
-      }
-      const itemSrc = join3(sourceDir, item);
-      const itemDest = join3(shadowDir, item);
-      fs.copySync(itemSrc, itemDest, {
-        filter: (src) => !ignoredDirs.some((dir) => src.includes(`/${dir}/`) || src.endsWith(`/${dir}`) || src.includes(`\\${dir}\\`) || src.endsWith(`\\${dir}`))
-      });
+}
+function findSrcRoot(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const idx = normalized.lastIndexOf("/src/");
+  if (idx === -1) return null;
+  return filePath.slice(0, idx + 4);
+}
+function resolveImport(fromFile, spec) {
+  const dir = path3.dirname(fromFile);
+  const base = spec.startsWith("@/") ? (() => {
+    const src = findSrcRoot(fromFile);
+    return src ? path3.join(src, spec.slice(2)) : path3.resolve(dir, spec);
+  })() : path3.resolve(dir, spec);
+  const candidates = [
+    base,
+    `${base}.tsx`,
+    `${base}.ts`,
+    `${base}.jsx`,
+    `${base}.js`,
+    `${base}.vue`,
+    `${base}.svelte`,
+    path3.join(base, "index.tsx"),
+    path3.join(base, "index.ts"),
+    path3.join(base, "index.vue"),
+    path3.join(base, "index.svelte")
+  ];
+  return candidates.find((file) => fs2.existsSync(file) && fs2.statSync(file).isFile()) || null;
+}
+function localImportSpecs(content) {
+  const specs = [];
+  const re = /from\s+['"](\.\.?\/[^'"]+|@\/[^'"]+)['"]/g;
+  let match;
+  while ((match = re.exec(content)) !== null) specs.push(match[1]);
+  return specs;
+}
+function listNearbyModules(fromFile, limit) {
+  const shadow = findShadowRoot(fromFile);
+  const src = findSrcRoot(fromFile) || (shadow ? path3.join(shadow, "src") : path3.dirname(fromFile));
+  if (!fs2.existsSync(src)) return [];
+  const interesting = /(?:Page|page|View|Screen|layout|Layout|main|App|routes|Routes|app\.routes)\.(t|j)sx?$|\.(vue|svelte)$/;
+  const out = [];
+  const stack = [src];
+  while (stack.length > 0 && out.length < limit) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
     }
-    return shadowDir;
-  }
-  /**
-   * Removes the shadow workspace for a given run, effectively
-   * discarding any in-progress migration work.
-   */
-  rollback(runId) {
-    const shadowDir = join3(this.baseDir, runId);
-    if (fs.existsSync(shadowDir)) {
-      fs.removeSync(shadowDir);
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const full = path3.join(dir, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else if (interesting.test(entry.name)) out.push(full);
+      if (out.length >= limit) break;
     }
   }
-  /**
-   * Returns the absolute path of the shadow dir for a given runId.
-   */
-  getShadowPath(runId) {
-    return join3(this.baseDir, runId);
+  return out;
+}
+function buildNeighborContext(filePath) {
+  const sections = [];
+  let budget = MAX_TOTAL_CHARS;
+  const push = (title, body) => {
+    const block = `### ${title}
+\`\`\`
+${body}
+\`\`\`
+`;
+    if (block.length > budget) return;
+    budget -= block.length;
+    sections.push(block);
+  };
+  const self = readTruncated(filePath);
+  if (self) {
+    push(filePath, self);
+  } else {
+    sections.push(`### ${filePath}
+(file does not exist yet \u2014 you may need to create it)
+`);
   }
-  /**
-   * Cleans up old shadow runs to save disk space, keeping only the specified number of most recent runs.
-   * @param keepCount Number of recent runs to keep (default: 3)
-   */
-  cleanupOldRuns(keepCount = 3) {
-    if (!fs.existsSync(this.baseDir)) return;
-    const runs = fs.readdirSync(this.baseDir).filter((f) => f.startsWith("run_") && fs.statSync(join3(this.baseDir, f)).isDirectory());
-    runs.sort();
-    if (runs.length > keepCount) {
-      const toDelete = runs.slice(0, runs.length - keepCount);
-      for (const run of toDelete) {
-        this.rollback(run);
-      }
-    }
+  const importSpecs = self ? localImportSpecs(self) : [];
+  const resolved = importSpecs.map((spec) => resolveImport(filePath, spec)).filter((file) => Boolean(file && file !== path3.resolve(filePath)));
+  const unique = [...new Set(resolved)].slice(0, MAX_FILES);
+  for (const dep of unique) {
+    const body = readTruncated(dep);
+    if (body) push(`imported: ${dep}`, body);
+  }
+  const nearby = listNearbyModules(filePath, 24).filter((file) => path3.resolve(file) !== path3.resolve(filePath));
+  if (nearby.length > 0) {
+    const listing = nearby.map((file) => path3.relative(findShadowRoot(filePath) || path3.dirname(filePath), file)).join("\n");
+    sections.push(`### Nearby screen / bootstrap files (paths only \u2014 read before inventing a new UI)
+${listing}
+`);
   }
-};
+  if (sections.length === 0) return "";
+  return `
+Evidence from disk (read this before editing; match existing exports and callback prop names):
+${sections.join("\n")}`;
+}
 
-// ../infrastructure/src/workspace/MigrationIntegrator.ts
-import fs2 from "fs-extra";
-import * as path from "path";
-import { execSync } from "child_process";
-import * as os from "os";
-var MigrationIntegrator = class {
-  shadowWorkspace;
-  constructor(shadowWorkspace) {
-    this.shadowWorkspace = shadowWorkspace;
-  }
-  /**
-   * Applies the migrated code from the shadow workspace back to the target directory.
-   * Prioritizes Git if available, otherwise falls back to a Zip backup.
-   * 
-   * @param runId The ID of the migration run to apply.
-   * @param targetPath The original target path of the project.
-   */
-  async applyMigration(runId, targetPath) {
-    const shadowDir = this.shadowWorkspace.getShadowPath(runId);
-    if (!fs2.existsSync(shadowDir)) {
-      throw new Error(`Shadow run not found: ${shadowDir}`);
-    }
-    const resolvedTarget = path.resolve(process.cwd(), targetPath);
-    if (this.isGitRepo(resolvedTarget)) {
-      return this.applyWithGit(runId, shadowDir, resolvedTarget);
-    } else {
-      return this.applyWithZipFallback(runId, shadowDir, resolvedTarget);
-    }
+// ../application/src/utils/workerCompletion.ts
+var MISSING_AFTER_WORKER = "File missing after worker inference (missing_after_worker)";
+function workerCompletionKind(fileExists) {
+  return fileExists ? "migrated" : "failed_missing";
+}
+
+// ../application/src/agents/WorkerAgent.ts
+var MAX_RETRIES = 2;
+var ConcurrencyQueue = class {
+  constructor(concurrencyLimit) {
+    this.concurrencyLimit = concurrencyLimit;
   }
-  isGitRepo(targetPath) {
-    return fs2.existsSync(path.join(targetPath, ".git"));
+  queue = [];
+  activeCount = 0;
+  async enqueue(task) {
+    this.queue.push(task);
+    this.pump();
   }
-  async applyWithGit(runId, shadowDir, targetPath) {
-    const branchName = `metamorph/${runId}`;
-    try {
-      execSync(`git checkout -B ${branchName}`, { cwd: targetPath, stdio: "ignore" });
-    } catch (e) {
-      if (e instanceof Error) {
-        throw new Error(`Failed to create/reset git branch ${branchName}: ${e.message}`);
-      }
-      throw new Error(`Failed to create/reset git branch ${branchName}: ${String(e)}`);
-    }
-    this.copyShadowToTarget(shadowDir, targetPath);
-    try {
-      execSync(`git add .`, { cwd: targetPath, stdio: "ignore" });
-      execSync(`git commit --allow-empty -m "chore: apply metamorph ai migration (${runId})"`, { cwd: targetPath, stdio: "ignore" });
-    } catch (e) {
-      if (e instanceof Error) {
-        throw new Error(`Failed to commit changes to branch ${branchName}: ${e.message}`);
-      }
-      throw new Error(`Failed to commit changes to branch ${branchName}: ${String(e)}`);
+  async pump() {
+    if (this.activeCount >= this.concurrencyLimit || this.queue.length === 0) {
+      return;
     }
-    return `Successfully applied migration via Git to branch: ${branchName}`;
-  }
-  async applyWithZipFallback(runId, shadowDir, targetPath) {
-    const backupDir = path.resolve(os.tmpdir(), "metamorph_backups", `${runId}_backup`);
-    fs2.ensureDirSync(backupDir);
-    fs2.copySync(targetPath, backupDir, {
-      filter: (src) => !src.includes("node_modules") && !src.includes(".git") && !src.includes(".metamorph")
-    });
-    this.copyShadowToTarget(shadowDir, targetPath);
-    return `Successfully applied migration. Git was not detected, so a backup was saved at: ${backupDir}`;
-  }
-  copyShadowToTarget(shadowDir, targetPath) {
-    const ignoredDirs = ["node_modules", ".git", ".metamorph"];
-    if (fs2.existsSync(targetPath)) {
-      const targetItems = fs2.readdirSync(targetPath);
-      for (const item of targetItems) {
-        if (ignoredDirs.includes(item)) continue;
-        fs2.removeSync(path.join(targetPath, item));
+    const task = this.queue.shift();
+    if (task) {
+      this.activeCount++;
+      try {
+        await task();
+      } catch (error) {
+        console.error("Task error:", error);
+      } finally {
+        this.activeCount--;
+        this.pump();
       }
     }
-    const shadowItems = fs2.readdirSync(shadowDir);
-    for (const item of shadowItems) {
-      if (ignoredDirs.includes(item)) continue;
-      const itemSrc = path.join(shadowDir, item);
-      const itemDest = path.join(targetPath, item);
-      fs2.copySync(itemSrc, itemDest, { overwrite: true });
-    }
   }
 };
-
-// ../domain/src/entities/catalogs/backendCatalog.ts
-var backendCatalog = [
-  {
-    source: "nestjs",
-    target: "express",
-    description: "Migration from NestJS framework to a plain Express application structure.",
-    filesToDelete: ["nest-cli.json", "tsconfig.build.json"],
-    dependenciesToRemove: ["@nestjs/common", "@nestjs/core", "@nestjs/platform-express", "reflect-metadata", "rxjs"],
-    dependenciesToAdd: { "express": "^4.18.2" },
-    devDependenciesToRemove: ["@nestjs/cli", "@nestjs/schematics", "@nestjs/testing", "@types/express", "@types/supertest", "source-map-support", "supertest"],
-    devDependenciesToAdd: { "@types/express": "^4.17.17" },
-    architecturalRules: [
-      "Remove all NestJS decorators (@Module, @Controller, @Injectable, @Get, @Post, etc.).",
-      'Remove all NestJS core imports (e.g., from "@nestjs/common" or "@nestjs/core").',
-      "Controllers must be converted into Express Router factory functions or classes that return an Express Router.",
-      "Modules must be converted to plain dependency composition functions or startup scripts that wire Routers together.",
-      "Services/Providers must be converted to plain TypeScript classes or functions, with dependencies passed explicitly via constructors (manual dependency injection) since NestJS DI is gone.",
-      "Make sure to export the router or the configured Express application, not a Nest module."
-    ],
-    examples: [
-      {
-        description: "Converting a NestJS Controller to an Express Router",
-        before: `import { Controller, Get } from '@nestjs/common';
-import { AppService } from './app.service';
-
-@Controller()
-export class AppController {
-  constructor(private readonly appService: AppService) {}
-
-  @Get()
-  getHello(): string {
-    return this.appService.getHello();
-  }
-}`,
-        after: `import { Router } from 'express';
-import { AppService } from './app.service';
-
-export function createAppRouter(appService: AppService): Router {
-  const router = Router();
-
-  router.get('/', (req, res) => {
-    const result = appService.getHello();
-    res.send(result);
-  });
-
-  return router;
-}`
-      }
-    ]
-  },
-  {
-    source: "express",
-    target: "nestjs",
-    description: "Migration from a plain Express application to the NestJS framework.",
-    dependenciesToRemove: ["express"],
-    dependenciesToAdd: {
-      "@nestjs/common": "latest",
-      "@nestjs/core": "latest",
-      "@nestjs/platform-express": "latest",
-      "reflect-metadata": "^0.1.13",
-      "rxjs": "^7.8.1"
-    },
-    devDependenciesToRemove: ["@types/express"],
-    devDependenciesToAdd: {
-      "@nestjs/cli": "latest",
-      "@nestjs/schematics": "latest",
-      "@nestjs/testing": "latest",
-      "@types/supertest": "^2.0.12",
-      "source-map-support": "^0.5.21",
-      "supertest": "^6.3.3"
-    },
-    architecturalRules: [
-      "Express routing logic must be encapsulated in classes decorated with @Controller().",
-      "Business logic must be encapsulated in classes decorated with @Injectable() (Providers/Services).",
-      "All Controllers and Providers must be registered in a class decorated with @Module().",
-      "Use NestJS decorators for routing (@Get(), @Post(), @Param(), @Body(), etc.) instead of Express route definitions.",
-      "Rely on NestJS dependency injection instead of manual class instantiation or function passing.",
-      "The entry point must use NestFactory.create() to bootstrap the application, replacing app.listen().",
-      "You are authorized to rename, create, or delete files to adhere strictly to the NestJS directory and file structure conventions (e.g., app.module.ts, app.controller.ts, app.service.ts, main.ts)."
-    ],
-    examples: [
-      {
-        description: "Converting an Express Router to a NestJS Controller and Service",
-        before: `import { Router } from 'express';
-import { getHelloLogic } from './logic';
-
-export function createAppRouter(): Router {
-  const router = Router();
-  router.get('/', (req, res) => {
-    res.send(getHelloLogic());
-  });
-  return router;
-}`,
-        after: `import { Controller, Get, Injectable } from '@nestjs/common';
-
-@Injectable()
-export class AppService {
-  getHello(): string {
-    return 'Hello from logic';
-  }
-}
-
-@Controller()
-export class AppController {
-  constructor(private readonly appService: AppService) {}
-
-  @Get()
-  getHello(): string {
-    return this.appService.getHello();
-  }
-}`
-      }
-    ]
-  },
-  {
-    source: "nestjs",
-    target: "fastify",
-    description: "Migration from NestJS framework to a Fastify application structure.",
-    filesToDelete: ["nest-cli.json", "tsconfig.build.json"],
-    dependenciesToRemove: ["@nestjs/common", "@nestjs/core", "@nestjs/platform-express", "reflect-metadata", "rxjs"],
-    dependenciesToAdd: { "fastify": "latest" },
-    devDependenciesToRemove: ["@nestjs/cli", "@nestjs/schematics", "@nestjs/testing", "@types/express", "@types/supertest", "source-map-support", "supertest"],
-    devDependenciesToAdd: { "fastify-plugin": "latest" },
-    architecturalRules: [
-      "Remove all NestJS decorators (@Module, @Controller, @Injectable, @Get, @Post, etc.).",
-      "Remove all NestJS core imports.",
-      "The entry point (main.ts) must initialize a FastifyInstance (fastify()) instead of NestFactory.",
-      "Controllers and routing logic must be converted to Fastify route declarations (fastify.get, fastify.post).",
-      "Ideally, encapsulate routes and modules as Fastify plugins.",
-      "Remove NestJS dependency injection; use standard JavaScript/TypeScript classes or functions passing dependencies directly.",
-      "Ensure standard Fastify schema validation (JSON Schema) is added if types or DTOs are available.",
-      "You are authorized to rename, create, or delete files to adhere to a standard fastify plugin-based directory structure."
-    ],
-    examples: [
-      {
-        description: "Converting a NestJS Controller to a Fastify Plugin",
-        before: `import { Controller, Get } from '@nestjs/common';
-import { AppService } from './app.service';
-
-@Controller('users')
-export class UsersController {
-  constructor(private readonly appService: AppService) {}
-
-  @Get()
-  getUsers() {
-    return this.appService.getUsers();
-  }
-}`,
-        after: `import { FastifyInstance } from 'fastify';
-import { AppService } from './app.service';
-
-export default async function usersPlugin(fastify: FastifyInstance, options: any) {
-  const appService = new AppService(); // Or inject via options
-
-  fastify.get('/users', async (request, reply) => {
-    return appService.getUsers();
-  });
-}`
-      }
-    ]
-  },
-  {
-    source: "express",
-    target: "fastify",
-    description: "Migration from a plain Express application to Fastify.",
-    dependenciesToRemove: ["express"],
-    dependenciesToAdd: { "fastify": "latest", "fastify-plugin": "latest" },
-    devDependenciesToRemove: ["@types/express"],
-    devDependenciesToAdd: {},
-    architecturalRules: [
-      "Replace all Express app instantiations with fastify().",
-      "Replace Express middleware signatures (req, res, next) with Fastify hooks (onRequest, preHandler, etc.) or Fastify plugins.",
-      "Replace Express routing (app.use(), app.get()) with Fastify routing (fastify.get(), fastify.register()).",
-      "Replace Express response methods (res.send(), res.json()) with Fastify reply methods (reply.send()) or simply return the payload from the async handler.",
-      "Migrate standard Express middlewares (like cors, helmet) to their Fastify native equivalents (@fastify/cors, @fastify/helmet) if they are present.",
-      "You are authorized to rename, create, or delete files to restructure the Express app into modular Fastify plugins."
-    ],
-    examples: [
-      {
-        description: "Converting an Express Route to a Fastify Route",
-        before: `const express = require('express');
-const app = express();
-
-app.get('/api/data', (req, res) => {
-  res.json({ message: 'Hello Express' });
-});
-
-app.listen(3000);`,
-        after: `import Fastify from 'fastify';
-
-const fastify = Fastify({ logger: true });
-
-fastify.get('/api/data', async (request, reply) => {
-  return { message: 'Hello Fastify' };
-});
-
-fastify.listen({ port: 3000 }, (err) => {
-  if (err) {
-    fastify.log.error(err);
-    process.exit(1);
-  }
-});`
-      }
-    ]
-  },
-  {
-    source: "fastify",
-    target: "express",
-    description: "Migration from a Fastify application to Express.",
-    dependenciesToRemove: ["fastify", "fastify-plugin"],
-    dependenciesToAdd: { "express": "latest" },
-    devDependenciesToRemove: [],
-    devDependenciesToAdd: { "@types/express": "latest" },
-    architecturalRules: [
-      "Replace all fastify() app instantiations with express().",
-      "Replace Fastify hooks (onRequest, preHandler, etc.) with standard Express middleware signatures (req, res, next).",
-      "Replace Fastify routing (fastify.get, fastify.register) with Express routing (app.get, express.Router().use).",
-      "Replace Fastify reply methods (reply.send) or implicit returns with Express response methods (res.send, res.json).",
-      "CRITICAL: Fastify catches async errors automatically. When migrating to Express, ensure all asynchronous route handlers use try/catch blocks passing the error to next(err), or wrap them in an async wrapper.",
-      "You are authorized to rename, create, or delete files to restructure the Fastify plugins into standard Express routers."
-    ],
-    examples: [
-      {
-        description: "Converting a Fastify Route to an Express Route",
-        before: `import Fastify from 'fastify';
-
-const fastify = Fastify();
-
-fastify.get('/api/data', async (request, reply) => {
-  return { message: 'Hello Fastify' };
-});
-
-fastify.listen({ port: 3000 });`,
-        after: `const express = require('express');
-const app = express();
-
-app.get('/api/data', async (req, res, next) => {
-  try {
-    res.json({ message: 'Hello Fastify' });
-  } catch (err) {
-    next(err);
-  }
-});
-
-app.listen(3000);`
-      }
-    ]
-  },
-  {
-    source: "fastify",
-    target: "nestjs",
-    description: "Migration from Fastify framework to NestJS (using platform-express by default).",
-    dependenciesToRemove: ["fastify", "fastify-plugin"],
-    dependenciesToAdd: {
-      "@nestjs/common": "latest",
-      "@nestjs/core": "latest",
-      "@nestjs/platform-express": "latest",
-      "reflect-metadata": "^0.1.13",
-      "rxjs": "^7.8.1"
-    },
-    devDependenciesToRemove: [],
-    devDependenciesToAdd: {
-      "@nestjs/cli": "latest",
-      "@nestjs/schematics": "latest",
-      "@nestjs/testing": "latest",
-      "@types/supertest": "^2.0.12",
-      "source-map-support": "^0.5.21",
-      "supertest": "^6.3.3"
-    },
-    architecturalRules: [
-      "Fastify routing logic must be encapsulated in classes decorated with @Controller().",
-      "Business logic must be encapsulated in classes decorated with @Injectable() (Providers/Services).",
-      "All Controllers and Providers must be registered in a class decorated with @Module().",
-      "Use NestJS decorators for routing (@Get(), @Post(), @Param(), @Body(), etc.) instead of fastify route definitions.",
-      "Rely on NestJS dependency injection instead of Fastify decorators or options passing.",
-      "The entry point must use NestFactory.create() to bootstrap the application, replacing fastify().",
-      "You are authorized to rename, create, or delete files to adhere strictly to the NestJS directory and file structure conventions (e.g., app.module.ts, app.controller.ts, app.service.ts, main.ts)."
-    ],
-    examples: [
-      {
-        description: "Converting a Fastify Plugin to a NestJS Controller and Service",
-        before: `export default async function usersPlugin(fastify, options) {
-  fastify.get('/users', async (request, reply) => {
-    return { users: [] };
-  });
-}`,
-        after: `import { Controller, Get, Injectable } from '@nestjs/common';
-
-@Injectable()
-export class UsersService {
-  getUsers() {
-    return { users: [] };
-  }
-}
-
-@Controller('users')
-export class UsersController {
-  constructor(private readonly usersService: UsersService) {}
-
-  @Get()
-  getUsers() {
-    return this.usersService.getUsers();
-  }
-}`
-      }
-    ]
-  }
-];
-
-// ../domain/src/entities/catalogs/frontendCatalog.ts
-var frontendCatalog = [
-  {
-    source: "react",
-    target: "next",
-    description: "Migration from a plain React SPA (like Vite or Create React App) to Next.js using the App Router.",
-    filesToDelete: ["vite.config.ts", "vite.config.js", "index.html"],
-    dependenciesToRemove: ["react-router-dom", "vite", "@vitejs/plugin-react"],
-    dependenciesToAdd: { "next": "latest", "react": "latest", "react-dom": "latest" },
-    devDependenciesToRemove: [],
-    devDependenciesToAdd: {},
-    architecturalRules: [
-      'Migrate standard React routing (e.g. react-router-dom) to Next.js file-system routing in the "app" directory.',
-      "Convert the main entry point (usually main.tsx or index.tsx) into Next.js app/layout.tsx and app/page.tsx.",
-      'For components that use browser-only APIs (like window, useEffect, useState), add the "use client" directive at the very top of the file.',
-      "Remove any react-router-dom <BrowserRouter>, <Routes>, and <Route> components.",
-      "Replace react-router-dom <Link> components with Next.js next/link <Link> components.",
-      "You are authorized to rename, create, or delete files to restructure the source into the Next.js App Router structure (e.g. app/page.tsx, app/layout.tsx)."
-    ],
-    examples: [
-      {
-        description: "Converting a React Router setup to Next.js App Router",
-        before: `import { BrowserRouter, Routes, Route } from 'react-router-dom';
-import Home from './Home';
-import About from './About';
-
-export default function App() {
-  return (
-    <BrowserRouter>
-      <Routes>
-        <Route path="/" element={<Home />} />
-        <Route path="/about" element={<About />} />
-      </Routes>
-    </BrowserRouter>
-  );
-}`,
-        after: `// This routing logic is deleted.
-// Instead, create app/page.tsx for Home and app/about/page.tsx for About.`
-      }
-    ]
-  },
-  {
-    source: "next",
-    target: "react",
-    description: "Migration from Next.js to a plain React SPA using Vite.",
-    filesToDelete: ["next.config.js", "next.config.mjs", "next.config.ts"],
-    dependenciesToRemove: ["next"],
-    dependenciesToAdd: { "react-router-dom": "latest" },
-    devDependenciesToRemove: [],
-    devDependenciesToAdd: { "vite": "latest", "@vitejs/plugin-react": "latest" },
-    architecturalRules: [
-      "Replace Next.js file-system routing (app/ or pages/) with declarative React Router (react-router-dom) components.",
-      'Remove all "use client" and "use server" directives, as they are Next.js specific.',
-      "Convert Next.js Server Components into standard React Client Components (they will need to fetch data via useEffect or a data-fetching library).",
-      'Replace Next.js <Link href="..."> with React Router <Link to="...">.',
-      "Replace Next.js next/image <Image> with standard HTML <img>.",
-      "Create a standard Vite entry point (index.html at the root, and src/main.tsx) to bootstrap the React application."
-    ]
-  },
-  {
-    source: "vue",
-    target: "react",
-    description: "Migration from Vue.js (Vue 3 Composition API) to React.",
-    filesToDelete: ["vite.config.ts", "vue.config.js"],
-    dependenciesToRemove: ["vue", "vue-router", "pinia"],
-    dependenciesToAdd: { "react": "latest", "react-dom": "latest", "react-router-dom": "latest" },
-    devDependenciesToRemove: ["@vitejs/plugin-vue"],
-    devDependenciesToAdd: { "@vitejs/plugin-react": "latest" },
-    architecturalRules: [
-      "Convert all .vue Single File Components (SFC) into .tsx or .jsx React function components.",
-      "Replace Vue <template> with React JSX/TSX return statements.",
-      "Replace Vue ref() and reactive() with React useState().",
-      "Replace Vue computed() with React useMemo().",
-      "Replace Vue watch() and lifecycle hooks (onMounted, etc.) with React useEffect().",
-      "Replace vue-router with react-router-dom.",
-      "Convert Vue props definition (defineProps) into React function component parameters.",
-      "Convert Vue emit (defineEmits) into React callback props (e.g. onAction={...})."
-    ]
-  },
-  {
-    source: "react",
-    target: "vue",
-    description: "Migration from React to Vue.js (Vue 3 Composition API).",
-    filesToDelete: ["vite.config.ts"],
-    dependenciesToRemove: ["react", "react-dom", "react-router-dom"],
-    dependenciesToAdd: { "vue": "latest", "vue-router": "latest" },
-    devDependenciesToRemove: ["@vitejs/plugin-react"],
-    devDependenciesToAdd: { "@vitejs/plugin-vue": "latest" },
-    architecturalRules: [
-      "Convert React .tsx/.jsx function components into Vue 3 .vue Single File Components (using <script setup>).",
-      "Move the JSX return statement into the Vue <template> block.",
-      "Replace React useState() with Vue ref() or reactive().",
-      "Replace React useMemo() with Vue computed().",
-      "Replace React useEffect() with Vue watch() or lifecycle hooks (onMounted).",
-      "Replace react-router-dom with vue-router.",
-      "Extract component props into defineProps().",
-      "Extract callback props (e.g. onClick) into defineEmits() and emit events."
-    ]
-  }
-];
-
-// ../domain/src/entities/catalogs/index.ts
-var MigrationCatalog = [
-  ...backendCatalog,
-  ...frontendCatalog
-];
-function findMigrationCatalogEntry(source, target) {
-  return MigrationCatalog.find(
-    (entry) => entry.source.toLowerCase() === source.toLowerCase() && entry.target.toLowerCase() === target.toLowerCase()
-  );
-}
-
-// ../infrastructure/src/server/api.ts
-async function createApiServer(store, migrationRunner) {
-  const express = (await import("express")).default;
-  const cors = (await import("cors")).default;
-  const app = express();
-  app.use(cors());
-  app.use(express.json());
-  app.get("/api/plans", async (_req, res) => {
-    try {
-      const plans = await store.getAllPlans();
-      res.json(plans);
-    } catch (error) {
-      if (error instanceof Error) {
-        res.status(500).json({ error: error.message });
-      } else {
-        res.status(500).json({ error: String(error) });
-      }
-    }
-  });
-  app.get("/api/events", async (_req, res) => {
-    try {
-      const events = await store.getEvents();
-      res.json(events);
-    } catch (error) {
-      if (error instanceof Error) {
-        res.status(500).json({ error: error.message });
-      } else {
-        res.status(500).json({ error: String(error) });
-      }
-    }
-  });
-  app.get("/api/browse", async (req, res) => {
-    try {
-      const { readdirSync: readdirSync2, statSync: statSync2 } = await import("fs");
-      const { resolve: resolve3, join: join8 } = await import("path");
-      const targetPath = req.query.path ? resolve3(String(req.query.path)) : resolve3(".");
-      const entries = readdirSync2(targetPath).filter(
-        (name) => !name.startsWith(".") && name !== "node_modules" && name !== "dist" && name !== "build"
-      ).map((name) => {
-        const full = join8(targetPath, name);
-        try {
-          const stat = statSync2(full);
-          return {
-            name,
-            path: full,
-            isDirectory: stat.isDirectory()
-          };
-        } catch {
-          return null;
-        }
-      }).filter(Boolean);
-      res.json({
-        current: targetPath,
-        parent: resolve3(targetPath, ".."),
-        entries
-      });
-    } catch (error) {
-      if (error instanceof Error) {
-        res.status(500).json({ error: error.message });
-      } else {
-        res.status(500).json({ error: String(error) });
-      }
-    }
-  });
-  app.get("/api/detect", async (req, res) => {
-    try {
-      const { detectTechnologies: detectTechnologies2 } = await import("./TechDetector-5YP44RVR.js");
-      const targetPath = req.query.path ? String(req.query.path) : ".";
-      const detected = detectTechnologies2(targetPath);
-      res.json({
-        detected,
-        primary: detected.length > 0 ? detected[0].framework : null
-      });
-    } catch (error) {
-      if (error instanceof Error) {
-        res.status(500).json({ error: error.message });
-      } else {
-        res.status(500).json({ error: String(error) });
-      }
-    }
-  });
-  if (migrationRunner) {
-    app.post("/api/migrations/start", async (req, res) => {
-      try {
-        const { targetPath, from, to } = req.body;
-        if (!targetPath || !from || !to) {
-          res.status(400).json({
-            error: "Missing required fields: targetPath, from, to"
-          });
-          return;
-        }
-        const catalogEntry = findMigrationCatalogEntry(from, to);
-        if (!catalogEntry) {
-          res.status(400).json({
-            error: `Unsupported migration profile: ${from} -> ${to}. Please check the supported catalog.`
-          });
-          return;
-        }
-        const result = await migrationRunner.startMigration({
-          targetPath,
-          from,
-          to
-        });
-        res.json({ ok: true, ...result });
-      } catch (error) {
-        if (error instanceof Error) {
-          res.status(500).json({ error: error.message });
-        } else {
-          res.status(500).json({ error: String(error) });
-        }
-      }
-    });
-    app.post("/api/migrations/apply", async (req, res) => {
-      try {
-        const { runId, targetPath } = req.body;
-        if (!runId || !targetPath) {
-          res.status(400).json({
-            error: "Missing required fields: runId, targetPath"
-          });
-          return;
-        }
-        const integrator = new MigrationIntegrator(migrationRunner.workspace);
-        const message = await integrator.applyMigration(runId, targetPath);
-        res.json({ ok: true, message });
-      } catch (error) {
-        if (error instanceof Error) {
-          res.status(500).json({ error: error.message });
-        } else {
-          res.status(500).json({ error: String(error) });
-        }
-      }
-    });
-    app.post("/api/migrations/rollback", async (req, res) => {
-      try {
-        const { runId } = req.body;
-        if (!runId) {
-          res.status(400).json({
-            error: "Missing required field: runId"
-          });
-          return;
-        }
-        await migrationRunner.rollbackMigration(runId);
-        res.json({ ok: true, message: `Rolled back run: ${runId}` });
-      } catch (error) {
-        if (error instanceof Error) {
-          res.status(500).json({ error: error.message });
-        } else {
-          res.status(500).json({ error: String(error) });
-        }
-      }
-    });
-    app.post("/api/migrations/reset", async (_req, res) => {
-      try {
-        await store.reset();
-        res.json({ ok: true, message: "Migration state reset successfully" });
-      } catch (error) {
-        if (error instanceof Error) {
-          res.status(500).json({ error: error.message });
-        } else {
-          res.status(500).json({ error: String(error) });
-        }
-      }
-    });
-  }
-  const path6 = await import("path");
-  const fs7 = await import("fs");
-  let publicDir = path6.join(import.meta.dirname, "public");
-  if (!fs7.existsSync(publicDir)) {
-    publicDir = path6.join(import.meta.dirname, "../public");
-  }
-  if (fs7.existsSync(publicDir)) {
-    app.use(express.static(publicDir));
-    app.get(/^(.*)$/, (_req, res) => {
-      res.sendFile(path6.join(publicDir, "index.html"));
-    });
-  }
-  return app;
-}
-
-// ../application/src/agents/MapperAgent.ts
-import * as fs3 from "fs";
-import * as path2 from "path";
-import {
-  createAgent,
-  SituationSpecification
-} from "@mozaik-ai/core";
-var WhenMigrationStarts = class extends SituationSpecification {
-  isSatisfiedBy({ event }) {
-    return event.type === "migration.started" /* MIGRATION_STARTED */;
-  }
-};
-var mapFilesProcessor = {
-  async apply({ event, participant }) {
-    const payload = event.payload;
-    console.log(`[MapperAgent] Migration started for Plan: ${payload.planId}`);
-    const shadowDir = payload.shadowWorkspacePath || "";
-    if (!shadowDir) {
-      console.warn("[MapperAgent] No shadow workspace provided. Skipping.");
-      return;
-    }
-    const filesToMigrate = [];
-    const scanDir = (dir) => {
-      if (!fs3.existsSync(dir)) return;
-      const files = fs3.readdirSync(dir);
-      const ignoredDirs = ["node_modules", "dist", "build", "out", "coverage", ".next"];
-      for (const file of files) {
-        if (ignoredDirs.includes(file) || file.startsWith(".")) continue;
-        const fullPath = path2.join(dir, file);
-        if (fs3.statSync(fullPath).isDirectory()) {
-          scanDir(fullPath);
-        } else if (file.endsWith(".ts") || file.endsWith(".js") || file.endsWith(".tsx") || file.endsWith(".jsx")) {
-          filesToMigrate.push(fullPath);
-        }
-      }
-    };
-    scanDir(shadowDir);
-    const runtime = resolveRuntime();
-    const repository = runtime.state.repository;
-    for (const discoveredFile of filesToMigrate) {
-      console.log(`[MapperAgent] Discovered file: ${discoveredFile}`);
-      await repository.updateTaskStatus(payload.planId, discoveredFile, "pending");
-      sendEvent(
-        {
-          type: "file.discovered" /* FILE_DISCOVERED */,
-          producerId: participant.getId(),
-          occurredAt: /* @__PURE__ */ new Date(),
-          payload: {
-            planId: payload.planId,
-            filePath: discoveredFile
-          }
-        },
-        participant.getId()
-      );
-    }
-  }
-};
-var mapFilesHandler = {
-  specification: new WhenMigrationStarts(),
-  processor: mapFilesProcessor
-};
-function createMapperAgent() {
-  return createAgent({
-    name: "Mapper",
-    capabilities: ["code_analysis"],
-    instruction: "You are the Architect Mapper. Your job is to analyze the source code and discover files that need migration.",
-    tools: [],
-    // AST scanning tools will go here later
-    handlers: [mapFilesHandler]
-  });
-}
-
-// ../application/src/agents/WorkerAgent.ts
-import * as fs4 from "fs";
-import {
-  createAgent as createAgent2,
-  SituationSpecification as SituationSpecification2
-} from "@mozaik-ai/core";
-
-// ../application/src/utils/FileTreeBuilder.ts
-import * as path3 from "path";
-function getCommonBaseDir(filePaths) {
-  if (!filePaths || filePaths.length === 0) return "";
-  if (filePaths.length === 1) return path3.dirname(filePaths[0]);
-  const splitPaths = filePaths.map((p) => path3.normalize(p).split(path3.sep));
-  let commonPath = "";
-  for (let i = 0; i < splitPaths[0].length; i++) {
-    const part = splitPaths[0][i];
-    const isCommon = splitPaths.every((parts) => parts[i] === part);
-    if (isCommon) {
-      commonPath = commonPath === "" ? part : commonPath + path3.sep + part;
-    } else {
-      break;
-    }
-  }
-  return commonPath;
-}
-function buildFileTree(filePaths) {
-  if (!filePaths || filePaths.length === 0) return "No files found.";
-  const baseDir = getCommonBaseDir(filePaths);
-  const relativePaths = filePaths.map((p) => path3.relative(baseDir, p)).filter((p) => p.length > 0).sort();
-  if (relativePaths.length === 0) return "No files found.";
-  const tree = {};
-  for (const relPath of relativePaths) {
-    const parts = relPath.split(path3.sep);
-    let current = tree;
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
-      if (i === parts.length - 1) {
-        current[part] = null;
-      } else {
-        current[part] = current[part] || {};
-        current = current[part];
-      }
-    }
-  }
-  let output = `/
-`;
-  function renderTree(node, prefix = "") {
-    if (node === null) return;
-    const keys = Object.keys(node);
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      const isLast = i === keys.length - 1;
-      const isFile = node[key] === null;
-      const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-      output += `${prefix}${connector}${key}
-`;
-      if (!isFile) {
-        const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
-        renderTree(node[key], nextPrefix);
-      }
-    }
-  }
-  renderTree(tree);
-  return output.trim();
-}
-
-// ../application/src/agents/WorkerAgent.ts
-var retryCountMap = /* @__PURE__ */ new Map();
-var MAX_RETRIES = 2;
-var ConcurrencyQueue = class {
-  constructor(concurrencyLimit) {
-    this.concurrencyLimit = concurrencyLimit;
-  }
-  queue = [];
-  activeCount = 0;
-  async enqueue(task) {
-    this.queue.push(task);
-    this.pump();
-  }
-  async pump() {
-    if (this.activeCount >= this.concurrencyLimit || this.queue.length === 0) {
-      return;
-    }
-    const task = this.queue.shift();
-    if (task) {
-      this.activeCount++;
-      try {
-        await task();
-      } catch (error) {
-        console.error("Task error:", error);
-      } finally {
-        this.activeCount--;
-        this.pump();
-      }
-    }
-  }
-};
-var workerQueue = new ConcurrencyQueue(2);
-var WhenFileDiscovered = class extends SituationSpecification2 {
-  isSatisfiedBy({ event }) {
-    return event.type === "file.discovered" /* FILE_DISCOVERED */;
+var workerQueue = new ConcurrencyQueue(3);
+var WhenFileDiscovered = class extends SituationSpecification2 {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.discovered" /* FILE_DISCOVERED */;
   }
 };
 var WhenFileRejected = class extends SituationSpecification2 {
@@ -1291,7 +367,7 @@ var WhenInferenceCompleted = class extends SituationSpecification2 {
 async function startWorkerLoop(planId, filePath, prompt, participant) {
   return new Promise(async (originalResolve) => {
     let isDone = false;
-    const resolve3 = () => {
+    const resolve4 = () => {
       if (!isDone) {
         isDone = true;
         originalResolve();
@@ -1299,32 +375,54 @@ async function startWorkerLoop(planId, filePath, prompt, participant) {
     };
     const runtime = resolveRuntime();
     const repository = runtime.state.repository;
-    console.log(`[WorkerAgent] Marking file as 'in_progress' in database...`);
     await repository.updateTaskStatus(planId, filePath, "in_progress");
     const { createAgent: createMozaikAgent } = await import("@mozaik-ai/core");
+    const { findShadowRoot: findShadowRoot2 } = await import("./NextMigrationHints-BGO2W3K4.js");
+    const shadowRoot = findShadowRoot2(filePath);
+    let workerTools = participant.getTools();
+    if (shadowRoot) {
+      const { createShadowTools } = await import("./src-JHOGUCRS.js");
+      workerTools = createShadowTools(shadowRoot);
+    }
     const tempAgent = createMozaikAgent({
       name: `Worker-${Date.now()}-${Math.floor(Math.random() * 1e3)}`,
       capabilities: ["code_refactoring", "inference"],
-      instruction: "You are the Programmer Worker. Your job is to refactor specific files based on the migration profile. If the target framework requires a different file structure, you are authorized to use your tools to rename, create, or delete files to adhere to architectural rules. When you are done modifying the file(s), simply finish your response.",
-      tools: participant.getTools(),
+      instruction: "You are a staff engineer migrating a real codebase. Deduce from files on disk: read the target and every local module it imports before writing. Never invent callback prop names or re-implement a screen you could import. Prefer evidence over catalog examples.",
+      tools: workerTools,
       handlers: [
         {
           specification: new WhenInferenceCompleted(),
           processor: {
-            async apply({ event: completionEvent, participant: tempParticipant }) {
-              console.log(`[WorkerAgent:${tempParticipant.getId()}] Inference completed. Emitting FILE_MIGRATED.`);
-              let fileContent = "No content available";
+            async apply({ participant: tempParticipant }) {
+              if (isDone) {
+                return;
+              }
+              const exists = fs3.existsSync(filePath);
+              if (workerCompletionKind(exists) === "failed_missing") {
+                console.warn(`[WorkerAgent:${tempParticipant.getId()}] File not found on disk after inference: ${filePath}`);
+                await repository.updateTaskStatus(planId, filePath, "failed", MISSING_AFTER_WORKER);
+                sendEvent(
+                  {
+                    type: "file.failed" /* FILE_FAILED */,
+                    producerId: tempParticipant.getId(),
+                    occurredAt: /* @__PURE__ */ new Date(),
+                    payload: { planId, filePath, reason: MISSING_AFTER_WORKER }
+                  },
+                  tempParticipant.getId()
+                );
+                leave(tempParticipant);
+                resolve4();
+                return;
+              }
+              let fileContent = "";
               try {
-                if (fs4.existsSync(filePath)) {
-                  fileContent = fs4.readFileSync(filePath, "utf-8");
-                  console.log(`[WorkerAgent:${tempParticipant.getId()}] Read ${fileContent.length} chars from ${filePath}`);
-                } else {
-                  console.warn(`[WorkerAgent:${tempParticipant.getId()}] File not found on disk: ${filePath}`);
-                }
+                fileContent = fs3.readFileSync(filePath, "utf-8");
+                console.log(`[WorkerAgent:${tempParticipant.getId()}] Read ${fileContent.length} chars from ${filePath}`);
               } catch (e) {
                 console.error(`[WorkerAgent:${tempParticipant.getId()}] Error reading file:`, e);
               }
-              await repository.updateTaskStatus(planId, filePath, "completed");
+              console.log(`[WorkerAgent:${tempParticipant.getId()}] Inference completed. Emitting FILE_MIGRATED.`);
+              await repository.updateTaskStatus(planId, filePath, "in_progress");
               sendEvent(
                 {
                   type: "file.migrated" /* FILE_MIGRATED */,
@@ -1339,7 +437,7 @@ async function startWorkerLoop(planId, filePath, prompt, participant) {
                 tempParticipant.getId()
               );
               leave(tempParticipant);
-              resolve3();
+              resolve4();
             }
           }
         }
@@ -1356,19 +454,31 @@ async function startWorkerLoop(planId, filePath, prompt, participant) {
       });
       setTimeout(async () => {
         if (!isDone) {
-          console.error(`[WorkerAgent:${tempAgent.getId()}] Inference timed out.`);
-          await repository.updateTaskStatus(planId, filePath, "failed", "Inference timed out");
+          console.error(`[WorkerAgent:${tempAgent.getId()}] Inference timed out after 120s.`);
+          await repository.updateTaskStatus(planId, filePath, "failed", "Inference timed out after 120s");
+          sendEvent({
+            type: "file.failed" /* FILE_FAILED */,
+            producerId: tempAgent.getId(),
+            occurredAt: /* @__PURE__ */ new Date(),
+            payload: { planId, filePath, reason: "Inference timed out after 120s" }
+          }, tempAgent.getId());
           leave(tempAgent);
-          resolve3();
+          resolve4();
         }
-      }, 45e3);
+      }, 12e4);
     } catch (error) {
       console.error(`[WorkerAgent:${tempAgent.getId()}] Sync error:`, error);
       if (!isDone) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         await repository.updateTaskStatus(planId, filePath, "failed", errorMessage || "Sync error");
+        sendEvent({
+          type: "file.failed" /* FILE_FAILED */,
+          producerId: tempAgent.getId(),
+          occurredAt: /* @__PURE__ */ new Date(),
+          payload: { planId, filePath, reason: errorMessage || "Sync error" }
+        }, tempAgent.getId());
         leave(tempAgent);
-        resolve3();
+        resolve4();
       }
     }
   });
@@ -1384,13 +494,13 @@ var workOnFileProcessor = {
     if (plan) {
       prompt += `Migration Profile: Transform from ${plan.profile.source} to ${plan.profile.target}.
 `;
-      const catalogEntry = findMigrationCatalogEntry(plan.profile.source, plan.profile.target);
+      const catalogEntry = resolveMigrationCatalog(plan.profile.source, plan.profile.target);
       if (catalogEntry) {
         prompt += `
-Strict Architectural Rules for this Migration:
+Architectural rules (all \u2192 ${catalogEntry.layer} \u2192 frameworks \u2192 this pair):
+`;
+        prompt += `${formatCatalogRules(catalogEntry.ruleSections)}
 `;
-        catalogEntry.architecturalRules.forEach((rule) => prompt += `- ${rule}
-`);
         if (catalogEntry.examples && catalogEntry.examples.length > 0) {
           prompt += `
 Reference Examples:
@@ -1427,8 +537,20 @@ ${projectTree}
         prompt += `Use this context to ensure your changes align with the overall project structure and other files.
 `;
       }
+      prompt += collectFileHints(
+        payload.filePath,
+        { source: plan.profile.source, target: plan.profile.target },
+        catalogEntry?.layer
+      );
     }
-    prompt += `Please read the file using your tools, rewrite it according to the rules, and write it back. If the rules require breaking this file into multiple files, use your create, rename, or delete file tools accordingly.`;
+    prompt += buildNeighborContext(payload.filePath);
+    prompt += `
+You are not a mechanical find-replace bot. Deduce the correct change from the evidence above and from tools (read_file, list_directory).
+Before writing:
+1. Read every local import you will call.
+2. Keep that module's public prop/export names exactly.
+3. If this is a router/bootstrap file, import an existing screen from the nearby paths \u2014 do not paste a new copy of its JSX.
+Then write the file(s). If structure must change, create/rename/delete accordingly.`;
     workerQueue.enqueue(async () => {
       await startWorkerLoop(payload.planId, payload.filePath, prompt, participant);
     });
@@ -1438,22 +560,39 @@ var fixRejectedFileProcessor = {
   async apply({ event, participant }) {
     const payload = event.payload;
     const retryKey = `${payload.planId}:${payload.filePath}`;
-    const currentRetries = retryCountMap.get(retryKey) || 0;
+    const retries = resolveRuntime().state.retryCounts;
+    if (payload.source === "integration") {
+      retries.delete(retryKey);
+    }
+    const currentRetries = retries.get(retryKey) || 0;
     if (currentRetries >= MAX_RETRIES) {
       console.warn(`[WorkerAgent] File ${payload.filePath} exceeded max retries (${MAX_RETRIES}). Marking as failed.`);
       const runtime2 = resolveRuntime();
       await runtime2.state.repository.updateTaskStatus(payload.planId, payload.filePath, "failed", `Exceeded max retries (${MAX_RETRIES})`);
-      retryCountMap.delete(retryKey);
+      retries.delete(retryKey);
+      sendEvent({
+        type: "file.failed" /* FILE_FAILED */,
+        producerId: participant.getId(),
+        occurredAt: /* @__PURE__ */ new Date(),
+        payload: { planId: payload.planId, filePath: payload.filePath, reason: `Exceeded max retries (${MAX_RETRIES})` }
+      }, participant.getId());
       return;
     }
-    retryCountMap.set(retryKey, currentRetries + 1);
+    retries.set(retryKey, currentRetries + 1);
     console.log(`[WorkerAgent] File REJECTED (attempt ${currentRetries + 1}/${MAX_RETRIES}), initiating repair loop: ${payload.filePath}`);
     const runtime = resolveRuntime();
     const plan = await runtime.state.repository.getPlan(payload.planId);
     let prompt = `You need to FIX the file at path: ${payload.filePath}
 `;
-    prompt += `Your previous migration was REJECTED by the Quality Assurance Reviewer.
+    if (payload.source === "integration") {
+      prompt += `The Integration Agent rejected this file because the shadow workspace failed npm install / npm run build, or a catalog verifier flagged it.
+`;
+      prompt += `If the file does not exist yet, create it. If it is a router/bootstrap file, import existing screens \u2014 do not re-implement them or rename their callback props.
 `;
+    } else {
+      prompt += `Your previous migration was REJECTED by the Quality Assurance Reviewer.
+`;
+    }
     prompt += `Feedback/Errors:
 ${payload.errors.join("\n")}
 
@@ -1461,13 +600,13 @@ ${payload.errors.join("\n")}
     if (plan) {
       prompt += `Migration Profile: Transform from ${plan.profile.source} to ${plan.profile.target}.
 `;
-      const catalogEntry = findMigrationCatalogEntry(plan.profile.source, plan.profile.target);
+      const catalogEntry = resolveMigrationCatalog(plan.profile.source, plan.profile.target);
       if (catalogEntry) {
         prompt += `
-Strict Architectural Rules for this Migration:
+Architectural rules (all \u2192 ${catalogEntry.layer} \u2192 frameworks \u2192 this pair):
+`;
+        prompt += `${formatCatalogRules(catalogEntry.ruleSections)}
 `;
-        catalogEntry.architecturalRules.forEach((rule) => prompt += `- ${rule}
-`);
       }
       if (plan.tasks && plan.tasks.length > 0) {
         const allFiles = plan.tasks.map((t) => t.filePath);
@@ -1482,19 +621,26 @@ ${projectTree}
         prompt += `Ensure you respect this overall project structure while fixing the issues.
 `;
       }
+      prompt += collectFileHints(
+        payload.filePath,
+        { source: plan.profile.source, target: plan.profile.target },
+        catalogEntry?.layer
+      );
     }
-    prompt += `Please read the file, fix the issues mentioned, and write it back. You may restructure the files if the architectural rules demand it.`;
+    prompt += buildNeighborContext(payload.filePath);
+    prompt += `
+Deduce the fix from the errors and the disk evidence. Read imported modules (and list_directory if you need another screen). Do not guess APIs. Then write the corrected file(s). If the path does not exist, create it. Do not delete existing screens just to make a router file compile.`;
     workerQueue.enqueue(async () => {
       await startWorkerLoop(payload.planId, payload.filePath, prompt, participant);
     });
   }
 };
 var fatalMismatchProcessor = {
-  async apply({ event }) {
+  async apply({ event, participant }) {
     const payload = event.payload;
     console.error(`[WorkerAgent] \u{1F6D1} FATAL MISMATCH received for ${payload.filePath}. Reason: ${payload.reason}`);
     const retryKey = `${payload.planId}:${payload.filePath}`;
-    retryCountMap.delete(retryKey);
+    resolveRuntime().state.retryCounts.delete(retryKey);
     const runtime = resolveRuntime();
     await runtime.state.repository.updateTaskStatus(
       payload.planId,
@@ -1502,6 +648,12 @@ var fatalMismatchProcessor = {
       "failed",
       `Fatal Architectural Mismatch: ${payload.reason}`
     );
+    sendEvent({
+      type: "file.failed" /* FILE_FAILED */,
+      producerId: participant.getId(),
+      occurredAt: /* @__PURE__ */ new Date(),
+      payload: { planId: payload.planId, filePath: payload.filePath, reason: payload.reason }
+    }, participant.getId());
   }
 };
 function createWorkerAgent(tools) {
@@ -1523,6 +675,116 @@ import {
   createAgent as createAgent3,
   SituationSpecification as SituationSpecification3
 } from "@mozaik-ai/core";
+import * as path5 from "path";
+
+// ../application/src/utils/classifyMissingFile.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+var NEXT_CONFIG_NAMES = [
+  "next.config.js",
+  "next.config.mjs",
+  "next.config.ts",
+  "next.config.cjs"
+];
+var CONFIG_FILE_PATTERN = /[/\\](vite\.config|craco\.config|webpack\.config)\.(js|ts|mjs|cjs)$/i;
+function classifyMissingFile(input) {
+  const { filePath, target } = input;
+  const fileExists = input.fileExists || fs4.existsSync;
+  const shadowRoot = input.shadowRoot !== void 0 ? input.shadowRoot : findShadowRoot(filePath);
+  const normalizedTarget = target.toLowerCase();
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  if (CONFIG_FILE_PATTERN.test(filePath)) {
+    if (normalizedTarget === "next" && shadowRoot) {
+      const hasNextConfig = NEXT_CONFIG_NAMES.some(
+        (cfg) => fileExists(path4.join(shadowRoot, cfg))
+      );
+      if (hasNextConfig) {
+        return {
+          verdict: "approved",
+          reason: `Config file removed because a Next.js configuration exists in shadow workspace.`
+        };
+      }
+      return {
+        verdict: "rejected",
+        errors: [
+          `Configuration file was removed, but no Next.js configuration (next.config.js/mjs/ts) was found in the project root.`
+        ]
+      };
+    }
+  }
+  if (/[/\\]index\.html$/i.test(filePath)) {
+    if (normalizedTarget === "next" && shadowRoot) {
+      const layoutCandidates = [
+        path4.join(shadowRoot, "src", "app", "layout.tsx"),
+        path4.join(shadowRoot, "src", "app", "layout.jsx"),
+        path4.join(shadowRoot, "src", "app", "layout.js"),
+        path4.join(shadowRoot, "app", "layout.tsx"),
+        path4.join(shadowRoot, "app", "layout.jsx"),
+        path4.join(shadowRoot, "app", "layout.js"),
+        path4.join(shadowRoot, "src", "pages", "_document.tsx"),
+        path4.join(shadowRoot, "pages", "_document.tsx")
+      ];
+      const hasLayout = layoutCandidates.some((candidate) => fileExists(candidate));
+      if (hasLayout) {
+        return {
+          verdict: "approved",
+          reason: `index.html was removed because Next.js root layout or _document exists.`
+        };
+      }
+      return {
+        verdict: "rejected",
+        errors: [
+          `index.html was removed, but no Next.js root layout (app/layout.tsx) or _document was created to provide the HTML structure.`
+        ]
+      };
+    }
+  }
+  if (isSpaRootComponent(filePath)) {
+    if (normalizedTarget === "next") {
+      const hasRoutes = shadowRoot ? hasNextAppRoutes(shadowRoot) : false;
+      if (hasRoutes) {
+        return {
+          verdict: "approved",
+          reason: `SPA root component was removed because Next.js App Router routes exist.`
+        };
+      }
+      return {
+        verdict: "rejected",
+        errors: [
+          `The SPA root was deleted before src/app/**/page.tsx existed with real UI. Recreate routing as Next App Router pages that import the original screen components. Do not import App from those pages.`
+        ]
+      };
+    }
+  }
+  if (isFsdPageComponent(filePath) || isSpaPagesTreeFile(filePath)) {
+    if (normalizedTarget === "next") {
+      const viewsReplacement = filePath.replace(/([/\\])src\1pages\1/, "$1src$1views$1");
+      const screensReplacement = filePath.replace(/([/\\])src\1pages\1/, "$1src$1screens$1");
+      const compReplacement = filePath.replace(/([/\\])src\1pages\1/, "$1src$1components$1pages$1");
+      if (fileExists(viewsReplacement) || fileExists(screensReplacement) || fileExists(compReplacement)) {
+        return {
+          verdict: "approved",
+          reason: `File moved out of src/pages into a non-reserved directory for Next.js.`
+        };
+      }
+      return {
+        verdict: "rejected",
+        errors: [
+          `This file lived under src/pages as SPA UI. Next.js reserves src/pages for the Pages Router \u2014 move the tree to a non-reserved folder (e.g. src/views) and import those screens from src/app. Do not delete the UI without a replacement.`
+        ]
+      };
+    }
+  }
+  const fileName = path4.basename(filePath);
+  return {
+    verdict: "rejected",
+    errors: [
+      `File "${fileName}" does not exist on disk and has no demonstrable replacement or migration successor. Code migrations must preserve UI or migrate to a target equivalent.`
+    ]
+  };
+}
+
+// ../application/src/agents/ReviewerAgent.ts
 var ConcurrencyQueue2 = class {
   constructor(concurrencyLimit) {
     this.concurrencyLimit = concurrencyLimit;
@@ -1551,7 +813,7 @@ var ConcurrencyQueue2 = class {
     }
   }
 };
-var reviewerQueue = new ConcurrencyQueue2(2);
+var reviewerQueue = new ConcurrencyQueue2(3);
 var WhenFileMigrated = class extends SituationSpecification3 {
   isSatisfiedBy({ event }) {
     return event.type === "file.migrated" /* FILE_MIGRATED */;
@@ -1559,15 +821,9 @@ var WhenFileMigrated = class extends SituationSpecification3 {
 };
 var WhenReviewCompleted = class extends SituationSpecification3 {
   isSatisfiedBy({ event, participant }) {
-    console.log(`[DEBUG:WhenReviewCompleted] Event received -> type: "${event.type}", producerId: "${event.producerId}", participantId: "${participant.getId()}", match: ${event.type === "model.answer" && event.producerId === participant.getId()}`);
     return event.type === "model.answer" && event.producerId === participant.getId();
   }
 };
-var WhenAnythingHappens = class extends SituationSpecification3 {
-  isSatisfiedBy() {
-    return true;
-  }
-};
 var reviewFileProcessor = {
   async apply({ event, participant }) {
     const payload = event.payload;
@@ -1575,56 +831,46 @@ var reviewFileProcessor = {
     reviewerQueue.enqueue(async () => {
       return new Promise(async (originalResolve) => {
         let isDone = false;
-        const resolve3 = () => {
+        const resolve4 = () => {
           if (!isDone) {
             isDone = true;
-            console.log(`[DEBUG:ReviewerAgent] Promise resolved for ${payload.filePath}`);
             originalResolve();
           }
         };
         const { createAgent: createMozaikAgent } = await import("@mozaik-ai/core");
-        const { sendEvent: sendEvent3 } = await import("./runtime-5OVGH2Y7.js");
+        const { sendEvent: sendEvent3 } = await import("./runtime-L7VOQROE.js");
         const reviewerId = `Reviewer-${Date.now()}-${Math.floor(Math.random() * 1e3)}`;
         const tempAgent = createMozaikAgent({
           name: reviewerId,
           capabilities: ["code_review", "inference"],
-          instruction: "You are the Quality Assurance Reviewer. You must review the migrated code. Note that you are reviewing a SINGLE FILE within a larger migration. Evaluate if the file violates architectural rules, but DO NOT reject it simply because it does not demonstrate all architectural features (e.g. do not reject a test file or a bootstrap file just because it lacks a Controller). If the worker completely violated the architectural paradigm in a way that cannot be fixed by a simple code edit, use status FATAL_MISMATCH to abort.",
+          instruction: "You are a staff engineer reviewing a migrated file against its neighbors. Reject if public props/emits do not match imported modules, if a router file re-implements a screen instead of importing it, or if a screen was hollowed out. UI that lived under src/pages in a SPA is not a Next Pages Router file. Do not reject a file just because it lacks every catalog feature. FATAL_MISMATCH only for an unfixable paradigm break.",
           tools: [],
           // No tools to avoid Gemini thought_signature crash
           handlers: [
-            // DEBUG: Catch-all handler to log every event this agent receives
-            {
-              specification: new WhenAnythingHappens(),
-              processor: {
-                async apply({ event: anyEvent, participant: anyParticipant }) {
-                  console.log(`[DEBUG:ReviewerAgent:${reviewerId}:CATCH_ALL] Event -> type: "${anyEvent.type}", producerId: "${anyEvent.producerId}", myId: "${anyParticipant.getId()}", payload keys: ${Object.keys(anyEvent.payload || {}).join(",")}`);
-                }
-              }
-            },
             {
               specification: new WhenReviewCompleted(),
               processor: {
                 async apply({ event: event2, participant: tempParticipant }) {
-                  console.log(`[DEBUG:ReviewerAgent:${reviewerId}] model.answer RECEIVED!`);
+                  if (isDone) {
+                    return;
+                  }
                   const answerItem = event2.payload.answer;
                   const answerText = answerItem?.content?.text || answerItem?.text || null;
-                  console.log(`[DEBUG:ReviewerAgent:${reviewerId}] answerText:`, answerText);
                   let reviewResult = null;
                   if (answerText) {
                     try {
                       reviewResult = JSON.parse(answerText);
-                      console.log(`[DEBUG:ReviewerAgent:${reviewerId}] Parsed result:`, JSON.stringify(reviewResult));
                     } catch (e) {
                       console.error(`[ReviewerAgent:${reviewerId}] Failed to parse JSON:`, e);
                     }
-                  } else {
-                    console.warn(`[DEBUG:ReviewerAgent:${reviewerId}] answerItem has no extractable text.`);
                   }
                   if (reviewResult) {
                     const participantId = tempParticipant.getId();
                     try {
                       if (reviewResult.status === "APPROVED") {
                         console.log(`[ReviewerAgent:${reviewerId}] File ${payload.filePath} APPROVED!`);
+                        const runtime2 = await resolveRuntime();
+                        await runtime2.state.repository.updateTaskStatus(payload.planId, payload.filePath, "completed");
                         sendEvent3({
                           type: "file.reviewed" /* FILE_REVIEWED */,
                           producerId: participantId,
@@ -1651,46 +897,66 @@ var reviewFileProcessor = {
                     } catch (e) {
                       console.error(`[ReviewerAgent:${reviewerId}] Failed to send review event:`, e);
                     }
-                    try {
-                      const runtime2 = await resolveRuntime();
-                      const plan2 = await runtime2.state.repository.getPlan(payload.planId);
-                      if (plan2) {
-                        const allTerminal = plan2.tasks.every((t) => t.status === "completed" || t.status === "failed");
-                        if (allTerminal) {
-                          console.log(`[App] All tasks reached terminal state. Emitting MIGRATION_COMPLETED.`);
-                          sendEvent3({
-                            type: "migration.completed" /* MIGRATION_COMPLETED */,
-                            producerId: participantId,
-                            occurredAt: /* @__PURE__ */ new Date(),
-                            payload: { planId: payload.planId }
-                          }, participantId);
-                        }
-                      }
-                    } catch (e) {
-                      console.error(`[ReviewerAgent:${reviewerId}] Failed to check migration completion:`, e);
-                    }
                   }
                   leave(tempParticipant);
-                  resolve3();
+                  resolve4();
                 }
               }
             }
           ]
         });
-        console.log(`[DEBUG:ReviewerAgent:${reviewerId}] tempAgent created with id: ${tempAgent.getId()}`);
         join(tempAgent);
-        console.log(`[DEBUG:ReviewerAgent:${reviewerId}] tempAgent joined the runtime`);
         const runtime = resolveRuntime();
+        const { existsSync: existsSync8 } = await import("fs");
+        if (!existsSync8(payload.filePath)) {
+          const { sendEvent: sendEvent4 } = await import("./runtime-L7VOQROE.js");
+          const planForMissing = await runtime.state.repository.getPlan(payload.planId);
+          const sourceFramework = planForMissing?.profile.source || "react";
+          const targetFramework = planForMissing?.profile.target || "next";
+          const shadowRoot = findShadowRoot(payload.filePath);
+          const classification = classifyMissingFile({
+            filePath: payload.filePath,
+            source: sourceFramework,
+            target: targetFramework,
+            shadowRoot,
+            fileExists: existsSync8
+          });
+          if (classification.verdict === "approved") {
+            console.log(`[ReviewerAgent:${reviewerId}] Missing ${payload.filePath} approved: ${classification.reason}`);
+            await runtime.state.repository.updateTaskStatus(payload.planId, payload.filePath, "completed");
+            sendEvent4({
+              type: "file.reviewed" /* FILE_REVIEWED */,
+              producerId: tempAgent.getId(),
+              occurredAt: /* @__PURE__ */ new Date(),
+              payload: { planId: payload.planId, filePath: payload.filePath }
+            }, tempAgent.getId());
+          } else {
+            console.log(`[ReviewerAgent:${reviewerId}] Missing ${payload.filePath} rejected:`, classification.errors);
+            sendEvent4({
+              type: "file.rejected" /* FILE_REJECTED */,
+              producerId: tempAgent.getId(),
+              occurredAt: /* @__PURE__ */ new Date(),
+              payload: {
+                planId: payload.planId,
+                filePath: payload.filePath,
+                errors: classification.errors || ["File does not exist and has no demonstrable replacement"]
+              }
+            }, tempAgent.getId());
+          }
+          leave(tempAgent);
+          resolve4();
+          return;
+        }
         if (payload.filePath.endsWith(".ts") || payload.filePath.endsWith(".tsx")) {
           try {
-            const { Project: Project2 } = await import("ts-morph");
-            const tsProject = new Project2();
+            const { Project } = await import("ts-morph");
+            const tsProject = new Project();
             const sf = tsProject.addSourceFileAtPath(payload.filePath);
             const diagnostics = sf.getPreEmitDiagnostics();
             const syntaxErrors = diagnostics.filter((d) => d.getCode() >= 1e3 && d.getCode() < 2e3);
             if (syntaxErrors.length > 0) {
               console.error(`[ReviewerAgent:${reviewerId}] Syntax Error in ${payload.filePath}. Rejecting immediately.`);
-              const { sendEvent: sendEvent4 } = await import("./runtime-5OVGH2Y7.js");
+              const { sendEvent: sendEvent4 } = await import("./runtime-L7VOQROE.js");
               sendEvent4({
                 type: "file.rejected" /* FILE_REJECTED */,
                 producerId: tempAgent.getId(),
@@ -1702,7 +968,7 @@ var reviewFileProcessor = {
                 }
               }, tempAgent.getId());
               leave(tempAgent);
-              resolve3();
+              resolve4();
               return;
             }
           } catch (e) {
@@ -1710,28 +976,55 @@ var reviewFileProcessor = {
           }
         }
         const plan = await runtime.state.repository.getPlan(payload.planId);
+        if (plan && plan.profile.source.toLowerCase() === "react" && plan.profile.target.toLowerCase() === "next") {
+          const shadowRoot = findShadowRoot(payload.filePath);
+          if (shadowRoot) {
+            const current = path5.resolve(payload.filePath);
+            const structureIssues = analyzeReactToNextStructure(shadowRoot).filter(
+              (issue) => path5.resolve(issue.filePath) === current
+            );
+            if (structureIssues.length > 0) {
+              const errors = structureIssues.flatMap((issue) => issue.errors);
+              console.error(`[ReviewerAgent:${reviewerId}] Structure verifier rejected ${payload.filePath}.`, errors);
+              sendEvent3({
+                type: "file.rejected" /* FILE_REJECTED */,
+                producerId: tempAgent.getId(),
+                occurredAt: /* @__PURE__ */ new Date(),
+                payload: { planId: payload.planId, filePath: payload.filePath, errors }
+              }, tempAgent.getId());
+              leave(tempAgent);
+              resolve4();
+              return;
+            }
+          }
+        }
         let prompt = `Review the following file migration: ${payload.filePath}
 `;
         if (plan) {
           prompt += `Migration Profile: Transform from ${plan.profile.source} to ${plan.profile.target}.
 `;
-          const catalogEntry = findMigrationCatalogEntry(plan.profile.source, plan.profile.target);
+          const catalogEntry = resolveMigrationCatalog(plan.profile.source, plan.profile.target);
           if (catalogEntry) {
             prompt += `
-Strict Architectural Rules for this Migration (apply only if relevant to this file's purpose):
+Architectural rules (all \u2192 ${catalogEntry.layer} \u2192 frameworks \u2192 this pair; apply only if relevant to this file):
+`;
+            prompt += `${formatCatalogRules(catalogEntry.ruleSections)}
 `;
-            catalogEntry.architecturalRules.forEach((rule) => prompt += `- ${rule}
-`);
           }
+          prompt += collectFileHints(
+            payload.filePath,
+            { source: plan.profile.source, target: plan.profile.target },
+            catalogEntry?.layer
+          );
         }
         prompt += `
-Diff or new content:
+${buildNeighborContext(payload.filePath)}
+Diff or new content of the file under review:
 ${payload.diff}
-Does it meet the criteria? You MUST respond in JSON.`;
-        const modelToUse = process.env.METAMORPH_REVIEWER_MODEL || process.env.METAMORPH_MODEL || "gpt-5.4-mini";
+Compare the diff to imported modules in the evidence. If props/exports do not match, REJECT with a specific error. You MUST respond in JSON.`;
+        const modelToUse = process.env.METAMORPH_REVIEWER_MODEL || process.env.METAMORPH_MODEL || "gpt-5.4";
         console.log(`[ReviewerAgent:${reviewerId}] Starting inference loop for ${payload.filePath} with model ${modelToUse}...`);
         try {
-          console.log(`[DEBUG:ReviewerAgent:${reviewerId}] Calling runLoop with agentId: ${tempAgent.getId()}`);
           runLoop(tempAgent.getId(), prompt, {
             model: modelToUse,
             context: tempAgent.getMemory().getContext(),
@@ -1749,329 +1042,1694 @@ Does it meet the criteria? You MUST respond in JSON.`;
               strict: true
             }
           });
-          console.log(`[DEBUG:ReviewerAgent:${reviewerId}] runLoop called successfully (fire-and-forget)`);
           setTimeout(async () => {
             if (!isDone) {
-              console.error(`[ReviewerAgent:${reviewerId}] \u23F0 TIMEOUT after 45s for ${payload.filePath}. Model never responded.`);
-              const { resolveRuntime: resolveRuntime2 } = await import("./runtime-5OVGH2Y7.js");
+              console.error(`[ReviewerAgent:${reviewerId}] \u23F0 TIMEOUT after 120s for ${payload.filePath}. Model never responded.`);
+              const { resolveRuntime: resolveRuntime2 } = await import("./runtime-L7VOQROE.js");
               const runtime2 = resolveRuntime2();
-              await runtime2.state.repository.updateTaskStatus(payload.planId, payload.filePath, "failed", "Inference timed out after 45s");
+              await runtime2.state.repository.updateTaskStatus(payload.planId, payload.filePath, "failed", "Inference timed out after 120s");
+              sendEvent3({
+                type: "file.failed" /* FILE_FAILED */,
+                producerId: tempAgent.getId(),
+                occurredAt: /* @__PURE__ */ new Date(),
+                payload: { planId: payload.planId, filePath: payload.filePath, reason: "Inference timed out after 120s" }
+              }, tempAgent.getId());
               leave(tempAgent);
-              resolve3();
+              resolve4();
             }
-          }, 45e3);
+          }, 12e4);
         } catch (error) {
           console.error(`[ReviewerAgent:${reviewerId}] Sync error:`, error);
           if (!isDone) {
-            const { resolveRuntime: resolveRuntime2 } = await import("./runtime-5OVGH2Y7.js");
+            const { resolveRuntime: resolveRuntime2 } = await import("./runtime-L7VOQROE.js");
             const runtime2 = resolveRuntime2();
             const errorMessage = error instanceof Error ? error.message : String(error);
             await runtime2.state.repository.updateTaskStatus(payload.planId, payload.filePath, "failed", errorMessage || "Sync error");
+            sendEvent3({
+              type: "file.failed" /* FILE_FAILED */,
+              producerId: tempAgent.getId(),
+              occurredAt: /* @__PURE__ */ new Date(),
+              payload: { planId: payload.planId, filePath: payload.filePath, reason: errorMessage || "Sync error" }
+            }, tempAgent.getId());
             leave(tempAgent);
-            resolve3();
+            resolve4();
           }
         }
       });
     });
   }
 };
-var reviewFileHandler = {
-  specification: new WhenFileMigrated(),
-  processor: reviewFileProcessor
-};
-function createReviewerAgent(tools) {
-  return createAgent3({
-    name: "Reviewer",
-    capabilities: ["code_review", "inference"],
-    instruction: "You are the Reviewer Worker.",
+var reviewFileHandler = {
+  specification: new WhenFileMigrated(),
+  processor: reviewFileProcessor
+};
+function createReviewerAgent(tools) {
+  return createAgent3({
+    name: "Reviewer",
+    capabilities: ["code_review", "inference"],
+    instruction: "You are the Reviewer Worker.",
+    tools: [],
+    // No tools
+    handlers: [reviewFileHandler]
+  });
+}
+
+// ../application/src/agents/PackageManagerAgent.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+import {
+  createAgent as createAgent4,
+  SituationSpecification as SituationSpecification4
+} from "@mozaik-ai/core";
+var WhenMigrationStarts2 = class extends SituationSpecification4 {
+  isSatisfiedBy({ event }) {
+    return event.type === "migration.started" /* MIGRATION_STARTED */;
+  }
+};
+var managePackagesProcessor = {
+  async apply({ event, participant }) {
+    const payload = event.payload;
+    console.log(`[PackageManagerAgent] Managing dependencies and cleanup for Plan: ${payload.planId}`);
+    const runtime = resolveRuntime();
+    const emitPackagesReady = async (status = "completed") => {
+      const currentPlan = await runtime.state.repository.getPlan(payload.planId);
+      if (currentPlan) {
+        const pmTaskToComplete = currentPlan.tasks.find((t) => t.filePath === "system:package_manager");
+        if (pmTaskToComplete) {
+          pmTaskToComplete.status = status;
+          await runtime.state.repository.savePlan(currentPlan);
+        }
+      }
+      sendEvent({
+        type: "phase.packages_ready" /* PHASE_PACKAGES_READY */,
+        producerId: participant.getId(),
+        occurredAt: /* @__PURE__ */ new Date(),
+        payload: { planId: payload.planId }
+      }, participant.getId());
+    };
+    const shadowDir = payload.shadowWorkspacePath || "";
+    if (!shadowDir || !fs5.existsSync(shadowDir)) {
+      console.warn("[PackageManagerAgent] No valid shadow workspace provided. Skipping.");
+      await emitPackagesReady("failed");
+      return;
+    }
+    const plan = await runtime.state.repository.getPlan(payload.planId);
+    if (!plan) {
+      console.warn("[PackageManagerAgent] Migration plan not found.");
+      await emitPackagesReady("failed");
+      return;
+    }
+    const catalogEntry = resolveMigrationCatalog(plan.profile.source, plan.profile.target);
+    if (!catalogEntry) {
+      console.log(`[PackageManagerAgent] No catalog entry found for ${plan.profile.source} -> ${plan.profile.target}`);
+      await emitPackagesReady("failed");
+      return;
+    }
+    const pmTask = plan.tasks.find((t) => t.filePath === "system:package_manager");
+    if (pmTask) {
+      pmTask.status = "in_progress";
+      await runtime.state.repository.savePlan(plan);
+    }
+    if (catalogEntry.filesToDelete && catalogEntry.filesToDelete.length > 0) {
+      for (const fileToDelete of catalogEntry.filesToDelete) {
+        const fullPath = path6.join(shadowDir, fileToDelete);
+        if (fs5.existsSync(fullPath)) {
+          fs5.unlinkSync(fullPath);
+          console.log(`[PackageManagerAgent] Deleted deprecated file: ${fileToDelete}`);
+        }
+      }
+    }
+    if (catalogEntry.filesToScaffold) {
+      for (const [filename, content] of Object.entries(catalogEntry.filesToScaffold)) {
+        const fullPath = path6.join(shadowDir, filename);
+        if (!fs5.existsSync(fullPath)) {
+          fs5.mkdirSync(path6.dirname(fullPath), { recursive: true });
+          fs5.writeFileSync(fullPath, content, "utf-8");
+          console.log(`[PackageManagerAgent] Scaffolded missing structural file: ${filename}`);
+        }
+      }
+    }
+    const packageJsonPath = path6.join(shadowDir, "package.json");
+    if (fs5.existsSync(packageJsonPath)) {
+      try {
+        const pkgRaw = fs5.readFileSync(packageJsonPath, "utf-8");
+        const pkg = JSON.parse(pkgRaw);
+        if (!pkg.dependencies) pkg.dependencies = {};
+        if (!pkg.devDependencies) pkg.devDependencies = {};
+        if (catalogEntry.dependenciesToRemove) {
+          for (const dep of catalogEntry.dependenciesToRemove) {
+            delete pkg.dependencies[dep];
+            delete pkg.devDependencies[dep];
+          }
+        }
+        if (catalogEntry.devDependenciesToRemove) {
+          for (const dep of catalogEntry.devDependenciesToRemove) {
+            delete pkg.dependencies[dep];
+            delete pkg.devDependencies[dep];
+          }
+        }
+        if (catalogEntry.dependenciesToAdd) {
+          for (const [dep, ver] of Object.entries(catalogEntry.dependenciesToAdd)) {
+            pkg.dependencies[dep] = ver;
+          }
+        }
+        if (catalogEntry.devDependenciesToAdd) {
+          for (const [dep, ver] of Object.entries(catalogEntry.devDependenciesToAdd)) {
+            pkg.devDependencies[dep] = ver;
+          }
+        }
+        if (Object.keys(pkg.devDependencies).length === 0) delete pkg.devDependencies;
+        if (catalogEntry.scriptsToUpdate) {
+          if (!pkg.scripts) pkg.scripts = {};
+          for (const [scriptName, scriptCmd] of Object.entries(catalogEntry.scriptsToUpdate)) {
+            pkg.scripts[scriptName] = scriptCmd;
+          }
+        }
+        if (catalogEntry.scriptsToRemove && pkg.scripts) {
+          for (const scriptName of catalogEntry.scriptsToRemove) {
+            delete pkg.scripts[scriptName];
+          }
+        }
+        fs5.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+        console.log(`[PackageManagerAgent] Updated package.json dependencies directly (no npm subprocess).`);
+        sendEvent({
+          type: "system.log" /* SYSTEM_LOG */,
+          producerId: participant.getId(),
+          occurredAt: /* @__PURE__ */ new Date(),
+          payload: { planId: payload.planId, message: "PackageManager updated package.json. IntegrationAgent will run npm install in the shadow workspace \u2014 the original project is untouched until you Apply.", level: "info" }
+        }, participant.getId());
+      } catch (err) {
+        console.error(`[PackageManagerAgent] Error editing package.json:`, err);
+      }
+    } else {
+      console.log(`[PackageManagerAgent] No package.json found at ${packageJsonPath}`);
+    }
+    await emitPackagesReady("completed");
+  }
+};
+var managePackagesHandler = {
+  specification: new WhenMigrationStarts2(),
+  processor: managePackagesProcessor
+};
+function createPackageManagerAgent() {
+  return createAgent4({
+    name: "PackageManager",
+    capabilities: ["package_management"],
+    instruction: "You are the Package Manager Agent. Your job is to resolve dependencies and clean up unused framework files.",
+    tools: [],
+    handlers: [managePackagesHandler]
+  });
+}
+
+// ../application/src/agents/CoordinatorAgent.ts
+import {
+  createAgent as createAgent5,
+  SituationSpecification as SituationSpecification5
+} from "@mozaik-ai/core";
+
+// ../application/src/agents/planReady.ts
+function planReadyForIntegration(plan) {
+  if (plan.phase === "integration" || plan.phase === "completed" || plan.phase === "failed") {
+    return false;
+  }
+  const files = plan.tasks.filter((task) => !task.filePath.startsWith("system:"));
+  if (files.length === 0) return false;
+  const packages = plan.tasks.find((task) => task.filePath === "system:package_manager");
+  if (packages && packages.status !== "completed" && packages.status !== "failed") {
+    return false;
+  }
+  const live = plan.tasks.filter((task) => !task.filePath.startsWith("system:"));
+  if (live.some((task) => task.status === "pending" || task.status === "in_progress")) {
+    return false;
+  }
+  return live.every((task) => task.status === "completed" || task.status === "failed");
+}
+
+// ../application/src/agents/CoordinatorAgent.ts
+var WATCHDOG_MS = 8e3;
+var WATCHDOG_MAX_MS = 30 * 60 * 1e3;
+var WhenSwarmMayBeIdle = class extends SituationSpecification5 {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.reviewed" /* FILE_REVIEWED */ || event.type === "file.failed" /* FILE_FAILED */ || event.type === "file.fatal_mismatch" /* FILE_FATAL_MISMATCH */ || event.type === "phase.packages_ready" /* PHASE_PACKAGES_READY */;
+  }
+};
+var WhenMigrationStarted = class extends SituationSpecification5 {
+  isSatisfiedBy({ event }) {
+    return event.type === "migration.started" /* MIGRATION_STARTED */;
+  }
+};
+async function emitIntegrationIfReady(producerId, planId) {
+  const runtime = resolveRuntime();
+  const plan = await runtime.state.repository.getPlan(planId);
+  if (!plan || !planReadyForIntegration(plan)) return;
+  console.log(`[Coordinator] File work and packages are settled. Emitting phase.integration_started.`);
+  sendEvent({
+    type: "phase.integration_started" /* PHASE_INTEGRATION_STARTED */,
+    producerId,
+    occurredAt: /* @__PURE__ */ new Date(),
+    payload: { planId }
+  }, producerId);
+}
+function stopWatchdog(planId) {
+  const runtime = resolveRuntime();
+  const timer = runtime.state.integrationWatchdogs.get(planId);
+  if (!timer) return;
+  clearInterval(timer);
+  runtime.state.integrationWatchdogs.delete(planId);
+}
+var startIntegrationIfIdle = {
+  async apply({ event, participant }) {
+    const planId = event.payload.planId;
+    if (!planId) return;
+    await emitIntegrationIfReady(participant.getId(), planId);
+  }
+};
+var startWatchdogProcessor = {
+  async apply({ event, participant }) {
+    const p = event.payload;
+    const runtime = resolveRuntime();
+    stopWatchdog(p.planId);
+    const startedAt = Date.now();
+    const producerId = participant.getId();
+    sendEvent({
+      type: "system.log" /* SYSTEM_LOG */,
+      producerId,
+      occurredAt: /* @__PURE__ */ new Date(),
+      payload: {
+        planId: p.planId,
+        message: "Coordinator watchdog is on: if file work settles and Integration never starts, it will kick within 8s. No extra model calls.",
+        level: "info"
+      }
+    }, producerId);
+    const timer = setInterval(async () => {
+      try {
+        const plan = await runtime.state.repository.getPlan(p.planId);
+        if (!plan || plan.phase === "completed" || plan.phase === "failed") {
+          stopWatchdog(p.planId);
+          return;
+        }
+        if (Date.now() - startedAt >= WATCHDOG_MAX_MS) {
+          stopWatchdog(p.planId);
+          sendEvent({
+            type: "system.log" /* SYSTEM_LOG */,
+            producerId,
+            occurredAt: /* @__PURE__ */ new Date(),
+            payload: {
+              planId: p.planId,
+              message: "Coordinator watchdog timed out after 30 minutes. Integration never became ready or the run stalled.",
+              level: "error"
+            }
+          }, producerId);
+          const currentPlan = await runtime.state.repository.getPlan(p.planId);
+          if (currentPlan && currentPlan.phase !== "completed" && currentPlan.phase !== "failed") {
+            currentPlan.phase = "failed";
+            currentPlan.outcome = "failed";
+            await runtime.state.repository.savePlan(currentPlan);
+            sendEvent({
+              type: "migration.completed" /* MIGRATION_COMPLETED */,
+              producerId,
+              occurredAt: /* @__PURE__ */ new Date(),
+              payload: {
+                planId: p.planId,
+                outcome: "failed",
+                reason: "Migration timed out after 30 minutes watchdog budget."
+              }
+            }, producerId);
+          }
+          return;
+        }
+        await emitIntegrationIfReady(producerId, p.planId);
+      } catch (error) {
+        console.error("[Coordinator] Watchdog tick failed:", error);
+      }
+    }, WATCHDOG_MS);
+    runtime.state.integrationWatchdogs.set(p.planId, timer);
+  }
+};
+function createCoordinatorAgent() {
+  return createAgent5({
+    name: "Coordinator",
+    capabilities: [],
+    instruction: "You watch the bus and start Integration when file tasks and packages are settled. You do not call the model.",
     tools: [],
-    // No tools
-    handlers: [reviewFileHandler]
+    handlers: [
+      { specification: new WhenMigrationStarted(), processor: startWatchdogProcessor },
+      { specification: new WhenSwarmMayBeIdle(), processor: startIntegrationIfIdle }
+    ]
   });
 }
 
-// ../application/src/agents/PackageManagerAgent.ts
-import * as fs5 from "fs";
-import * as path4 from "path";
+// ../application/src/agents/ReporterAgent.ts
 import {
-  createAgent as createAgent4,
-  SituationSpecification as SituationSpecification4
+  Agent as Agent6,
+  createAgent as createAgent6,
+  SituationSpecification as SituationSpecification6
 } from "@mozaik-ai/core";
-var WhenMigrationStarts2 = class extends SituationSpecification4 {
+function log(participantId, planId, message, level = "info") {
+  sendEvent({
+    type: "system.log" /* SYSTEM_LOG */,
+    producerId: participantId,
+    occurredAt: /* @__PURE__ */ new Date(),
+    payload: { planId, message, level }
+  }, participantId);
+}
+async function shadowPathFor(plan, journal) {
+  if (journal?.shadowPath) return journal.shadowPath;
+  const { ShadowWorkspace: ShadowWorkspace2 } = await import("./src-JHOGUCRS.js");
+  return new ShadowWorkspace2().getShadowPath(plan.runId);
+}
+function fallbackReport(params) {
+  const completed = params.tasks.filter((t) => t.status === "completed");
+  const failed = params.tasks.filter((t) => t.status === "failed");
+  const rejected = params.notes.filter((n) => n.outcome === "rejected" || n.outcome === "fatal");
+  const fileLines = params.tasks.filter((t) => !t.filePath.startsWith("system:")).slice(0, 40).map((t) => `- \`${t.filePath}\` \u2014 ${t.status}${t.error ? ` (${t.error})` : ""}`).join("\n");
+  const riskLines = rejected.slice(0, 12).map((n) => `- \`${n.filePath}\`: ${n.detail || n.outcome}`).join("\n");
+  return `# What changed
+
+Metamorph migrated this project from **${params.source}** to **${params.target}**.
+${params.phase === "failed" ? "\n**Status:** shadow `npm run build` (or catalog checks) did not pass. Treat this as an incomplete migration.\n" : ""}
+Your original files were not overwritten until you click **Apply Migration**. After apply, the result lives on a git branch named like \`metamorph/${params.runId}\`.
+
+## How to run it
+
+1. Apply the migration in the dashboard (or keep working in the shadow workspace).
+2. From the project folder:
+   \`\`\`bash
+   npm install
+   npm run dev
+   \`\`\`
+3. Open the URL the framework prints (\`next dev\` \u2192 port 3000, Vite \u2192 5173).
+
+## What we touched
+
+- Files completed: ${completed.length}
+- Files failed: ${failed.length}
+- Started: ${params.startedAt}
+- Finished: ${(/* @__PURE__ */ new Date()).toLocaleString()}
+
+${fileLines || "_No file tasks recorded._"}
+
+## Watch out for
+
+${riskLines || "- Review `package.json` scripts and the new entry files (layout/page or `index.html` + `src/main.tsx`).\n- Confirm global CSS still loads in the browser."}
+
+## Need a retry?
+
+Discard in the dashboard and start a new run. Do not mix two shadow workspaces in the same tree.
+`;
+}
+var STATUS_PASSED = "**Status:** Shadow `npm run build` passed.";
+var STATUS_FAILED = "**Status:** Shadow `npm run build` (or catalog checks) did not pass. Treat this as an incomplete migration.";
+function statusLine(phase) {
+  return phase === "failed" ? STATUS_FAILED : STATUS_PASSED;
+}
+function patchReportStatus(markdown, phase) {
+  const line = statusLine(phase);
+  const stripped = markdown.replace(/\n?\*\*Status:\*\*[^\n]*\n?/g, "\n");
+  if (stripped.startsWith("# ")) {
+    const nl = stripped.indexOf("\n");
+    if (nl === -1) return `${stripped}
+
+${line}
+`;
+    return `${stripped.slice(0, nl)}
+
+${line}${stripped.slice(nl)}`;
+  }
+  return `${line}
+
+${stripped.trimStart()}`;
+}
+async function writeOrPatchMigrationMd(dest, phase, fallback) {
+  const fs8 = await import("fs");
+  if (!fs8.existsSync(dest) || fs8.statSync(dest).size < 80) {
+    fs8.writeFileSync(dest, patchReportStatus(fallback, phase), "utf-8");
+    return "wrote";
+  }
+  const current = fs8.readFileSync(dest, "utf-8");
+  fs8.writeFileSync(dest, patchReportStatus(current, phase), "utf-8");
+  return "patched";
+}
+var WhenMigrationStarted2 = class extends SituationSpecification6 {
   isSatisfiedBy({ event }) {
     return event.type === "migration.started" /* MIGRATION_STARTED */;
   }
 };
-var managePackagesProcessor = {
+var WhenFileMigrated2 = class extends SituationSpecification6 {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.migrated" /* FILE_MIGRATED */;
+  }
+};
+var WhenFileReviewed = class extends SituationSpecification6 {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.reviewed" /* FILE_REVIEWED */;
+  }
+};
+var WhenFileRejected2 = class extends SituationSpecification6 {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.rejected" /* FILE_REJECTED */;
+  }
+};
+var WhenFileFatalMismatch2 = class extends SituationSpecification6 {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.fatal_mismatch" /* FILE_FATAL_MISMATCH */;
+  }
+};
+var WhenIntegrationStarts = class extends SituationSpecification6 {
+  isSatisfiedBy({ event }) {
+    return event.type === "phase.integration_started" /* PHASE_INTEGRATION_STARTED */;
+  }
+};
+var WhenMigrationCompleted = class extends SituationSpecification6 {
+  isSatisfiedBy({ event }) {
+    return event.type === "migration.completed" /* MIGRATION_COMPLETED */;
+  }
+};
+var WhenOwnAnswer = class extends SituationSpecification6 {
+  isSatisfiedBy({ event, participant }) {
+    return event.type === "model.answer" && event.producerId === participant.getId();
+  }
+};
+var startedProcessor = {
   async apply({ event, participant }) {
-    const payload = event.payload;
-    console.log(`[PackageManagerAgent] Managing dependencies and cleanup for Plan: ${payload.planId}`);
-    const shadowDir = payload.shadowWorkspacePath || "";
-    if (!shadowDir || !fs5.existsSync(shadowDir)) {
-      console.warn("[PackageManagerAgent] No valid shadow workspace provided. Skipping.");
+    const p = event.payload;
+    const entry = resolveRuntime().state.journal(p.planId);
+    if (p.shadowWorkspacePath) entry.shadowPath = p.shadowWorkspacePath;
+    log(participant.getId(), p.planId, "Reporter is on the bus. It will draft MIGRATION.md during install/build (one model call, in parallel with Integration).");
+  }
+};
+var migratedProcessor = {
+  async apply({ event }) {
+    const p = event.payload;
+    resolveRuntime().state.journal(p.planId).notes.push({ filePath: p.filePath, outcome: "migrated" });
+  }
+};
+var reviewedProcessor = {
+  async apply({ event }) {
+    const p = event.payload;
+    resolveRuntime().state.journal(p.planId).notes.push({ filePath: p.filePath, outcome: "approved" });
+  }
+};
+var rejectedProcessor = {
+  async apply({ event }) {
+    const p = event.payload;
+    resolveRuntime().state.journal(p.planId).notes.push({
+      filePath: p.filePath,
+      outcome: "rejected",
+      detail: (p.errors || []).slice(0, 3).join("; ")
+    });
+  }
+};
+var fatalProcessor = {
+  async apply({ event }) {
+    const p = event.payload;
+    resolveRuntime().state.journal(p.planId).notes.push({ filePath: p.filePath, outcome: "fatal", detail: p.reason });
+  }
+};
+function draftPrompt(params) {
+  const notable = params.notes.filter((n) => n.outcome === "rejected" || n.outcome === "fatal").slice(-15).map((n) => `${n.filePath}: ${n.detail || n.outcome}`).join("\n");
+  return `Write a user-facing migration briefing to this exact path:
+${params.reportAbs}
+
+Audience: the engineer who clicked Start Migration. They are not reading agent telemetry.
+File migration is done; Integration is installing/building in parallel \u2014 you may say the shadow build is still running.
+
+Migration: ${params.plan.profile.source} \u2192 ${params.plan.profile.target}
+Project path: ${params.plan.targetPath || "(unknown)"}
+Run id: ${params.plan.runId}
+
+Include these sections, in this order, with markdown headings:
+1. What changed \u2014 1-2 short paragraphs in plain language
+2. How to run it \u2014 concrete commands (npm install, npm run dev, which port if you can infer from package.json)
+3. What we touched \u2014 group by area (routes, styles, config, dependencies). Do not dump every file as a checklist unless there are under 12 files.
+4. Watch out for \u2014 honest risks from the notes below and from reading package.json / the new entry files
+5. Next steps after Apply \u2014 git branch checkout if they applied, npm install on the real project
+
+You may read package.json, README, src/app/layout.tsx, src/main.tsx, index.html, or MIGRATION.md if they exist.
+
+Rejected / structure notes:
+${notable || "(none recorded)"}
+
+If the model cannot infer something, say so briefly. Do not invent URLs, secrets, or features.
+
+A factual draft you may rewrite (keep facts, improve voice):
+---
+${params.draft}
+---
+When the file is written, stop.`;
+}
+var draftDuringInstallProcessor = {
+  async apply({ event, participant }) {
+    if (!(participant instanceof Agent6)) return;
+    const p = event.payload;
+    const runtime = resolveRuntime();
+    const board = runtime.state.journal(p.planId);
+    if (board.reportLoopActive || board.reportStarted) return;
+    const plan = await runtime.state.repository.getPlan(p.planId);
+    if (!plan) return;
+    const shadowPath = await shadowPathFor(plan, board);
+    const draft = fallbackReport({
+      source: plan.profile.source,
+      target: plan.profile.target,
+      targetPath: plan.targetPath,
+      runId: plan.runId,
+      phase: plan.phase,
+      tasks: plan.tasks || [],
+      notes: board.notes,
+      startedAt: board.startedAt
+    });
+    const tools = participant.getTools();
+    if (tools.length === 0) {
+      board.reportStarted = true;
+      const fs8 = await import("fs");
+      const path12 = await import("path");
+      fs8.writeFileSync(path12.join(shadowPath, "MIGRATION.md"), draft, "utf-8");
+      log(participant.getId(), p.planId, "Reporter wrote a fallback MIGRATION.md (no file tools on the agent).");
       return;
     }
+    board.reportStarted = true;
+    board.reportLoopActive = true;
+    log(participant.getId(), p.planId, "Reporter is drafting MIGRATION.md while Integration runs npm install / build (one model call).");
+    const reportAbs = `${shadowPath.replace(/\\/g, "/")}/MIGRATION.md`;
+    const modelToUse = process.env.METAMORPH_MODEL || "gpt-5.4";
+    runLoop(participant.getId(), draftPrompt({ reportAbs, plan, notes: board.notes, draft }), {
+      model: modelToUse,
+      context: participant.getMemory().getContext(),
+      tools
+    });
+    setTimeout(async () => {
+      const still = runtime.state.journals.get(p.planId);
+      if (!still?.reportLoopActive) return;
+      still.reportLoopActive = false;
+      try {
+        const path12 = await import("path");
+        const dest = path12.join(shadowPath, "MIGRATION.md");
+        const phase = still.pendingStatusPhase;
+        await writeOrPatchMigrationMd(dest, phase, draft);
+        still.pendingStatusPhase = void 0;
+        log(participant.getId(), p.planId, "Reporter draft timed out; kept fallback MIGRATION.md.", "warning");
+      } catch {
+      }
+    }, 9e4);
+  }
+};
+var ownAnswerProcessor = {
+  async apply() {
     const runtime = resolveRuntime();
-    const plan = await runtime.state.repository.getPlan(payload.planId);
-    if (!plan) {
-      console.warn("[PackageManagerAgent] Migration plan not found.");
-      return;
+    for (const [planId, journal] of runtime.state.journals) {
+      journal.reportLoopActive = false;
+      if (!journal.pendingStatusPhase) continue;
+      const plan = await runtime.state.repository.getPlan(planId);
+      if (!plan) continue;
+      const shadowPath = await shadowPathFor(plan, journal);
+      const path12 = await import("path");
+      const dest = path12.join(shadowPath, "MIGRATION.md");
+      const draft = fallbackReport({
+        source: plan.profile.source,
+        target: plan.profile.target,
+        targetPath: plan.targetPath,
+        runId: plan.runId,
+        phase: journal.pendingStatusPhase,
+        tasks: plan.tasks || [],
+        notes: journal.notes,
+        startedAt: journal.startedAt
+      });
+      await writeOrPatchMigrationMd(dest, journal.pendingStatusPhase, draft);
+      journal.pendingStatusPhase = void 0;
     }
-    const catalogEntry = findMigrationCatalogEntry(plan.profile.source, plan.profile.target);
-    if (!catalogEntry) {
-      console.log(`[PackageManagerAgent] No catalog entry found for ${plan.profile.source} -> ${plan.profile.target}`);
-      return;
+  }
+};
+var completedProcessor = {
+  async apply({ event, participant }) {
+    const p = event.payload;
+    const runtime = resolveRuntime();
+    const board = runtime.state.journal(p.planId);
+    const plan = await runtime.state.repository.getPlan(p.planId);
+    if (!plan) return;
+    const shadowPath = await shadowPathFor(plan, board);
+    const isFailed = plan.phase === "failed" || plan.outcome === "failed" || p.outcome === "failed";
+    const effectivePhase = isFailed ? "failed" : plan.phase || "completed";
+    const draft = fallbackReport({
+      source: plan.profile.source,
+      target: plan.profile.target,
+      targetPath: plan.targetPath,
+      runId: plan.runId,
+      phase: effectivePhase,
+      tasks: plan.tasks || [],
+      notes: board.notes,
+      startedAt: board.startedAt
+    });
+    board.pendingStatusPhase = isFailed ? "failed" : "completed";
+    try {
+      const path12 = await import("path");
+      const dest = path12.join(shadowPath, "MIGRATION.md");
+      if (board.reportLoopActive) {
+        log(participant.getId(), p.planId, "Reporter draft is still running; Status will be patched when it finishes (no second model call).");
+        return;
+      }
+      const result = await writeOrPatchMigrationMd(dest, effectivePhase, draft);
+      board.pendingStatusPhase = void 0;
+      log(
+        participant.getId(),
+        p.planId,
+        result === "patched" ? "Reporter patched MIGRATION.md with the final build Status (no extra model call)." : "Reporter finished. Open MIGRATION.md in the shadow workspace (it is copied to your project when you Apply)."
+      );
+    } catch (error) {
+      console.error("[ReporterAgent] Could not ensure MIGRATION.md:", error);
+      log(participant.getId(), p.planId, "Reporter could not write MIGRATION.md.", "warning");
     }
-    const pmTask = plan.tasks.find((t) => t.filePath === "system:package_manager");
-    if (pmTask) {
-      pmTask.status = "in_progress";
-      await runtime.state.repository.savePlan(plan);
+  }
+};
+function createReporterAgent(tools = []) {
+  return createAgent6({
+    name: "Reporter",
+    capabilities: ["reporting", "inference"],
+    instruction: "You are the Reporter on the Metamorph swarm. Watch the bus. When Integration starts, write MIGRATION.md for the human \u2014 not an internal log. Use write_file. Do not modify application source. Do not start extra model calls; one draft per run is enough.",
+    tools,
+    handlers: [
+      { specification: new WhenMigrationStarted2(), processor: startedProcessor },
+      { specification: new WhenFileMigrated2(), processor: migratedProcessor },
+      { specification: new WhenFileReviewed(), processor: reviewedProcessor },
+      { specification: new WhenFileRejected2(), processor: rejectedProcessor },
+      { specification: new WhenFileFatalMismatch2(), processor: fatalProcessor },
+      { specification: new WhenIntegrationStarts(), processor: draftDuringInstallProcessor },
+      { specification: new WhenOwnAnswer(), processor: ownAnswerProcessor },
+      { specification: new WhenMigrationCompleted(), processor: completedProcessor }
+    ]
+  });
+}
+
+// ../application/src/agents/IntegrationAgent.ts
+import {
+  createAgent as createAgent7,
+  SituationSpecification as SituationSpecification7
+} from "@mozaik-ai/core";
+var MAX_INTEGRATION_ROUNDS = 4;
+var REPAIR_TIMEOUT_MS = 12e4;
+var WhenIntegrationStarts2 = class extends SituationSpecification7 {
+  isSatisfiedBy({ event }) {
+    return event.type === "phase.integration_started" /* PHASE_INTEGRATION_STARTED */;
+  }
+};
+async function completeMigration(participantId, planId, message, level) {
+  const runtime = resolveRuntime();
+  const plan = await runtime.state.repository.getPlan(planId);
+  if (plan) {
+    let swept = 0;
+    for (const task of plan.tasks) {
+      if (task.status === "failed" && !task.filePath.startsWith("system:")) {
+        await runtime.state.repository.updateTaskStatus(
+          planId,
+          task.filePath,
+          "completed"
+        );
+        swept++;
+      }
     }
-    if (catalogEntry.filesToDelete && catalogEntry.filesToDelete.length > 0) {
-      for (const fileToDelete of catalogEntry.filesToDelete) {
-        const fullPath = path4.join(shadowDir, fileToDelete);
-        if (fs5.existsSync(fullPath)) {
-          fs5.unlinkSync(fullPath);
-          console.log(`[PackageManagerAgent] Deleted deprecated file: ${fileToDelete}`);
-        }
+    if (swept > 0) {
+      console.log(
+        `[IntegrationAgent] Swept ${swept} residual failed task(s) \u2192 completed (shadow build passed).`
+      );
+    }
+    plan.phase = "completed";
+    plan.outcome = "success";
+    await runtime.state.repository.savePlan(plan);
+  }
+  sendEvent(
+    {
+      type: "system.log" /* SYSTEM_LOG */,
+      producerId: participantId,
+      occurredAt: /* @__PURE__ */ new Date(),
+      payload: { planId, message, level }
+    },
+    participantId
+  );
+  sendEvent(
+    {
+      type: "migration.completed" /* MIGRATION_COMPLETED */,
+      producerId: participantId,
+      occurredAt: /* @__PURE__ */ new Date(),
+      payload: {
+        planId,
+        outcome: "success"
       }
+    },
+    participantId
+  );
+}
+function log2(participantId, planId, message, level = "info") {
+  sendEvent(
+    {
+      type: "system.log" /* SYSTEM_LOG */,
+      producerId: participantId,
+      occurredAt: /* @__PURE__ */ new Date(),
+      payload: { planId, message, level }
+    },
+    participantId
+  );
+}
+async function failMigration(participantId, planId, message) {
+  const runtime = resolveRuntime();
+  const plan = await runtime.state.repository.getPlan(planId);
+  if (plan) {
+    plan.phase = "failed";
+    plan.outcome = "failed";
+    await runtime.state.repository.savePlan(plan);
+  }
+  log2(participantId, planId, message, "error");
+  sendEvent(
+    {
+      type: "migration.completed" /* MIGRATION_COMPLETED */,
+      producerId: participantId,
+      occurredAt: /* @__PURE__ */ new Date(),
+      payload: {
+        planId,
+        outcome: "failed",
+        reason: message
+      }
+    },
+    participantId
+  );
+}
+async function requeueBrokenFiles(producerId, planId, files, errors) {
+  const runtime = resolveRuntime();
+  const unique = [...new Set(files.filter(Boolean))];
+  log2(
+    producerId,
+    planId,
+    `Shadow install/build did not pass. Reopening ${unique.length} file task(s) for Worker repair.`,
+    "warning"
+  );
+  for (const filePath of unique) {
+    await runtime.state.repository.updateTaskStatus(
+      planId,
+      filePath,
+      "pending",
+      errors.slice(0, 3).join("\n").slice(0, 1500)
+    );
+    sendEvent(
+      {
+        type: "file.rejected" /* FILE_REJECTED */,
+        producerId,
+        occurredAt: /* @__PURE__ */ new Date(),
+        payload: {
+          planId,
+          filePath,
+          errors,
+          source: "integration"
+        }
+      },
+      producerId
+    );
+  }
+  const plan = await runtime.state.repository.getPlan(planId);
+  if (plan) {
+    plan.phase = "files";
+    await runtime.state.repository.savePlan(plan);
+  }
+}
+var integrationProcessor = {
+  async apply({ event, participant }) {
+    const payload = event.payload;
+    const planId = payload.planId;
+    const producerId = participant.getId();
+    const locks = resolveRuntime().state.integrationLocks;
+    if (locks.has(planId)) {
+      console.log(
+        `[IntegrationAgent] Integration already running for ${planId}. Ignoring duplicate phase event.`
+      );
+      return;
     }
-    const packageJsonPath = path4.join(shadowDir, "package.json");
-    if (fs5.existsSync(packageJsonPath)) {
-      const { spawn } = await import("child_process");
-      const runCommandAsync = (cmd, args) => {
-        return new Promise((resolve3, reject) => {
-          const proc = spawn(cmd, args, { cwd: shadowDir, stdio: "ignore", shell: true });
-          proc.on("close", (code) => {
-            if (code === 0) resolve3();
-            else reject(new Error(`Command ${cmd} ${args.join(" ")} failed with code ${code}`));
-          });
-          proc.on("error", reject);
-        });
-      };
-      try {
-        let toRemove = [];
-        if (catalogEntry.dependenciesToRemove) toRemove.push(...catalogEntry.dependenciesToRemove);
-        if (catalogEntry.devDependenciesToRemove) toRemove.push(...catalogEntry.devDependenciesToRemove);
-        if (toRemove.length > 0) {
-          console.log(`[PackageManagerAgent] Uninstalling: ${toRemove.join(" ")}`);
-          await runCommandAsync("npm", ["uninstall", ...toRemove]);
+    locks.add(planId);
+    try {
+      const runtime = resolveRuntime();
+      const plan = await runtime.state.repository.getPlan(planId);
+      if (!plan) {
+        console.warn(`[IntegrationAgent] Plan ${planId} not found.`);
+        return;
+      }
+      if (plan.phase === "completed" || plan.phase === "failed") {
+        console.log(
+          `[IntegrationAgent] Plan ${planId} already finished (${plan.phase}). Ignoring extra integration phase.`
+        );
+        return;
+      }
+      plan.phase = "integration";
+      const currentRound = plan.integrationRounds ?? 0;
+      if (currentRound >= MAX_INTEGRATION_ROUNDS) {
+        await failMigration(
+          producerId,
+          planId,
+          `Integration budget exhausted after ${MAX_INTEGRATION_ROUNDS} shadow build rounds. npm run build still does not pass \u2014 the run is not successful.`
+        );
+        return;
+      }
+      plan.integrationRounds = currentRound + 1;
+      await runtime.state.repository.savePlan(plan);
+      const lastRound = plan.integrationRounds >= MAX_INTEGRATION_ROUNDS;
+      const {
+        ShadowWorkspace: ShadowWorkspace2,
+        createReadFileTool: createReadFileTool2,
+        createWriteFileTool: createWriteFileTool2,
+        createListDirectoryTool: createListDirectoryTool2,
+        createRunBuildTool: createRunBuildTool2,
+        runInShadowWorkspace,
+        parseImplicatedFiles
+      } = await import("./src-JHOGUCRS.js");
+      const { collectShadowIssues, collectRepairTargets } = await import("./registry-7WZ5RTGE.js");
+      const { resolveMigrationCatalog: resolveMigrationCatalog2 } = await import("./src-UC3SN46X.js");
+      const shadowPath = payload.shadowWorkspacePath || new ShadowWorkspace2().getShadowPath(plan.runId);
+      console.log(
+        `[IntegrationAgent] Shadow build round ${plan.integrationRounds}/${MAX_INTEGRATION_ROUNDS} in ${shadowPath}`
+      );
+      log2(
+        producerId,
+        planId,
+        `File migration is done. Next: install dependencies in the shadow workspace (npm install). This can take several minutes \u2014 counters staying at 0 is expected.`
+      );
+      console.log(`[IntegrationAgent] npm install starting in ${shadowPath}`);
+      let lastInstallBeat = Date.now();
+      const install = await runInShadowWorkspace(
+        shadowPath,
+        "npm install --no-fund --no-audit",
+        (chunk) => {
+          process.stdout.write(chunk);
+          if (Date.now() - lastInstallBeat >= 15e3) {
+            lastInstallBeat = Date.now();
+            log2(
+              producerId,
+              planId,
+              "npm install is still running in the shadow workspace. Wait \u2014 this is not finished."
+            );
+          }
         }
-        if (catalogEntry.dependenciesToAdd && Object.keys(catalogEntry.dependenciesToAdd).length > 0) {
-          const deps = Object.entries(catalogEntry.dependenciesToAdd).map(([pkg, ver]) => `${pkg}@${ver}`);
-          console.log(`[PackageManagerAgent] Installing dependencies (this may take a few minutes)...`);
-          sendEvent({
-            type: "system.log" /* SYSTEM_LOG */,
-            producerId: participant.getId(),
-            occurredAt: /* @__PURE__ */ new Date(),
-            payload: { planId: payload.planId, message: "Downloading and installing dependencies (this may take a few minutes)...", level: "info" }
-          }, participant.getId());
-          await runCommandAsync("npm", ["install", ...deps]);
+      );
+      if (!install.ok) {
+        console.warn(
+          "[IntegrationAgent] npm install failed in shadow:",
+          install.output.slice(0, 2e3)
+        );
+        log2(
+          producerId,
+          planId,
+          "npm install failed in the shadow workspace. Halting build to avoid noisy compile errors.",
+          "error"
+        );
+        if (lastRound) {
+          await failMigration(
+            producerId,
+            planId,
+            `npm install failed in the shadow workspace after ${MAX_INTEGRATION_ROUNDS} integration rounds. The migration is not successful.`
+          );
+          return;
         }
-        if (catalogEntry.devDependenciesToAdd && Object.keys(catalogEntry.devDependenciesToAdd).length > 0) {
-          const devDeps = Object.entries(catalogEntry.devDependenciesToAdd).map(([pkg, ver]) => `${pkg}@${ver}`);
-          console.log(`[PackageManagerAgent] Installing devDependencies...`);
-          await runCommandAsync("npm", ["install", "-D", ...devDeps]);
+        const path12 = await import("path");
+        const pkgPath = path12.join(shadowPath, "package.json");
+        await requeueBrokenFiles(
+          producerId,
+          planId,
+          [pkgPath],
+          [`npm install failed in shadow workspace:
+${install.output.slice(0, 2500)}`]
+        );
+        return;
+      }
+      log2(
+        producerId,
+        planId,
+        "npm install finished. Next: npm run build in the shadow workspace."
+      );
+      let lastBuildBeat = Date.now();
+      let build = await runInShadowWorkspace(
+        shadowPath,
+        "npm run build",
+        (chunk) => {
+          process.stdout.write(chunk);
+          if (Date.now() - lastBuildBeat >= 15e3) {
+            lastBuildBeat = Date.now();
+            log2(
+              producerId,
+              planId,
+              "npm run build is still running in the shadow workspace. Wait \u2014 this is not finished."
+            );
+          }
         }
-        console.log(`[PackageManagerAgent] Successfully updated dependencies via npm.`);
-        sendEvent({
-          type: "system.log" /* SYSTEM_LOG */,
-          producerId: participant.getId(),
-          occurredAt: /* @__PURE__ */ new Date(),
-          payload: { planId: payload.planId, message: "Dependencies installed successfully!", level: "info" }
-        }, participant.getId());
-      } catch (err) {
-        console.error(`[PackageManagerAgent] Error running npm commands:`, err);
+      );
+      if (!build.ok) {
+        log2(
+          producerId,
+          planId,
+          "Shadow build failed. IntegrationAgent will attempt local repairs before requeueing files."
+        );
+        const shadowTools = [
+          createReadFileTool2(shadowPath),
+          createWriteFileTool2(shadowPath),
+          createListDirectoryTool2(shadowPath),
+          createRunBuildTool2(shadowPath)
+        ];
+        const { createAgent: createMozaikAgent } = await import("@mozaik-ai/core");
+        await new Promise((originalResolve) => {
+          let isDone = false;
+          const resolve4 = () => {
+            if (!isDone) {
+              isDone = true;
+              originalResolve();
+            }
+          };
+          const tempAgent = createMozaikAgent({
+            name: `Integration-${Date.now()}`,
+            capabilities: ["integration_testing", "code_repair"],
+            instruction: "You are a staff engineer repairing a migrated project. Read failing files and their imports. Deduce real APIs from disk. Do not invent prop names. Do not wait for Git.",
+            tools: shadowTools,
+            handlers: []
+          });
+          join(tempAgent);
+          const modelToUse = process.env.METAMORPH_MODEL || "gpt-5.4";
+          const excerpt = build.output.slice(0, 4e3);
+          const prompt = `A real \`npm run build\` already failed in the shadow workspace at ${shadowPath}.
+You must deduce the fix from source, not guess. Use list_directory / read_file on the implicated files AND the modules they import. Keep existing callback/export names. If a router file was reassembled, import the existing screen instead.
+
+Do NOT require Git. You may run run_project_build again after edits.
+
+Build output:
+${excerpt}
+
+When you have applied fixes (or cannot fix further), stop. A deterministic rebuild will run after you finish.`;
+          Promise.resolve(
+            runLoop(tempAgent.getId(), prompt, {
+              model: modelToUse,
+              context: tempAgent.getMemory().getContext(),
+              tools: shadowTools
+            })
+          ).catch((error) => {
+            console.error("[IntegrationAgent] runLoop error:", error);
+            leave(tempAgent);
+            resolve4();
+          });
+          setTimeout(() => {
+            if (!isDone) {
+              console.warn(
+                "[IntegrationAgent] Repair loop timed out; continuing with deterministic rebuild."
+              );
+              leave(tempAgent);
+              resolve4();
+            }
+          }, REPAIR_TIMEOUT_MS);
+        });
+        build = await runInShadowWorkspace(shadowPath, "npm run build");
       }
-    } else {
-      console.log(`[PackageManagerAgent] No package.json found at ${packageJsonPath}`);
-    }
-    const currentPlan = await runtime.state.repository.getPlan(payload.planId);
-    if (currentPlan) {
-      const pmTaskToComplete = currentPlan.tasks.find((t) => t.filePath === "system:package_manager");
-      if (pmTaskToComplete) {
-        pmTaskToComplete.status = "completed";
-        await runtime.state.repository.savePlan(currentPlan);
+      const pluginCtx = {
+        source: plan.profile.source,
+        target: plan.profile.target
+      };
+      const catalogEntry = resolveMigrationCatalog2(
+        plan.profile.source,
+        plan.profile.target
+      );
+      const structureIssues = collectShadowIssues(
+        shadowPath,
+        pluginCtx,
+        catalogEntry?.layer
+      );
+      const buildFailed = !build.ok || !install.ok;
+      const verifierFailed = structureIssues.length > 0;
+      if (!buildFailed && !verifierFailed) {
+        await completeMigration(
+          producerId,
+          planId,
+          "Shadow build succeeded. Reporter is writing MIGRATION.md next. Then Apply copies the result into your project.",
+          "info"
+        );
+        return;
       }
-      const allTerminal = currentPlan.tasks.every((t) => t.status === "completed" || t.status === "failed");
-      if (allTerminal) {
-        console.log(`[App] All tasks reached terminal state. Emitting MIGRATION_COMPLETED.`);
-        sendEvent({
-          type: "system.log" /* SYSTEM_LOG */,
-          producerId: participant.getId(),
-          occurredAt: /* @__PURE__ */ new Date(),
-          payload: { planId: payload.planId, message: "All agents have finished their work. Please review the results and click APPLY MIGRATION or DISCARD.", level: "info" }
-        }, participant.getId());
-        sendEvent({
-          type: "migration.completed" /* MIGRATION_COMPLETED */,
-          producerId: participant.getId(),
-          occurredAt: /* @__PURE__ */ new Date(),
-          payload: { planId: payload.planId }
-        }, participant.getId());
+      const implicated = parseImplicatedFiles(
+        `${install.ok ? "" : install.output + "\n"}${build.output}`,
+        shadowPath
+      );
+      const repairFiles = collectRepairTargets(shadowPath, pluginCtx, {
+        implicated,
+        issues: structureIssues,
+        catalog: catalogEntry,
+        layer: catalogEntry?.layer
+      });
+      const errors = [
+        ...structureIssues.flatMap((issue) => issue.errors),
+        ...install.ok ? [] : [`npm install failed:
+${install.output.slice(0, 1500)}`],
+        ...build.ok ? [] : [`npm run build failed:
+${build.output.slice(0, 2500)}`]
+      ];
+      if (!lastRound && repairFiles.length > 0) {
+        log2(
+          producerId,
+          planId,
+          buildFailed ? "npm run build (or npm install) failed. Assigning repair tasks to Worker \u2014 the run is not finished." : `Shadow compile may succeed while the app is still wrong: ${structureIssues.length} verifier issue(s). Assigning repair tasks.`,
+          "warning"
+        );
+        await requeueBrokenFiles(
+          producerId,
+          planId,
+          repairFiles,
+          errors.length > 0 ? errors : ["Shadow verification failed."]
+        );
+        return;
       }
+      await failMigration(
+        producerId,
+        planId,
+        lastRound ? `npm run build still does not pass after ${MAX_INTEGRATION_ROUNDS} integration rounds. The migration is not successful.` : "Shadow verification failed and no repair files could be assigned."
+      );
+    } catch (error) {
+      console.error(`[IntegrationAgent] Error:`, error);
+      await failMigration(
+        producerId,
+        planId,
+        "Integration Phase encountered an error. The migration is not successful."
+      );
+    } finally {
+      resolveRuntime().state.integrationLocks.delete(planId);
     }
   }
 };
-var managePackagesHandler = {
-  specification: new WhenMigrationStarts2(),
-  processor: managePackagesProcessor
+var manageIntegrationHandler = {
+  specification: new WhenIntegrationStarts2(),
+  processor: integrationProcessor
 };
-function createPackageManagerAgent() {
-  return createAgent4({
-    name: "PackageManager",
-    capabilities: ["package_management"],
-    instruction: "You are the Package Manager Agent. Your job is to resolve dependencies and clean up unused framework files.",
-    tools: [],
-    handlers: [managePackagesHandler]
+function createIntegrationAgent(tools = []) {
+  return createAgent7({
+    name: "IntegrationAgent",
+    capabilities: ["integration_testing", "code_repair"],
+    instruction: "You are the Integration Agent. You run npm install and npm run build in the shadow workspace. A passing compile is not enough if catalog verifiers fail. Never mark the migration complete unless the shadow build passes and verifiers are clean. On failure, reopen file tasks for Worker.",
+    tools,
+    handlers: [manageIntegrationHandler]
   });
 }
 
-// ../application/src/agents/ReporterAgent.ts
+// ../application/src/migration/plugins/frontendTargets.ts
+import * as path8 from "path";
+
+// ../application/src/utils/FrontendRuntimeHints.ts
 import * as fs6 from "fs";
-import * as path5 from "path";
-import {
-  createAgent as createAgent5,
-  SituationSpecification as SituationSpecification5
-} from "@mozaik-ai/core";
-var WhenMigrationStarted = class extends SituationSpecification5 {
-  isSatisfiedBy({ event }) {
-    return event.type === "migration.started" /* MIGRATION_STARTED */;
+import * as path7 from "path";
+function readIfExists(...candidates) {
+  for (const filePath of candidates) {
+    if (fs6.existsSync(filePath) && fs6.statSync(filePath).isFile()) {
+      return { filePath, content: fs6.readFileSync(filePath, "utf-8") };
+    }
   }
-};
-var WhenFileMigrated2 = class extends SituationSpecification5 {
-  isSatisfiedBy({ event }) {
-    return event.type === "file.migrated" /* FILE_MIGRATED */;
+  return null;
+}
+function leftoverScripts(shadowRoot, forbidden, message) {
+  const pkgPath = path7.join(shadowRoot, "package.json");
+  if (!fs6.existsSync(pkgPath)) return [];
+  try {
+    const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+    const hits = Object.entries(pkg.scripts || {}).filter(([, cmd]) => forbidden.test(cmd));
+    if (hits.length === 0) return [];
+    return [{
+      filePath: pkgPath,
+      errors: [`${message} (${hits.map(([name]) => name).join(", ")}).`]
+    }];
+  } catch {
+    return [];
   }
-};
-var WhenFileReviewed = class extends SituationSpecification5 {
-  isSatisfiedBy({ event }) {
-    return event.type === "file.reviewed" /* FILE_REVIEWED */;
+}
+function viteConfigUsesPlugin(shadowRoot, pluginNeedle) {
+  const file = readIfExists(
+    path7.join(shadowRoot, "vite.config.ts"),
+    path7.join(shadowRoot, "vite.config.js")
+  );
+  if (!file) {
+    return [{
+      filePath: path7.join(shadowRoot, "vite.config.ts"),
+      errors: ["Missing vite.config.ts for this Vite SPA target."]
+    }];
+  }
+  const issues = [];
+  if (!pluginNeedle.test(file.content)) {
+    issues.push({
+      filePath: file.filePath,
+      errors: ["vite.config.ts does not register the plugin for the target framework."]
+    });
   }
-};
-var WhenFileRejected2 = class extends SituationSpecification5 {
-  isSatisfiedBy({ event }) {
-    return event.type === "file.rejected" /* FILE_REJECTED */;
+  if (/__dirname/.test(file.content) && !/import\.meta\.dirname/.test(file.content)) {
+    issues.push({
+      filePath: file.filePath,
+      errors: ["vite.config.ts uses __dirname in ESM. Replace it with import.meta.dirname."]
+    });
   }
-};
-var WhenFileFatalMismatch2 = class extends SituationSpecification5 {
-  isSatisfiedBy({ event }) {
-    return event.type === "file.fatal_mismatch" /* FILE_FATAL_MISMATCH */;
+  return issues;
+}
+function indexHtmlIssues(shadowRoot, mountId, scriptNeedle) {
+  const html = readIfExists(path7.join(shadowRoot, "index.html"));
+  if (!html) {
+    return [{
+      filePath: path7.join(shadowRoot, "index.html"),
+      errors: [`Missing Vite index.html. It must contain <div id="${mountId}"> and a module script to the SPA entry.`]
+    }];
+  }
+  const issues = [];
+  if (!new RegExp(`id=["']${mountId}["']`).test(html.content)) {
+    issues.push({
+      filePath: html.filePath,
+      errors: [`index.html must mount the app on #${mountId} (the entry's mount() / createApp / createRoot target).`]
+    });
   }
-};
-var WhenMigrationCompleted = class extends SituationSpecification5 {
-  isSatisfiedBy({ event }) {
-    return event.type === "migration.completed" /* MIGRATION_COMPLETED */;
+  if (!scriptNeedle.test(html.content)) {
+    issues.push({
+      filePath: html.filePath,
+      errors: ['index.html must load the SPA entry as <script type="module" src="/src/main.ts"> (or main.tsx).']
+    });
   }
-};
-function appendToReport(shadowDir, content) {
-  if (!shadowDir) return;
-  const reportPath = path5.join(shadowDir, "migration-report.md");
-  try {
-    fs6.appendFileSync(reportPath, content + "\n", "utf-8");
-  } catch (e) {
-    console.error("[ReporterAgent] Error writing to report:", e);
+  return issues;
+}
+function leftoverNextApp(shadowRoot) {
+  const files = [
+    path7.join(shadowRoot, "src", "app", "page.tsx"),
+    path7.join(shadowRoot, "src", "app", "layout.tsx"),
+    path7.join(shadowRoot, "app", "page.tsx"),
+    path7.join(shadowRoot, "app", "layout.tsx")
+  ].filter((file) => fs6.existsSync(file));
+  return files.map((filePath) => ({
+    filePath,
+    errors: ["Leftover Next App Router file. Delete it after the target SPA/CLI boots so it cannot be mistaken for the new tree."]
+  }));
+}
+function leftoverViteWhenAngular(shadowRoot) {
+  const issues = [];
+  for (const rel of ["vite.config.ts", "vite.config.js", "index.html"]) {
+    const filePath = path7.join(shadowRoot, rel);
+    if (fs6.existsSync(filePath)) {
+      issues.push({
+        filePath,
+        errors: [`Leftover Vite file ${rel}. Angular boots from src/main.ts + src/index.html + angular.json \u2014 delete the Vite entry.`]
+      });
+    }
   }
+  return issues;
 }
-var startedProcessor = {
-  async apply({ event }) {
-    const p = event.payload;
-    if (!("shadowWorkspacePath" in p)) return;
-    const shadowPath = p.shadowWorkspacePath;
-    if (!shadowPath) return;
-    const reportPath = path5.join(shadowPath, "migration-report.md");
-    const header = `# Metamorph Migration Report
-**Plan ID**: ${p.planId}
-**Date Started**: ${(/* @__PURE__ */ new Date()).toLocaleString()}
----
-
-## Migration Log
-
+function isStubEntry(content) {
+  const hasLocalImport = /from\s+['"](\.\.?\/|@\/)/.test(content);
+  const emptyHeading = /<h1[^>]*>[^<]{0,40}<\/h1>|TODO:|coming soon/i.test(content);
+  return emptyHeading && !hasLocalImport;
+}
+function analyzeVueTarget(shadowRoot) {
+  const issues = [
+    ...indexHtmlIssues(shadowRoot, "app", /src\/main\.(t|j)sx?/),
+    ...viteConfigUsesPlugin(shadowRoot, /plugin-vue|@vitejs\/plugin-vue/),
+    ...leftoverScripts(shadowRoot, /\b(next|ng)\b/, "package.json still runs Next/Angular scripts; Vue target must use Vite"),
+    ...leftoverNextApp(shadowRoot)
+  ];
+  const main = readIfExists(path7.join(shadowRoot, "src", "main.ts"), path7.join(shadowRoot, "src", "main.js"));
+  if (!main) {
+    issues.push({
+      filePath: path7.join(shadowRoot, "src", "main.ts"),
+      errors: ['Missing src/main.ts. createApp(App).use(router).mount("#app") and import global CSS.']
+    });
+  } else {
+    if (!/createApp\(/.test(main.content) || !/mount\(/.test(main.content)) {
+      issues.push({
+        filePath: main.filePath,
+        errors: ['Vue entry must createApp(...).mount("#app"). Do not leave ReactDOM.createRoot here.']
+      });
+    }
+    if (/createRoot|react-dom/.test(main.content)) {
+      issues.push({
+        filePath: main.filePath,
+        errors: ["Vue entry still mounts React. Replace createRoot with createApp and delete ReactDOM."]
+      });
+    }
+    if (!/import\s+['"][^'"]+\.(?:css|scss|sass)['"]/.test(main.content)) {
+      const css = path7.join(shadowRoot, "src", "index.css");
+      if (fs6.existsSync(css)) {
+        issues.push({
+          filePath: main.filePath,
+          errors: ["Global CSS exists but is not imported from src/main.ts. Vite will ship an unstyled app."]
+        });
+      }
+    }
+    if (isStubEntry(main.content)) {
+      issues.push({
+        filePath: main.filePath,
+        errors: ["Vue entry does not import the real App/router. Import existing screens; do not mount an empty shell."]
+      });
+    }
+  }
+  return issues;
+}
+function analyzeSvelteTarget(shadowRoot) {
+  const issues = [
+    ...indexHtmlIssues(shadowRoot, "app", /src\/main\.(t|j)sx?/),
+    ...viteConfigUsesPlugin(shadowRoot, /vite-plugin-svelte|svelte\(/),
+    ...leftoverScripts(shadowRoot, /\b(next|ng)\b/, "package.json still runs Next/Angular scripts; Svelte target must use Vite"),
+    ...leftoverNextApp(shadowRoot)
+  ];
+  const kit = path7.join(shadowRoot, "src", "routes", "+page.svelte");
+  if (fs6.existsSync(kit)) {
+    issues.push({
+      filePath: kit,
+      errors: ["SvelteKit +page.svelte appeared but this catalog targets a Vite SPA. Use App.svelte + mount() instead of Kit file routes."]
+    });
+  }
+  const main = readIfExists(path7.join(shadowRoot, "src", "main.ts"), path7.join(shadowRoot, "src", "main.js"));
+  if (!main) {
+    issues.push({
+      filePath: path7.join(shadowRoot, "src", "main.ts"),
+      errors: ['Missing src/main.ts. Use mount(App, { target: document.getElementById("app") }) and import global CSS.']
+    });
+  } else if (!/from\s+['"]svelte['"]/.test(main.content) && !/new\s+\w+\(\s*\{\s*target/.test(main.content)) {
+    issues.push({
+      filePath: main.filePath,
+      errors: ["Svelte entry must mount the root .svelte component onto #app."]
+    });
+  }
+  return issues;
+}
+function analyzeAngularTarget(shadowRoot) {
+  const issues = [
+    ...leftoverViteWhenAngular(shadowRoot),
+    ...leftoverScripts(shadowRoot, /\b(vite|next)\b/, "package.json still runs Vite/Next; Angular target must use ng serve / ng build")
+  ];
+  const angularJson = path7.join(shadowRoot, "angular.json");
+  if (!fs6.existsSync(angularJson)) {
+    issues.push({
+      filePath: angularJson,
+      errors: ["Missing angular.json. ng build will not run. Scaffold it and point browser to src/main.ts and styles to src/styles.css."]
+    });
+  }
+  const main = readIfExists(path7.join(shadowRoot, "src", "main.ts"));
+  if (!main || !/bootstrapApplication\(/.test(main.content || "")) {
+    issues.push({
+      filePath: path7.join(shadowRoot, "src", "main.ts"),
+      errors: ["Missing bootstrapApplication in src/main.ts. Angular standalone boots here, not from a Vite main.tsx."]
+    });
+  }
+  const routes = readIfExists(path7.join(shadowRoot, "src", "app", "app.routes.ts"));
+  if (routes && /export const routes: Routes = \[\s*\]/.test(routes.content)) {
+    issues.push({
+      filePath: routes.filePath,
+      errors: ["app.routes.ts has no routes. Map each source URL to the existing feature component. App stays a <router-outlet /> shell."]
+    });
+  }
+  const html = readIfExists(path7.join(shadowRoot, "src", "index.html"));
+  if (!html) {
+    issues.push({
+      filePath: path7.join(shadowRoot, "src", "index.html"),
+      errors: ["Missing src/index.html with <app-root></app-root>."]
+    });
+  }
+  return issues;
+}
+function vueFileHint(filePath, target) {
+  if (target !== "vue") return "";
+  const normalized = filePath.replace(/\\/g, "/");
+  if (/\/main\.(t|j)sx?$/.test(normalized)) {
+    return `
+This is the Vue entry. It must createApp(App).use(router).mount("#app") and import global CSS.
+index.html uses #app, not #root. Do not leave createRoot/ReactDOM.
 `;
-    fs6.writeFileSync(reportPath, header, "utf-8");
-    console.log(`[ReporterAgent] Initialized report at ${reportPath}`);
   }
-};
-var migratedProcessor = {
-  async apply({ event }) {
-    const p = event.payload;
-    const { resolveRuntime: resolveRuntime2 } = await import("./runtime-5OVGH2Y7.js");
-    const runtime = resolveRuntime2();
-    const plan = await runtime.state.repository.getPlan(p.planId);
-    if (!plan) return;
-    const shadowDir = plan.targetPath;
-    appendToReport(shadowDir, `- \u23F3 **Refactored**: \`${p.filePath}\` (Pending Review)`);
+  if (/\.(t|j)sx$/.test(normalized) && !/vite\.config/.test(normalized)) {
+    return `
+Convert this UI file into a .vue SFC (<script setup> + template + style). Keep prop and emit names. Then delete this leftover TSX once the SFC exists.
+`;
   }
-};
-var reviewedProcessor = {
-  async apply({ event }) {
-    const p = event.payload;
-    const { resolveRuntime: resolveRuntime2 } = await import("./runtime-5OVGH2Y7.js");
-    const runtime = resolveRuntime2();
-    const plan = await runtime.state.repository.getPlan(p.planId);
-    if (!plan) return;
-    appendToReport(plan.targetPath, `- \u2705 **Approved**: \`${p.filePath}\``);
+  return "";
+}
+function svelteFileHint(filePath, target) {
+  if (target !== "svelte") return "";
+  const normalized = filePath.replace(/\\/g, "/");
+  if (/\/main\.(t|j)sx?$/.test(normalized)) {
+    return `
+This is the Svelte entry. mount(App, { target: document.getElementById("app") }). Do not create SvelteKit +page.svelte routes.
+`;
+  }
+  return "";
+}
+function angularFileHint(filePath, target) {
+  if (target !== "angular") return "";
+  const normalized = filePath.replace(/\\/g, "/");
+  if (/app\.routes\.ts$/.test(normalized)) {
+    return `
+Map each source route to an existing feature component. Do not inline that component's template. App is <router-outlet />.
+Keep @Input / @Output names when the host binds them.
+`;
+  }
+  if (/\/main\.(t|j)sx$/.test(normalized)) {
+    return `
+Vite/React main.tsx is not the Angular entry. Angular boots from src/main.ts via bootstrapApplication. Delete this file after src/main.ts exists.
+`;
+  }
+  return "";
+}
+
+// ../application/src/migration/plugins/frontendTargets.ts
+var vueTargetPlugin = {
+  id: "target-vue",
+  target: "vue",
+  layer: "frontend",
+  fileHint(filePath, ctx) {
+    return vueFileHint(filePath, ctx.target);
+  },
+  verifyShadow(shadowRoot) {
+    return analyzeVueTarget(shadowRoot);
+  },
+  repairTargets(shadowRoot) {
+    return [
+      path8.join(shadowRoot, "package.json"),
+      path8.join(shadowRoot, "vite.config.ts"),
+      path8.join(shadowRoot, "index.html"),
+      path8.join(shadowRoot, "src", "main.ts"),
+      path8.join(shadowRoot, "src", "App.vue")
+    ];
   }
 };
-var rejectedProcessor = {
-  async apply({ event }) {
-    const p = event.payload;
-    const { resolveRuntime: resolveRuntime2 } = await import("./runtime-5OVGH2Y7.js");
-    const runtime = resolveRuntime2();
-    const plan = await runtime.state.repository.getPlan(p.planId);
-    if (!plan) return;
-    appendToReport(plan.targetPath, `- \u26A0\uFE0F **Rejected**: \`${p.filePath}\`
-  > Errors: ${p.errors?.join(", ")}`);
+var svelteTargetPlugin = {
+  id: "target-svelte",
+  target: "svelte",
+  layer: "frontend",
+  fileHint(filePath, ctx) {
+    return svelteFileHint(filePath, ctx.target);
+  },
+  verifyShadow(shadowRoot) {
+    return analyzeSvelteTarget(shadowRoot);
+  },
+  repairTargets(shadowRoot) {
+    return [
+      path8.join(shadowRoot, "package.json"),
+      path8.join(shadowRoot, "vite.config.ts"),
+      path8.join(shadowRoot, "svelte.config.js"),
+      path8.join(shadowRoot, "index.html"),
+      path8.join(shadowRoot, "src", "main.ts"),
+      path8.join(shadowRoot, "src", "App.svelte")
+    ];
   }
 };
-var fatalProcessor = {
-  async apply({ event }) {
-    const p = event.payload;
-    const { resolveRuntime: resolveRuntime2 } = await import("./runtime-5OVGH2Y7.js");
-    const runtime = resolveRuntime2();
-    const plan = await runtime.state.repository.getPlan(p.planId);
-    if (!plan) return;
-    appendToReport(plan.targetPath, `- \u274C **FATAL MISMATCH**: \`${p.filePath}\`
-  > Reason: ${p.reason}`);
+var angularTargetPlugin = {
+  id: "target-angular",
+  target: "angular",
+  layer: "frontend",
+  fileHint(filePath, ctx) {
+    return angularFileHint(filePath, ctx.target);
+  },
+  verifyShadow(shadowRoot) {
+    return analyzeAngularTarget(shadowRoot);
+  },
+  repairTargets(shadowRoot) {
+    return [
+      path8.join(shadowRoot, "package.json"),
+      path8.join(shadowRoot, "angular.json"),
+      path8.join(shadowRoot, "src", "main.ts"),
+      path8.join(shadowRoot, "src", "index.html"),
+      path8.join(shadowRoot, "src", "styles.css"),
+      path8.join(shadowRoot, "src", "app", "app.ts"),
+      path8.join(shadowRoot, "src", "app", "app.routes.ts"),
+      path8.join(shadowRoot, "src", "app", "app.config.ts")
+    ];
   }
 };
-var completedProcessor = {
-  async apply({ event }) {
-    const p = event.payload;
-    const { resolveRuntime: resolveRuntime2 } = await import("./runtime-5OVGH2Y7.js");
-    const runtime = resolveRuntime2();
-    const plan = await runtime.state.repository.getPlan(p.planId);
-    if (!plan) return;
-    const totalFiles = plan.tasks ? plan.tasks.length : 0;
-    const migratedFiles = plan.tasks ? plan.tasks.filter((t) => t.status === "completed").length : 0;
-    const footer = `
----
-## Migration Completed
-**Date Finished**: ${(/* @__PURE__ */ new Date()).toLocaleString()}
-**Total Files**: ${totalFiles}
-**Successfully Migrated**: ${migratedFiles}
+
+// ../application/src/migration/plugins/nextToReact.ts
+import * as fs7 from "fs";
+import * as path9 from "path";
+function readIfExists2(...candidates) {
+  for (const filePath of candidates) {
+    if (fs7.existsSync(filePath) && fs7.statSync(filePath).isFile()) {
+      return { filePath, content: fs7.readFileSync(filePath, "utf-8") };
+    }
+  }
+  return null;
+}
+function listCssFiles(dir) {
+  if (!fs7.existsSync(dir)) return [];
+  return fs7.readdirSync(dir).filter((name) => /\.(css|scss|sass)$/i.test(name)).map((name) => path9.join(dir, name));
+}
+function hasLocalComponentImport(content) {
+  return /import\s+(?:type\s+)?(?:[\w*{}\s,]+)\s+from\s+['"](\.\.?\/|@\/)(?!.*\.(?:css|scss|sass)['"])/i.test(content) || /import\s+['"](\.\.?\/|@\/)[^'"]+\.(t|j)sx['"]/.test(content);
+}
+function isStubSpaEntry(content) {
+  const emptyMount = /<div\s+id=["']app["']\s*\/>|<div\s*\/>\s*[;)]|return\s+null\s*;?|return\s*\(\s*<>\s*<\/>\s*\)/i.test(content);
+  const hasRouter = /BrowserRouter|RouterProvider|createBrowserRouter|HashRouter/i.test(content);
+  if (hasRouter && hasLocalComponentImport(content)) return false;
+  if (emptyMount) return true;
+  if (!hasLocalComponentImport(content) && /createRoot\(/.test(content)) return true;
+  return false;
+}
+function listTsxFiles(dir) {
+  if (!fs7.existsSync(dir)) return [];
+  const out = [];
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const entry of fs7.readdirSync(current, { withFileTypes: true })) {
+      const full = path9.join(current, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else if (/\.(t|j)sx$/.test(entry.name) && !entry.name.endsWith(".obsolete")) out.push(full);
+    }
+  }
+  return out;
+}
+function leftoverNextAppFiles(shadowRoot) {
+  const dirs = [path9.join(shadowRoot, "src", "app"), path9.join(shadowRoot, "app")];
+  const found = [];
+  for (const dir of dirs) {
+    for (const file of listTsxFiles(dir)) {
+      const base = path9.basename(file);
+      if (/^(page|layout|template|loading|error|not-found)\.(t|j)sx$/.test(base)) {
+        found.push(file);
+      }
+    }
+  }
+  return found;
+}
+function findUnmountedScreens(shadowRoot, entryContent) {
+  const candidates = [
+    path9.join(shadowRoot, "src", "App.tsx"),
+    path9.join(shadowRoot, "src", "App.jsx"),
+    path9.join(shadowRoot, "src", "routes", "AppRoutes.tsx"),
+    path9.join(shadowRoot, "src", "routes", "AppRoutes.jsx")
+  ];
+  const unused = [];
+  for (const file of candidates) {
+    if (!fs7.existsSync(file)) continue;
+    const stem = path9.basename(file).replace(/\.(t|j)sx$/, "");
+    if (!entryContent.includes(stem)) unused.push(file);
+  }
+  return unused;
+}
+function analyzeNextToReactBootstrap(shadowRoot) {
+  const issues = [];
+  const main = readIfExists2(
+    path9.join(shadowRoot, "src", "main.tsx"),
+    path9.join(shadowRoot, "src", "main.jsx"),
+    path9.join(shadowRoot, "src", "index.tsx")
+  );
+  if (!main) {
+    issues.push({
+      filePath: path9.join(shadowRoot, "src", "main.tsx"),
+      errors: [
+        "Missing SPA entry. Create src/main.tsx that mounts BrowserRouter and the former home screen into #root. Vite can start with a blank page if this file only renders an empty div."
+      ]
+    });
+    return issues;
+  }
+  if (isStubSpaEntry(main.content)) {
+    issues.push({
+      filePath: main.filePath,
+      errors: [
+        "src/main.tsx does not mount the application UI. Import the router and the former home screen. Do not render only an empty element, null, or a placeholder \u2014 that is a blank page even when npm run dev succeeds."
+      ]
+    });
+  } else if (!/BrowserRouter|RouterProvider|createBrowserRouter|HashRouter/i.test(main.content)) {
+    issues.push({
+      filePath: main.filePath,
+      errors: [
+        "SPA entry has no React Router. Wrap the tree in <BrowserRouter> (or RouterProvider) so former Next routes still have URLs."
+      ]
+    });
+  }
+  const unused = findUnmountedScreens(shadowRoot, main.content);
+  for (const file of unused) {
+    issues.push({
+      filePath: file,
+      errors: [
+        `${path9.relative(shadowRoot, file)} exists but is not imported from the SPA entry. Wire it from src/main.tsx or it will never render.`
+      ]
+    });
+  }
+  for (const file of leftoverNextAppFiles(shadowRoot)) {
+    issues.push({
+      filePath: file,
+      errors: [
+        "Leftover Next App Router file. After the Vite SPA boots, delete src/app/page.tsx and layout.tsx (or they confuse the next run)."
+      ]
+    });
+  }
+  const pkgPath = path9.join(shadowRoot, "package.json");
+  if (fs7.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+      const nextScripts = Object.entries(pkg.scripts || {}).filter(([, cmd]) => /\bnext\b/.test(cmd));
+      if (nextScripts.length > 0) {
+        issues.push({
+          filePath: pkgPath,
+          errors: [
+            `package.json still runs Next in scripts (${nextScripts.map(([name]) => name).join(", ")}). Replace them with Vite/eslint equivalents (dev/build/preview/start/lint).`
+          ]
+        });
+      }
+    } catch {
+    }
+  }
+  return issues;
+}
+function analyzeNextToReactStyles(shadowRoot) {
+  const issues = [];
+  const main = readIfExists2(
+    path9.join(shadowRoot, "src", "main.tsx"),
+    path9.join(shadowRoot, "src", "main.jsx"),
+    path9.join(shadowRoot, "src", "main.ts"),
+    path9.join(shadowRoot, "src", "index.tsx")
+  );
+  const layout = readIfExists2(
+    path9.join(shadowRoot, "src", "app", "layout.tsx"),
+    path9.join(shadowRoot, "src", "app", "layout.jsx"),
+    path9.join(shadowRoot, "app", "layout.tsx"),
+    path9.join(shadowRoot, "app", "layout.jsx")
+  );
+  const cssFromLayout = [];
+  if (layout) {
+    const importRe = /import\s+['"]([^'"]+\.(?:css|scss|sass))['"]/g;
+    let match;
+    while ((match = importRe.exec(layout.content)) !== null) {
+      cssFromLayout.push(match[1]);
+    }
+  }
+  const srcCss = listCssFiles(path9.join(shadowRoot, "src"));
+  const hasGlobalCss = srcCss.length > 0 || cssFromLayout.length > 0;
+  if (!main) {
+    if (hasGlobalCss) {
+      issues.push({
+        filePath: path9.join(shadowRoot, "src", "main.tsx"),
+        errors: [
+          "Missing Vite/React entry (src/main.tsx). Create it so it mounts the app into #root and imports the global CSS that Next layout used to load."
+        ]
+      });
+    }
+    return issues;
+  }
+  const entryImportsCss = /import\s+['"][^'"]+\.(?:css|scss|sass)['"]/.test(main.content);
+  if (hasGlobalCss && !entryImportsCss) {
+    const hint = cssFromLayout[0] || (srcCss[0] ? `./${path9.basename(srcCss[0])}` : "./index.css");
+    issues.push({
+      filePath: main.filePath,
+      errors: [
+        `Global CSS is not imported from the SPA entry. Next.js applied styles via layout; Vite only bundles CSS imported from JS. Add \`import '${hint}'\` (or the path layout used) to ${path9.basename(main.filePath)}.`
+      ]
+    });
+  }
+  const html = readIfExists2(path9.join(shadowRoot, "index.html"));
+  if (html && !/src\/main\.(t|j)sx?/.test(html.content) && !/\/src\/index\.(t|j)sx?/.test(html.content)) {
+    issues.push({
+      filePath: html.filePath,
+      errors: [
+        'index.html must load the SPA entry as a module script (typically <script type="module" src="/src/main.tsx">).'
+      ]
+    });
+  }
+  const viteConfig = readIfExists2(
+    path9.join(shadowRoot, "vite.config.ts"),
+    path9.join(shadowRoot, "vite.config.js")
+  );
+  if (viteConfig && /__dirname/.test(viteConfig.content) && !/import\.meta\.dirname/.test(viteConfig.content)) {
+    issues.push({
+      filePath: viteConfig.filePath,
+      errors: [
+        "vite.config.ts uses __dirname in ESM. Replace it with import.meta.dirname so aliases and CSS resolution work under Vite."
+      ]
+    });
+  }
+  return issues;
+}
+var nextToReactPlugin = {
+  id: "next-to-react",
+  source: "next",
+  target: "react",
+  layer: "frontend",
+  fileHint(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    if (/\/(main|index)\.(t|j)sx?$/i.test(normalized) && !/\/src\/app\//i.test(normalized)) {
+      return `
+This is the Vite/React entry. It must:
+1. import the global CSS Next loaded from layout (often ./index.css)
+2. wrap the tree in BrowserRouter
+3. render the former home screen (whatever the source used as "/")
+Never render only an empty mount node \u2014 Vite will show a blank page and still report ready.
+`;
+    }
+    if (/layout\.(t|j)sx?$/i.test(normalized) && /\/(src\/)?app\//i.test(normalized)) {
+      return `
+This Next layout will not run in Vite. Move its global CSS import to src/main.tsx and its HTML shell into index.html. Then delete this layout after the SPA boots.
 `;
-    appendToReport(plan.targetPath, footer);
+    }
+    return "";
+  },
+  verifyShadow(shadowRoot) {
+    return [...analyzeNextToReactStyles(shadowRoot), ...analyzeNextToReactBootstrap(shadowRoot)];
+  },
+  repairTargets(shadowRoot) {
+    return [
+      path9.join(shadowRoot, "package.json"),
+      path9.join(shadowRoot, "vite.config.ts"),
+      path9.join(shadowRoot, "vite.config.js"),
+      path9.join(shadowRoot, "index.html"),
+      path9.join(shadowRoot, "src", "main.tsx"),
+      path9.join(shadowRoot, "src", "main.jsx"),
+      path9.join(shadowRoot, "src", "App.tsx"),
+      path9.join(shadowRoot, "src", "App.jsx")
+    ];
   }
 };
-function createReporterAgent() {
-  return createAgent5({
-    name: "Reporter",
-    capabilities: ["reporting"],
-    instruction: "You are the Reporter Agent. Your job is to compile a human-readable markdown report of the migration process.",
-    tools: [],
-    handlers: [
-      { specification: new WhenMigrationStarted(), processor: startedProcessor },
-      { specification: new WhenFileMigrated2(), processor: migratedProcessor },
-      { specification: new WhenFileReviewed(), processor: reviewedProcessor },
-      { specification: new WhenFileRejected2(), processor: rejectedProcessor },
-      { specification: new WhenFileFatalMismatch2(), processor: fatalProcessor },
-      { specification: new WhenMigrationCompleted(), processor: completedProcessor }
-    ]
-  });
+
+// ../application/src/migration/plugins/reactToNext.ts
+import * as path10 from "path";
+var reactToNextPlugin = {
+  id: "react-to-next",
+  source: "react",
+  target: "next",
+  layer: "frontend",
+  fileHint(filePath, ctx) {
+    return nextMigrationFileHint(filePath, ctx.target);
+  },
+  verifyShadow(shadowRoot) {
+    return analyzeReactToNextStructure(shadowRoot);
+  },
+  repairTargets(shadowRoot) {
+    return [
+      path10.join(shadowRoot, "package.json"),
+      path10.join(shadowRoot, "next.config.ts"),
+      path10.join(shadowRoot, "next.config.js"),
+      path10.join(shadowRoot, "next.config.mjs"),
+      path10.join(shadowRoot, "src", "app", "page.tsx"),
+      path10.join(shadowRoot, "src", "app", "layout.tsx"),
+      path10.join(shadowRoot, "app", "page.tsx"),
+      path10.join(shadowRoot, "app", "layout.tsx"),
+      ...listAppRouterFiles(shadowRoot)
+    ];
+  }
+};
+
+// ../application/src/migration/plugins/index.ts
+function registerBuiltinMigrationPlugins() {
+  registerMigrationPlugin(reactToNextPlugin);
+  registerMigrationPlugin(nextToReactPlugin);
+  registerMigrationPlugin(vueTargetPlugin);
+  registerMigrationPlugin(svelteTargetPlugin);
+  registerMigrationPlugin(angularTargetPlugin);
 }
 
 // ../application/src/index.ts
-import { createAgent as createAgent6, SituationSpecification as SituationSpecification6 } from "@mozaik-ai/core";
+import { createAgent as createAgent8, createHuman, SituationSpecification as SituationSpecification8 } from "@mozaik-ai/core";
 
 // ../application/src/MigrationRunner.ts
 import { randomUUID } from "crypto";
@@ -2103,8 +2761,9 @@ var MigrationRunner = class {
    */
   async startMigration(request) {
     this.ensureInitialized();
-    await this.store.reset();
-    this.workspace.cleanupOldRuns(3);
+    const existing = await this.store.getAllPlans();
+    const protectedRunIds = existing.filter((p) => p.appliedAt).map((p) => p.runId);
+    this.workspace.cleanupOldRuns(3, protectedRunIds);
     const runId = `run_${Date.now()}`;
     const shadowPath = this.workspace.cloneDirectory(request.targetPath, runId);
     const planId = `plan_${randomUUID()}`;
@@ -2113,19 +2772,21 @@ var MigrationRunner = class {
       runId,
       profile: { source: request.from, target: request.to },
       targetPath: request.targetPath,
+      phase: "files",
       tasks: [
         { filePath: "system:package_manager", status: "pending" }
       ],
       createdAt: /* @__PURE__ */ new Date()
     };
     await this.store.savePlan(plan);
-    const { createHuman } = await import("@mozaik-ai/core");
-    const human = createHuman({ name: "System", capabilities: [], handlers: [] });
-    join(human);
+    const dispatcherId = resolveRuntime().state.dispatcherId;
+    if (!dispatcherId) {
+      throw new Error("Mozaik System participant is not joined.");
+    }
     sendEvent(
       {
         type: "migration.started" /* MIGRATION_STARTED */,
-        producerId: human.getId(),
+        producerId: dispatcherId,
         occurredAt: /* @__PURE__ */ new Date(),
         payload: {
           planId,
@@ -2133,7 +2794,7 @@ var MigrationRunner = class {
           shadowWorkspacePath: shadowPath
         }
       },
-      human.getId()
+      dispatcherId
     );
     return { planId, shadowPath, runId };
   }
@@ -2149,15 +2810,19 @@ var MigrationRunner = class {
 
 // ../application/src/index.ts
 function bootstrapMetamorph(repository, tools = []) {
+  registerBuiltinMigrationPlugins();
   initializeRuntime({
     state: new MetamorphState(repository)
   });
-  class AllEventsSpecification extends SituationSpecification6 {
+  const dispatcher = createHuman({ name: "System", capabilities: [], handlers: [] });
+  join(dispatcher);
+  resolveRuntime().state.dispatcherId = dispatcher.getId();
+  class AllEventsSpecification extends SituationSpecification8 {
     isSatisfiedBy() {
       return true;
     }
   }
-  const loggerAgent = createAgent6({
+  const loggerAgent = createAgent8({
     name: "TelemetryLogger",
     capabilities: [],
     instruction: "You silently log everything.",
@@ -2167,10 +2832,10 @@ function bootstrapMetamorph(repository, tools = []) {
         specification: new AllEventsSpecification(),
         processor: {
           async apply({ event }) {
-            const { resolveRuntime: resolveRuntime2 } = await import("./runtime-5OVGH2Y7.js");
+            const { resolveRuntime: resolveRuntime2 } = await import("./runtime-L7VOQROE.js");
             const runtime = resolveRuntime2();
             const repository2 = runtime.state.repository;
-            if (event.type.includes("migration") || event.type.includes("file")) {
+            if (event.type.includes("migration") || event.type.includes("file") || event.type.includes("phase") || event.type.includes("system")) {
               await repository2.logEvent(event.type, {
                 ...event.payload,
                 producerId: event.producerId
@@ -2186,13 +2851,18 @@ function bootstrapMetamorph(repository, tools = []) {
   const worker = createWorkerAgent(tools);
   const reviewer = createReviewerAgent(tools);
   const packageManager = createPackageManagerAgent();
-  const reporter = createReporterAgent();
+  const coordinator = createCoordinatorAgent();
+  const reporterTools = tools.filter((tool) => tool.name === "read_file" || tool.name === "write_file" || tool.name === "list_directory");
+  const reporter = createReporterAgent(reporterTools);
+  const integrationAgent = createIntegrationAgent(tools);
   join(mapper);
   join(worker);
   join(reviewer);
   join(packageManager);
+  join(coordinator);
   join(reporter);
-  console.log(`[App] Mozaik initialized. Agents joined: Mapper, Worker, Reviewer, PackageManager, Reporter`);
+  join(integrationAgent);
+  console.log(`[App] Mozaik initialized. Agents joined: Mapper, Worker, Reviewer, PackageManager, Coordinator, Reporter, IntegrationAgent`);
   return {
     mapperId: mapper.getId(),
     workerId: worker.getId(),
@@ -2201,9 +2871,18 @@ function bootstrapMetamorph(repository, tools = []) {
 }
 
 // src/index.ts
+function logStartupContext() {
+  const isDev = process.env.METAMORPH_DEV === "1";
+  console.log(chalk.gray(`[Metamorph] CWD: ${process.cwd()}`));
+  console.log(chalk.gray(`[Metamorph] Binary: ${import.meta.url}`));
+  if (!isDev && import.meta.url.includes("/src/")) {
+    console.log(chalk.yellow(`[Metamorph] Notice: Running directly from source without METAMORPH_DEV=1.`));
+  }
+}
 var program = new Command();
-program.name("metamorph").description("AI-powered technology migration tool using Mozaik Agents").version("1.0.0");
+program.name("metamorph").description("AI-powered technology migration tool using Mozaik Agents").version("2.1.1");
 program.command("run [path]").description("Run a migration on the specified directory").option("--from <source>", "Source framework (e.g. express)").option("--to <target>", "Target framework (e.g. fastify)").action(async (targetPathArg, options) => {
+  logStartupContext();
   let targetPath = targetPathArg || ".";
   const { select, input } = await import("@inquirer/prompts");
   let from = options.from;
@@ -2212,9 +2891,11 @@ program.command("run [path]").description("Run a migration on the specified dire
     express: ["fastify", "nestjs"],
     fastify: ["express", "nestjs"],
     nestjs: ["express", "fastify"],
-    react: ["next", "vue"],
-    next: ["react"],
-    vue: ["react"]
+    react: ["next", "vue", "angular", "svelte"],
+    next: ["react", "vue", "angular", "svelte"],
+    vue: ["react", "next", "angular", "svelte"],
+    angular: ["react", "next", "vue", "svelte"],
+    svelte: ["react", "next", "vue", "angular"]
   };
   if (!from) {
     console.log(chalk.gray(`
@@ -2265,12 +2946,16 @@ program.command("run [path]").description("Run a migration on the specified dire
   const spinner = ora("Initializing...").start();
   try {
     const store = new SQLiteStateStore(".metamorph");
+    const shadowBase = path11.resolve(".metamorph/shadow");
     const tools = [
-      createReadFileTool(),
-      createWriteFileTool(),
-      createRenameFileTool(),
-      createCreateFileTool(),
-      createDeleteFileTool()
+      createReadFileTool(shadowBase),
+      createWriteFileTool(shadowBase),
+      createRenameFileTool(shadowBase),
+      createCreateFileTool(shadowBase),
+      createDeleteFileTool(shadowBase),
+      createListDirectoryTool(shadowBase),
+      createCheckProjectDiagnosticsTool(shadowBase),
+      createRunBuildTool(shadowBase)
     ];
     const runner = new MigrationRunner(store, tools);
     const result = await runner.startMigration({
@@ -2281,22 +2966,71 @@ program.command("run [path]").description("Run a migration on the specified dire
     spinner.succeed(`Migration dispatched! Plan: ${result.planId}`);
     console.log(chalk.gray(`Shadow: ${result.shadowPath}`));
     console.log(chalk.blue(`
-\u23F3 Agents are now working...`));
-    await new Promise((resolve3) => setTimeout(resolve3, 2e4));
-    console.log(chalk.green(`
-\u2705 Migration simulation finished.`));
-    process.exit(0);
+\u23F3 Swarm is executing migration in shadow workspace...`));
+    const waitSpinner = ora("Waiting for swarm to complete migration...").start();
+    const startTime = Date.now();
+    const MAX_TIMEOUT_MS = 30 * 60 * 1e3;
+    while (true) {
+      if (Date.now() - startTime >= MAX_TIMEOUT_MS) {
+        waitSpinner.fail(chalk.red(`Migration timed out after 30 minutes.`));
+        process.exit(1);
+      }
+      await new Promise((r) => setTimeout(r, 2e3));
+      const plan = await store.getPlan(result.planId);
+      if (!plan) continue;
+      const terminalTasks = plan.tasks.filter((t) => t.status === "completed" || t.status === "failed");
+      const inProgressTasks = plan.tasks.filter((t) => t.status === "in_progress");
+      const pendingTasks = plan.tasks.filter((t) => t.status === "pending");
+      waitSpinner.text = `Phase: ${plan.phase || "files"} | Tasks: ${terminalTasks.length}/${plan.tasks.length} terminal (${inProgressTasks.length} in progress, ${pendingTasks.length} pending)`;
+      if (plan.outcome === "success") {
+        waitSpinner.succeed(chalk.green(`
+\u2705 Migration finished successfully in shadow workspace!`));
+        console.log(chalk.white(`
+Next steps:`));
+        console.log(chalk.gray(`  1. Review changes in shadow workspace: `) + chalk.cyan(result.shadowPath));
+        console.log(chalk.gray(`  2. Apply changes to a dedicated Git branch: `) + chalk.cyan(`metamorph apply ${result.runId} ${targetPath}
+`));
+        process.exit(0);
+      }
+      if (plan.phase === "failed" || plan.outcome === "failed") {
+        waitSpinner.fail(chalk.red(`
+\u274C Migration failed in shadow workspace.`));
+        console.log(chalk.yellow(`Check .metamorph/shadow/${result.runId}/MIGRATION.md or run 'metamorph ui' for failure details.`));
+        console.log(chalk.gray(`Your original codebase in "${targetPath}" remains completely untouched.
+`));
+        process.exit(1);
+      }
+    }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     spinner.fail(`Migration failed: ${errorMessage}`);
     process.exit(1);
   }
 });
-program.command("apply <runId> <targetPath>").description("Apply a completed migration to the target project").action(async (runId, targetPath) => {
+program.command("apply <runId> <targetPath>").description("Apply a completed migration to the target project (requires Git at the project or monorepo root)").action(async (runId, targetPath) => {
   try {
+    const store = new SQLiteStateStore(".metamorph");
+    const plans = await store.getAllPlans();
+    const plan = plans.find((p) => p.runId === runId);
+    if (!plan) {
+      throw new Error(`Plan for run "${runId}" not found in database.`);
+    }
+    if (plan.phase !== "completed" || plan.outcome !== "success") {
+      throw new Error(
+        `Cannot apply migration: plan is not completed successfully (phase: "${plan.phase}", outcome: "${plan.outcome || "none"}"). Only successful migrations can be applied.`
+      );
+    }
+    if (plan.appliedAt) {
+      throw new Error(
+        `Migration for run "${runId}" has already been applied at ${new Date(plan.appliedAt).toISOString()} to branch ${plan.appliedBranch || "unknown"}.`
+      );
+    }
     const integrator = new MigrationIntegrator(new ShadowWorkspace());
-    const message = await integrator.applyMigration(runId, targetPath);
-    console.log(chalk.green(`\u2705 ${message}`));
+    const result = await integrator.applyMigration(runId, targetPath);
+    plan.appliedAt = /* @__PURE__ */ new Date();
+    plan.appliedBranch = result.branch;
+    await store.savePlan(plan);
+    console.log(chalk.green(`\u2705 ${result.message}`));
   } catch (error) {
     console.error(chalk.red(`\u274C Failed to apply migration: ${error instanceof Error ? error.message : String(error)}`));
     process.exit(1);
@@ -2358,6 +3092,7 @@ program.command("list").description("List past migration plans").action(async ()
   }
 });
 program.command("ui").description("Start the Metamorph Dashboard API server").option("-p, --port <number>", "Port for the API server", "9876").action(async (options) => {
+  logStartupContext();
   let desiredPort = parseInt(options.port, 10);
   const spinner = ora("Starting Metamorph API server...").start();
   try {
@@ -2380,12 +3115,16 @@ program.command("ui").description("Start the Metamorph Dashboard API server").op
       process.exit(1);
     }
     const store = new SQLiteStateStore(".metamorph");
+    const shadowBase = path11.resolve(".metamorph/shadow");
     const tools = [
-      createReadFileTool(),
-      createWriteFileTool(),
-      createRenameFileTool(),
-      createCreateFileTool(),
-      createDeleteFileTool()
+      createReadFileTool(shadowBase),
+      createWriteFileTool(shadowBase),
+      createRenameFileTool(shadowBase),
+      createCreateFileTool(shadowBase),
+      createDeleteFileTool(shadowBase),
+      createListDirectoryTool(shadowBase),
+      createCheckProjectDiagnosticsTool(shadowBase),
+      createRunBuildTool(shadowBase)
     ];
     const runner = new MigrationRunner(store, tools);
     const app = await createApiServer(store, runner);