@nikelyh/metamorph 2.0.11 → 2.1.0

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-OXXEISZT.js";
+import {
+  findMigrationCatalogEntry,
+  formatCatalogRules
+} from "./chunk-VEAYUIOZ.js";
 import {
   detectTechnologies
 } from "./chunk-3QN2Q75J.js";
@@ -10,1234 +28,573 @@ import {
   resolveRuntime,
   runLoop,
   sendEvent
-} from "./chunk-GNWRSZXT.js";
+} from "./chunk-GKRBTA6E.js";
+import {
+  collectFileHints,
+  registerMigrationPlugin
+} from "./chunk-O2QLEES3.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()
+      );
+    }
   }
 };
+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]
+  });
+}
 
-// ../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);
+// ../application/src/agents/WorkerAgent.ts
+import {
+  createAgent as createAgent2,
+  SituationSpecification as SituationSpecification2
+} from "@mozaik-ai/core";
+import * as fs4 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 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 {
-        await sourceFile.refreshFromFileSystem();
+        current[part] = current[part] || {};
+        current = current[part];
       }
-      return {
-        filePath,
-        content: sourceFile.getFullText()
-      };
     }
-  };
-}
-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, "");
-        }
+  }
+  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);
       }
-      sourceFile.replaceWithText(newContent);
-      await sourceFile.save();
-      return {
-        success: true,
-        message: `File ${filePath} successfully updated.`
-      };
     }
-  };
+  }
+  renderTree(tree);
+  return output.trim();
 }
-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);
-        }
+
+// ../application/src/utils/NeighborContext.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+
+// ../application/src/utils/NextMigrationHints.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+function findShadowRoot(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const marker = "/.metamorph/shadow/";
+  const index = normalized.indexOf(marker);
+  if (index === -1) return null;
+  const after = normalized.slice(index + marker.length);
+  const runId = after.split("/")[0];
+  if (!runId) return null;
+  return filePath.slice(0, index + marker.length + runId.length);
+}
+function isFsdPageComponent(filePath) {
+  return /[/\\]src[/\\]pages[/\\][^/\\]+[/\\]ui[/\\]/i.test(filePath);
+}
+function isSpaRootComponent(filePath) {
+  return /[/\\](App|main|index)\.(t|j)sx?$/i.test(filePath) && !/[/\\]src[/\\]app[/\\]/i.test(filePath) && !isFsdPageComponent(filePath);
+}
+function hasNextAppRoutes(shadowRoot) {
+  const appDir = path3.join(shadowRoot, "src", "app");
+  if (!fs2.existsSync(appDir)) return false;
+  const stack = [appDir];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        stack.push(path3.join(dir, entry.name));
+      } else if (entry.name === "page.tsx" || entry.name === "page.jsx" || entry.name === "page.js") {
+        return true;
       }
-      return { success: true, message: `File renamed from ${oldPath} to ${newPath}.` };
     }
-  };
+  }
+  return false;
 }
-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 nextMigrationFileHint(filePath, target) {
+  if (target !== "next") return "";
+  if (isFsdPageComponent(filePath) || isSpaPagesTreeFile(filePath)) {
+    return `
+This file sits under src/pages. In Next.js that directory is the Pages Router.
+Move this file out of src/pages (keep the component and its business logic) into a folder Next does not treat as routes.
+Then add or update src/app/<route>/page.tsx so the App Router imports that screen for the former URL.
+The home route ("/") is src/app/page.tsx and must render the former "/" screen \u2014 not an empty shell, null, a TODO, or a deleted App.tsx.
+Delete the old src/pages copy after the screen exists elsewhere.
+`;
+  }
+  if (isSpaRootComponent(filePath)) {
+    return `
+This is a SPA root/entry file (App.tsx / main.tsx / index.tsx).
+Read it and map each route to src/app/<path>/page.tsx that imports the actual screen component (after moving anything that lived under src/pages).
+src/app/page.tsx must render the home screen. Never import App from the new page (App is being removed).
+Never write a stub that the root component "could not be resolved". After App Router files exist with real UI, delete this legacy root file.
+`;
+  }
+  if (/[/\\]src[/\\]app[/\\].*page\.(t|j)sx$/i.test(filePath)) {
+    return `
+This is a Next App Router page. Import the existing screen component and return it.
+Do not paste that screen's JSX here. Do not rename its public props at the wrapper.
+Do not hollow out the module you imported from.
+`;
+  }
+  return "";
+}
+var NEXT_PAGES_RESERVED = /(?:^|[/\\])(_app|_document|_error|404|500)\.(t|j)sx?$/i;
+function isSpaPagesTreeFile(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  if (!/\/src\/pages\//i.test(normalized)) return false;
+  if (/\/src\/pages\/api\//i.test(normalized)) return false;
+  if (NEXT_PAGES_RESERVED.test(normalized)) return false;
+  return true;
+}
+function listFilesRecursive(dir) {
+  if (!fs2.existsSync(dir)) return [];
+  const out = [];
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const entry of fs2.readdirSync(current, { withFileTypes: true })) {
+      const full = path3.join(current, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else if (/\.(t|j)sx?$/.test(entry.name)) out.push(full);
     }
-  };
+  }
+  return out;
 }
