@stackwright-pro/mcp 0.2.0-alpha.0 → 0.2.0-alpha.10

package/dist/server.js

@@ -111,8 +111,8 @@ function registerDataExplorerTools(server2) {
       lines.push("    endpoints:");
       if (result.filter.include && result.filter.include.length > 0) {
         lines.push("      include:");
-        for (const path4 of result.filter.include) {
-          lines.push(`        - ${path4}`);
+        for (const path3 of result.filter.include) {
+          lines.push(`        - ${path3}`);
         }
       }
       if (result.filter.exclude && result.filter.exclude.length > 0) {
@@ -142,6 +142,7 @@ function registerDataExplorerTools(server2) {
 
 // src/tools/security.ts
 var import_zod2 = require("zod");
+var import_crypto = require("crypto");
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 function registerSecurityTools(server2) {
@@ -219,8 +220,7 @@ This spec is not on the approved-specs allowlist. Add it using stackwright_pro_a
       if (!specPath.startsWith("http://") && !specPath.startsWith("https://")) {
         if (import_fs.default.existsSync(specPath)) {
           const specContent = import_fs.default.readFileSync(specPath, "utf8");
-          const crypto = require("crypto");
-          const sha256 = crypto.createHash("sha256").update(specContent).digest("hex");
+          const sha256 = (0, import_crypto.createHash)("sha256").update(specContent).digest("hex");
           if (sha256 !== matchingSpec.sha256) {
             return {
               content: [
@@ -271,8 +271,7 @@ Status: Valid (${allowlist.length} specs on allowlist)`
           sha256 = "<computed-at-build>";
         } else if (import_fs.default.existsSync(url)) {
           const specContent = import_fs.default.readFileSync(url, "utf8");
-          const crypto = require("crypto");
-          sha256 = crypto.createHash("sha256").update(specContent).digest("hex");
+          sha256 = (0, import_crypto.createHash)("sha256").update(specContent).digest("hex");
         } else {
           return {
             content: [
@@ -647,297 +646,165 @@ ${yaml}
 
 // src/tools/clarification.ts
 var import_zod5 = require("zod");
-var import_child_process = require("child_process");
-var import_os = require("os");
-var import_path2 = require("path");
-var import_crypto = require("crypto");
-var import_fs2 = require("fs");
-var activeServers = /* @__PURE__ */ new Map();
-async function startPythonServer(sessionId) {
-  const socketPath = (0, import_path2.join)((0, import_os.tmpdir)(), `otter-raft-${(0, import_crypto.randomUUID)()}.sock`);
-  const port = 8765 + Math.floor(Math.random() * 100);
-  return new Promise((resolve, reject) => {
-    const pythonPath = process.platform === "win32" ? "python" : "python3";
-    const packageRoot = findPythonPackageRoot();
-    const proc = (0, import_child_process.spawn)(
-      pythonPath,
-      ["-m", "stackwright_pro.raft.server", "--socket", socketPath, "--port", String(port)],
-      {
-        stdio: ["pipe", "pipe", "pipe"],
-        env: {
-          ...process.env,
-          PYTHONPATH: packageRoot
-        }
-      }
-    );
-    activeServers.set(sessionId, proc);
-    let startupOutput = "";
-    let started = false;
-    proc.stdout?.on("data", (data) => {
-      startupOutput += data.toString();
-      if (startupOutput.includes("Server ready") || startupOutput.includes("HTTP server")) {
-        started = true;
-        resolve({ port, socketPath });
-      }
-    });
-    proc.stderr?.on("data", (data) => {
-      if (!startupOutput.includes("Starting")) {
-        console.error("[Python Clarification]", data.toString().trim());
-      }
-    });
-    proc.on("error", (err) => {
-      if (!started) {
-        activeServers.delete(sessionId);
-        reject(new Error(`Failed to start Python server: ${err.message}`));
-      }
-    });
-    proc.on("exit", (code) => {
-      activeServers.delete(sessionId);
-      if ((0, import_fs2.existsSync)(socketPath)) {
-        try {
-          (0, import_fs2.unlinkSync)(socketPath);
-        } catch {
-        }
-      }
-    });
-    setTimeout(() => {
-      if (!started) {
-        proc.kill();
-        activeServers.delete(sessionId);
-        reject(new Error("Python server startup timeout"));
-      }
-    }, 1e4);
-  });
-}
-async function stopPythonServer(sessionId) {
-  const proc = activeServers.get(sessionId);
-  if (proc) {
-    proc.kill("SIGTERM");
-    activeServers.delete(sessionId);
-  }
-}
-async function httpRequest(host, port, path4, body) {
-  const http = await import("http");
-  return new Promise((resolve, reject) => {
-    const url = new URL(path4, `http://${host}:${port}`);
-    const reqOptions = {
-      hostname: host,
-      port,
-      path: url.pathname,
-      method: body ? "POST" : "GET",
-      headers: {
-        "Content-Type": "application/json"
-      }
+var CONTRADICTION_PATTERNS = [
+  {
+    keywords: ["minimal", "clean", "simple"],
+    conflicts: ["vibrant", "rich", "content-heavy", "playful"]
+  },
+  {
+    keywords: ["dark", "dark mode"],
+    conflicts: ["light mode only", "light"]
+  },
+  {
+    keywords: ["enterprise", "professional", "corporate"],
+    conflicts: ["playful", "casual", "fun"]
+  },
+  {
+    keywords: ["accessible", "wcag", "section 508"],
+    conflicts: ["compact", "dense", "small text"]
+  },
+  {
+    keywords: ["government", "defense", "federal"],
+    conflicts: ["public", "no auth", "consumer"]
+  }
+];
+function handleClarify(input) {
+  const { question_type, question, choices, priority, target_field, context } = input;
+  const base = {
+    action: "ask_user",
+    targetField: target_field
+  };
+  if (question_type === "closed_choice" && choices && choices.length > 0) {
+    const header = truncateHeader(question);
+    base.adaptedQuestion = {
+      question,
+      header,
+      options: choices.map((c) => ({ label: c }))
     };
-    const req = http.request(reqOptions, (res) => {
-      let data = "";
-      res.on("data", (chunk) => {
-        data += chunk.toString();
-      });
-      res.on("end", () => {
-        try {
-          const parsed = JSON.parse(data);
-          if (res.statusCode && res.statusCode >= 400) {
-            reject(new Error(parsed.detail || parsed.error || `HTTP ${res.statusCode}`));
-          } else {
-            resolve(parsed);
-          }
-        } catch (e) {
-          reject(new Error(`Failed to parse response: ${data}`));
-        }
-      });
-    });
-    req.on("error", reject);
-    if (body) {
-      req.write(JSON.stringify(body));
-    }
-    req.end();
-  });
+  } else {
+    const contextPrefix = context ? `Context: ${context}
+
+` : "";
+    base.prompt = `${contextPrefix}${question}`;
+  }
+  if (priority === "optional") {
+    base.suggestedDefault = inferDefault(question_type, choices);
+  }
+  return base;
 }
-function findPythonPackageRoot() {
-  const candidates = [
-    (0, import_path2.join)(__dirname, "../../python/src"),
-    (0, import_path2.join)(__dirname, "../../../python/src"),
-    (0, import_path2.join)(process.cwd(), "python/src")
-  ];
-  for (const candidate of candidates) {
-    if ((0, import_fs2.existsSync)(candidate)) {
-      return candidate;
+function handleDetectConflict(input) {
+  const preferenceLower = input.stated_preference.toLowerCase();
+  const valuesLower = Object.values(input.selected_values).map((v) => v.toLowerCase());
+  for (const pattern of CONTRADICTION_PATTERNS) {
+    const preferenceMatch = pattern.keywords.some((kw) => preferenceLower.includes(kw));
+    if (!preferenceMatch) continue;
+    const conflictingValues = valuesLower.filter(
+      (val) => pattern.conflicts.some((c) => val.includes(c))
+    );
+    if (conflictingValues.length > 0) {
+      const matchedKeywords = pattern.keywords.filter((kw) => preferenceLower.includes(kw));
+      const primaryKeyword = matchedKeywords[0] ?? "preference";
+      return {
+        conflict: true,
+        description: `Stated preference includes "${matchedKeywords.join(", ")}" but selections contain "${conflictingValues.join(", ")}" \u2014 these are contradictory.`,
+        resolution_options: [
+          `Align selections with the "${primaryKeyword}" preference`,
+          `Revise stated preference to match current selections`,
+          "Ask user which direction they actually want"
+        ]
+      };
     }
   }
-  return process.cwd();
+  return { conflict: false };
+}
+function truncateHeader(text) {
+  const MAX = 50;
+  if (text.length <= MAX) return text;
+  return text.slice(0, MAX - 1) + "\u2026";
+}
+function inferDefault(questionType, choices) {
+  if (questionType === "closed_choice" && choices && choices.length > 0) {
+    return choices[0] ?? "(first choice)";
+  }
+  return "(use sensible project default)";
 }
 function registerClarificationTools(server2) {
   server2.tool(
     "stackwright_pro_clarify",
-    "Ask the user for clarification when an otter encounters ambiguity. This is for MID-EXECUTION questions, not upfront question collection. Use this when the otter needs user input to proceed. Returns the user's decision which should be used to continue execution.",
+    "Ask the user for clarification when a specialist otter encounters ambiguity. This is for MID-EXECUTION questions, NOT upfront question collection (use the Question Manifest Protocol for that). Returns a structured response for the foreman to present to the user via ask_user_question (closed_choice) or directly (open_text).",
     {
       context: import_zod5.z.string().optional().describe("Context about what the otter is trying to do"),
-      question_type: import_zod5.z.enum(["closed_choice", "open_text", "conditional", "multi_step", "reconciliation"]).describe("Type of question being asked"),
+      question_type: import_zod5.z.enum(["closed_choice", "open_text"]).describe("Type of question being asked"),
       question: import_zod5.z.string().describe("The clarification question to ask the user"),
-      choices: import_zod5.z.array(import_zod5.z.string()).optional().describe("Options for closed_choice or multi_step questions"),
-      priority: import_zod5.z.enum(["blocking", "preferred", "optional"]).optional().describe("How critical is this clarification? Default: preferred"),
+      choices: import_zod5.z.array(import_zod5.z.string()).optional().describe("Options for closed_choice questions"),
+      priority: import_zod5.z.enum(["blocking", "preferred", "optional"]).optional().default("preferred").describe("How critical is this clarification? Default: preferred"),
       target_field: import_zod5.z.string().optional().describe("What field/config does this clarify?")
     },
-    async ({ context, question_type, question, choices, priority = "preferred", target_field }) => {
-      const sessionId = `mcp_${(0, import_crypto.randomUUID)().slice(0, 8)}`;
-      try {
-        const { port } = await startPythonServer(sessionId);
-        await httpRequest(port === 8765 ? "127.0.0.1" : "127.0.0.1", port, "/sessions", {});
-        if (context) {
-          await httpRequest(
-            port === 8765 ? "127.0.0.1" : "127.0.0.1",
-            port,
-            `/sessions/${sessionId}/context`,
-            { context: { purpose: context } }
-          );
-        }
-        const request = {
-          ...context !== void 0 && { context },
-          question_type,
-          question,
-          ...choices !== void 0 && { choices },
-          priority,
-          ...target_field !== void 0 && { target_field }
-        };
-        const response = await httpRequest(
-          port === 8765 ? "127.0.0.1" : "127.0.0.1",
-          port,
-          "/clarify",
-          { request }
-        );
-        await stopPythonServer(sessionId);
-        const decision = response.decision;
-        const value = decision.value;
-        const source = decision.source;
-        const explicit = decision.explicit ? "explicitly" : "via fallback";
-        if (response.fallback_used) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `\u26A0\uFE0F Clarification fallback used: ${response.fallback_reason || "No user input available"}
-
-Default value used: ${JSON.stringify(value)}
-
-\u{1F4A1} Consider following up with the user later if this default isn't appropriate.`
-              }
-            ]
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: `\u2705 User clarified (${source}): ${JSON.stringify(value)}
-
-Use this value to continue execution.`
-            }
-          ]
-        };
-      } catch (error) {
-        await stopPythonServer(sessionId);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `\u274C Clarification failed: ${error instanceof Error ? error.message : "Unknown error"}
-
-Cannot proceed without user input. Consider:
-1. Using a reasonable default
-2. Asking the user directly in your response
-3. Skipping this step if optional`
-            }
-          ],
-          isError: true
-        };
-      }
+    async ({ context, question_type, question, choices, priority, target_field }) => {
+      const result = handleClarify({
+        context: context ?? void 0,
+        question_type,
+        question,
+        choices: choices ?? void 0,
+        priority: priority ?? "preferred",
+        target_field: target_field ?? void 0
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u{1F9A6} Clarification needed${target_field ? ` for "${target_field}"` : ""}. Present the following to the user. ` + (result.adaptedQuestion ? "Pass the adaptedQuestion to ask_user_question directly." : "Ask the user the prompt below.")
+          },
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
     }
   );
   server2.tool(
     "stackwright_pro_detect_conflict",
-    "Detect when a user's stated preference conflicts with their selected choices. Use this to identify when users might be indecisive or misunderstood a question. Returns conflict details and resolution options.",
+    "Detect when a user's stated preference conflicts with their selected choices. Uses keyword heuristics against known contradiction patterns (minimal vs vibrant, dark vs light, etc). Returns conflict details and resolution options.",
     {
       stated_preference: import_zod5.z.string().describe("What the user said they wanted"),
-      selected_values: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string()).describe("What the user actually selected")
+      selected_values: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string()).describe("What the user actually selected (field \u2192 value)")
     },
     async ({ stated_preference, selected_values }) => {
-      const sessionId = `mcp_${(0, import_crypto.randomUUID)().slice(0, 8)}`;
-      try {
-        const { port } = await startPythonServer(sessionId);
-        const response = await httpRequest(
-          port === 8765 ? "127.0.0.1" : "127.0.0.1",
-          port,
-          "/conflict",
-          { stated_preference, selected_values }
-        );
-        await stopPythonServer(sessionId);
-        if (response.conflict) {
-          const data = response.data;
-          return {
-            content: [
-              {
-                type: "text",
-                text: `\u26A0\uFE0F CONFLICT DETECTED
+      const result = handleDetectConflict({ stated_preference, selected_values });
+      if (result.conflict) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\u26A0\uFE0F CONFLICT DETECTED
 
 User stated: "${stated_preference}"
 But selected: ${JSON.stringify(selected_values)}
 
-Conflict: ${data.description}
+${result.description}
 
-Resolution options: ${data.options?.join(", ") || "Ask user to clarify"}
+Resolution options:
+${result.resolution_options?.map((o) => `  \u2022 ${o}`).join("\n")}
 
 \u{1F4A1} Consider asking the user to reconcile this conflict.`
-              }
-            ]
-          };
-        }
-        return {
-          content: [
+            },
             {
               type: "text",
-              text: `\u2705 No conflict detected between stated preference and selections.`
+              text: JSON.stringify(result)
             }
           ]
         };
-      } catch (error) {
-        await stopPythonServer(sessionId);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `\u274C Conflict detection failed: ${error instanceof Error ? error.message : "Unknown error"}`
-            }
-          ],
-          isError: true
-        };
       }
-    }
-  );
-  server2.tool(
-    "stackwright_pro_get_defaults",
-    "Get the current clarification defaults from config. Use this to understand what fallback values will be used if user doesn't provide input.",
-    {
-      config_path: import_zod5.z.string().optional().describe("Path to config file. Default: .stackwright/clarification.yaml")
-    },
-    async ({ config_path }) => {
       return {
         content: [
           {
             type: "text",
-            text: `\u{1F4CB} Clarification defaults
-
-Configuration is loaded from:
-- Environment: CLARIFICATION_* variables
-- Config file: ${config_path || ".stackwright/clarification.yaml"}
-- CLI args: --clarify-* flags
-
-Default behaviors:
-- allow_dont_know: true (users can skip)
-- default_timeout: 120 seconds
-- channel_priority: [tui, cli_args, config, defaults]
-
-\u{1F4A1} Set CLARIFICATION_DEFAULT_<FIELD>=value to change defaults.`
+            text: "\u2705 No conflict detected between stated preference and selections."
+          },
+          {
+            type: "text",
+            text: JSON.stringify(result)
           }
         ]
       };
@@ -947,38 +814,48 @@ Default behaviors:
 
 // src/tools/packages.ts
 var import_zod6 = require("zod");
-var import_fs3 = require("fs");
-var import_child_process2 = require("child_process");
-var import_path3 = __toESM(require("path"));
+var import_fs2 = require("fs");
+var import_child_process = require("child_process");
+var import_path2 = __toESM(require("path"));
+var BASELINE_DEPS = {
+  "@stackwright-pro/mcp": "latest",
+  "@stackwright-pro/otters": "latest",
+  "@stackwright-pro/openapi": "latest",
+  "@stackwright-pro/auth": "latest",
+  "@stackwright-pro/auth-nextjs": "latest",
+  zod: "^3.23.0"
+};
+var BASELINE_DEV_DEPS = {
+  "@stoplight/prism-cli": "^5.14.2"
+};
 function registerPackageTools(server2) {
   server2.tool(
     "stackwright_pro_setup_packages",
-    "Ensures pro packages are present in a project's package.json. Safe to call multiple times \u2014 never overwrites existing version pins. Use this to bootstrap dependencies before specialist otters run.",
+    "Ensures pro packages are present in a project's package.json. Safe to call multiple times \u2014 never overwrites existing version pins. Use this to bootstrap dependencies before specialist otters run. Pass includeBaseline: true to automatically include all required @stackwright-pro/* baseline dependencies. Safe to call on existing projects \u2014 never overwrites pinned versions.",
     {
       // FIX 3 (B-new-1): Zod v4 requires two-arg z.record(keySchema, valueSchema)
       packages: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).describe(
         'Dependencies to add. Record<packageName, version>. e.g. { "@stackwright-pro/auth": "latest" }'
       ),
-      devPackages: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional().describe(
-        "devDependencies to add. Same format as packages."
-      ),
-      scripts: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional().describe(
-        "npm scripts to add. Only adds if key does not already exist."
-      ),
+      devPackages: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional().describe("devDependencies to add. Same format as packages."),
+      scripts: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional().describe("npm scripts to add. Only adds if key does not already exist."),
       targetDir: import_zod6.z.string().optional().describe(
         "Project directory containing package.json. Defaults to process.cwd(). Must be an absolute path within the current working directory."
       ),
-      runInstall: import_zod6.z.boolean().optional().default(true).describe(
-        "Run pnpm install after writing package.json. Defaults to true."
+      runInstall: import_zod6.z.boolean().optional().default(true).describe("Run pnpm install after writing package.json. Defaults to true."),
+      includeBaseline: import_zod6.z.boolean().optional().default(false).describe(
+        "When true, automatically merges BASELINE_DEPS and BASELINE_DEV_DEPS before applying packages/devPackages args. Safe to call on existing projects \u2014 never overwrites pinned versions."
       )
     },
-    async ({ packages, devPackages, scripts, targetDir, runInstall }) => {
+    async ({ packages, devPackages, scripts, targetDir, runInstall, includeBaseline }) => {
+      const mergedPackages = includeBaseline ? { ...BASELINE_DEPS, ...packages } : { ...packages };
+      const mergedDevPackages = includeBaseline ? { ...BASELINE_DEV_DEPS, ...devPackages ?? {} } : devPackages;
       const result = setupPackages({
-        packages,
-        devPackages,
-        scripts,
-        targetDir,
-        runInstall
+        packages: mergedPackages,
+        runInstall,
+        ...mergedDevPackages !== void 0 ? { devPackages: mergedDevPackages } : {},
+        ...scripts !== void 0 ? { scripts } : {},
+        ...targetDir !== void 0 ? { targetDir } : {}
       });
       const statusLine = result.success ? `\u2705 package.json updated: ${result.packageJsonPath}` : `\u274C Failed: ${result.error}`;
       const lines = [
@@ -1014,8 +891,8 @@ function setupPackages(opts) {
   };
   try {
     const cwd = process.cwd();
-    const resolvedTarget = opts.targetDir ? import_path3.default.resolve(opts.targetDir) : cwd;
-    const cwdWithSep = cwd.endsWith(import_path3.default.sep) ? cwd : cwd + import_path3.default.sep;
+    const resolvedTarget = opts.targetDir ? import_path2.default.resolve(opts.targetDir) : cwd;
+    const cwdWithSep = cwd.endsWith(import_path2.default.sep) ? cwd : cwd + import_path2.default.sep;
     if (resolvedTarget !== cwd && !resolvedTarget.startsWith(cwdWithSep)) {
       return {
         success: false,
@@ -1028,8 +905,8 @@ function setupPackages(opts) {
         error: `Path traversal rejected: target directory is outside the allowed working directory`
       };
     }
-    const preResolvePackageJsonPath = import_path3.default.join(resolvedTarget, "package.json");
-    if (!(0, import_fs3.existsSync)(preResolvePackageJsonPath)) {
+    const preResolvePackageJsonPath = import_path2.default.join(resolvedTarget, "package.json");
+    if (!(0, import_fs2.existsSync)(preResolvePackageJsonPath)) {
       return {
         success: false,
         ...emptyResult,
@@ -1038,7 +915,7 @@ function setupPackages(opts) {
     }
     let realTarget;
     try {
-      realTarget = (0, import_fs3.realpathSync)(resolvedTarget);
+      realTarget = (0, import_fs2.realpathSync)(resolvedTarget);
     } catch {
       return {
         success: false,
@@ -1050,8 +927,8 @@ function setupPackages(opts) {
         error: `Could not resolve real path of target directory`
       };
     }
-    const realCwd = (0, import_fs3.realpathSync)(cwd);
-    const realCwdWithSep = realCwd.endsWith(import_path3.default.sep) ? realCwd : realCwd + import_path3.default.sep;
+    const realCwd = (0, import_fs2.realpathSync)(cwd);
+    const realCwdWithSep = realCwd.endsWith(import_path2.default.sep) ? realCwd : realCwd + import_path2.default.sep;
     if (realTarget !== realCwd && !realTarget.startsWith(realCwdWithSep)) {
       return {
         success: false,
@@ -1064,8 +941,8 @@ function setupPackages(opts) {
         error: `Path traversal rejected: target directory resolved to a location outside the allowed working directory`
       };
     }
-    const realPackageJsonPath = import_path3.default.join(realTarget, "package.json");
-    const pkgStat = (0, import_fs3.lstatSync)(realPackageJsonPath);
+    const realPackageJsonPath = import_path2.default.join(realTarget, "package.json");
+    const pkgStat = (0, import_fs2.lstatSync)(realPackageJsonPath);
     if (pkgStat.isSymbolicLink()) {
       return {
         ...emptyResult,
@@ -1124,7 +1001,7 @@ function setupPackages(opts) {
         }
       }
     }
-    const raw = (0, import_fs3.readFileSync)(realPackageJsonPath, "utf8");
+    const raw = (0, import_fs2.readFileSync)(realPackageJsonPath, "utf8");
     const PackageJsonSchema = import_zod6.z.object({
       // Zod v4: z.record(keySchema, valueSchema) — two-arg form required
       dependencies: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional(),
@@ -1178,12 +1055,12 @@ function setupPackages(opts) {
         }
       }
     }
-    (0, import_fs3.writeFileSync)(realPackageJsonPath, JSON.stringify(parsed, null, 2) + "\n");
+    (0, import_fs2.writeFileSync)(realPackageJsonPath, JSON.stringify(parsed, null, 2) + "\n");
     let installed = false;
     let installError;
     if (opts.runInstall) {
       try {
-        (0, import_child_process2.execSync)("pnpm install", { cwd: realTarget, stdio: "pipe", timeout: 6e4 });
+        (0, import_child_process.execSync)("pnpm install", { cwd: realTarget, stdio: "pipe", timeout: 6e4 });
         installed = true;
       } catch (err) {
         installed = false;
@@ -1201,17 +1078,2426 @@ function setupPackages(opts) {
       ...installError !== void 0 ? { installError } : {}
     };
   } catch (err) {
-    return { ...emptyResult, success: false, error: err instanceof Error ? err.message : String(err) };
+    return {
+      ...emptyResult,
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
   }
 }
 
-// src/server.ts
-var import_fs4 = require("fs");
-var import_path4 = __toESM(require("path"));
-var packageJson = JSON.parse((0, import_fs4.readFileSync)(import_path4.default.join(__dirname, "package.json"), "utf8"));
+// src/tools/questions.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_zod7 = require("zod");
+
+// src/question-adapter.ts
+function truncate(str, maxLength) {
+  if (str.length <= maxLength) return str;
+  return str.substring(0, maxLength - 1) + "\u2026";
+}
+function generateHeader(id) {
+  const parts = id.split("-");
+  if (parts.length >= 2) {
+    const prefix = parts[0].toUpperCase().substring(0, 4);
+    const num = parts[1];
+    return truncate(`${prefix}-${num}`, 12);
+  }
+  return truncate(
+    id.toUpperCase().replace(/[^A-Z0-9]/g, "").substring(0, 12),
+    12
+  );
+}
+function generateDefaultOptions(type) {
+  switch (type) {
+    case "confirm":
+      return [
+        { label: "Yes", description: "Enable or confirm this option" },
+        { label: "No", description: "Disable or decline this option" }
+      ];
+    case "text":
+      return [
+        { label: "Specify", description: "I will provide a specific value" },
+        { label: "Skip", description: "Use default or skip this question" }
+      ];
+    default:
+      return [
+        { label: "Option 1", description: "First option" },
+        { label: "Option 2", description: "Second option" }
+      ];
+  }
+}
+function adaptQuestion(q) {
+  const header = generateHeader(q.id);
+  const multiSelect = q.type === "multi-select";
+  let options;
+  if (q.options && q.options.length >= 2) {
+    options = q.options.map((opt) => ({
+      label: truncate(opt.label, 50),
+      description: opt.value !== opt.label ? opt.value : void 0
+    }));
+  } else if (q.options && q.options.length === 1) {
+    options = [
+      ...q.options.map((opt) => ({ label: truncate(opt.label, 50), description: opt.value })),
+      { label: "Other", description: "Specify a different value" }
+    ];
+  } else {
+    options = generateDefaultOptions(q.type);
+  }
+  if (options.length < 2) {
+    options.push({ label: "Other", description: "Alternative option" });
+  }
+  options = options.slice(0, 6);
+  return {
+    question: q.question + (q.help ? `
+
+${q.help}` : ""),
+    header,
+    multi_select: multiSelect,
+    options
+  };
+}
+function adaptQuestions(questions, answers = {}) {
+  const adapted = [];
+  for (const q of questions) {
+    if (q.dependsOn) {
+      const dependsAnswer = answers[q.dependsOn.questionId];
+      if (dependsAnswer === void 0) {
+        continue;
+      }
+      const expectedValues = Array.isArray(q.dependsOn.value) ? q.dependsOn.value : [q.dependsOn.value];
+      const answerValue = Array.isArray(dependsAnswer) ? dependsAnswer[0] : dependsAnswer;
+      if (!expectedValues.includes(answerValue)) {
+        continue;
+      }
+    }
+    adapted.push(adaptQuestion(q));
+  }
+  return adapted;
+}
+function parseLLMQuestionsResponse(text) {
+  let jsonStr = text;
+  jsonStr = jsonStr.replace(/```(?:json|javascript)?\s*/gi, "");
+  jsonStr = jsonStr.replace(/```\s*$/gm, "");
+  const firstBrace = jsonStr.indexOf("{");
+  const firstBracket = jsonStr.indexOf("[");
+  let start = -1;
+  if (firstBrace !== -1 && firstBracket !== -1) {
+    start = Math.min(firstBrace, firstBracket);
+  } else if (firstBrace !== -1) {
+    start = firstBrace;
+  } else if (firstBracket !== -1) {
+    start = firstBracket;
+  }
+  if (start === -1) {
+    throw new Error("No JSON found in response");
+  }
+  jsonStr = jsonStr.substring(start);
+  const lastBrace = jsonStr.lastIndexOf("}");
+  const lastBracket = jsonStr.lastIndexOf("]");
+  const end = Math.max(lastBrace, lastBracket);
+  if (end === -1) {
+    throw new Error("Invalid JSON structure");
+  }
+  jsonStr = jsonStr.substring(0, end + 1);
+  jsonStr = jsonStr.replace(/,(\s*[}\]])/g, "$1");
+  jsonStr = jsonStr.replace(/'/g, '"');
+  const parsed = JSON.parse(jsonStr);
+  let questions;
+  if (Array.isArray(parsed)) {
+    questions = parsed;
+  } else if (parsed.questions && Array.isArray(parsed.questions)) {
+    questions = parsed.questions;
+  } else if (parsed.data && Array.isArray(parsed.data.questions)) {
+    questions = parsed.data.questions;
+  } else {
+    throw new Error("No questions array found in response");
+  }
+  function sanitize(obj) {
+    const sanitized = {};
+    for (const key of Object.keys(obj)) {
+      if (key === "__proto__" || key === "constructor" || key === "prototype") {
+        continue;
+      }
+      const val = obj[key];
+      if (val && typeof val === "object" && !Array.isArray(val)) {
+        sanitized[key] = sanitize(val);
+      } else if (Array.isArray(val)) {
+        sanitized[key] = val.map(
+          (item) => item && typeof item === "object" && !Array.isArray(item) ? sanitize(item) : item
+        );
+      } else {
+        sanitized[key] = val;
+      }
+    }
+    return sanitized;
+  }
+  questions = questions.map((q) => {
+    if (q && typeof q === "object") {
+      return sanitize(q);
+    }
+    return q;
+  });
+  return questions;
+}
+function answersToManifestFormat(answers, questions) {
+  const result = {};
+  for (const answer of answers) {
+    const headerLower = answer.question_header.toLowerCase();
+    const question = questions.find((q) => {
+      const qHeader = generateHeader(q.id).toLowerCase();
+      return qHeader === headerLower || q.id.toLowerCase().includes(headerLower);
+    });
+    if (!question) {
+      const matched = questions.find((q) => {
+        const qHeader = generateHeader(q.id).toLowerCase();
+        return qHeader.startsWith(headerLower.split("-")[0]);
+      });
+      if (matched) {
+        result[matched.id] = answer.selected_options[0] || "";
+      }
+      continue;
+    }
+    if (question.type === "multi-select" || answer.selected_options.length > 1) {
+      result[question.id] = answer.selected_options;
+    } else if (question.type === "confirm") {
+      result[question.id] = answer.selected_options[0] === "Yes";
+    } else {
+      if (answer.other_text) {
+        result[question.id] = answer.other_text;
+      } else if (answer.selected_options.length > 0) {
+        const option = question.options?.find((o) => o.label === answer.selected_options[0]);
+        result[question.id] = option?.value ?? answer.selected_options[0];
+      }
+    }
+  }
+  return result;
+}
+
+// src/tools/questions.ts
+var ManifestQuestionSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  question: import_zod7.z.string(),
+  type: import_zod7.z.enum(["text", "select", "multi-select", "confirm"]),
+  required: import_zod7.z.boolean().optional(),
+  options: import_zod7.z.array(
+    import_zod7.z.object({
+      label: import_zod7.z.string(),
+      value: import_zod7.z.string()
+    })
+  ).optional(),
+  default: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.boolean(), import_zod7.z.array(import_zod7.z.string())]).optional(),
+  help: import_zod7.z.string().optional(),
+  dependsOn: import_zod7.z.object({
+    questionId: import_zod7.z.string(),
+    value: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.array(import_zod7.z.string())])
+  }).optional()
+});
+function registerQuestionTools(server2) {
+  server2.tool(
+    "stackwright_pro_present_phase_questions",
+    "Adapt manifest-format questions from a specialist otter and present them to the user via ask_user_question. Pass only the phase name \u2014 this tool reads questions from .stackwright/question-manifest.json automatically. The questions parameter is optional and only needed if the manifest has not been written yet. Use this instead of calling ask_user_question directly \u2014 it handles label truncation (50-char limit), header generation, confirm/text defaults, and correct array formatting automatically. IMPORTANT: This is the ONLY approved way to prepare questions before calling ask_user_question. Never call ask_user_question with raw manifest questions. Never retry ask_user_question validation errors by calling it directly \u2014 always re-call this tool.",
+    {
+      phase: import_zod7.z.string().describe('Phase name for display context, e.g. "designer", "api", "auth"'),
+      questions: import_zod7.z.array(ManifestQuestionSchema).optional().describe(
+        "Questions in Question Manifest format. If omitted, questions are read from .stackwright/question-manifest.json using the phase name."
+      ),
+      answers: import_zod7.z.record(import_zod7.z.union([import_zod7.z.string(), import_zod7.z.array(import_zod7.z.string()), import_zod7.z.boolean()])).optional().describe("Previously collected answers used to resolve dependsOn conditions")
+    },
+    async ({ phase, questions, answers }) => {
+      let resolvedQuestions;
+      const SAFE_PHASE = /^[a-z][a-z0-9-]{0,30}$/;
+      if (!SAFE_PHASE.test(phase)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Invalid phase name: "${phase.slice(0, 50)}". Must be lowercase alphanumeric with hyphens, max 31 chars.`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      if (questions && questions.length > 0) {
+        resolvedQuestions = questions;
+      } else {
+        const phaseQuestionPath = (0, import_node_path.join)(process.cwd(), ".stackwright", "questions", `${phase}.json`);
+        try {
+          const raw = await (0, import_promises.readFile)(phaseQuestionPath, "utf-8");
+          const phaseData = JSON.parse(raw);
+          resolvedQuestions = phaseData.questions ?? [];
+        } catch {
+          try {
+            const manifestPath = (0, import_node_path.join)(process.cwd(), ".stackwright", "question-manifest.json");
+            const raw = await (0, import_promises.readFile)(manifestPath, "utf-8");
+            const manifest = JSON.parse(raw);
+            const phaseData = manifest.phases.find((p) => p.phase === phase);
+            resolvedQuestions = phaseData?.questions ?? [];
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    error: `Could not read question manifest for phase "${phase}": ${msg}`,
+                    hint: "Write the manifest first, or pass questions directly to this tool."
+                  })
+                }
+              ],
+              isError: true
+            };
+          }
+        }
+      }
+      const adapted = adaptQuestions(resolvedQuestions, answers ?? {});
+      if (adapted.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                phase,
+                skipped: true,
+                reason: "No questions to present (all filtered by dependsOn conditions)",
+                answers: []
+              })
+            }
+          ],
+          isError: false
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Adapted ${adapted.length} questions for phase "${phase}". Pass the JSON array below DIRECTLY to ask_user_question as the "questions" parameter. Do NOT JSON.stringify() it. Do NOT wrap it in an object. Pass the parsed array value as-is.`
+          },
+          {
+            type: "text",
+            text: JSON.stringify(adapted)
+          }
+        ],
+        isError: false
+      };
+    }
+  );
+}
+
+// src/tools/orchestration.ts
+var import_zod8 = require("zod");
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var OTTER_NAME_TO_PHASE = [
+  ["designer", "designer"],
+  ["theme", "theme"],
+  ["api", "api"],
+  ["auth", "auth"],
+  ["dashboard", "dashboard"],
+  ["data", "data"],
+  ["page", "pages"],
+  ["workflow", "workflow"]
+];
+var PHASE_TO_OTTER = {
+  designer: "stackwright-pro-designer-otter",
+  theme: "stackwright-pro-theme-otter",
+  api: "stackwright-pro-api-otter",
+  auth: "stackwright-pro-auth-otter",
+  pages: "stackwright-pro-page-otter",
+  dashboard: "stackwright-pro-dashboard-otter",
+  data: "stackwright-pro-data-otter",
+  workflow: "stackwright-pro-workflow-otter"
+};
+function detectPhase(otterName) {
+  const lower = otterName.toLowerCase();
+  for (const [keyword, phase] of OTTER_NAME_TO_PHASE) {
+    if (lower.includes(keyword)) return phase;
+  }
+  return lower.replace(/^stackwright-pro-/, "").replace(/-otter$/, "");
+}
+function handleParseOtterResponse(input) {
+  const phase = detectPhase(input.otterName);
+  try {
+    const questions = parseLLMQuestionsResponse(input.responseText);
+    return {
+      result: { phase, otter: input.otterName, questions },
+      isError: false
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      result: {
+        error: true,
+        otterName: input.otterName,
+        phase,
+        questions: [],
+        parseError: message
+      },
+      isError: true
+    };
+  }
+}
+function handleSaveManifest(input) {
+  const cwd = input._cwd ?? process.cwd();
+  const dir = (0, import_path3.join)(cwd, ".stackwright");
+  const filePath = (0, import_path3.join)(dir, "question-manifest.json");
+  try {
+    (0, import_fs3.mkdirSync)(dir, { recursive: true });
+    if ((0, import_fs3.existsSync)(filePath)) {
+      const stat = (0, import_fs3.lstatSync)(filePath);
+      if (stat.isSymbolicLink()) {
+        const message = `Refusing to write to symlink: ${filePath}`;
+        return {
+          text: JSON.stringify({ success: false, error: message }),
+          isError: true
+        };
+      }
+    }
+    const manifest = {
+      version: "1.0",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      phases: input.phases
+    };
+    (0, import_fs3.writeFileSync)(filePath, JSON.stringify(manifest, null, 2) + "\n");
+    return {
+      text: JSON.stringify({ success: true, path: filePath, phaseCount: input.phases.length }),
+      isError: false
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      text: JSON.stringify({ success: false, error: message }),
+      isError: true
+    };
+  }
+}
+function handleSavePhaseAnswers(input) {
+  const cwd = input._cwd ?? process.cwd();
+  const dir = (0, import_path3.join)(cwd, ".stackwright", "answers");
+  const filePath = (0, import_path3.join)(dir, `${input.phase}.json`);
+  try {
+    (0, import_fs3.mkdirSync)(dir, { recursive: true });
+    let answers;
+    if (input.questions && input.questions.length > 0) {
+      answers = answersToManifestFormat(input.rawAnswers, input.questions);
+    } else {
+      answers = Object.fromEntries(
+        input.rawAnswers.map((a) => [a.question_header, a.selected_options[0] ?? ""])
+      );
+    }
+    const payload = {
+      version: "1.0",
+      phase: input.phase,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      answers
+    };
+    if ((0, import_fs3.existsSync)(filePath)) {
+      const stat = (0, import_fs3.lstatSync)(filePath);
+      if (stat.isSymbolicLink()) {
+        const message = `Refusing to write to symlink: ${filePath}`;
+        return {
+          text: JSON.stringify({ success: false, error: message }),
+          isError: true
+        };
+      }
+    }
+    (0, import_fs3.writeFileSync)(filePath, JSON.stringify(payload, null, 2) + "\n");
+    return {
+      text: JSON.stringify({
+        success: true,
+        path: filePath,
+        answersCount: Object.keys(answers).length
+      }),
+      isError: false
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      text: JSON.stringify({ success: false, error: message }),
+      isError: true
+    };
+  }
+}
+function handleReadPhaseAnswers(input) {
+  const cwd = input._cwd ?? process.cwd();
+  const filePath = (0, import_path3.join)(cwd, ".stackwright", "answers", `${input.phase}.json`);
+  if (!(0, import_fs3.existsSync)(filePath)) {
+    return {
+      text: JSON.stringify({ missing: true, phase: input.phase }),
+      isError: false
+    };
+  }
+  try {
+    const raw = (0, import_fs3.readFileSync)(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return { text: JSON.stringify(parsed), isError: false };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      text: JSON.stringify({ error: true, phase: input.phase, readError: message }),
+      isError: true
+    };
+  }
+}
+function handleGetOtterName(input) {
+  const normalised = input.phase.toLowerCase().trim();
+  const otterName = PHASE_TO_OTTER[normalised];
+  if (!otterName) {
+    return {
+      text: JSON.stringify({ error: true, message: `Unknown phase: ${input.phase}` }),
+      isError: true
+    };
+  }
+  return {
+    text: JSON.stringify({ phase: normalised, otterName }),
+    isError: false
+  };
+}
+function registerOrchestrationTools(server2) {
+  server2.tool(
+    "stackwright_pro_parse_otter_response",
+    "Parse and validate a specialist otter's QUESTION_COLLECTION_MODE JSON response. Handles JSON extraction from LLM responses (strips markdown, fixes single quotes, trailing commas). Detects the phase from the otter name. Use this immediately after invoke_agent() to get a validated manifest phase object.",
+    {
+      otterName: import_zod8.z.string().describe('The agent name, e.g. "stackwright-pro-api-otter"'),
+      responseText: import_zod8.z.string().describe("Raw text response from the otter's QUESTION_COLLECTION_MODE invocation")
+    },
+    async ({ otterName, responseText }) => {
+      const { result, isError } = handleParseOtterResponse({ otterName, responseText });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        isError
+      };
+    }
+  );
+  server2.tool(
+    "stackwright_pro_save_manifest",
+    "Write the question manifest to .stackwright/question-manifest.json. Call this after collecting and parsing questions from all otters via stackwright_pro_parse_otter_response.",
+    {
+      phases: import_zod8.z.array(
+        import_zod8.z.object({
+          phase: import_zod8.z.string(),
+          otter: import_zod8.z.string(),
+          questions: import_zod8.z.array(import_zod8.z.any()),
+          requiredPackages: import_zod8.z.object({
+            dependencies: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).optional(),
+            devPackages: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).optional()
+          }).optional()
+        })
+      ).describe("Array of parsed phase objects from stackwright_pro_parse_otter_response")
+    },
+    async ({ phases }) => {
+      const { text, isError } = handleSaveManifest({ phases });
+      return {
+        content: [{ type: "text", text }],
+        isError
+      };
+    }
+  );
+  server2.tool(
+    "stackwright_pro_save_phase_answers",
+    "Save user answers for a phase to .stackwright/answers/{phase}.json. Pass rawAnswers directly from ask_user_question and the original manifest questions for label-to-value reverse mapping.",
+    {
+      phase: import_zod8.z.string().describe('Phase name, e.g. "designer"'),
+      rawAnswers: import_zod8.z.array(
+        import_zod8.z.object({
+          question_header: import_zod8.z.string(),
+          selected_options: import_zod8.z.array(import_zod8.z.string()),
+          other_text: import_zod8.z.string().nullable().optional()
+        })
+      ).describe("Answers as returned by ask_user_question"),
+      questions: import_zod8.z.array(import_zod8.z.any()).optional().describe("Original manifest questions for label\u2192value reverse-mapping")
+    },
+    async ({ phase, rawAnswers, questions }) => {
+      const { text, isError } = handleSavePhaseAnswers({
+        phase,
+        rawAnswers,
+        ...questions && questions.length > 0 ? { questions } : {}
+      });
+      return {
+        content: [{ type: "text", text }],
+        isError
+      };
+    }
+  );
+  server2.tool(
+    "stackwright_pro_read_phase_answers",
+    "Read saved answers for a phase from .stackwright/answers/{phase}.json. Returns { missing: true } when no answers exist yet \u2014 use this to skip phases safely in the execution loop.",
+    {
+      phase: import_zod8.z.string().describe('Phase name, e.g. "designer"')
+    },
+    async ({ phase }) => {
+      const { text, isError } = handleReadPhaseAnswers({ phase });
+      return {
+        content: [{ type: "text", text }],
+        isError
+      };
+    }
+  );
+  server2.tool(
+    "stackwright_pro_get_otter_name",
+    "Get the agent name for a phase (e.g. 'designer' \u2192 'stackwright-pro-designer-otter'). Use this in the execution loop to invoke the correct specialist otter without hardcoding names in the prompt.",
+    {
+      phase: import_zod8.z.string().describe('Phase name, e.g. "designer", "api", "pages"')
+    },
+    async ({ phase }) => {
+      const { text, isError } = handleGetOtterName({ phase });
+      return {
+        content: [{ type: "text", text }],
+        isError
+      };
+    }
+  );
+}
+
+// src/tools/pipeline.ts
+var import_zod9 = require("zod");
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+var PHASE_ORDER = [
+  "designer",
+  "theme",
+  "api",
+  "auth",
+  "data",
+  "pages",
+  "dashboard",
+  "workflow"
+];
+var PHASE_DEPENDENCIES = {
+  designer: [],
+  theme: ["designer"],
+  api: [],
+  auth: [],
+  data: ["api"],
+  pages: ["designer", "theme", "api", "data", "auth"],
+  dashboard: ["designer", "theme", "api", "data"],
+  workflow: ["auth"]
+};
+var PHASE_ARTIFACT = {
+  designer: "design-language.json",
+  theme: "theme-tokens.json",
+  api: "api-config.json",
+  auth: "auth-config.json",
+  data: "data-config.json",
+  pages: "pages-manifest.json",
+  dashboard: "dashboard-manifest.json",
+  workflow: "workflow-config.json"
+};
+var PHASE_TO_OTTER2 = {
+  designer: "stackwright-pro-designer-otter",
+  theme: "stackwright-pro-theme-otter",
+  api: "stackwright-pro-api-otter",
+  auth: "stackwright-pro-auth-otter",
+  data: "stackwright-pro-data-otter",
+  pages: "stackwright-pro-page-otter",
+  dashboard: "stackwright-pro-dashboard-otter",
+  workflow: "stackwright-pro-workflow-otter"
+};
+function isValidPhase(phase) {
+  return PHASE_ORDER.includes(phase);
+}
+function defaultPhaseStatus() {
+  return {
+    questionsCollected: false,
+    answered: false,
+    executed: false,
+    artifactWritten: false,
+    retryCount: 0
+  };
+}
+function createDefaultState() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const phases = {};
+  for (const p of PHASE_ORDER) {
+    phases[p] = defaultPhaseStatus();
+  }
+  return {
+    version: "1.0",
+    currentPhase: PHASE_ORDER[0],
+    status: "setup",
+    phases,
+    startedAt: now,
+    updatedAt: now
+  };
+}
+function statePath(cwd) {
+  return (0, import_path4.join)(cwd, ".stackwright", "pipeline-state.json");
+}
+function readState(cwd) {
+  const p = statePath(cwd);
+  if (!(0, import_fs4.existsSync)(p)) return createDefaultState();
+  const raw = JSON.parse(safeReadSync(p));
+  if (typeof raw !== "object" || raw === null || raw.version !== "1.0") {
+    return createDefaultState();
+  }
+  return raw;
+}
+function safeWriteSync(filePath, content) {
+  if ((0, import_fs4.existsSync)(filePath)) {
+    const stat = (0, import_fs4.lstatSync)(filePath);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`Refusing to write to symlink: ${filePath}`);
+    }
+  }
+  (0, import_fs4.writeFileSync)(filePath, content);
+}
+function safeReadSync(filePath) {
+  if ((0, import_fs4.existsSync)(filePath)) {
+    const stat = (0, import_fs4.lstatSync)(filePath);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`Refusing to read symlink: ${filePath}`);
+    }
+  }
+  return (0, import_fs4.readFileSync)(filePath, "utf-8");
+}
+function writeState(cwd, state) {
+  const dir = (0, import_path4.join)(cwd, ".stackwright");
+  (0, import_fs4.mkdirSync)(dir, { recursive: true });
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  safeWriteSync(statePath(cwd), JSON.stringify(state, null, 2) + "\n");
+}
+function extractJsonFromResponse(text) {
+  let cleaned = text;
+  cleaned = cleaned.replace(/```(?:json)?\s*/gi, "");
+  cleaned = cleaned.replace(/```\s*$/gm, "");
+  const firstBrace = cleaned.indexOf("{");
+  if (firstBrace === -1) throw new Error("No JSON object found in response");
+  cleaned = cleaned.substring(firstBrace);
+  const lastBrace = cleaned.lastIndexOf("}");
+  if (lastBrace === -1) throw new Error("Unclosed JSON object in response");
+  cleaned = cleaned.substring(0, lastBrace + 1);
+  cleaned = cleaned.replace(/,(\s*[}\]])/g, "$1");
+  return JSON.parse(cleaned);
+}
+function handleGetPipelineState(_cwd) {
+  const cwd = _cwd ?? process.cwd();
+  try {
+    const state = readState(cwd);
+    return { text: JSON.stringify(state), isError: false };
+  } catch (err) {
+    return { text: JSON.stringify({ error: true, message: String(err) }), isError: true };
+  }
+}
+function handleSetPipelineState(input) {
+  const cwd = input._cwd ?? process.cwd();
+  if (input.phase && !isValidPhase(input.phase)) {
+    return {
+      text: JSON.stringify({
+        error: true,
+        message: `Invalid phase: ${input.phase}. Valid phases are: ${PHASE_ORDER.join(", ")}`
+      }),
+      isError: true
+    };
+  }
+  const VALID_FIELDS = ["questionsCollected", "answered", "executed", "artifactWritten"];
+  if (input.field && !VALID_FIELDS.includes(input.field)) {
+    return {
+      text: JSON.stringify({
+        error: true,
+        message: `Invalid field: ${input.field}. Valid fields are: ${VALID_FIELDS.join(", ")}`
+      }),
+      isError: true
+    };
+  }
+  try {
+    const state = readState(cwd);
+    if (input.status) {
+      state.status = input.status;
+    }
+    if (input.phase) {
+      const phase = input.phase;
+      if (!state.phases[phase]) {
+        state.phases[phase] = defaultPhaseStatus();
+      }
+      const phaseState = state.phases[phase];
+      if (input.field && input.value !== void 0) {
+        phaseState[input.field] = input.value;
+      }
+      if (input.incrementRetry) {
+        phaseState.retryCount += 1;
+      }
+      state.currentPhase = phase;
+    }
+    writeState(cwd, state);
+    return { text: JSON.stringify(state), isError: false };
+  } catch (err) {
+    return { text: JSON.stringify({ error: true, message: String(err) }), isError: true };
+  }
+}
+function handleCheckExecutionReady(_cwd) {
+  const cwd = _cwd ?? process.cwd();
+  try {
+    const answersDir = (0, import_path4.join)(cwd, ".stackwright", "answers");
+    const answeredPhases = [];
+    const missingPhases = [];
+    for (const phase of PHASE_ORDER) {
+      const answerFile = (0, import_path4.join)(answersDir, `${phase}.json`);
+      if ((0, import_fs4.existsSync)(answerFile)) {
+        try {
+          const raw = safeReadSync(answerFile);
+          const parsed = JSON.parse(raw);
+          if (typeof parsed["version"] !== "string" || typeof parsed["phase"] !== "string" || typeof parsed["answers"] !== "object" || parsed["answers"] === null) {
+            missingPhases.push(phase);
+            continue;
+          }
+          answeredPhases.push(phase);
+        } catch {
+          missingPhases.push(phase);
+        }
+      } else {
+        missingPhases.push(phase);
+      }
+    }
+    return {
+      text: JSON.stringify({
+        ready: missingPhases.length === 0,
+        answeredPhases,
+        missingPhases,
+        totalPhases: PHASE_ORDER.length
+      }),
+      isError: false
+    };
+  } catch (err) {
+    return { text: JSON.stringify({ error: true, message: String(err) }), isError: true };
+  }
+}
+function handleListArtifacts(_cwd) {
+  const cwd = _cwd ?? process.cwd();
+  try {
+    const artifactsDir = (0, import_path4.join)(cwd, ".stackwright", "artifacts");
+    const artifacts = [];
+    let completedCount = 0;
+    for (const phase of PHASE_ORDER) {
+      const expectedFile = PHASE_ARTIFACT[phase];
+      const fullPath = (0, import_path4.join)(artifactsDir, expectedFile);
+      const exists = (0, import_fs4.existsSync)(fullPath);
+      if (exists) completedCount++;
+      artifacts.push({ phase, expectedFile, exists, path: fullPath });
+    }
+    return {
+      text: JSON.stringify({ artifacts, completedCount, totalCount: PHASE_ORDER.length }),
+      isError: false
+    };
+  } catch (err) {
+    return { text: JSON.stringify({ error: true, message: String(err) }), isError: true };
+  }
+}
+function handleWritePhaseQuestions(input) {
+  const cwd = input._cwd ?? process.cwd();
+  const { phase, responseText } = input;
+  if (!isValidPhase(phase)) {
+    return {
+      text: JSON.stringify({ error: true, message: `Unknown phase: ${phase}` }),
+      isError: true
+    };
+  }
+  try {
+    const questions = parseLLMQuestionsResponse(responseText);
+    let requiredPackages = {
+      dependencies: {},
+      devPackages: {}
+    };
+    try {
+      const fullParsed = extractJsonFromResponse(responseText);
+      if (fullParsed.requiredPackages && typeof fullParsed.requiredPackages === "object") {
+        const rp = fullParsed.requiredPackages;
+        requiredPackages = {
+          dependencies: rp.dependencies ?? {},
+          devPackages: rp.devPackages ?? {}
+        };
+      }
+    } catch {
+    }
+    const questionsDir = (0, import_path4.join)(cwd, ".stackwright", "questions");
+    (0, import_fs4.mkdirSync)(questionsDir, { recursive: true });
+    const filePath = (0, import_path4.join)(questionsDir, `${phase}.json`);
+    const payload = {
+      version: "1.0",
+      phase,
+      otter: PHASE_TO_OTTER2[phase],
+      collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      questions,
+      requiredPackages
+    };
+    safeWriteSync(filePath, JSON.stringify(payload, null, 2) + "\n");
+    const state = readState(cwd);
+    if (!state.phases[phase]) state.phases[phase] = defaultPhaseStatus();
+    const ps = state.phases[phase];
+    ps.questionsCollected = true;
+    writeState(cwd, state);
+    return {
+      text: JSON.stringify({
+        success: true,
+        phase,
+        questionCount: questions.length,
+        requiredPackages,
+        path: filePath
+      }),
+      isError: false
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { text: JSON.stringify({ error: true, phase, message }), isError: true };
+  }
+}
+function handleBuildSpecialistPrompt(input) {
+  const cwd = input._cwd ?? process.cwd();
+  const { phase } = input;
+  if (!isValidPhase(phase)) {
+    return {
+      text: JSON.stringify({ error: true, message: `Unknown phase: ${phase}` }),
+      isError: true
+    };
+  }
+  try {
+    const answersPath = (0, import_path4.join)(cwd, ".stackwright", "answers", `${phase}.json`);
+    let answers = {};
+    if ((0, import_fs4.existsSync)(answersPath)) {
+      answers = JSON.parse(safeReadSync(answersPath));
+    }
+    const deps = PHASE_DEPENDENCIES[phase];
+    const artifactSections = [];
+    const missingDependencies = [];
+    for (const dep of deps) {
+      const artifactFile = PHASE_ARTIFACT[dep];
+      const artifactPath = (0, import_path4.join)(cwd, ".stackwright", "artifacts", artifactFile);
+      if ((0, import_fs4.existsSync)(artifactPath)) {
+        const content = JSON.parse(safeReadSync(artifactPath));
+        const expectedOtter = PHASE_TO_OTTER2[dep];
+        const artifactOtter = content["generatedBy"];
+        if (!artifactOtter) {
+          missingDependencies.push(dep);
+          artifactSections.push(
+            `[${artifactFile}]:
+(integrity check failed: missing generatedBy field)`
+          );
+        } else if (artifactOtter !== expectedOtter) {
+          missingDependencies.push(dep);
+          artifactSections.push(
+            `[${artifactFile}]:
+(integrity check failed: artifact claims generatedBy="${artifactOtter}" but expected="${expectedOtter}")`
+          );
+        } else {
+          artifactSections.push(`[${artifactFile}]:
+${JSON.stringify(content, null, 2)}`);
+        }
+      } else {
+        missingDependencies.push(dep);
+        artifactSections.push(`[${artifactFile}]:
+(not yet available)`);
+      }
+    }
+    const parts = ["ANSWERS:", JSON.stringify(answers, null, 2)];
+    if (artifactSections.length > 0) {
+      parts.push("", "UPSTREAM ARTIFACTS:", "", ...artifactSections);
+    }
+    parts.push("", "Execute using these answers and the upstream artifacts provided.");
+    const prompt = parts.join("\n");
+    const dependenciesSatisfied = missingDependencies.length === 0;
+    return {
+      text: JSON.stringify({
+        otterName: PHASE_TO_OTTER2[phase],
+        phase,
+        prompt,
+        dependenciesSatisfied,
+        missingDependencies
+      }),
+      isError: false
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { text: JSON.stringify({ error: true, phase, message }), isError: true };
+  }
+}
+var OFF_SCRIPT_PATTERNS = [
+  {
+    pattern: /```(?:ts|tsx|js|jsx|python|bash|sh|sql|ruby|go|rust|java|csharp|c\+\+)\b/,
+    label: "code fence"
+  },
+  { pattern: /\bimport\s+[\w{]/, label: "import statement" },
+  { pattern: /\bexport\s+(?:const|function|default|class)\b/, label: "export statement" },
+  { pattern: /\brequire\s*\(/, label: "require() call" },
+  { pattern: /\beval\s*\(/, label: "eval() call" },
+  { pattern: /^#!/m, label: "shebang" },
+  { pattern: /<script[\s>]/i, label: "script tag" },
+  { pattern: /\.(ts|tsx|js|jsx)\b.*\bfile\b/i, label: "code file reference" }
+];
+var PHASE_REQUIRED_KEYS = {
+  designer: ["designLanguage", "themeTokenSeeds"],
+  theme: ["tokens"],
+  api: ["entities"],
+  auth: ["version", "generatedBy"],
+  data: ["version", "generatedBy"],
+  pages: ["version", "generatedBy"],
+  dashboard: ["version", "generatedBy"],
+  workflow: ["version", "generatedBy"]
+};
+function handleValidateArtifact(input) {
+  const cwd = input._cwd ?? process.cwd();
+  const { phase, responseText } = input;
+  if (!isValidPhase(phase)) {
+    return {
+      text: JSON.stringify({ error: true, message: `Unknown phase: ${phase}` }),
+      isError: true
+    };
+  }
+  for (const { pattern, label } of OFF_SCRIPT_PATTERNS) {
+    if (pattern.test(responseText)) {
+      const result = {
+        valid: false,
+        phase,
+        violation: "off-script",
+        retryPrompt: `You returned code output (detected: ${label}). Return ONLY a JSON artifact \u2014 no code, no files.`
+      };
+      return { text: JSON.stringify(result), isError: false };
+    }
+  }
+  let artifact;
+  try {
+    artifact = extractJsonFromResponse(responseText);
+  } catch {
+    const result = {
+      valid: false,
+      phase,
+      violation: "invalid-json",
+      retryPrompt: "Your response did not contain valid JSON. Return a single JSON object with no surrounding text."
+    };
+    return { text: JSON.stringify(result), isError: false };
+  }
+  if (!artifact.version || !artifact.generatedBy) {
+    const result = {
+      valid: false,
+      phase,
+      violation: "missing-fields",
+      retryPrompt: 'Your JSON artifact is missing required fields. Every artifact MUST include "version" and "generatedBy" at the top level.'
+    };
+    return { text: JSON.stringify(result), isError: false };
+  }
+  const requiredKeys = PHASE_REQUIRED_KEYS[phase];
+  const missingKeys = requiredKeys.filter((k) => !(k in artifact));
+  if (missingKeys.length > 0) {
+    const result = {
+      valid: false,
+      phase,
+      violation: "schema-mismatch",
+      retryPrompt: `Your ${phase} artifact is missing required keys: ${missingKeys.join(", ")}. Include them and try again.`
+    };
+    return { text: JSON.stringify(result), isError: false };
+  }
+  try {
+    const artifactsDir = (0, import_path4.join)(cwd, ".stackwright", "artifacts");
+    (0, import_fs4.mkdirSync)(artifactsDir, { recursive: true });
+    const artifactFile = PHASE_ARTIFACT[phase];
+    const artifactPath = (0, import_path4.join)(artifactsDir, artifactFile);
+    safeWriteSync(artifactPath, JSON.stringify(artifact, null, 2) + "\n");
+    const state = readState(cwd);
+    if (!state.phases[phase]) state.phases[phase] = defaultPhaseStatus();
+    const ps = state.phases[phase];
+    ps.artifactWritten = true;
+    writeState(cwd, state);
+    const topKeys = Object.keys(artifact).slice(0, 5).join(", ");
+    const result = {
+      valid: true,
+      phase,
+      artifactPath,
+      summary: `Wrote ${artifactFile} (keys: ${topKeys}${Object.keys(artifact).length > 5 ? ", ..." : ""})`
+    };
+    return { text: JSON.stringify(result), isError: false };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { text: JSON.stringify({ error: true, phase, message }), isError: true };
+  }
+}
+function registerPipelineTools(server2) {
+  const DESC = "Writes state to .stackwright/ \u2014 the filesystem is the state machine.";
+  const res = (r) => ({
+    content: [{ type: "text", text: r.text }],
+    isError: r.isError
+  });
+  server2.tool(
+    "stackwright_pro_get_pipeline_state",
+    `Read pipeline state from .stackwright/pipeline-state.json. ${DESC}`,
+    {},
+    async () => res(handleGetPipelineState())
+  );
+  server2.tool(
+    "stackwright_pro_set_pipeline_state",
+    `Atomic read\u2192modify\u2192write pipeline state. ${DESC}`,
+    {
+      phase: import_zod9.z.string().optional().describe('Phase to update, e.g. "designer"'),
+      field: import_zod9.z.enum(["questionsCollected", "answered", "executed", "artifactWritten"]).optional().describe("Boolean field to set"),
+      value: import_zod9.z.boolean().optional().describe("Value for the field"),
+      status: import_zod9.z.enum(["setup", "questions", "execution", "done"]).optional().describe("Top-level status override"),
+      incrementRetry: import_zod9.z.boolean().optional().describe("Bump retryCount by 1")
+    },
+    async (args) => res(
+      handleSetPipelineState({
+        ...args.phase != null ? { phase: args.phase } : {},
+        ...args.field != null ? { field: args.field } : {},
+        ...args.value != null ? { value: args.value } : {},
+        ...args.status != null ? { status: args.status } : {},
+        ...args.incrementRetry != null ? { incrementRetry: args.incrementRetry } : {}
+      })
+    )
+  );
+  server2.tool(
+    "stackwright_pro_check_execution_ready",
+    `Check all phases have answer files in .stackwright/answers/. ${DESC}`,
+    {},
+    async () => res(handleCheckExecutionReady())
+  );
+  server2.tool(
+    "stackwright_pro_list_artifacts",
+    `List phase artifacts in .stackwright/artifacts/ with completedCount/totalCount. ${DESC}`,
+    {},
+    async () => res(handleListArtifacts())
+  );
+  server2.tool(
+    "stackwright_pro_write_phase_questions",
+    `Parse otter question-collection response \u2192 .stackwright/questions/{phase}.json. ${DESC}`,
+    {
+      phase: import_zod9.z.string().describe('Phase name, e.g. "designer"'),
+      responseText: import_zod9.z.string().describe("Raw LLM response from QUESTION_COLLECTION_MODE")
+    },
+    async ({ phase, responseText }) => res(handleWritePhaseQuestions({ phase, responseText }))
+  );
+  server2.tool(
+    "stackwright_pro_build_specialist_prompt",
+    `Assemble execution prompt from answers + upstream artifacts. Foreman passes verbatim. ${DESC}`,
+    { phase: import_zod9.z.string().describe('Phase to build prompt for, e.g. "pages"') },
+    async ({ phase }) => res(handleBuildSpecialistPrompt({ phase }))
+  );
+  server2.tool(
+    "stackwright_pro_validate_artifact",
+    `Validate specialist response + write artifact to .stackwright/artifacts/. Returns retryPrompt on failure. ${DESC}`,
+    {
+      phase: import_zod9.z.string().describe('Phase that produced this artifact, e.g. "designer"'),
+      responseText: import_zod9.z.string().describe("Raw response text from the specialist otter")
+    },
+    async ({ phase, responseText }) => res(handleValidateArtifact({ phase, responseText }))
+  );
+}
+
+// src/tools/safe-write.ts
+var import_zod10 = require("zod");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
+var OTTER_WRITE_ALLOWLISTS = {
+  "stackwright-pro-designer-otter": [
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Design language artifact" }
+  ],
+  "stackwright-pro-theme-otter": [
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Theme tokens artifact" }
+  ],
+  "stackwright-pro-auth-otter": [
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Auth config artifact" },
+    { prefix: "config/", suffix: ".yml", description: "Auth YAML config" },
+    { prefix: "config/", suffix: ".yaml", description: "Auth YAML config" },
+    {
+      prefix: ".env",
+      suffix: "",
+      description: "Dotenv files (.env, .env.local, .env.production, etc.)"
+    }
+  ],
+  "stackwright-pro-data-otter": [
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Data config artifact" },
+    { prefix: "stackwright.yml", suffix: "", description: "Stackwright config" }
+  ],
+  "stackwright-pro-page-otter": [
+    { prefix: "pages/", suffix: "/content.yml", description: "Page content YAML" },
+    { prefix: "pages/", suffix: "/content.yaml", description: "Page content YAML" },
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Pages manifest" }
+  ],
+  "stackwright-pro-dashboard-otter": [
+    { prefix: "pages/", suffix: "/content.yml", description: "Dashboard content YAML" },
+    { prefix: "pages/", suffix: "/content.yaml", description: "Dashboard content YAML" },
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Dashboard manifest" }
+  ],
+  "stackwright-pro-workflow-otter": [
+    { prefix: "workflows/", suffix: ".yml", description: "Workflow definition" },
+    { prefix: "workflows/", suffix: ".yaml", description: "Workflow definition" },
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Workflow config" }
+  ],
+  "stackwright-pro-api-otter": [
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "API config artifact" }
+  ]
+};
+var PROTECTED_PATH_PREFIXES = [
+  ".stackwright/pipeline-state.json",
+  ".stackwright/questions/",
+  ".stackwright/answers/"
+];
+function checkPathAllowed(callerOtter, filePath) {
+  const normalized = (0, import_path5.normalize)(filePath);
+  if (normalized.includes("..")) {
+    return { allowed: false, error: 'Path traversal detected: ".." segments are not allowed' };
+  }
+  if ((0, import_path5.isAbsolute)(normalized)) {
+    return {
+      allowed: false,
+      error: "Absolute paths are not allowed \u2014 use paths relative to project root"
+    };
+  }
+  if (callerOtter === "stackwright-pro-foreman-otter") {
+    return {
+      allowed: false,
+      error: "The foreman otter coordinates \u2014 it does not write files directly"
+    };
+  }
+  const allowlist = OTTER_WRITE_ALLOWLISTS[callerOtter];
+  if (!allowlist) {
+    return {
+      allowed: false,
+      error: `Unknown otter: "${callerOtter}" is not in the write allowlist`
+    };
+  }
+  for (const protectedPrefix of PROTECTED_PATH_PREFIXES) {
+    if (normalized === protectedPrefix || normalized.startsWith(protectedPrefix)) {
+      return {
+        allowed: false,
+        error: `Path "${normalized}" is managed by dedicated sink tools, not safe_write`
+      };
+    }
+  }
+  for (const rule of allowlist) {
+    const prefixMatch = normalized.startsWith(rule.prefix);
+    const suffixMatch = rule.suffix === "" || normalized.endsWith(rule.suffix);
+    if (prefixMatch && suffixMatch) {
+      if (rule.prefix === ".env" && rule.suffix === "") {
+        if (!/^\.env(\.[a-zA-Z0-9]{3,})*$/.test(normalized)) {
+          continue;
+        }
+      }
+      return { allowed: true, rule: rule.description };
+    }
+  }
+  return {
+    allowed: false,
+    error: `Path "${normalized}" does not match any allowed write pattern for ${callerOtter}`
+  };
+}
+function validateJsonContent(content) {
+  try {
+    JSON.parse(content);
+    return null;
+  } catch (err) {
+    return `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+function validateYamlContent(content) {
+  const trimmed = content.trimStart();
+  const anchorRefPattern = /\[(\*[\w]+)\]/g;
+  const matches = [...content.matchAll(anchorRefPattern)];
+  if (matches.length >= 20) {
+    return "YAML entity expansion pattern detected \u2014 too many anchor references";
+  }
+  const anchorDefPattern = /&([\w]+)/g;
+  const defs = [...content.matchAll(anchorDefPattern)];
+  if (defs.length >= 10) {
+    const anchorNameCounts = /* @__PURE__ */ new Map();
+    for (const [, name] of defs) {
+      const count = (anchorNameCounts.get(name) ?? 0) + 1;
+      anchorNameCounts.set(name, count);
+      if (count >= 10) {
+        return "YAML entity expansion: repeated anchor definitions detected";
+      }
+    }
+  }
+  if (trimmed.startsWith("import ") || trimmed.startsWith("import{")) {
+    return 'Content starts with "import" \u2014 this looks like code, not YAML';
+  }
+  if (trimmed.startsWith("export ") || trimmed.startsWith("export{")) {
+    return 'Content starts with "export" \u2014 this looks like code, not YAML';
+  }
+  if (trimmed.startsWith("#!"))
+    return "Content starts with shebang \u2014 this looks like a script, not YAML";
+  if (/!!(?:python|ruby|perl|js|java)/i.test(content))
+    return "YAML deserialization attack tags detected";
+  if (trimmed.startsWith("<") && !trimmed.startsWith("<<"))
+    return "Content looks like markup, not YAML";
+  return null;
+}
+function validateEnvContent(content) {
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    if (raw === void 0) continue;
+    const line = raw.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    if (!/^[A-Za-z_][A-Za-z0-9_]*=/.test(line)) {
+      return `Line ${i + 1} is not a valid env entry (expected KEY=value): "${line}"`;
+    }
+  }
+  return null;
+}
+function validateContent(filePath, content) {
+  if (filePath.endsWith(".json")) return validateJsonContent(content);
+  if (filePath.endsWith(".yml") || filePath.endsWith(".yaml")) return validateYamlContent(content);
+  if (filePath === ".env" || filePath.startsWith(".env")) return validateEnvContent(content);
+  return null;
+}
+function handleSafeWrite(input) {
+  const cwd = input._cwd ?? process.cwd();
+  const { callerOtter, filePath, content, createDirectories = true } = input;
+  const check = checkPathAllowed(callerOtter, filePath);
+  if (!check.allowed) {
+    const allowlist = OTTER_WRITE_ALLOWLISTS[callerOtter] ?? [];
+    const allowedPaths = allowlist.map((r) => `${r.prefix}*${r.suffix} (${r.description})`);
+    const result = {
+      success: false,
+      error: check.error ?? "Path not allowed",
+      callerOtter,
+      attemptedPath: filePath,
+      allowedPaths
+    };
+    return { text: JSON.stringify(result), isError: true };
+  }
+  const normalized = (0, import_path5.normalize)(filePath);
+  const fullPath = (0, import_path5.join)(cwd, normalized);
+  if ((0, import_fs5.existsSync)(fullPath)) {
+    try {
+      const stat = (0, import_fs5.lstatSync)(fullPath);
+      if (stat.isSymbolicLink()) {
+        const result = {
+          success: false,
+          error: "Target path is a symlink \u2014 refusing to write through symlinks for security",
+          callerOtter,
+          attemptedPath: filePath,
+          allowedPaths: []
+        };
+        return { text: JSON.stringify(result), isError: true };
+      }
+    } catch {
+    }
+  }
+  const contentError = validateContent(normalized, content);
+  if (contentError) {
+    const result = {
+      success: false,
+      error: `Content validation failed: ${contentError}`,
+      callerOtter,
+      attemptedPath: filePath,
+      allowedPaths: []
+    };
+    return { text: JSON.stringify(result), isError: true };
+  }
+  try {
+    if (createDirectories) {
+      (0, import_fs5.mkdirSync)((0, import_path5.dirname)(fullPath), { recursive: true });
+    }
+    (0, import_fs5.writeFileSync)(fullPath, content, { encoding: "utf-8" });
+    const result = {
+      success: true,
+      path: normalized,
+      bytesWritten: Buffer.byteLength(content, "utf-8"),
+      allowRule: check.rule ?? "unknown"
+    };
+    return { text: JSON.stringify(result), isError: false };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const result = {
+      success: false,
+      error: `Write failed: ${message}`,
+      callerOtter,
+      attemptedPath: filePath,
+      allowedPaths: []
+    };
+    return { text: JSON.stringify(result), isError: true };
+  }
+}
+function registerSafeWriteTools(server2) {
+  const DESC = "Controlled file-write chokepoint. Every write from specialist otters goes through this tool with per-otter path allowlists. The LLM cannot write to arbitrary filesystem paths.";
+  server2.tool(
+    "stackwright_pro_safe_write",
+    DESC,
+    {
+      callerOtter: import_zod10.z.string().describe('The otter agent name requesting the write, e.g. "stackwright-pro-page-otter"'),
+      filePath: import_zod10.z.string().describe('Relative path from project root, e.g. "pages/dashboard/content.yml"'),
+      content: import_zod10.z.string().describe("File content to write"),
+      createDirectories: import_zod10.z.boolean().optional().describe("Create parent directories if they don't exist. Default: true")
+    },
+    async ({ callerOtter, filePath, content, createDirectories }) => {
+      const result = handleSafeWrite({
+        callerOtter,
+        filePath,
+        content,
+        ...createDirectories != null ? { createDirectories } : {}
+      });
+      return { content: [{ type: "text", text: result.text }], isError: result.isError };
+    }
+  );
+}
+
+// src/tools/auth.ts
+var import_zod11 = require("zod");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
+function buildHierarchy(roles) {
+  const h = {};
+  for (let i = 0; i < roles.length - 1; i++) {
+    h[roles[i]] = roles.slice(i + 1);
+  }
+  return h;
+}
+function hierarchyToYaml(hierarchy, indent) {
+  const entries = Object.entries(hierarchy);
+  if (entries.length === 0) return `${indent}{}`;
+  return entries.map(([role, subs]) => `${indent}${role}: [${subs.join(", ")}]`).join("\n");
+}
+function rolesToYaml(roles, indent) {
+  return roles.map((r) => `${indent}- ${r}`).join("\n");
+}
+function routesToYaml(routes, defaultRole, indent) {
+  return routes.map((r) => `${indent}- pattern: ${r}
+${indent}  requiredRole: ${defaultRole}`).join("\n");
+}
+function upsertAuthBlock(existing, authYaml) {
+  const lines = existing.split("\n");
+  let authStart = -1;
+  let authEnd = lines.length;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^auth:/.test(lines[i])) {
+      authStart = i;
+    } else if (authStart >= 0 && i > authStart && /^\S/.test(lines[i]) && lines[i].trim() !== "") {
+      authEnd = i;
+      break;
+    }
+  }
+  if (authStart < 0) {
+    return existing.trimEnd() + "\n" + authYaml + "\n";
+  }
+  const before = lines.slice(0, authStart);
+  const after = lines.slice(authEnd);
+  return [...before, ...authYaml.trimEnd().split("\n"), ...after.length ? after : []].join("\n");
+}
+function generateMiddlewareContent(method, params, roles, defaultRole, hierarchy, auditEnabled, auditRetentionDays, protectedRoutes) {
+  const rbacBlock = `  rbac: {
+    roles: ${JSON.stringify(roles)},
+    defaultRole: '${defaultRole}',
+    hierarchy: ${JSON.stringify(hierarchy, null, 4)},
+  },`;
+  const auditBlock = `  audit: {
+    enabled: ${auditEnabled},
+    retentionDays: ${auditRetentionDays},
+  },`;
+  const routesBlock = `  protectedRoutes: ${JSON.stringify(protectedRoutes)},`;
+  const configBlock = `export const config = {
+  matcher: ${JSON.stringify(protectedRoutes)},
+};`;
+  if (method === "cac") {
+    const caBundle = params.cacCaBundle ?? "./certs/dod-ca-bundle.pem";
+    const edipiLookup = params.cacEdipiLookup ?? "./config/edipi-lookup.json";
+    const ocspEndpoint = params.cacOcspEndpoint ?? "https://ocsp.disa.mil";
+    const certHeader = params.cacCertHeader ?? "X-SSL-Client-Cert";
+    return `// middleware.ts \u2014 generated by @stackwright-pro/auth
+// \u26A0\uFE0F  SECURITY REVIEW REQUIRED \u2014 CAC/PKI certificate validation
+// DoD security officer review required before production deployment.
+// Verify: CA bundle completeness, EDIPI lookup endpoint, OCSP accessibility.
+import { createProMiddleware } from '@stackwright-pro/auth-nextjs';
+
+export const middleware = createProMiddleware({
+  method: 'cac',
+  cac: {
+    caBundle: process.env.CAC_CA_BUNDLE ?? '${caBundle}',
+    edipiLookup: '${edipiLookup}',
+    ocspEndpoint: process.env.CAC_OCSP_ENDPOINT ?? '${ocspEndpoint}',
+    certHeader: '${certHeader}',
+  },
+${rbacBlock}
+${auditBlock}
+${routesBlock}
+});
+
+${configBlock}
+`;
+  }
+  if (method === "oidc") {
+    const scopes2 = params.oidcScopes ?? "openid profile email";
+    const roleClaim = params.oidcRoleClaim ?? "roles";
+    return `// middleware.ts \u2014 generated by @stackwright-pro/auth-nextjs
+import { createProMiddleware } from '@stackwright-pro/auth-nextjs';
+
+export const middleware = createProMiddleware({
+  method: 'oidc',
+  oidc: {
+    discoveryUrl: process.env.OIDC_DISCOVERY_URL!,
+    clientId: process.env.OIDC_CLIENT_ID!,
+    clientSecret: process.env.OIDC_CLIENT_SECRET!,
+    scopes: '${scopes2}',
+    roleClaim: '${roleClaim}',
+  },
+${rbacBlock}
+${auditBlock}
+${routesBlock}
+});
+
+${configBlock}
+`;
+  }
+  const scopes = params.oauth2Scopes ?? "read write";
+  return `// middleware.ts \u2014 generated by @stackwright-pro/auth-nextjs
+import { createProMiddleware } from '@stackwright-pro/auth-nextjs';
+
+export const middleware = createProMiddleware({
+  method: 'oauth2',
+  oauth2: {
+    authorizationUrl: process.env.OAUTH2_AUTH_URL!,
+    tokenUrl: process.env.OAUTH2_TOKEN_URL!,
+    clientId: process.env.OAUTH2_CLIENT_ID!,
+    clientSecret: process.env.OAUTH2_CLIENT_SECRET!,
+    scopes: '${scopes}',
+  },
+${rbacBlock}
+${auditBlock}
+${routesBlock}
+});
+
+${configBlock}
+`;
+}
+function generateEnvBlock(method, params) {
+  if (method === "cac") {
+    return `# Authentication (CAC/PKI \u2014 DoD)
+# \u26A0\uFE0F  SECURITY REVIEW REQUIRED before production deployment
+CAC_CA_BUNDLE=./certs/dod-ca-bundle.pem
+CAC_OCSP_ENDPOINT=https://ocsp.disa.mil
+`;
+  }
+  if (method === "oidc") {
+    const label = params.provider ?? "OIDC";
+    const discoveryUrl = params.oidcDiscoveryUrl ?? "https://your-provider/.well-known/openid-configuration";
+    return `# Authentication (OIDC \u2014 ${label})
+OIDC_DISCOVERY_URL=${discoveryUrl}
+OIDC_CLIENT_ID=your-client-id
+OIDC_CLIENT_SECRET=your-client-secret
+`;
+  }
+  const authUrl = params.oauth2AuthUrl ?? "https://your-auth-server/authorize";
+  const tokenUrl = params.oauth2TokenUrl ?? "https://your-auth-server/token";
+  return `# Authentication (OAuth2)
+OAUTH2_AUTH_URL=${authUrl}
+OAUTH2_TOKEN_URL=${tokenUrl}
+OAUTH2_CLIENT_ID=your-client-id
+OAUTH2_CLIENT_SECRET=your-client-secret
+`;
+}
+function generateYamlBlock(method, params, roles, defaultRole, hierarchy, auditEnabled, auditRetentionDays, protectedRoutes) {
+  const rbacSection = `  rbac:
+    roles:
+${rolesToYaml(roles, "      ")}
+    defaultRole: ${defaultRole}
+    hierarchy:
+${hierarchyToYaml(hierarchy, "      ")}`;
+  const auditSection = `  audit:
+    enabled: ${auditEnabled}
+    retentionDays: ${auditRetentionDays}`;
+  const routesSection = `  protectedRoutes:
+${routesToYaml(protectedRoutes, "    ", defaultRole)}`.replace(/\n\s+,/g, "");
+  const routeLines = protectedRoutes.map((r) => `    - pattern: ${r}
+      requiredRole: ${defaultRole}`).join("\n");
+  const providerLine = params.provider ? `  provider: ${params.provider}
+` : "";
+  if (method === "cac") {
+    const caBundle = params.cacCaBundle ?? "./certs/dod-ca-bundle.pem";
+    const edipiLookup = params.cacEdipiLookup ?? "./config/edipi-lookup.json";
+    const ocspEndpoint = params.cacOcspEndpoint ?? "https://ocsp.disa.mil";
+    const certHeader = params.cacCertHeader ?? "X-SSL-Client-Cert";
+    return `auth:
+  method: cac
+${providerLine}  middleware: ./middleware.ts
+  cac:
+    caBundle: \${CAC_CA_BUNDLE}
+    edipiLookup: ${edipiLookup}
+    ocspEndpoint: \${CAC_OCSP_ENDPOINT}
+    certHeader: ${certHeader}
+${rbacSection}
+  protectedRoutes:
+${routeLines}
+${auditSection}
+`;
+  }
+  if (method === "oidc") {
+    const scopes2 = params.oidcScopes ?? "openid profile email";
+    const roleClaim = params.oidcRoleClaim ?? "roles";
+    return `auth:
+  method: oidc
+${providerLine}  middleware: ./middleware.ts
+  oidc:
+    discoveryUrl: \${OIDC_DISCOVERY_URL}
+    clientId: \${OIDC_CLIENT_ID}
+    clientSecret: \${OIDC_CLIENT_SECRET}
+    scopes: ${scopes2}
+    roleClaim: ${roleClaim}
+${rbacSection}
+  protectedRoutes:
+${routeLines}
+${auditSection}
+`;
+  }
+  const scopes = params.oauth2Scopes ?? "read write";
+  return `auth:
+  method: oauth2
+${providerLine}  middleware: ./middleware.ts
+  oauth2:
+    authorizationUrl: \${OAUTH2_AUTH_URL}
+    tokenUrl: \${OAUTH2_TOKEN_URL}
+    clientId: \${OAUTH2_CLIENT_ID}
+    clientSecret: \${OAUTH2_CLIENT_SECRET}
+    scopes: ${scopes}
+${rbacSection}
+  protectedRoutes:
+${routeLines}
+${auditSection}
+`;
+}
+async function configureAuthHandler(params, cwd) {
+  const {
+    method,
+    provider,
+    rbacRoles = ["SUPER_ADMIN", "ADMIN", "ANALYST"],
+    auditEnabled = true,
+    auditRetentionDays = 90,
+    protectedRoutes = ["/dashboard/:path*"]
+  } = params;
+  const roles = rbacRoles;
+  const defaultRole = params.rbacDefaultRole ?? roles[roles.length - 1];
+  const hierarchy = buildHierarchy(roles);
+  if (method === "none") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            method: "none",
+            provider: null,
+            rbacRoles: roles,
+            rbacDefaultRole: defaultRole,
+            protectedRoutesCount: protectedRoutes.length,
+            filesWritten: [],
+            securityWarning: null
+          })
+        }
+      ]
+    };
+  }
+  const filesWritten = [];
+  try {
+    const middlewareContent = generateMiddlewareContent(
+      method,
+      params,
+      roles,
+      defaultRole,
+      hierarchy,
+      auditEnabled,
+      auditRetentionDays,
+      protectedRoutes
+    );
+    (0, import_fs6.writeFileSync)((0, import_path6.join)(cwd, "middleware.ts"), middlewareContent, "utf8");
+    filesWritten.push("middleware.ts");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: false, error: `Failed writing middleware.ts: ${msg}` })
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    const envBlock = generateEnvBlock(method, params);
+    const envPath = (0, import_path6.join)(cwd, ".env.example");
+    if ((0, import_fs6.existsSync)(envPath)) {
+      const existing = (0, import_fs6.readFileSync)(envPath, "utf8");
+      (0, import_fs6.writeFileSync)(envPath, existing.trimEnd() + "\n\n" + envBlock, "utf8");
+    } else {
+      (0, import_fs6.writeFileSync)(envPath, envBlock, "utf8");
+    }
+    filesWritten.push(".env.example");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: false, error: `Failed writing .env.example: ${msg}` })
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    const authYaml = generateYamlBlock(
+      method,
+      params,
+      roles,
+      defaultRole,
+      hierarchy,
+      auditEnabled,
+      auditRetentionDays,
+      protectedRoutes
+    );
+    const ymlPath = (0, import_path6.join)(cwd, "stackwright.yml");
+    if (!(0, import_fs6.existsSync)(ymlPath)) {
+      (0, import_fs6.writeFileSync)(ymlPath, authYaml, "utf8");
+    } else {
+      const existing = (0, import_fs6.readFileSync)(ymlPath, "utf8");
+      (0, import_fs6.writeFileSync)(ymlPath, upsertAuthBlock(existing, authYaml), "utf8");
+    }
+    filesWritten.push("stackwright.yml");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: false, error: `Failed writing stackwright.yml: ${msg}` })
+        }
+      ],
+      isError: true
+    };
+  }
+  const securityWarning = method === "cac" ? "SECURITY REVIEW REQUIRED \u2014 CAC certificate chain must be verified before production deployment" : null;
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          method,
+          provider: provider ?? null,
+          rbacRoles: roles,
+          rbacDefaultRole: defaultRole,
+          protectedRoutesCount: protectedRoutes.length,
+          filesWritten,
+          securityWarning
+        })
+      }
+    ]
+  };
+}
+function registerAuthTools(server2) {
+  server2.tool(
+    "stackwright_pro_configure_auth",
+    "Generate authentication middleware and configuration for a Next.js Stackwright application. Writes `middleware.ts` from a secure template, appends/updates the `auth:` section in `stackwright.yml`, and generates `.env.example` with required environment variables. \u26A0\uFE0F For CAC/PKI: generated `middleware.ts` carries a SECURITY REVIEW REQUIRED comment \u2014 certificate chain validation must be verified by a DoD security officer before production deployment. This is the ONLY approved path to generating `middleware.ts`. Never write TypeScript auth files directly.",
+    {
+      method: import_zod11.z.enum(["cac", "oidc", "oauth2", "none"]),
+      provider: import_zod11.z.enum(["azure-ad", "okta", "ping", "cognito", "custom"]).optional(),
+      // CAC
+      cacCaBundle: import_zod11.z.string().optional(),
+      cacEdipiLookup: import_zod11.z.string().optional(),
+      cacOcspEndpoint: import_zod11.z.string().optional(),
+      cacCertHeader: import_zod11.z.string().optional(),
+      // OIDC
+      oidcDiscoveryUrl: import_zod11.z.string().optional(),
+      oidcClientId: import_zod11.z.string().optional(),
+      oidcClientSecret: import_zod11.z.string().optional(),
+      oidcScopes: import_zod11.z.string().optional(),
+      oidcRoleClaim: import_zod11.z.string().optional(),
+      // OAuth2
+      oauth2AuthUrl: import_zod11.z.string().optional(),
+      oauth2TokenUrl: import_zod11.z.string().optional(),
+      oauth2ClientId: import_zod11.z.string().optional(),
+      oauth2ClientSecret: import_zod11.z.string().optional(),
+      oauth2Scopes: import_zod11.z.string().optional(),
+      // RBAC
+      rbacRoles: import_zod11.z.array(import_zod11.z.string()).optional(),
+      rbacDefaultRole: import_zod11.z.string().optional(),
+      // Audit
+      auditEnabled: import_zod11.z.boolean().optional(),
+      auditRetentionDays: import_zod11.z.number().int().positive().optional(),
+      // Routes
+      protectedRoutes: import_zod11.z.array(import_zod11.z.string()).optional(),
+      // Injection for tests
+      _cwd: import_zod11.z.string().optional()
+    },
+    async (params) => {
+      const cwd = params._cwd ?? process.cwd();
+      return configureAuthHandler(params, cwd);
+    }
+  );
+}
+
+// src/integrity.ts
+var import_crypto2 = require("crypto");
+var import_fs7 = require("fs");
+var import_path7 = require("path");
+var _checksums = /* @__PURE__ */ new Map([
+  [
+    "stackwright-pro-api-otter.json",
+    "f1cc9edf2dd1df3ebcea1d0ab33d17a358faaf8aa97ee232cd7994042f2eac0d"
+  ],
+  [
+    "stackwright-pro-auth-otter.json",
+    "a19e06c503209a8a35fe321d30448623545b36b48c47a6ec064d13406ad1f725"
+  ],
+  [
+    "stackwright-pro-dashboard-otter.json",
+    "b3cb3d7554f2e9eed3b57d5e0e3bf85d6ba5b4db5d3af5514391cf0575fcc001"
+  ],
+  [
+    "stackwright-pro-data-otter.json",
+    "bfacb87ae82867472a75982215554336a105a658d6cd3dd2c8b819fa1e11d7ac"
+  ],
+  [
+    "stackwright-pro-designer-otter.json",
+    "c58fa7c7ead9e6398074e1c7ce3f31a8ef4eb3679f5fa18cc03cae3a87878c88"
+  ],
+  [
+    "stackwright-pro-foreman-otter.json",
+    "27f4dfd4676246c9fea14fd1de4f148928eeaf06e58b08240761fd3e663dd540"
+  ],
+  [
+    "stackwright-pro-page-otter.json",
+    "65bec3a3a0dda6b7591bba2de9399f1e3a4fb99cfe1075342f4f4be98d917b67"
+  ],
+  [
+    "stackwright-pro-theme-otter.json",
+    "64ffaeeceacd739922788a1d074f6feaffc3f91d09706c2c104f0c0281677732"
+  ],
+  [
+    "stackwright-pro-workflow-otter.json",
+    "0eec9d6a731678cf547c2a7b0b6fc338ca143c35501365a1e4e5dd2779dd5510"
+  ]
+]);
+Object.freeze(_checksums);
+var CANONICAL_CHECKSUMS = _checksums;
+var SHA256_HEX_RE = /^[0-9a-f]{64}$/;
+for (const [name, digest] of CANONICAL_CHECKSUMS) {
+  if (!SHA256_HEX_RE.test(digest)) {
+    throw new Error(
+      `Malformed SHA-256 in CANONICAL_CHECKSUMS for "${name}": expected 64 hex chars, got ${digest.length}: "${digest}"`
+    );
+  }
+}
+var MAX_OTTER_BYTES = 1 * 1024 * 1024;
+function computeSha256(data) {
+  return (0, import_crypto2.createHash)("sha256").update(data).digest("hex");
+}
+function safeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  return (0, import_crypto2.timingSafeEqual)(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
+}
+function verifyOtterFile(filePath) {
+  const filename = (0, import_path7.basename)(filePath);
+  const expected = CANONICAL_CHECKSUMS.get(filename);
+  if (expected === void 0) {
+    return { verified: false, filename, error: `Unknown otter file: not in canonical set` };
+  }
+  let stat;
+  try {
+    stat = (0, import_fs7.lstatSync)(filePath);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { verified: false, filename, error: `Cannot stat file: ${msg}` };
+  }
+  if (stat.isSymbolicLink()) {
+    return { verified: false, filename, error: "Refusing to verify symlink" };
+  }
+  const size = stat.size;
+  if (size > MAX_OTTER_BYTES) {
+    return {
+      verified: false,
+      filename,
+      error: `File exceeds size limit (${MAX_OTTER_BYTES.toLocaleString()} bytes, got ${size.toLocaleString()})`
+    };
+  }
+  let raw;
+  try {
+    raw = (0, import_fs7.readFileSync)(filePath);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { verified: false, filename, error: `Cannot read file: ${msg}` };
+  }
+  if (raw.length > MAX_OTTER_BYTES) {
+    return {
+      verified: false,
+      filename,
+      error: `File exceeds size limit after read (${MAX_OTTER_BYTES.toLocaleString()} bytes, got ${raw.length.toLocaleString()})`
+    };
+  }
+  const actual = computeSha256(raw);
+  if (!safeEqual(actual, expected)) {
+    return {
+      verified: false,
+      filename,
+      error: `SHA-256 mismatch: expected ${expected.substring(0, 8)}\u2026, got ${actual.substring(0, 8)}\u2026`
+    };
+  }
+  try {
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    decoder.decode(raw);
+  } catch {
+    return {
+      verified: false,
+      filename,
+      error: "File is not valid UTF-8 \u2014 may be corrupted or contain binary injection"
+    };
+  }
+  return { verified: true, filename };
+}
+function verifyAllOtters(otterDir) {
+  const verified = [];
+  const failed = [];
+  const unknown = [];
+  let entries;
+  try {
+    entries = (0, import_fs7.readdirSync)(otterDir);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      verified: [],
+      failed: [{ filename: "<directory>", error: `Cannot read directory: ${msg}` }],
+      unknown: []
+    };
+  }
+  const otterFiles = entries.filter((f) => f.endsWith("-otter.json"));
+  for (const filename of otterFiles) {
+    const filePath = (0, import_path7.join)(otterDir, filename);
+    try {
+      if ((0, import_fs7.lstatSync)(filePath).isSymbolicLink()) {
+        failed.push({ filename, error: "Skipped: symlink" });
+        continue;
+      }
+    } catch {
+    }
+    const result = verifyOtterFile(filePath);
+    if (result.verified) {
+      verified.push(result.filename);
+    } else if (result.error?.startsWith("Unknown otter file")) {
+      unknown.push(result.filename);
+    } else {
+      failed.push({ filename: result.filename, error: result.error ?? "Unknown error" });
+    }
+  }
+  for (const canonicalName of CANONICAL_CHECKSUMS.keys()) {
+    if (!otterFiles.includes(canonicalName)) {
+      failed.push({ filename: canonicalName, error: "Missing from directory" });
+    }
+  }
+  return { verified, failed, unknown };
+}
+var DEFAULT_SEARCH_PATHS = ["node_modules/@stackwright-pro/otters/src/", "packages/otters/src/"];
+function resolveOtterDir() {
+  const cwd = process.cwd();
+  for (const relative of DEFAULT_SEARCH_PATHS) {
+    const candidate = (0, import_path7.join)(cwd, relative);
+    try {
+      (0, import_fs7.lstatSync)(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function registerIntegrityTools(server2) {
+  server2.tool(
+    "stackwright_pro_verify_otter_integrity",
+    "Verify SHA-256 integrity of all Pro otter agent definitions. Call this at startup before discovering otters. Auto-discovers the otter directory from known paths. Returns verified/failed/unknown lists.",
+    {},
+    async () => {
+      const resolved = resolveOtterDir();
+      if (!resolved) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: true,
+                message: "Could not locate otter directory. Searched: " + DEFAULT_SEARCH_PATHS.join(", ")
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const result = verifyAllOtters(resolved);
+      const allGood = result.failed.length === 0 && result.unknown.length === 0;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              otterDir: resolved,
+              totalCanonical: CANONICAL_CHECKSUMS.size,
+              verifiedCount: result.verified.length,
+              failedCount: result.failed.length,
+              unknownCount: result.unknown.length,
+              verified: result.verified,
+              failed: result.failed,
+              unknown: result.unknown,
+              warning: result.failed.length > 0 ? "SHA-256 mismatches detected (non-blocking). PKI-signed manifest support coming soon." : void 0
+            })
+          }
+        ],
+        isError: false
+      };
+    }
+  );
+}
+
+// src/tools/domain.ts
+var import_zod12 = require("zod");
+var import_fs8 = require("fs");
+var import_path8 = require("path");
+function handleListCollections(input) {
+  const cwd = input._cwd ?? process.cwd();
+  const sources = [
+    {
+      path: (0, import_path8.join)(cwd, ".stackwright", "artifacts", "data-config.json"),
+      source: "data-config.json",
+      parse: (raw) => {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+          return [];
+        }
+        return extractCollectionsFromArtifact(parsed);
+      }
+    },
+    {
+      path: (0, import_path8.join)(cwd, "stackwright.yml"),
+      source: "stackwright.yml",
+      parse: extractCollectionsFromYaml
+    }
+  ];
+  for (const { path: path3, source, parse } of sources) {
+    if (!(0, import_fs8.existsSync)(path3)) continue;
+    try {
+      const collections = parse((0, import_fs8.readFileSync)(path3, "utf8"));
+      return {
+        text: JSON.stringify({ collections, source, collectionCount: collections.length }),
+        isError: false
+      };
+    } catch {
+    }
+  }
+  return {
+    text: JSON.stringify({
+      collections: [],
+      source: "none",
+      collectionCount: 0,
+      hint: "Run API Otter and Data Otter first"
+    }),
+    isError: false
+  };
+}
+function extractCollectionsFromArtifact(raw) {
+  const collections = [];
+  const integrations = raw.integrations ?? raw.collections ?? [];
+  if (!Array.isArray(integrations)) return collections;
+  for (const item of integrations) {
+    if (!item || typeof item !== "object") continue;
+    const obj = item;
+    if (typeof obj.name === "string" && typeof obj.endpoint === "string") {
+      collections.push(makeCollectionInfo(obj.name, obj.endpoint, obj.type));
+      continue;
+    }
+    if (!Array.isArray(obj.collections)) continue;
+    for (const col of obj.collections) {
+      if (!col || typeof col !== "object") continue;
+      const c = col;
+      if (typeof c.name === "string" && typeof c.endpoint === "string") {
+        collections.push(makeCollectionInfo(c.name, c.endpoint, c.type ?? obj.type));
+      }
+    }
+  }
+  return collections;
+}
+function makeCollectionInfo(name, endpoint, type) {
+  return { name, endpoint, ...typeof type === "string" ? { type } : {} };
+}
+function extractCollectionsFromYaml(yamlText) {
+  const collections = [];
+  const lines = yamlText.split("\n");
+  let inIntegrations = false;
+  let currentName = null;
+  let currentEndpoint = null;
+  let currentType = null;
+  for (const line of lines) {
+    if (line.length > 1e3) continue;
+    if (/^integrations:\s*$/.test(line)) {
+      inIntegrations = true;
+      continue;
+    }
+    if (inIntegrations && /^[a-z]/.test(line) && !line.startsWith(" ")) {
+      inIntegrations = false;
+    }
+    if (!inIntegrations) continue;
+    const stripQuotes = (s) => s.trim().replace(/^['"]|['"]$/g, "");
+    const typeMatch = line.match(/^\s+type:\s*(.+)$/);
+    if (typeMatch?.[1]) currentType = stripQuotes(typeMatch[1]);
+    const nameMatch = line.match(/^[\s-]+name:\s*(.+)$/);
+    if (nameMatch?.[1]) {
+      if (currentName && currentEndpoint) {
+        collections.push(makeCollectionInfo(currentName, currentEndpoint, currentType));
+      }
+      currentName = stripQuotes(nameMatch[1]);
+      currentEndpoint = null;
+    }
+    const endpointMatch = line.match(/^\s+endpoint:\s*(.+)$/);
+    if (endpointMatch?.[1]) currentEndpoint = stripQuotes(endpointMatch[1]);
+  }
+  if (currentName && currentEndpoint) {
+    collections.push(makeCollectionInfo(currentName, currentEndpoint, currentType));
+  }
+  return collections;
+}
+var DATA_STRATEGIES = {
+  "pulse-fast": {
+    strategy: "pulse-fast",
+    mechanism: "Client-side polling via @stackwright-pro/pulse",
+    mechanismPackage: "@stackwright-pro/pulse",
+    pulse: true,
+    requiredPackages: { "@stackwright-pro/pulse": "latest", "@tanstack/react-query": "^5.0.0" },
+    handoffFlags: ["PULSE_MODE=true"],
+    description: "Real-time updates every few seconds. Uses client-side polling. Dashboard Otter should use *_pulse component variants."
+  },
+  "isr-fast": {
+    strategy: "isr-fast",
+    mechanism: "Next.js ISR",
+    revalidateSeconds: 60,
+    pulse: false,
+    requiredPackages: {},
+    handoffFlags: [],
+    description: "Near real-time with 60-second ISR revalidation. Good for dashboards that need minute-level freshness."
+  },
+  "isr-standard": {
+    strategy: "isr-standard",
+    mechanism: "Next.js ISR",
+    revalidateSeconds: 3600,
+    pulse: false,
+    requiredPackages: {},
+    handoffFlags: [],
+    description: "Standard hourly revalidation. Good for most API-backed pages."
+  },
+  "isr-slow": {
+    strategy: "isr-slow",
+    mechanism: "Next.js ISR",
+    revalidateSeconds: 86400,
+    pulse: false,
+    requiredPackages: {},
+    handoffFlags: [],
+    description: "Daily revalidation. Good for infrequently changing data."
+  }
+};
+function handleResolveDataStrategy(input) {
+  const key = input.strategy.trim().toLowerCase();
+  const match = DATA_STRATEGIES[key];
+  if (!match) {
+    const validKeys = Object.keys(DATA_STRATEGIES).join(", ");
+    return {
+      text: JSON.stringify({
+        error: true,
+        message: `Unknown strategy: "${input.strategy}". Valid strategies: ${validKeys}`,
+        validStrategies: Object.keys(DATA_STRATEGIES)
+      }),
+      isError: true
+    };
+  }
+  const configureIsrCall = match.pulse ? null : {
+    tool: "stackwright_pro_configure_isr_batch",
+    args: {
+      collections: [{ name: "$COLLECTION", revalidateSeconds: match.revalidateSeconds }]
+    }
+  };
+  return {
+    text: JSON.stringify({ ...match, configureIsrCall }),
+    isError: false
+  };
+}
+function fail(errors) {
+  return { text: JSON.stringify({ valid: false, errors, warnings: [] }), isError: true };
+}
+function handleValidateWorkflow(input) {
+  const cwd = input._cwd ?? process.cwd();
+  let raw;
+  if (input.workflow && Object.keys(input.workflow).length > 0) {
+    raw = input.workflow;
+  } else {
+    const artifactPath = (0, import_path8.join)(cwd, ".stackwright", "artifacts", "workflow-config.json");
+    if (!(0, import_fs8.existsSync)(artifactPath)) {
+      return fail([
+        {
+          code: "NO_WORKFLOW",
+          message: "No workflow provided and .stackwright/artifacts/workflow-config.json not found. Pass a workflow object or run the workflow otter first."
+        }
+      ]);
+    }
+    try {
+      raw = JSON.parse((0, import_fs8.readFileSync)(artifactPath, "utf8"));
+    } catch (err) {
+      return fail([{ code: "INVALID_JSON", message: `Failed to parse workflow artifact: ${err}` }]);
+    }
+  }
+  const workflow = raw.workflow && typeof raw.workflow === "object" ? raw.workflow : raw;
+  const errors = [];
+  const warnings = [];
+  if (typeof workflow.id !== "string" || !workflow.id) {
+    errors.push({ code: "MISSING_ID", message: "workflow.id is required", path: "workflow.id" });
+  } else if (!/^[a-z0-9-]+$/.test(workflow.id)) {
+    errors.push({
+      code: "INVALID_ID",
+      message: `workflow.id "${workflow.id}" must match ^[a-z0-9-]+$`,
+      path: "workflow.id"
+    });
+  }
+  if (typeof workflow.label !== "string" || !workflow.label) {
+    errors.push({
+      code: "MISSING_LABEL",
+      message: "workflow.label is required",
+      path: "workflow.label"
+    });
+  }
+  const steps = workflow.steps;
+  if (!Array.isArray(steps)) {
+    errors.push({
+      code: "MISSING_STEPS",
+      message: "workflow.steps must be an array",
+      path: "workflow.steps"
+    });
+    return { text: JSON.stringify({ valid: false, errors, warnings }), isError: false };
+  }
+  if (steps.length < 2) {
+    errors.push({
+      code: "TOO_FEW_STEPS",
+      message: "A workflow must have at least 2 steps",
+      path: "workflow.steps"
+    });
+  }
+  const stepIds = /* @__PURE__ */ new Set();
+  const duplicateIds = [];
+  for (const step of steps) {
+    if (!step || typeof step !== "object") continue;
+    const id = step.id;
+    if (typeof id !== "string" || !id) {
+      errors.push({
+        code: "MISSING_STEP_ID",
+        message: "Every step must have an id",
+        path: "workflow.steps"
+      });
+      continue;
+    }
+    if (!/^[a-z0-9_]+$/.test(id)) {
+      errors.push({
+        code: "INVALID_STEP_ID",
+        message: `Step ID "${id}" must match ^[a-z0-9_]+$`,
+        path: `workflow.steps[${id}].id`
+      });
+    }
+    if (stepIds.has(id)) duplicateIds.push(id);
+    stepIds.add(id);
+  }
+  if (duplicateIds.length > 0) {
+    errors.push({
+      code: "DUPLICATE_STEP_IDS",
+      message: `Duplicate step IDs: ${duplicateIds.join(", ")}`,
+      path: "workflow.steps"
+    });
+  }
+  const initialStep = workflow.initial_step;
+  if (typeof initialStep !== "string" || !initialStep) {
+    errors.push({
+      code: "MISSING_INITIAL_STEP",
+      message: "workflow.initial_step is required",
+      path: "workflow.initial_step"
+    });
+  } else if (!stepIds.has(initialStep)) {
+    errors.push({
+      code: "INVALID_INITIAL_STEP",
+      message: `initial_step "${initialStep}" does not reference an existing step. Valid: ${[...stepIds].join(", ")}`,
+      path: "workflow.initial_step"
+    });
+  }
+  for (const step of steps) {
+    if (!step || typeof step !== "object") continue;
+    const s = step;
+    const stepId = String(s.id ?? "??");
+    validateTransitionTargets(s, stepId, stepIds, errors);
+    collectServiceWarnings(s, stepId, warnings);
+  }
+  if (typeof workflow.persistence === "string" && workflow.persistence.startsWith("service:")) {
+    warnings.push({
+      code: "WARN_SERVICE_REFERENCE",
+      message: 'service: reference at "workflow.persistence" requires @stackwright-pro/services. Prism mock fallback will be used until services layer is configured.',
+      path: "workflow.persistence"
+    });
+  }
+  const hasTerminal = steps.some((step) => {
+    if (!step || typeof step !== "object") return false;
+    return step.type === "terminal";
+  });
+  if (!hasTerminal) {
+    errors.push({
+      code: "NO_TERMINAL_STATE",
+      message: "Workflow must have at least one step with type: terminal",
+      path: "workflow.steps"
+    });
+  }
+  return { text: JSON.stringify({ valid: errors.length === 0, errors, warnings }), isError: false };
+}
+function validateTransitionTargets(step, stepId, stepIds, errors) {
+  const check = (target, path3) => {
+    if (typeof target === "string" && !stepIds.has(target)) {
+      errors.push({
+        code: "ORPHANED_TRANSITION",
+        message: `Step "${stepId}" transitions to "${target}" which does not exist`,
+        path: path3
+      });
+    }
+  };
+  const onSubmit = step.on_submit;
+  if (onSubmit && typeof onSubmit === "object") {
+    check(onSubmit.transition, `workflow.steps[${stepId}].on_submit.transition`);
+  }
+  if (Array.isArray(step.actions)) {
+    for (const action of step.actions) {
+      if (!action || typeof action !== "object") continue;
+      const a = action;
+      check(a.transition, `workflow.steps[${stepId}].actions[${a.id ?? "??"}].transition`);
+    }
+  }
+  if (Array.isArray(step.conditions)) {
+    for (const cond of step.conditions) {
+      if (!cond || typeof cond !== "object") continue;
+      const then = cond.then;
+      if (then && typeof then === "object") {
+        check(then.transition, `workflow.steps[${stepId}].conditions`);
+      }
+    }
+  }
+  if (Array.isArray(step.show_fields_from)) {
+    for (const ref of step.show_fields_from)
+      check(ref, `workflow.steps[${stepId}].show_fields_from`);
+  }
+  const display = step.display;
+  if (display && typeof display === "object") {
+    check(display.source_step, `workflow.steps[${stepId}].display.source_step`);
+    if (Array.isArray(display.source_steps)) {
+      for (const ref of display.source_steps)
+        check(ref, `workflow.steps[${stepId}].display.source_steps`);
+    }
+  }
+}
+function collectServiceWarnings(step, stepId, warnings) {
+  const isService = (val) => typeof val === "string" && val.startsWith("service:");
+  const warn = (path3) => {
+    warnings.push({
+      code: "WARN_SERVICE_REFERENCE",
+      message: `service: reference at "${path3}" requires @stackwright-pro/services. Prism mock fallback will be used until services layer is configured.`,
+      path: path3
+    });
+  };
+  const onSubmit = step.on_submit;
+  if (onSubmit && typeof onSubmit === "object" && isService(onSubmit.action))
+    warn(`${stepId}.on_submit.action`);
+  const onEnter = step.on_enter;
+  if (onEnter && typeof onEnter === "object" && isService(onEnter.action))
+    warn(`${stepId}.on_enter.action`);
+  if (Array.isArray(step.actions)) {
+    for (const action of step.actions) {
+      if (!action || typeof action !== "object") continue;
+      const a = action;
+      if (isService(a.action)) warn(`${stepId}.actions.${a.id ?? "??"}.action`);
+    }
+  }
+  if (Array.isArray(step.fields)) {
+    for (const field of step.fields) {
+      if (!field || typeof field !== "object") continue;
+      const f = field;
+      if (isService(f.data_source)) warn(`${stepId}.fields.${f.name ?? "??"}.data_source`);
+    }
+  }
+}
+function registerDomainTools(server2) {
+  const res = (r) => ({
+    content: [{ type: "text", text: r.text }],
+    isError: r.isError
+  });
+  server2.tool(
+    "stackwright_pro_list_collections",
+    "List API-backed collections available for page generation. Reads from Data Otter artifact (.stackwright/artifacts/data-config.json) or stackwright.yml. Call this before generating pages that bind to data.",
+    {},
+    async () => res(handleListCollections({}))
+  );
+  server2.tool(
+    "stackwright_pro_resolve_data_strategy",
+    "Look up the data freshness strategy configuration from the user's answer. Returns mechanism, revalidation seconds, required packages, and the exact MCP tool call to make. Replaces the strategy table in the data-otter prompt.",
+    {
+      strategy: import_zod12.z.string().describe(
+        'The data-1 answer value: "pulse-fast", "isr-fast", "isr-standard", or "isr-slow"'
+      )
+    },
+    async ({ strategy }) => res(handleResolveDataStrategy({ strategy }))
+  );
+  server2.tool(
+    "stackwright_pro_validate_workflow",
+    "Validate a workflow definition against the Stackwright workflow schema. Checks step ID uniqueness, transition targets, terminal state existence, and service references. Call this after the workflow otter produces output.",
+    {
+      workflow: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown()).optional().describe(
+        "Parsed workflow object. If omitted, reads from .stackwright/artifacts/workflow-config.json"
+      )
+    },
+    async ({ workflow }) => res(handleValidateWorkflow(workflow ? { workflow } : {}))
+  );
+}
+
+// package.json
+var package_default = {
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.10.0",
+    "@stackwright-pro/cli-data-explorer": "workspace:*",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@types/node": "^24.1.0",
+    tsup: "^8.5.0",
+    typescript: "^5.8.3",
+    vitest: "^4.0.18"
+  },
+  scripts: {
+    prepublishOnly: "node scripts/verify-integrity-sync.js",
+    build: "tsup",
+    dev: "tsup --watch",
+    start: "node dist/server.js",
+    test: "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
+  name: "@stackwright-pro/mcp",
+  version: "0.2.0-alpha.10",
+  description: "MCP tools for Stackwright Pro - Data Explorer, Security, ISR, and Dashboard generation",
+  license: "PROPRIETARY",
+  main: "./dist/server.js",
+  module: "./dist/server.mjs",
+  types: "./dist/server.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/server.d.ts",
+      import: "./dist/server.mjs",
+      require: "./dist/server.js"
+    },
+    "./integrity": {
+      types: "./dist/integrity.d.ts",
+      import: "./dist/integrity.mjs",
+      require: "./dist/integrity.js"
+    }
+  },
+  files: [
+    "dist"
+  ],
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/server.ts
 var server = new import_mcp.McpServer({
   name: "stackwright-pro",
-  version: packageJson.version
+  version: package_default.version
 });
 registerDataExplorerTools(server);
 registerSecurityTools(server);
@@ -1219,6 +3505,13 @@ registerIsrTools(server);
 registerDashboardTools(server);
 registerClarificationTools(server);
 registerPackageTools(server);
+registerQuestionTools(server);
+registerOrchestrationTools(server);
+registerPipelineTools(server);
+registerSafeWriteTools(server);
+registerAuthTools(server);
+registerIntegrityTools(server);
+registerDomainTools(server);
 async function main() {
   const transport = new import_stdio.StdioServerTransport();
   await server.connect(transport);