-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);
+function findAppRouterHome(shadowRoot) {
+  const candidates = [
+    path3.join(shadowRoot, "src", "app", "page.tsx"),
+    path3.join(shadowRoot, "src", "app", "page.jsx"),
+    path3.join(shadowRoot, "app", "page.tsx"),
+    path3.join(shadowRoot, "app", "page.jsx")
+  ];
+  return candidates.find((file) => fs2.existsSync(file)) || null;
+}
+function listAppRouterFiles(shadowRoot) {
+  const roots = [path3.join(shadowRoot, "src", "app"), path3.join(shadowRoot, "app")];
+  const names = /^(page|layout)\.(t|j)sx$/i;
+  return roots.flatMap((dir) => listFilesRecursive(dir).filter((file) => names.test(path3.basename(file))));
+}
+function isHollowView(content) {
+  const withoutComments = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+  const hasFeatureImports = /from\s+['"][^'"]*\/(features|entities|widgets)\//.test(withoutComments);
+  const tinyTree = /<h1[^>]*>[^<]{0,40}<\/h1>/.test(withoutComments) && !hasFeatureImports;
+  const emptyMain = /<main>\s*<h1>/.test(withoutComments) && !hasFeatureImports;
+  return tinyTree || emptyMain;
+}
+function findViewPages(shadowRoot) {
+  const viewsDir = path3.join(shadowRoot, "src", "views");
+  return listFilesRecursive(viewsDir).filter((file) => /(?:^|[/\\])(?:.+Page|page)\.(t|j)sx$/i.test(file));
+}
+function localTsxImports(fromFile, content) {
+  const dir = path3.dirname(fromFile);
+  const out = [];
+  const re = /import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"](\.\.?\/[^'"]+|@\/[^'"]+)['"]/g;
+  let match;
+  while ((match = re.exec(content)) !== null) {
+    const resolved = match[3].startsWith("@/") ? path3.join(findSrcRoot(fromFile), match[3].slice(2)) : path3.resolve(dir, match[3]);
+    const candidates = [
+      resolved,
+      `${resolved}.tsx`,
+      `${resolved}.jsx`,
+      `${resolved}.ts`,
+      path3.join(resolved, "index.tsx"),
+      path3.join(resolved, "index.ts")
+    ];
+    const absPath = candidates.find((file) => fs2.existsSync(file));
+    if (!absPath) continue;
+    if (match[2]) out.push({ tag: match[2], absPath });
+    if (match[1]) {
+      for (const part of match[1].split(",")) {
+        const name = part.trim().split(/\s+as\s+/).pop()?.trim();
+        if (name) out.push({ tag: name, absPath });
       }
-      return { success: true, message: `File marked as obsolete at ${obsoletePath} instead of deleting.` };
     }
-  };
-}
-
-// ../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);
   }
-  /**
-   * 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);
+  return out;
+}
+function findSrcRoot(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const idx = normalized.lastIndexOf("/src/");
+  if (idx === -1) return path3.dirname(filePath);
+  return filePath.slice(0, idx + 4);
+}
+function declaredCallbackProps(componentSource) {
+  const names = /* @__PURE__ */ new Set();
+  const iface = /interface\s+\w+\s*\{([^}]+)\}/g;
+  let block;
+  while ((block = iface.exec(componentSource)) !== null) {
+    const field = /(\b(?:on[A-Z]\w+|action[A-Z]\w+)\??)\s*:/g;
+    let f;
+    while ((f = field.exec(block[1])) !== null) names.add(f[1].replace("?", ""));
+  }
+  const dest = /export\s+(?:default\s+)?function\s+\w+\s*\(\s*\{\s*([^}]+)\}/;
+  const d = dest.exec(componentSource);
+  if (d) {
+    for (const part of d[1].split(",")) {
+      const name = part.trim().split(":")[0].trim();
+      if (/^(on[A-Z]|action[A-Z])/.test(name)) names.add(name);
     }
-    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)) {
+  }
+  return [...names];
+}
+function jsxCallbackProps(callerSource, tag) {
+  const names = [];
+  const tagRe = new RegExp(`<${tag}\\b([^>]*)\\/?>`, "g");
+  let match;
+  while ((match = tagRe.exec(callerSource)) !== null) {
+    const propRe = /\b((?:on|action)[A-Z]\w+)\s*=/g;
+    let p;
+    while ((p = propRe.exec(match[1])) !== null) names.push(p[1]);
+  }
+  return names;
+}
+function analyzeCallbackPropMismatches(shadowRoot) {
+  const issues = [];
+  const files = [
+    ...listFilesRecursive(path3.join(shadowRoot, "src", "app")),
+    ...listFilesRecursive(path3.join(shadowRoot, "app")),
+    ...listFilesRecursive(path3.join(shadowRoot, "src", "views"))
+  ].filter((file) => /\.(t|j)sx$/.test(file));
+  for (const file of files) {
+    const content = fs2.readFileSync(file, "utf-8");
+    for (const imp of localTsxImports(file, content)) {
+      let callee;
+      try {
+        callee = fs2.readFileSync(imp.absPath, "utf-8");
+      } catch {
         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}`))
+      const expected = declaredCallbackProps(callee);
+      if (expected.length === 0) continue;
+      const passed = jsxCallbackProps(content, imp.tag);
+      const missing = expected.filter((name) => !passed.includes(name));
+      const extra = passed.filter((name) => !expected.includes(name));
+      if (missing.length === 0 && extra.length === 0) continue;
+      issues.push({
+        filePath: file,
+        errors: [
+          `<${imp.tag}> public callback props do not match ${path3.relative(shadowRoot, imp.absPath)}. Expected: ${expected.join(", ") || "(none)"}. Passed: ${passed.join(", ") || "(none)"}. Do not rename props when wrapping a screen in a router file.`
+        ]
       });
     }
-    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);
-    }
+  return issues;
+}
+function analyzeReactToNextComposition(shadowRoot) {
+  const issues = [];
+  const home = findAppRouterHome(shadowRoot);
+  if (!home) return issues;
+  const homeContent = fs2.readFileSync(home, "utf-8");
+  const views = findViewPages(shadowRoot);
+  const hollowViews = views.filter((file) => isHollowView(fs2.readFileSync(file, "utf-8")));
+  const homeImportsView = views.some((file) => {
+    const stem = path3.basename(file).replace(/\.(t|j)sx$/, "");
+    return homeContent.includes(stem);
+  });
+  const homeAssemblesFeatures = /from\s+['"][^'"]*\/(features|entities|widgets)\//.test(homeContent);
+  if (views.length > 0 && !homeImportsView && homeAssemblesFeatures) {
+    issues.push({
+      filePath: home,
+      errors: [
+        "The App Router home reassembles the UI from lower-level modules instead of importing the existing route-level screen. Import that screen and return it. Renaming props at the wrapper causes runtime TypeError while next build still succeeds."
+      ]
+    });
   }
-  /**
-   * Returns the absolute path of the shadow dir for a given runId.
-   */
-  getShadowPath(runId) {
-    return join3(this.baseDir, runId);
+  for (const file of hollowViews) {
+    issues.push({
+      filePath: file,
+      errors: [
+        "This screen was hollowed out. Restore the original UI here. The App Router page should import this file, not replace it with a stub heading."
+      ]
+    });
   }
-  /**
-   * 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);
-      }
+  return issues;
+}
+function isStubAppRouterPage(content) {
+  const hasLocalImport = /from\s+['"](\.\.?\/|@\/)/.test(content);
+  const emptyish = /return\s*\(\s*<main\s*\/>\s*\)|return\s+null\s*;?|return\s*\(\s*<>\s*<\/>\s*\)|TODO:|could not be resolved/i.test(content);
+  const onlyLayoutShell = /<main\s*\/>/.test(content) && !hasLocalImport;
+  return !hasLocalImport || emptyish || onlyLayoutShell;
+}
+function analyzeReactToNextStructure(shadowRoot) {
+  const issues = [];
+  const pagesDir = path3.join(shadowRoot, "src", "pages");
+  if (fs2.existsSync(pagesDir)) {
+    for (const file of listFilesRecursive(pagesDir)) {
+      if (!isSpaPagesTreeFile(file)) continue;
+      issues.push({
+        filePath: file,
+        errors: [
+          "This UI still lives under src/pages. Next.js will treat it as a Pages Router route. Move it to a folder Next does not reserve, then import it from src/app/**/page.tsx for the old URL. Remove the src/pages copy."
+        ]
+      });
     }
   }
-};
-
-// ../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;
+  const home = findAppRouterHome(shadowRoot);
+  if (!home) {
+    issues.push({
+      filePath: path3.join(shadowRoot, "src", "app", "page.tsx"),
+      errors: [
+        'Missing App Router home (src/app/page.tsx). Create it so it imports and renders the screen the SPA showed at "/".'
+      ]
+    });
+    return issues;
+  }
+  const homeContent = fs2.readFileSync(home, "utf-8");
+  if (isStubAppRouterPage(homeContent)) {
+    issues.push({
+      filePath: home,
+      errors: [
+        "src/app/page.tsx does not render the application UI. Import the former home screen component (after moving any SPA UI out of src/pages if needed). Do not return an empty shell, null, a TODO, or a deleted App.tsx."
+      ]
+    });
   }
-  /**
-   * 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);
+  issues.push(...analyzeReactToNextComposition(shadowRoot));
+  issues.push(...analyzeCallbackPropMismatches(shadowRoot));
+  const pkgPath = path3.join(shadowRoot, "package.json");
+  if (fs2.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+      const viteScripts = Object.entries(pkg.scripts || {}).filter(([, cmd]) => /\bvite\b/.test(cmd));
+      if (viteScripts.length > 0) {
+        issues.push({
+          filePath: pkgPath,
+          errors: [
+            `package.json still runs Vite in scripts (${viteScripts.map(([name]) => name).join(", ")}). After moving to Next, drop leftover preview/vite scripts.`
+          ]
+        });
+      }
+    } catch {
     }
   }
-  isGitRepo(targetPath) {
-    return fs2.existsSync(path.join(targetPath, ".git"));
+  return issues;
+}
+
+// ../application/src/utils/NeighborContext.ts
+var MAX_FILES = 8;
+var MAX_FILE_CHARS = 4e3;
+var MAX_TOTAL_CHARS = 24e3;
+function readTruncated(filePath) {
+  try {
+    if (!fs3.existsSync(filePath) || !fs3.statSync(filePath).isFile()) return null;
+    const raw = fs3.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;
   }
-  async applyWithGit(runId, shadowDir, targetPath) {
-    const branchName = `metamorph/${runId}`;
+}
+function findSrcRoot2(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 = path4.dirname(fromFile);
+  const base = spec.startsWith("@/") ? (() => {
+    const src = findSrcRoot2(fromFile);
+    return src ? path4.join(src, spec.slice(2)) : path4.resolve(dir, spec);
+  })() : path4.resolve(dir, spec);
+  const candidates = [
+    base,
+    `${base}.tsx`,
+    `${base}.ts`,
+    `${base}.jsx`,
+    `${base}.js`,
+    `${base}.vue`,
+    `${base}.svelte`,
+    path4.join(base, "index.tsx"),
+    path4.join(base, "index.ts"),
+    path4.join(base, "index.vue"),
+    path4.join(base, "index.svelte")
+  ];
+  return candidates.find((file) => fs3.existsSync(file) && fs3.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 = findSrcRoot2(fromFile) || (shadow ? path4.join(shadow, "src") : path4.dirname(fromFile));
+  if (!fs3.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 {
-      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)}`);
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
     }
-    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)}`);
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const full = path4.join(dir, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else if (interesting.test(entry.name)) out.push(full);
+      if (out.length >= limit) break;
     }
-    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 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 });
-    }
+  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)
+`);
   }
-};
-
-// ../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();
+  const importSpecs = self ? localImportSpecs(self) : [];
+  const resolved = importSpecs.map((spec) => resolveImport(filePath, spec)).filter((file) => Boolean(file && file !== path4.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) => path4.resolve(file) !== path4.resolve(filePath));
+  if (nearby.length > 0) {
+    const listing = nearby.map((file) => path4.relative(findShadowRoot(filePath) || path4.dirname(filePath), file)).join("\n");
+    sections.push(`### Nearby screen / bootstrap files (paths only \u2014 read before inventing a new UI)
+${listing}
+`);
   }
-}`,
-        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();
-}
+  if (sections.length === 0) return "";
+  return `
+Evidence from disk (read this before editing; match existing exports and callback prop names):
+${sections.join("\n")}`;
+}
 
 // ../application/src/agents/WorkerAgent.ts
-var retryCountMap = /* @__PURE__ */ new Map();
 var MAX_RETRIES = 2;
 var ConcurrencyQueue = class {
   constructor(concurrencyLimit) {
@@ -1267,7 +624,7 @@ var ConcurrencyQueue = class {
     }
   }
 };
-var workerQueue = new ConcurrencyQueue(2);
+var workerQueue = new ConcurrencyQueue(3);
 var WhenFileDiscovered = class extends SituationSpecification2 {
   isSatisfiedBy({ event }) {
     return event.type === "file.discovered" /* FILE_DISCOVERED */;
@@ -1291,7 +648,7 @@ var WhenInferenceCompleted = class extends SituationSpecification2 {
 async function startWorkerLoop(planId, filePath, prompt, participant) {
   return new Promise(async (originalResolve) => {
     let isDone = false;
-    const resolve3 = () => {
+    const resolve5 = () => {
       if (!isDone) {
         isDone = true;
         originalResolve();
@@ -1299,13 +656,12 @@ 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 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.",
+      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: participant.getTools(),
       handlers: [
         {
@@ -1324,7 +680,7 @@ async function startWorkerLoop(planId, filePath, prompt, participant) {
               } catch (e) {
                 console.error(`[WorkerAgent:${tempParticipant.getId()}] Error reading file:`, e);
               }
-              await repository.updateTaskStatus(planId, filePath, "completed");
+              await repository.updateTaskStatus(planId, filePath, "in_progress");
               sendEvent(
                 {
                   type: "file.migrated" /* FILE_MIGRATED */,
@@ -1339,7 +695,7 @@ async function startWorkerLoop(planId, filePath, prompt, participant) {
                 tempParticipant.getId()
               );
               leave(tempParticipant);
-              resolve3();
+              resolve5();
             }
           }
         }
@@ -1358,8 +714,14 @@ async function startWorkerLoop(planId, filePath, prompt, participant) {
         if (!isDone) {
           console.error(`[WorkerAgent:${tempAgent.getId()}] Inference timed out.`);
           await repository.updateTaskStatus(planId, filePath, "failed", "Inference timed out");
+          sendEvent({
+            type: "file.failed" /* FILE_FAILED */,
+            producerId: tempAgent.getId(),
+            occurredAt: /* @__PURE__ */ new Date(),
+            payload: { planId, filePath, reason: "Inference timed out" }
+          }, tempAgent.getId());
           leave(tempAgent);
-          resolve3();
+          resolve5();
         }
       }, 45e3);
     } catch (error) {
@@ -1367,8 +729,14 @@ async function startWorkerLoop(planId, filePath, prompt, participant) {
       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();
+        resolve5();
       }
     }
   });
@@ -1387,10 +755,10 @@ var workOnFileProcessor = {
       const catalogEntry = findMigrationCatalogEntry(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 +795,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 +818,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")}
 
@@ -1464,10 +861,10 @@ ${payload.errors.join("\n")}
       const catalogEntry = findMigrationCatalogEntry(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 +879,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 +906,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 +933,7 @@ import {
   createAgent as createAgent3,
   SituationSpecification as SituationSpecification3
 } from "@mozaik-ai/core";
+import * as path5 from "path";
 var ConcurrencyQueue2 = class {
   constructor(concurrencyLimit) {
     this.concurrencyLimit = concurrencyLimit;
@@ -1551,7 +962,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 */;
@@ -1575,7 +986,7 @@ var reviewFileProcessor = {
     reviewerQueue.enqueue(async () => {
       return new Promise(async (originalResolve) => {
         let isDone = false;
-        const resolve3 = () => {
+        const resolve5 = () => {
           if (!isDone) {
             isDone = true;
             console.log(`[DEBUG:ReviewerAgent] Promise resolved for ${payload.filePath}`);
@@ -1583,12 +994,12 @@ var reviewFileProcessor = {
           }
         };
         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: [
@@ -1625,6 +1036,8 @@ var reviewFileProcessor = {
                     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,27 +1064,9 @@ 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();
+                  resolve5();
                 }
               }
             }
@@ -1681,16 +1076,58 @@ var reviewFileProcessor = {
         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 target = planForMissing?.profile.target;
+          const shadowRoot = findShadowRoot(payload.filePath);
+          const deletedFsdPage = target === "next" && isFsdPageComponent(payload.filePath);
+          const viewsReplacement = payload.filePath.replace(/([/\\])src\1pages\1/, "$1src$1views$1");
+          const fsdMovedToViews = deletedFsdPage && existsSync8(viewsReplacement);
+          const deletedRootWithoutRoutes = target === "next" && isSpaRootComponent(payload.filePath) && (!shadowRoot || !hasNextAppRoutes(shadowRoot));
+          if (deletedFsdPage && !fsdMovedToViews || deletedRootWithoutRoutes) {
+            console.log(`[ReviewerAgent:${reviewerId}] Missing ${payload.filePath} is not a valid Next.js move. Rejecting.`);
+            sendEvent4({
+              type: "file.rejected" /* FILE_REJECTED */,
+              producerId: tempAgent.getId(),
+              occurredAt: /* @__PURE__ */ new Date(),
+              payload: {
+                planId: payload.planId,
+                filePath: payload.filePath,
+                errors: deletedFsdPage ? [
+                  "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 and import those screens from src/app. Do not delete the UI without a replacement."
+                ] : [
+                  "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."
+                ]
+              }
+            }, tempAgent.getId());
+            leave(tempAgent);
+            resolve5();
+            return;
+          }
+          console.log(`[ReviewerAgent:${reviewerId}] File ${payload.filePath} does not exist on disk (likely intentionally deleted/moved). Auto-approving.`);
+          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());
+          leave(tempAgent);
+          resolve5();
+          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 +1139,7 @@ var reviewFileProcessor = {
                 }
               }, tempAgent.getId());
               leave(tempAgent);
-              resolve3();
+              resolve5();
               return;
             }
           } catch (e) {
@@ -1710,6 +1147,28 @@ 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);
+              resolve5();
+              return;
+            }
+          }
+        }
         let prompt = `Review the following file migration: ${payload.filePath}
 `;
         if (plan) {
@@ -1718,360 +1177,1579 @@ var reviewFileProcessor = {
           const catalogEntry = findMigrationCatalogEntry(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):
 `;
-            catalogEntry.architecturalRules.forEach((rule) => prompt += `- ${rule}
-`);
+            prompt += `${formatCatalogRules(catalogEntry.ruleSections)}
+`;
+          }
+          prompt += collectFileHints(
+            payload.filePath,
+            { source: plan.profile.source, target: plan.profile.target },
+            catalogEntry?.layer
+          );
+        }
+        prompt += `
+${buildNeighborContext(payload.filePath)}
+Diff or new content of the file under review:
+${payload.diff}
+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(),
+            structuredOutput: {
+              name: "review_result",
+              schema: {
+                type: "object",
+                properties: {
+                  status: { type: "string", enum: ["APPROVED", "REJECTED", "FATAL_MISMATCH"] },
+                  errors: { type: "array", items: { type: "string" } }
+                },
+                required: ["status", "errors"],
+                additionalProperties: false
+              },
+              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-L7VOQROE.js");
+              const runtime2 = resolveRuntime2();
+              await runtime2.state.repository.updateTaskStatus(payload.planId, payload.filePath, "failed", "Inference timed out after 45s");
+              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 45s" }
+              }, tempAgent.getId());
+              leave(tempAgent);
+              resolve5();
+            }
+          }, 45e3);
+        } catch (error) {
+          console.error(`[ReviewerAgent:${reviewerId}] Sync error:`, error);
+          if (!isDone) {
+            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);
+            resolve5();
+          }
+        }
+      });
+    });
+  }
+};
+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 = findMigrationCatalogEntry(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;
           }
         }
-        prompt += `
-Diff or new content:
-${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";
-        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(),
-            structuredOutput: {
-              name: "review_result",
-              schema: {
-                type: "object",
-                properties: {
-                  status: { type: "string", enum: ["APPROVED", "REJECTED", "FATAL_MISMATCH"] },
-                  errors: { type: "array", items: { type: "string" } }
-                },
-                required: ["status", "errors"],
-                additionalProperties: false
-              },
-              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");
-              const runtime2 = resolveRuntime2();
-              await runtime2.state.repository.updateTaskStatus(payload.planId, payload.filePath, "failed", "Inference timed out after 45s");
-              leave(tempAgent);
-              resolve3();
+        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 stopped after 30 minutes. Integration never became ready (files still in progress, or the run stalled).",
+              level: "warning"
             }
-          }, 45e3);
-        } catch (error) {
-          console.error(`[ReviewerAgent:${reviewerId}] Sync error:`, error);
-          if (!isDone) {
-            const { resolveRuntime: resolveRuntime2 } = await import("./runtime-5OVGH2Y7.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");
-            leave(tempAgent);
-            resolve3();
-          }
+          }, 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);
   }
 };
-var reviewFileHandler = {
-  specification: new WhenFileMigrated(),
-  processor: reviewFileProcessor
-};
-function createReviewerAgent(tools) {
-  return createAgent3({
-    name: "Reviewer",
-    capabilities: ["code_review", "inference"],
-    instruction: "You are the Reviewer Worker.",
+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-2UXWWNPF.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}`);
+  }
+};
+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 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
+    });
+    board.pendingStatusPhase = plan.phase === "failed" ? "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, plan.phase, 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");
+    }
+  }
+};
+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) {
+    plan.phase = "completed";
+    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 }
+  }, 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";
+    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 }
+  }, 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 pmTask = plan.tasks.find((t) => t.filePath === "system:package_manager");
-    if (pmTask) {
-      pmTask.status = "in_progress";
+    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);
-    }
-    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}`);
+      const lastRound = plan.integrationRounds >= MAX_INTEGRATION_ROUNDS;
+      const { ShadowWorkspace: ShadowWorkspace2, createReadFileTool: createReadFileTool2, createWriteFileTool: createWriteFileTool2, createListDirectoryTool: createListDirectoryTool2, createRunBuildTool: createRunBuildTool2, runInShadowWorkspace, parseImplicatedFiles } = await import("./src-2UXWWNPF.js");
+      const { collectShadowIssues, collectRepairTargets } = await import("./registry-7WZ5RTGE.js");
+      const { findMigrationCatalogEntry: findMigrationCatalogEntry2 } = 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 (!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. Continuing to build anyway.", "warning");
+      } else {
+        log2(producerId, planId, "npm install finished. Next: npm run build in the shadow workspace.");
       }
-    }
-    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}`));
+      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.");
+        }
+      });
+      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 resolve5 = () => {
+            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);
+            resolve5();
           });
-          proc.on("error", reject);
+          setTimeout(() => {
+            if (!isDone) {
+              console.warn("[IntegrationAgent] Repair loop timed out; continuing with deterministic rebuild.");
+              leave(tempAgent);
+              resolve5();
+            }
+          }, REPAIR_TIMEOUT_MS);
         });
-      };
-      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]);
-        }
-        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 (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]);
-        }
-        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);
+        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 = findMigrationCatalogEntry2(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";
@@ -2119,13 +2797,14 @@ var MigrationRunner = class {
       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 +2812,7 @@ var MigrationRunner = class {
           shadowWorkspacePath: shadowPath
         }
       },
-      human.getId()
+      dispatcherId
     );
     return { planId, shadowPath, runId };
   }
@@ -2149,15 +2828,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 +2850,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 +2869,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(),
@@ -2212,9 +2900,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 +2955,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({
@@ -2282,7 +2976,7 @@ program.command("run [path]").description("Run a migration on the specified dire
     console.log(chalk.gray(`Shadow: ${result.shadowPath}`));
     console.log(chalk.blue(`
 \u23F3 Agents are now working...`));
-    await new Promise((resolve3) => setTimeout(resolve3, 2e4));
+    await new Promise((resolve5) => setTimeout(resolve5, 2e4));
     console.log(chalk.green(`
 \u2705 Migration simulation finished.`));
     process.exit(0);
@@ -2292,11 +2986,11 @@ program.command("run [path]").description("Run a migration on the specified dire
     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 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);
+    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);
@@ -2380,12 +3074,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);