@stackwright-pro/mcp 0.2.0-alpha.105 → 0.2.0-alpha.106

package/dist/server.js

@@ -2023,9 +2023,9 @@ function registerOrchestrationTools(server2) {
 
 // src/tools/pipeline.ts
 var import_zod13 = require("zod");
-var import_fs6 = require("fs");
+var import_fs7 = require("fs");
 var import_proper_lockfile = require("proper-lockfile");
-var import_path6 = require("path");
+var import_path7 = require("path");
 var import_crypto3 = require("crypto");
 
 // src/artifact-signing.ts
@@ -2350,6 +2350,208 @@ function registerArtifactSigningTools(server2) {
   );
 }
 
+// src/tools/validate-pulse-content.ts
+var import_js_yaml = require("js-yaml");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
+var import_pulse = require("@stackwright-pro/pulse");
+function getAllowedProps(schema) {
+  let inner = schema;
+  while (inner && typeof inner.unwrap === "function") {
+    inner = inner.unwrap();
+  }
+  if (inner && typeof inner === "object" && inner.shape && typeof inner.shape === "object") {
+    return Object.keys(inner.shape);
+  }
+  return [];
+}
+var COLUMN_ALLOWED_PROPS = getAllowedProps(import_pulse.ColumnSchema);
+function walk(node, path5, relativeFilePath, violations, counter) {
+  if (node === null || node === void 0 || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) {
+      walk(node[i], `${path5}[${i}]`, relativeFilePath, violations, counter);
+    }
+    return;
+  }
+  const obj = node;
+  const contentType = typeof obj["type"] === "string" ? obj["type"] : null;
+  if (contentType !== null && contentType in import_pulse.PULSE_CONTENT_SCHEMAS) {
+    counter.checked++;
+    const schema = import_pulse.PULSE_CONTENT_SCHEMAS[contentType];
+    const result = schema.safeParse(obj);
+    if (!result.success) {
+      violations.push({
+        file: relativeFilePath,
+        yamlPath: path5,
+        contentType,
+        issues: result.error.issues.map((issue) => ({
+          path: issue.path.map(String),
+          message: issue.message
+        })),
+        emittedProps: Object.keys(obj).filter((k) => k !== "type"),
+        allowedProps: getAllowedProps(schema),
+        rawItem: obj
+      });
+    }
+  }
+  for (const [key, child] of Object.entries(obj)) {
+    walk(child, `${path5}.${key}`, relativeFilePath, violations, counter);
+  }
+}
+function findContentYamlFiles(dir) {
+  const results = [];
+  if (!(0, import_fs5.existsSync)(dir)) return results;
+  for (const entry of (0, import_fs5.readdirSync)(dir)) {
+    const fullPath = (0, import_path5.join)(dir, entry);
+    const stat = (0, import_fs5.statSync)(fullPath);
+    if (stat.isDirectory()) {
+      results.push(...findContentYamlFiles(fullPath));
+    } else if (entry === "content.yml") {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function validatePulseContent(projectRoot) {
+  const pagesDir = (0, import_path5.join)(projectRoot, "pages");
+  const contentFiles = findContentYamlFiles(pagesDir);
+  const violations = [];
+  const counter = { checked: 0 };
+  for (const absolutePath of contentFiles) {
+    const relPath = (0, import_path5.relative)(projectRoot, absolutePath);
+    let parsed;
+    try {
+      const raw = (0, import_fs5.readFileSync)(absolutePath, "utf-8");
+      parsed = (0, import_js_yaml.load)(raw);
+    } catch {
+      continue;
+    }
+    walk(parsed, "content", relPath, violations, counter);
+  }
+  return {
+    valid: violations.length === 0,
+    filesScanned: contentFiles.length,
+    itemsChecked: counter.checked,
+    violations
+  };
+}
+function unknownProps(violation) {
+  const allowed = new Set(violation.allowedProps);
+  return violation.emittedProps.filter((p) => !allowed.has(p));
+}
+function extractColumnViolations(violation) {
+  if (violation.contentType !== "data_table_pulse") return [];
+  const byColumn = /* @__PURE__ */ new Map();
+  for (const issue of violation.issues) {
+    if (issue.path[0] === "columns" && typeof issue.path[1] === "string") {
+      const colIdx = parseInt(issue.path[1], 10);
+      if (!isNaN(colIdx)) {
+        const missing = issue.path[2] ?? issue.message;
+        if (!byColumn.has(colIdx)) byColumn.set(colIdx, []);
+        byColumn.get(colIdx).push(String(missing));
+      }
+    }
+  }
+  if (byColumn.size === 0) return [];
+  const rawColumns = Array.isArray(violation.rawItem["columns"]) ? violation.rawItem["columns"] : [];
+  const columnAllowed = new Set(COLUMN_ALLOWED_PROPS);
+  const summaries = [];
+  for (const [colIdx, missingProps] of byColumn.entries()) {
+    const rawCol = rawColumns[colIdx] ?? {};
+    const emitted = Object.keys(rawCol);
+    const unknown = emitted.filter((p) => !columnAllowed.has(p));
+    summaries.push({
+      index: colIdx,
+      emittedProps: emitted,
+      unknownProps: unknown,
+      missingProps: [...new Set(missingProps)]
+    });
+  }
+  return summaries.sort((a, b) => a.index - b.index);
+}
+function swapSuggestion(unknownPropNames, missingPropNames, itemType) {
+  if (unknownPropNames.length !== 1 || missingPropNames.length !== 1) return null;
+  const level = itemType === "column" ? "column property" : "property";
+  return `  Fix: rename ${level} \`${unknownPropNames[0]}\` \u2192 \`${missingPropNames[0]}\``;
+}
+function formatPulseRetryPrompt(result) {
+  if (result.valid) return "";
+  const byFile = /* @__PURE__ */ new Map();
+  for (const v of result.violations) {
+    if (!byFile.has(v.file)) byFile.set(v.file, []);
+    byFile.get(v.file).push(v);
+  }
+  const fileCount = byFile.size;
+  const totalViolations = result.violations.length;
+  const lines = [
+    `Pulse schema validation failed: ${totalViolations} violation(s) across ${fileCount} content.yml file(s).`,
+    "",
+    "You MUST fix ALL violations and re-call stackwright_pro_validate_artifact.",
+    'Do NOT invent new prop names. Only use props listed in "Schema allows".',
+    ""
+  ];
+  for (const [file, violations] of byFile.entries()) {
+    lines.push(`${file} \u2014 ${violations.length} violation(s):`);
+    for (const v of violations) {
+      lines.push(`  ${v.yamlPath} (${v.contentType}):`);
+      const unknown = unknownProps(v);
+      const colViolations = extractColumnViolations(v);
+      if (colViolations.length > 0) {
+        for (const col of colViolations) {
+          lines.push(`    columns[${col.index}]:`);
+          if (col.unknownProps.length > 0) {
+            lines.push(
+              `      Unknown prop(s) used: ${col.unknownProps.map((p) => `\`${p}\``).join(", ")}`
+            );
+          }
+          if (col.missingProps.length > 0) {
+            lines.push(
+              `      Missing required prop(s): ${col.missingProps.map((p) => `\`${p}\``).join(", ")}`
+            );
+          }
+          const suggestion = swapSuggestion(col.unknownProps, col.missingProps, "column");
+          if (suggestion) lines.push(suggestion);
+        }
+        lines.push(
+          `    Schema allows ONLY these column props: ${COLUMN_ALLOWED_PROPS.join(", ")}.`
+        );
+        lines.push(
+          `    Do NOT use: \`label\` (use \`header\`), \`renderAs\` (use \`type\`), \`severityMap\` (use \`colorMap\`), \`width\` (not supported).`
+        );
+      } else if (unknown.length > 0 || v.issues.length > 0) {
+        const missingFromIssues = v.issues.filter((i) => i.path.length === 1 && !i.path[0].match(/^\d+$/)).map((i) => i.path[0]).filter(Boolean);
+        if (unknown.length > 0) {
+          lines.push(`    Unknown prop(s) used: ${unknown.map((p) => `\`${p}\``).join(", ")}`);
+        }
+        if (missingFromIssues.length > 0) {
+          lines.push(
+            `    Missing required prop(s): ${[...new Set(missingFromIssues)].map((p) => `\`${p}\``).join(", ")}`
+          );
+        }
+        const suggestion = swapSuggestion(unknown, [...new Set(missingFromIssues)], "top");
+        if (suggestion) lines.push(suggestion);
+        lines.push(`    Schema allows ONLY these props: ${v.allowedProps.join(", ")}.`);
+        if (v.contentType === "metric_card_pulse") {
+          lines.push(
+            `    Do NOT use: \`valueField\`, \`valuePath\`, \`dataField\`, \`value\`. The correct prop is \`field\` (dot-path into the collection).`
+          );
+        }
+      } else {
+        for (const issue of v.issues) {
+          lines.push(`    ${issue.path.join(".")}: ${issue.message}`);
+        }
+        lines.push(`    Schema allows ONLY these props: ${v.allowedProps.join(", ")}.`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push(
+    "After fixing ALL violations above, re-call stackwright_pro_validate_artifact with the corrected artifact."
+  );
+  return lines.join("\n");
+}
+
 // src/tools/pipeline.ts
 var import_types3 = require("@stackwright-pro/types");
 
@@ -2359,7 +2561,7 @@ var import_types2 = require("@stackwright-pro/types");
 
 // src/tools/validate-yaml-fragment.ts
 var import_zod11 = require("zod");
-var import_js_yaml = require("js-yaml");
+var import_js_yaml2 = require("js-yaml");
 var import_types = require("@stackwright-pro/types");
 var SUPPORTED_SCHEMA_NAMES = [
   "workflow_step",
@@ -2461,7 +2663,7 @@ function handleValidateYamlFragment(input) {
   const name = schemaName;
   let parsed;
   try {
-    parsed = (0, import_js_yaml.load)(yaml3);
+    parsed = (0, import_js_yaml2.load)(yaml3);
   } catch (err) {
     return {
       valid: false,
@@ -2688,8 +2890,8 @@ function registerGetSchemaTool(server2) {
 }
 
 // src/tools/pipeline-graph.ts
-var import_fs5 = require("fs");
-var import_path5 = require("path");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
 var MANIFEST_NAME_TO_PHASE = {
   "stackwright-pro-designer-otter": "designer",
   "stackwright-pro-theme-otter": "theme",
@@ -2718,10 +2920,10 @@ var OTTER_SEARCH_PATHS = [
 ];
 function resolveOtterDirFromCwd() {
   const cwd = process.cwd();
-  for (const relative of OTTER_SEARCH_PATHS) {
-    const candidate = (0, import_path5.join)(cwd, relative);
+  for (const relative2 of OTTER_SEARCH_PATHS) {
+    const candidate = (0, import_path6.join)(cwd, relative2);
     try {
-      (0, import_fs5.lstatSync)(candidate);
+      (0, import_fs6.lstatSync)(candidate);
       return candidate;
     } catch {
     }
@@ -2731,14 +2933,14 @@ function resolveOtterDirFromCwd() {
   );
 }
 function loadOtterManifestsFromDir(otterDir) {
-  const entries = (0, import_fs5.readdirSync)(otterDir);
+  const entries = (0, import_fs6.readdirSync)(otterDir);
   const manifests = [];
   for (const filename of entries) {
     if (!filename.endsWith("-otter.json")) continue;
-    const filePath = (0, import_path5.join)(otterDir, filename);
-    if ((0, import_fs5.lstatSync)(filePath).isSymbolicLink()) continue;
+    const filePath = (0, import_path6.join)(otterDir, filename);
+    if ((0, import_fs6.lstatSync)(filePath).isSymbolicLink()) continue;
     try {
-      const raw = (0, import_fs5.readFileSync)(filePath, "utf-8");
+      const raw = (0, import_fs6.readFileSync)(filePath, "utf-8");
       const manifest = JSON.parse(raw);
       manifests.push(manifest);
     } catch (err) {
@@ -2843,19 +3045,19 @@ var DISTRIBUTED_NAMESPACES = ["@stackwright-pro", "@stackwright"];
 function loadDistributedOtterManifests(cwd) {
   const results = [];
   for (const namespace of DISTRIBUTED_NAMESPACES) {
-    const nsDir = (0, import_path5.join)(cwd, "node_modules", namespace);
+    const nsDir = (0, import_path6.join)(cwd, "node_modules", namespace);
     let pkgDirNames;
     try {
-      pkgDirNames = (0, import_fs5.readdirSync)(nsDir);
+      pkgDirNames = (0, import_fs6.readdirSync)(nsDir);
     } catch {
       continue;
     }
     for (const pkgDirName of pkgDirNames) {
-      const pkgDir = (0, import_path5.join)(nsDir, pkgDirName);
+      const pkgDir = (0, import_path6.join)(nsDir, pkgDirName);
       const packageName = `${namespace}/${pkgDirName}`;
       let otterRelPaths;
       try {
-        const raw = (0, import_fs5.readFileSync)((0, import_path5.join)(pkgDir, "package.json"), "utf-8");
+        const raw = (0, import_fs6.readFileSync)((0, import_path6.join)(pkgDir, "package.json"), "utf-8");
         const pkgJson = JSON.parse(raw);
         const declared = pkgJson.stackwright?.otters;
         if (!Array.isArray(declared) || declared.length === 0) continue;
@@ -2864,9 +3066,9 @@ function loadDistributedOtterManifests(cwd) {
         continue;
       }
       for (const relPath of otterRelPaths) {
-        const otterFilePath = (0, import_path5.join)(pkgDir, relPath);
+        const otterFilePath = (0, import_path6.join)(pkgDir, relPath);
         try {
-          const raw = (0, import_fs5.readFileSync)(otterFilePath, "utf-8");
+          const raw = (0, import_fs6.readFileSync)(otterFilePath, "utf-8");
           const manifest = JSON.parse(raw);
           results.push({ manifest, packageName });
         } catch (err) {
@@ -2907,6 +3109,7 @@ function loadPipelineGraph() {
 
 // src/tools/pipeline.ts
 var import_telemetry = require("@stackwright-pro/telemetry");
+var PULSE_CONTENT_PHASES = /* @__PURE__ */ new Set(["pages", "dashboard", "geo", "workflow"]);
 var PHASE_ORDER = [
   "designer",
   "theme",
@@ -2983,11 +3186,11 @@ function createDefaultState() {
   };
 }
 function statePath(cwd) {
-  return (0, import_path6.join)(cwd, ".stackwright", "pipeline-state.json");
+  return (0, import_path7.join)(cwd, ".stackwright", "pipeline-state.json");
 }
 function readState(cwd) {
   const p = statePath(cwd);
-  if (!(0, import_fs6.existsSync)(p)) return createDefaultState();
+  if (!(0, import_fs7.existsSync)(p)) return createDefaultState();
   const raw = JSON.parse(safeReadSync(p));
   if (typeof raw !== "object" || raw === null || raw.version !== "1.0") {
     return createDefaultState();
@@ -2995,34 +3198,34 @@ function readState(cwd) {
   return raw;
 }
 function safeWriteSync(filePath, content) {
-  if ((0, import_fs6.existsSync)(filePath)) {
-    const stat = (0, import_fs6.lstatSync)(filePath);
+  if ((0, import_fs7.existsSync)(filePath)) {
+    const stat = (0, import_fs7.lstatSync)(filePath);
     if (stat.isSymbolicLink()) {
       throw new Error(`Refusing to write to symlink: ${filePath}`);
     }
   }
-  (0, import_fs6.writeFileSync)(filePath, content);
+  (0, import_fs7.writeFileSync)(filePath, content);
 }
 function safeReadSync(filePath) {
-  if ((0, import_fs6.existsSync)(filePath)) {
-    const stat = (0, import_fs6.lstatSync)(filePath);
+  if ((0, import_fs7.existsSync)(filePath)) {
+    const stat = (0, import_fs7.lstatSync)(filePath);
     if (stat.isSymbolicLink()) {
       throw new Error(`Refusing to read symlink: ${filePath}`);
     }
   }
-  return (0, import_fs6.readFileSync)(filePath, "utf-8");
+  return (0, import_fs7.readFileSync)(filePath, "utf-8");
 }
 function writeState(cwd, state) {
-  const dir = (0, import_path6.join)(cwd, ".stackwright");
-  (0, import_fs6.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path7.join)(cwd, ".stackwright");
+  (0, import_fs7.mkdirSync)(dir, { recursive: true });
   state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   safeWriteSync(statePath(cwd), JSON.stringify(state, null, 2) + "\n");
 }
 function updateStateAtomic(cwd, mutator) {
-  const dir = (0, import_path6.join)(cwd, ".stackwright");
-  (0, import_fs6.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path7.join)(cwd, ".stackwright");
+  (0, import_fs7.mkdirSync)(dir, { recursive: true });
   const path5 = statePath(cwd);
-  if (!(0, import_fs6.existsSync)(path5)) {
+  if (!(0, import_fs7.existsSync)(path5)) {
     safeWriteSync(path5, JSON.stringify(createDefaultState(), null, 2) + "\n");
   }
   const release = (0, import_proper_lockfile.lockSync)(path5, {
@@ -3056,8 +3259,8 @@ function handleGetPipelineState(_cwd) {
   const cwd = _cwd ?? process.cwd();
   try {
     const state = readState(cwd);
-    const keyPath = (0, import_path6.join)(cwd, ".stackwright", "pipeline-keys.json");
-    if (!(0, import_fs6.existsSync)(keyPath)) {
+    const keyPath = (0, import_path7.join)(cwd, ".stackwright", "pipeline-keys.json");
+    if (!(0, import_fs7.existsSync)(keyPath)) {
       try {
         const { fingerprint } = initPipelineKeys(cwd);
         state["signingKeyFingerprint"] = fingerprint;
@@ -3188,8 +3391,8 @@ function handleCheckExecutionReady(_cwd, phase) {
         isError: true
       };
     }
-    const answerFile = (0, import_path6.join)(cwd, ".stackwright", "answers", `${phase}.json`);
-    if (!(0, import_fs6.existsSync)(answerFile)) {
+    const answerFile = (0, import_path7.join)(cwd, ".stackwright", "answers", `${phase}.json`);
+    if (!(0, import_fs7.existsSync)(answerFile)) {
       return {
         text: JSON.stringify({ ready: false, phase, reason: "Answer file not found" }),
         isError: false
@@ -3213,12 +3416,12 @@ function handleCheckExecutionReady(_cwd, phase) {
     }
   }
   try {
-    const answersDir = (0, import_path6.join)(cwd, ".stackwright", "answers");
+    const answersDir = (0, import_path7.join)(cwd, ".stackwright", "answers");
     const answeredPhases = [];
     const missingPhases = [];
     for (const phase2 of PHASE_ORDER) {
-      const answerFile = (0, import_path6.join)(answersDir, `${phase2}.json`);
-      if ((0, import_fs6.existsSync)(answerFile)) {
+      const answerFile = (0, import_path7.join)(answersDir, `${phase2}.json`);
+      if ((0, import_fs7.existsSync)(answerFile)) {
         try {
           const raw = safeReadSync(answerFile);
           const parsed = JSON.parse(raw);
@@ -3287,7 +3490,7 @@ function handleGetReadyPhases(_cwd) {
 function handleListArtifacts(_cwd) {
   const cwd = _cwd ?? process.cwd();
   try {
-    const artifactsDir = (0, import_path6.join)(cwd, ".stackwright", "artifacts");
+    const artifactsDir = (0, import_path7.join)(cwd, ".stackwright", "artifacts");
     let manifest = null;
     try {
       manifest = loadSignatureManifest(cwd);
@@ -3297,8 +3500,8 @@ function handleListArtifacts(_cwd) {
     let completedCount = 0;
     for (const phase of PHASE_ORDER) {
       const expectedFile = PHASE_ARTIFACT[phase];
-      const fullPath = (0, import_path6.join)(artifactsDir, expectedFile);
-      const exists = (0, import_fs6.existsSync)(fullPath);
+      const fullPath = (0, import_path7.join)(artifactsDir, expectedFile);
+      const exists = (0, import_fs7.existsSync)(fullPath);
       if (exists) completedCount++;
       let signed = false;
       let signatureValid = null;
@@ -3351,9 +3554,9 @@ function handleWritePhaseQuestions(input) {
       }
     } catch {
     }
-    const questionsDir = (0, import_path6.join)(cwd, ".stackwright", "questions");
-    (0, import_fs6.mkdirSync)(questionsDir, { recursive: true });
-    const filePath = (0, import_path6.join)(questionsDir, `${phase}.json`);
+    const questionsDir = (0, import_path7.join)(cwd, ".stackwright", "questions");
+    (0, import_fs7.mkdirSync)(questionsDir, { recursive: true });
+    const filePath = (0, import_path7.join)(questionsDir, `${phase}.json`);
     const payload = {
       version: "1.0",
       phase,
@@ -3393,14 +3596,14 @@ function handleBuildSpecialistPrompt(input) {
     };
   }
   try {
-    const answersPath = (0, import_path6.join)(cwd, ".stackwright", "answers", `${phase}.json`);
+    const answersPath = (0, import_path7.join)(cwd, ".stackwright", "answers", `${phase}.json`);
     let answers = {};
-    if ((0, import_fs6.existsSync)(answersPath)) {
+    if ((0, import_fs7.existsSync)(answersPath)) {
       answers = JSON.parse(safeReadSync(answersPath));
     }
     let buildContextText = "";
-    const buildContextPath = (0, import_path6.join)(cwd, ".stackwright", "build-context.json");
-    if ((0, import_fs6.existsSync)(buildContextPath)) {
+    const buildContextPath = (0, import_path7.join)(cwd, ".stackwright", "build-context.json");
+    if ((0, import_fs7.existsSync)(buildContextPath)) {
       try {
         const bcRaw = JSON.parse(safeReadSync(buildContextPath));
         if (typeof bcRaw.buildContext === "string" && bcRaw.buildContext.trim().length > 0) {
@@ -3415,8 +3618,8 @@ function handleBuildSpecialistPrompt(input) {
     const missingDependencies = [];
     for (const dep of deps) {
       const artifactFile = PHASE_ARTIFACT[dep];
-      const artifactPath = (0, import_path6.join)(cwd, ".stackwright", "artifacts", artifactFile);
-      if ((0, import_fs6.existsSync)(artifactPath)) {
+      const artifactPath = (0, import_path7.join)(cwd, ".stackwright", "artifacts", artifactFile);
+      if ((0, import_fs7.existsSync)(artifactPath)) {
         const rawContent = safeReadSync(artifactPath);
         const rawBytes = Buffer.from(rawContent, "utf-8");
         const content = JSON.parse(rawContent);
@@ -3481,8 +3684,8 @@ ${JSON.stringify(content, null, 2)}`
       parts.push("BUILD_CONTEXT:", buildContextText, "");
     }
     if (phase === "auth") {
-      const initContextPath = (0, import_path6.join)(cwd, ".stackwright", "init-context.json");
-      if ((0, import_fs6.existsSync)(initContextPath)) {
+      const initContextPath = (0, import_path7.join)(cwd, ".stackwright", "init-context.json");
+      if ((0, import_fs7.existsSync)(initContextPath)) {
         try {
           const initContext = JSON.parse(safeReadSync(initContextPath));
           if (initContext.devOnly === true || initContext.nonInteractive === true) {
@@ -3987,13 +4190,13 @@ function _validateArtifactInner(input) {
     // to a flow or state-machine in this services-config artifact.
     // Skips gracefully when wizard-otter didn't run (Pro-only install) or declared no hooks.
     services: (artifact2) => {
-      const workflowArtifactPath = (0, import_path6.join)(cwd, ".stackwright", "artifacts", "workflow-config.json");
-      if (!(0, import_fs6.existsSync)(workflowArtifactPath)) {
+      const workflowArtifactPath = (0, import_path7.join)(cwd, ".stackwright", "artifacts", "workflow-config.json");
+      if (!(0, import_fs7.existsSync)(workflowArtifactPath)) {
         return { success: true };
       }
       let workflowArtifact;
       try {
-        workflowArtifact = JSON.parse((0, import_fs6.readFileSync)(workflowArtifactPath, "utf-8"));
+        workflowArtifact = JSON.parse((0, import_fs7.readFileSync)(workflowArtifactPath, "utf-8"));
       } catch {
         return { success: true };
       }
@@ -4063,11 +4266,23 @@ function _validateArtifactInner(input) {
       return { text: JSON.stringify(result), isError: false };
     }
   }
+  if (PULSE_CONTENT_PHASES.has(phase)) {
+    const pulseResult = validatePulseContent(cwd);
+    if (!pulseResult.valid) {
+      const result = {
+        valid: false,
+        phase,
+        violation: "schema-mismatch",
+        retryPrompt: formatPulseRetryPrompt(pulseResult)
+      };
+      return { text: JSON.stringify(result), isError: false };
+    }
+  }
   try {
-    const artifactsDir = (0, import_path6.join)(cwd, ".stackwright", "artifacts");
-    (0, import_fs6.mkdirSync)(artifactsDir, { recursive: true });
+    const artifactsDir = (0, import_path7.join)(cwd, ".stackwright", "artifacts");
+    (0, import_fs7.mkdirSync)(artifactsDir, { recursive: true });
     const artifactFile = phase === "api" && input.integrationName ? `api-config-${input.integrationName}.json` : PHASE_ARTIFACT[phase];
-    const artifactPath = (0, import_path6.join)(artifactsDir, artifactFile);
+    const artifactPath = (0, import_path7.join)(artifactsDir, artifactFile);
     const serialized = JSON.stringify(artifact, null, 2) + "\n";
     const artifactBytes = Buffer.from(serialized, "utf-8");
     safeWriteSync(artifactPath, serialized);
@@ -4286,10 +4501,10 @@ function registerPipelineTools(server2) {
             isError: true
           };
         }
-        const questionsDir = (0, import_path6.join)(process.cwd(), ".stackwright", "questions");
-        (0, import_fs6.mkdirSync)(questionsDir, { recursive: true });
-        const outPath = (0, import_path6.join)(questionsDir, `${phase}.json`);
-        (0, import_fs6.writeFileSync)(
+        const questionsDir = (0, import_path7.join)(process.cwd(), ".stackwright", "questions");
+        (0, import_fs7.mkdirSync)(questionsDir, { recursive: true });
+        const outPath = (0, import_path7.join)(questionsDir, `${phase}.json`);
+        (0, import_fs7.writeFileSync)(
           outPath,
           JSON.stringify({ phase, questions, writtenAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)
         );
@@ -4376,8 +4591,8 @@ function registerPipelineTools(server2) {
 
 // src/tools/safe-write.ts
 var import_zod14 = require("zod");
-var import_fs7 = require("fs");
-var import_path7 = require("path");
+var import_fs8 = require("fs");
+var import_path8 = require("path");
 var import_telemetry2 = require("@stackwright-pro/telemetry");
 var OTTER_WRITE_ALLOWLISTS = {
   "stackwright-pro-designer-otter": [
@@ -4543,7 +4758,7 @@ function getMaxBytesForPath(filePath) {
 }
 var PAGE_REGISTRY_FILE = ".stackwright/page-registry.json";
 function extractPageSlug(filePath) {
-  const match = (0, import_path7.normalize)(filePath).match(/^pages\/(.+?)\/content\.ya?ml$/);
+  const match = (0, import_path8.normalize)(filePath).match(/^pages\/(.+?)\/content\.ya?ml$/);
   return match?.[1] ?? null;
 }
 function extractContentTypes(yamlContent) {
@@ -4559,27 +4774,27 @@ function extractContentTypes(yamlContent) {
   return types.length > 0 ? types : ["unknown"];
 }
 function readPageRegistry(cwd) {
-  const regPath = (0, import_path7.join)(cwd, PAGE_REGISTRY_FILE);
-  if (!(0, import_fs7.existsSync)(regPath)) return {};
+  const regPath = (0, import_path8.join)(cwd, PAGE_REGISTRY_FILE);
+  if (!(0, import_fs8.existsSync)(regPath)) return {};
   try {
-    const stat = (0, import_fs7.lstatSync)(regPath);
+    const stat = (0, import_fs8.lstatSync)(regPath);
     if (stat.isSymbolicLink()) return {};
-    return JSON.parse((0, import_fs7.readFileSync)(regPath, "utf-8"));
+    return JSON.parse((0, import_fs8.readFileSync)(regPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function writePageRegistry(cwd, registry) {
-  const dir = (0, import_path7.join)(cwd, ".stackwright");
-  (0, import_fs7.mkdirSync)(dir, { recursive: true });
-  const regPath = (0, import_path7.join)(cwd, PAGE_REGISTRY_FILE);
-  if ((0, import_fs7.existsSync)(regPath)) {
-    const stat = (0, import_fs7.lstatSync)(regPath);
+  const dir = (0, import_path8.join)(cwd, ".stackwright");
+  (0, import_fs8.mkdirSync)(dir, { recursive: true });
+  const regPath = (0, import_path8.join)(cwd, PAGE_REGISTRY_FILE);
+  if ((0, import_fs8.existsSync)(regPath)) {
+    const stat = (0, import_fs8.lstatSync)(regPath);
     if (stat.isSymbolicLink()) {
       throw new Error("Refusing to write page registry through symlink");
     }
   }
-  (0, import_fs7.writeFileSync)(regPath, JSON.stringify(registry, null, 2) + "\n", { encoding: "utf-8" });
+  (0, import_fs8.writeFileSync)(regPath, JSON.stringify(registry, null, 2) + "\n", { encoding: "utf-8" });
 }
 function checkPageOwnership(cwd, slug, callerOtter) {
   const registry = readPageRegistry(cwd);
@@ -4598,11 +4813,11 @@ function stripNextjsBracketSegments(path5) {
   return path5.replace(NEXTJS_BRACKET_SEGMENT_RE, "");
 }
 function checkPathAllowed(callerOtter, filePath) {
-  const normalized = (0, import_path7.normalize)(filePath);
+  const normalized = (0, import_path8.normalize)(filePath);
   if (stripNextjsBracketSegments(normalized).includes("..")) {
     return { allowed: false, error: 'Path traversal detected: ".." segments are not allowed' };
   }
-  if ((0, import_path7.isAbsolute)(normalized)) {
+  if ((0, import_path8.isAbsolute)(normalized)) {
     return {
       allowed: false,
       error: "Absolute paths are not allowed \u2014 use paths relative to project root"
@@ -4744,11 +4959,11 @@ function _safeWriteInner(input) {
     };
     return { text: JSON.stringify(result), isError: true };
   }
-  const normalized = (0, import_path7.normalize)(filePath);
-  const fullPath = (0, import_path7.join)(cwd, normalized);
-  if ((0, import_fs7.existsSync)(fullPath)) {
+  const normalized = (0, import_path8.normalize)(filePath);
+  const fullPath = (0, import_path8.join)(cwd, normalized);
+  if ((0, import_fs8.existsSync)(fullPath)) {
     try {
-      const stat = (0, import_fs7.lstatSync)(fullPath);
+      const stat = (0, import_fs8.lstatSync)(fullPath);
       if (stat.isSymbolicLink()) {
         const result = {
           success: false,
@@ -4789,9 +5004,9 @@ function _safeWriteInner(input) {
   }
   try {
     if (createDirectories) {
-      (0, import_fs7.mkdirSync)((0, import_path7.dirname)(fullPath), { recursive: true });
+      (0, import_fs8.mkdirSync)((0, import_path8.dirname)(fullPath), { recursive: true });
     }
-    (0, import_fs7.writeFileSync)(fullPath, content, { encoding: "utf-8" });
+    (0, import_fs8.writeFileSync)(fullPath, content, { encoding: "utf-8" });
     if (pageSlug) {
       try {
         const registry = readPageRegistry(cwd);
@@ -4876,8 +5091,8 @@ function registerSafeWriteTools(server2) {
 
 // src/tools/auth.ts
 var import_zod15 = require("zod");
-var import_fs8 = require("fs");
-var import_path8 = require("path");
+var import_fs9 = require("fs");
+var import_path9 = require("path");
 function buildHierarchy(roles) {
   const h = {};
   for (let i = 0; i < roles.length - 1; i++) {
@@ -4904,9 +5119,9 @@ ${indent}  requiredRole: ${r.requiredRole}`).join("\n");
 }
 function detectNextMajorVersion(cwd) {
   try {
-    const pkgPath = (0, import_path8.join)(cwd, "package.json");
-    if (!(0, import_fs8.existsSync)(pkgPath)) return null;
-    const pkg = JSON.parse((0, import_fs8.readFileSync)(pkgPath, "utf8"));
+    const pkgPath = (0, import_path9.join)(cwd, "package.json");
+    if (!(0, import_fs9.existsSync)(pkgPath)) return null;
+    const pkg = JSON.parse((0, import_fs9.readFileSync)(pkgPath, "utf8"));
     const nextVersion = pkg.dependencies?.next ?? pkg.devDependencies?.next;
     if (!nextVersion) return null;
     const match = nextVersion.match(/(\d+)/);
@@ -5570,7 +5785,7 @@ async function configureAuthHandler(params, cwd) {
       auditRetentionDays,
       normalizedRoutes
     );
-    (0, import_fs8.writeFileSync)((0, import_path8.join)(cwd, conventionFile), authFileContent, "utf8");
+    (0, import_fs9.writeFileSync)((0, import_path9.join)(cwd, conventionFile), authFileContent, "utf8");
     filesWritten.push(conventionFile);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -5590,12 +5805,12 @@ async function configureAuthHandler(params, cwd) {
   if (!devOnly) {
     try {
       const envBlock = generateEnvBlock(effectiveMethod, params);
-      const envPath = (0, import_path8.join)(cwd, ".env.example");
-      if ((0, import_fs8.existsSync)(envPath)) {
-        const existing = (0, import_fs8.readFileSync)(envPath, "utf8");
-        (0, import_fs8.writeFileSync)(envPath, existing.trimEnd() + "\n\n" + envBlock, "utf8");
+      const envPath = (0, import_path9.join)(cwd, ".env.example");
+      if ((0, import_fs9.existsSync)(envPath)) {
+        const existing = (0, import_fs9.readFileSync)(envPath, "utf8");
+        (0, import_fs9.writeFileSync)(envPath, existing.trimEnd() + "\n\n" + envBlock, "utf8");
       } else {
-        (0, import_fs8.writeFileSync)(envPath, envBlock, "utf8");
+        (0, import_fs9.writeFileSync)(envPath, envBlock, "utf8");
       }
       filesWritten.push(".env.example");
     } catch (err) {
@@ -5613,10 +5828,10 @@ async function configureAuthHandler(params, cwd) {
   }
   if (devOnly) {
     try {
-      const mockAuthDir = (0, import_path8.join)(cwd, "lib");
-      (0, import_fs8.mkdirSync)(mockAuthDir, { recursive: true });
+      const mockAuthDir = (0, import_path9.join)(cwd, "lib");
+      (0, import_fs9.mkdirSync)(mockAuthDir, { recursive: true });
       const mockAuthContent = generateMockAuthContent(roles, mockUsers);
-      (0, import_fs8.writeFileSync)((0, import_path8.join)(mockAuthDir, "mock-auth.ts"), mockAuthContent, "utf8");
+      (0, import_fs9.writeFileSync)((0, import_path9.join)(mockAuthDir, "mock-auth.ts"), mockAuthContent, "utf8");
       filesWritten.push("lib/mock-auth.ts");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -5634,11 +5849,11 @@ async function configureAuthHandler(params, cwd) {
       };
     }
     try {
-      const pkgPath = (0, import_path8.join)(cwd, "package.json");
-      if ((0, import_fs8.existsSync)(pkgPath)) {
-        const existingPkg = (0, import_fs8.readFileSync)(pkgPath, "utf8");
+      const pkgPath = (0, import_path9.join)(cwd, "package.json");
+      if ((0, import_fs9.existsSync)(pkgPath)) {
+        const existingPkg = (0, import_fs9.readFileSync)(pkgPath, "utf8");
         const updatedPkg = updatePackageJsonScripts(existingPkg, roles, mockUsers);
-        (0, import_fs8.writeFileSync)(pkgPath, updatedPkg, "utf8");
+        (0, import_fs9.writeFileSync)(pkgPath, updatedPkg, "utf8");
         filesWritten.push("package.json");
       }
     } catch (err) {
@@ -5679,7 +5894,7 @@ async function configureAuthHandler(params, cwd) {
       normalizedRoutes,
       useProxy
     );
-    (0, import_fs8.writeFileSync)((0, import_path8.join)(cwd, "stackwright.auth.yml"), authYaml, "utf8");
+    (0, import_fs9.writeFileSync)((0, import_path9.join)(cwd, "stackwright.auth.yml"), authYaml, "utf8");
     filesWritten.push("stackwright.auth.yml");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -5792,8 +6007,8 @@ function registerAuthTools(server2) {
 
 // src/integrity.ts
 var import_crypto4 = require("crypto");
-var import_fs9 = require("fs");
-var import_path9 = require("path");
+var import_fs10 = require("fs");
+var import_path10 = require("path");
 var _checksums = /* @__PURE__ */ new Map([
   [
     "stackwright-pro-api-otter.json",
@@ -5876,14 +6091,14 @@ function safeEqual(a, b) {
   return (0, import_crypto4.timingSafeEqual)(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
 }
 function verifyOtterFile(filePath) {
-  const filename = (0, import_path9.basename)(filePath);
+  const filename = (0, import_path10.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_fs9.lstatSync)(filePath);
+    stat = (0, import_fs10.lstatSync)(filePath);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { verified: false, filename, error: `Cannot stat file: ${msg}` };
@@ -5901,7 +6116,7 @@ function verifyOtterFile(filePath) {
   }
   let raw;
   try {
-    raw = (0, import_fs9.readFileSync)(filePath);
+    raw = (0, import_fs10.readFileSync)(filePath);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { verified: false, filename, error: `Cannot read file: ${msg}` };
@@ -5951,7 +6166,7 @@ function verifyAllOtters(otterDir) {
   const unknown = [];
   let entries;
   try {
-    entries = (0, import_fs9.readdirSync)(otterDir);
+    entries = (0, import_fs10.readdirSync)(otterDir);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return {
@@ -5962,9 +6177,9 @@ function verifyAllOtters(otterDir) {
   }
   const otterFiles = entries.filter((f) => f.endsWith("-otter.json"));
   for (const filename of otterFiles) {
-    const filePath = (0, import_path9.join)(otterDir, filename);
+    const filePath = (0, import_path10.join)(otterDir, filename);
     try {
-      if ((0, import_fs9.lstatSync)(filePath).isSymbolicLink()) {
+      if ((0, import_fs10.lstatSync)(filePath).isSymbolicLink()) {
         failed.push({ filename, error: "Skipped: symlink" });
         continue;
       }
@@ -5989,10 +6204,10 @@ function verifyAllOtters(otterDir) {
 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_path9.join)(cwd, relative);
+  for (const relative2 of DEFAULT_SEARCH_PATHS) {
+    const candidate = (0, import_path10.join)(cwd, relative2);
     try {
-      (0, import_fs9.lstatSync)(candidate);
+      (0, import_fs10.lstatSync)(candidate);
       return candidate;
     } catch {
     }
@@ -6071,13 +6286,13 @@ function registerIntegrityTools(server2) {
 
 // src/tools/domain.ts
 var import_zod16 = require("zod");
-var import_fs10 = require("fs");
-var import_path10 = require("path");
+var import_fs11 = require("fs");
+var import_path11 = require("path");
 function handleListCollections(input) {
   const cwd = input._cwd ?? process.cwd();
   const sources = [
     {
-      path: (0, import_path10.join)(cwd, ".stackwright", "artifacts", "data-config.json"),
+      path: (0, import_path11.join)(cwd, ".stackwright", "artifacts", "data-config.json"),
       source: "data-config.json",
       parse: (raw) => {
         const parsed = JSON.parse(raw);
@@ -6088,15 +6303,15 @@ function handleListCollections(input) {
       }
     },
     {
-      path: (0, import_path10.join)(cwd, "stackwright.yml"),
+      path: (0, import_path11.join)(cwd, "stackwright.yml"),
       source: "stackwright.yml",
       parse: extractCollectionsFromYaml
     }
   ];
   for (const { path: path5, source, parse } of sources) {
-    if (!(0, import_fs10.existsSync)(path5)) continue;
+    if (!(0, import_fs11.existsSync)(path5)) continue;
     try {
-      const collections = parse((0, import_fs10.readFileSync)(path5, "utf8"));
+      const collections = parse((0, import_fs11.readFileSync)(path5, "utf8"));
       return {
         text: JSON.stringify({ collections, source, collectionCount: collections.length }),
         isError: false
@@ -6247,8 +6462,8 @@ function handleValidateWorkflow(input) {
   if (input.workflow && Object.keys(input.workflow).length > 0) {
     raw = input.workflow;
   } else {
-    const artifactPath = (0, import_path10.join)(cwd, ".stackwright", "artifacts", "workflow-config.json");
-    if (!(0, import_fs10.existsSync)(artifactPath)) {
+    const artifactPath = (0, import_path11.join)(cwd, ".stackwright", "artifacts", "workflow-config.json");
+    if (!(0, import_fs11.existsSync)(artifactPath)) {
       return fail([
         {
           code: "NO_WORKFLOW",
@@ -6257,7 +6472,7 @@ function handleValidateWorkflow(input) {
       ]);
     }
     try {
-      raw = JSON.parse((0, import_fs10.readFileSync)(artifactPath, "utf8"));
+      raw = JSON.parse((0, import_fs11.readFileSync)(artifactPath, "utf8"));
     } catch (err) {
       return fail([{ code: "INVALID_JSON", message: `Failed to parse workflow artifact: ${err}` }]);
     }
@@ -6569,7 +6784,7 @@ var fs2 = __toESM(require("fs"));
 var os = __toESM(require("os"));
 var path3 = __toESM(require("path"));
 var import_zod18 = require("zod");
-var import_js_yaml2 = require("js-yaml");
+var import_js_yaml3 = require("js-yaml");
 var import_cli = require("@stackwright/cli");
 var import_types4 = require("@stackwright-pro/types");
 var BCP47_RE = /^[a-z]{2}(-[A-Z]{2})?$/;
@@ -6623,7 +6838,7 @@ function handleProWritePage(input) {
   }
   let parsed;
   try {
-    parsed = (0, import_js_yaml2.load)(content);
+    parsed = (0, import_js_yaml3.load)(content);
   } catch (err) {
     return {
       isError: true,
@@ -6637,7 +6852,7 @@ function handleProWritePage(input) {
   }
   const clone = JSON.parse(JSON.stringify(parsed));
   const sanitized = sanitizeNode(clone);
-  const sanitizedYaml = (0, import_js_yaml2.dump)(sanitized);
+  const sanitizedYaml = (0, import_js_yaml3.dump)(sanitized);
   const tmpDir = fs2.mkdtempSync(path3.join(os.tmpdir(), "sw-pro-validate-"));
   try {
     (0, import_cli.writePage)(path3.join(tmpDir, "pages"), "__validation__", sanitizedYaml);
@@ -6694,8 +6909,8 @@ function registerProPageTools(server2) {
 }
 
 // src/tools/scaffold-cleanup.ts
-var import_fs11 = require("fs");
-var import_path11 = require("path");
+var import_fs12 = require("fs");
+var import_path12 = require("path");
 var SCAFFOLD_FILES_TO_DELETE = [
   "content/posts/getting-started.yaml",
   "content/posts/hello-world.yaml"
@@ -6720,12 +6935,12 @@ var FALLBACK_COLORS = {
   mutedForeground: "#737373"
 };
 function readThemeColors(cwd) {
-  const tokenPath = (0, import_path11.join)(cwd, ".stackwright", "artifacts", "theme-tokens.json");
-  if (!(0, import_fs11.existsSync)(tokenPath)) return { ...FALLBACK_COLORS };
-  const stat = (0, import_fs11.lstatSync)(tokenPath);
+  const tokenPath = (0, import_path12.join)(cwd, ".stackwright", "artifacts", "theme-tokens.json");
+  if (!(0, import_fs12.existsSync)(tokenPath)) return { ...FALLBACK_COLORS };
+  const stat = (0, import_fs12.lstatSync)(tokenPath);
   if (stat.isSymbolicLink()) return { ...FALLBACK_COLORS };
   try {
-    const raw = JSON.parse((0, import_fs11.readFileSync)(tokenPath, "utf-8"));
+    const raw = JSON.parse((0, import_fs12.readFileSync)(tokenPath, "utf-8"));
     const css = raw?.cssVariables ?? {};
     const toHsl = (hslValue) => {
       if (!hslValue || typeof hslValue !== "string") return null;
@@ -6785,15 +7000,15 @@ function generateNotFoundPage(colors) {
 `;
 }
 function isSafePath(fullPath) {
-  if (!(0, import_fs11.existsSync)(fullPath)) return true;
-  const stat = (0, import_fs11.lstatSync)(fullPath);
+  if (!(0, import_fs12.existsSync)(fullPath)) return true;
+  const stat = (0, import_fs12.lstatSync)(fullPath);
   return !stat.isSymbolicLink();
 }
 function isDirEmpty(dirPath) {
-  if (!(0, import_fs11.existsSync)(dirPath)) return false;
-  const stat = (0, import_fs11.lstatSync)(dirPath);
+  if (!(0, import_fs12.existsSync)(dirPath)) return false;
+  const stat = (0, import_fs12.lstatSync)(dirPath);
   if (!stat.isDirectory()) return false;
-  return (0, import_fs11.readdirSync)(dirPath).length === 0;
+  return (0, import_fs12.readdirSync)(dirPath).length === 0;
 }
 function handleCleanupScaffold(_cwd) {
   const cwd = _cwd ?? process.cwd();
@@ -6806,8 +7021,8 @@ function handleCleanupScaffold(_cwd) {
     cleanupWarnings: []
   };
   for (const relPath of SCAFFOLD_FILES_TO_DELETE) {
-    const fullPath = (0, import_path11.join)(cwd, relPath);
-    if (!(0, import_fs11.existsSync)(fullPath)) {
+    const fullPath = (0, import_path12.join)(cwd, relPath);
+    if (!(0, import_fs12.existsSync)(fullPath)) {
       result.skipped.push(relPath);
       continue;
     }
@@ -6816,7 +7031,7 @@ function handleCleanupScaffold(_cwd) {
       continue;
     }
     try {
-      (0, import_fs11.unlinkSync)(fullPath);
+      (0, import_fs12.unlinkSync)(fullPath);
       result.deleted.push(relPath);
     } catch (err) {
       result.errors.push(`Failed to delete ${relPath}: ${String(err)}`);
@@ -6824,19 +7039,19 @@ function handleCleanupScaffold(_cwd) {
   }
   {
     const relPath = "pages/getting-started/content.yml";
-    const fullPath = (0, import_path11.join)(cwd, relPath);
-    if (!(0, import_fs11.existsSync)(fullPath)) {
+    const fullPath = (0, import_path12.join)(cwd, relPath);
+    if (!(0, import_fs12.existsSync)(fullPath)) {
       result.skipped.push(relPath);
     } else if (!isSafePath(fullPath)) {
       result.errors.push(`Refusing to delete symlink: ${relPath}`);
     } else {
-      const content = (0, import_fs11.readFileSync)(fullPath, "utf-8");
+      const content = (0, import_fs12.readFileSync)(fullPath, "utf-8");
       const isScaffoldDefault = GETTING_STARTED_SCAFFOLD_FINGERPRINTS.some(
         (marker) => content.includes(marker)
       );
       if (isScaffoldDefault) {
         try {
-          (0, import_fs11.unlinkSync)(fullPath);
+          (0, import_fs12.unlinkSync)(fullPath);
           result.deleted.push(relPath);
         } catch (err) {
           result.errors.push(`Failed to delete ${relPath}: ${String(err)}`);
@@ -6850,21 +7065,21 @@ function handleCleanupScaffold(_cwd) {
   }
   {
     const relPath = `content/posts/${POSTS_COLLECTION_FILE}`;
-    const fullPath = (0, import_path11.join)(cwd, relPath);
-    const postsDir = (0, import_path11.join)(cwd, "content/posts");
-    if (!(0, import_fs11.existsSync)(fullPath)) {
+    const fullPath = (0, import_path12.join)(cwd, relPath);
+    const postsDir = (0, import_path12.join)(cwd, "content/posts");
+    if (!(0, import_fs12.existsSync)(fullPath)) {
       result.skipped.push(relPath);
     } else if (!isSafePath(fullPath)) {
       result.errors.push(`Refusing to delete symlink: ${relPath}`);
-    } else if (!(0, import_fs11.existsSync)(postsDir)) {
+    } else if (!(0, import_fs12.existsSync)(postsDir)) {
       result.skipped.push(relPath);
     } else {
-      const userPostFiles = (0, import_fs11.readdirSync)(postsDir).filter(
+      const userPostFiles = (0, import_fs12.readdirSync)(postsDir).filter(
         (f) => f !== POSTS_COLLECTION_FILE && POST_FILE_EXTENSIONS.some((ext) => f.endsWith(ext))
       );
       if (userPostFiles.length === 0) {
         try {
-          (0, import_fs11.unlinkSync)(fullPath);
+          (0, import_fs12.unlinkSync)(fullPath);
           result.deleted.push(relPath);
         } catch (err) {
           result.errors.push(`Failed to delete ${relPath}: ${String(err)}`);
@@ -6877,15 +7092,15 @@ function handleCleanupScaffold(_cwd) {
     }
   }
   for (const relDir of SCAFFOLD_DIRS_TO_PRUNE) {
-    const fullDir = (0, import_path11.join)(cwd, relDir);
-    if (!(0, import_fs11.existsSync)(fullDir)) continue;
+    const fullDir = (0, import_path12.join)(cwd, relDir);
+    if (!(0, import_fs12.existsSync)(fullDir)) continue;
     if (!isSafePath(fullDir)) {
       result.errors.push(`Refusing to prune symlink directory: ${relDir}`);
       continue;
     }
     if (isDirEmpty(fullDir)) {
       try {
-        (0, import_fs11.rmdirSync)(fullDir);
+        (0, import_fs12.rmdirSync)(fullDir);
         result.prunedDirs.push(relDir);
       } catch (err) {
         result.errors.push(`Failed to prune directory ${relDir}: ${String(err)}`);
@@ -6893,8 +7108,8 @@ function handleCleanupScaffold(_cwd) {
     }
   }
   {
-    const fullPath = (0, import_path11.join)(cwd, NOT_FOUND_PATH);
-    if (!(0, import_fs11.existsSync)(fullPath)) {
+    const fullPath = (0, import_path12.join)(cwd, NOT_FOUND_PATH);
+    if (!(0, import_fs12.existsSync)(fullPath)) {
       result.skipped.push(NOT_FOUND_PATH);
     } else if (!isSafePath(fullPath)) {
       result.errors.push(`Refusing to rewrite symlink: ${NOT_FOUND_PATH}`);
@@ -6902,9 +7117,9 @@ function handleCleanupScaffold(_cwd) {
       try {
         const colors = readThemeColors(cwd);
         const content = generateNotFoundPage(colors);
-        const dir = (0, import_path11.dirname)(fullPath);
-        (0, import_fs11.mkdirSync)(dir, { recursive: true });
-        (0, import_fs11.writeFileSync)(fullPath, content, "utf-8");
+        const dir = (0, import_path12.dirname)(fullPath);
+        (0, import_fs12.mkdirSync)(dir, { recursive: true });
+        (0, import_fs12.writeFileSync)(fullPath, content, "utf-8");
         result.rewritten.push(NOT_FOUND_PATH);
       } catch (err) {
         result.errors.push(`Failed to rewrite ${NOT_FOUND_PATH}: ${String(err)}`);
@@ -7173,23 +7388,23 @@ function registerContrastTools(server2) {
 
 // src/tools/compile.ts
 var import_zod20 = require("zod");
-var import_fs12 = __toESM(require("fs"));
-var import_path12 = __toESM(require("path"));
+var import_fs13 = __toESM(require("fs"));
+var import_path13 = __toESM(require("path"));
 var import_server = require("@stackwright-pro/pulse/server");
 var import_server2 = require("@stackwright-pro/auth-nextjs/server");
 var import_server3 = require("@stackwright-pro/openapi/server");
 function buildContext(projectRoot) {
   return {
     projectRoot,
-    contentOutDir: import_path12.default.join(projectRoot, "public", "stackwright-content"),
-    imagesDir: import_path12.default.join(projectRoot, "public", "images"),
+    contentOutDir: import_path13.default.join(projectRoot, "public", "stackwright-content"),
+    imagesDir: import_path13.default.join(projectRoot, "public", "images"),
     siteConfig: loadSiteConfig(projectRoot)
   };
 }
 function loadSiteConfig(projectRoot) {
   try {
-    const sitePath = import_path12.default.join(projectRoot, "public", "stackwright-content", "_site.json");
-    return JSON.parse(import_fs12.default.readFileSync(sitePath, "utf8"));
+    const sitePath = import_path13.default.join(projectRoot, "public", "stackwright-content", "_site.json");
+    return JSON.parse(import_fs13.default.readFileSync(sitePath, "utf8"));
   } catch {
     return {};
   }
@@ -7200,8 +7415,8 @@ function formatDuration(startMs) {
 }
 async function tryOssCompile(fn, ctx, extra) {
   try {
-    const bsPath = import_path12.default.join(ctx.projectRoot, "node_modules", "@stackwright", "build-scripts");
-    if (!import_fs12.default.existsSync(bsPath)) {
+    const bsPath = import_path13.default.join(ctx.projectRoot, "node_modules", "@stackwright", "build-scripts");
+    if (!import_fs13.default.existsSync(bsPath)) {
       return {
         ok: false,
         error: `@stackwright/build-scripts not found at ${bsPath}. Is it installed in your project?`
@@ -7415,14 +7630,14 @@ ${results.join("\n")}`;
 
 // src/tools/strip-legacy-integrations.ts
 var import_zod21 = require("zod");
-var import_fs13 = require("fs");
-var import_path13 = require("path");
+var import_fs14 = require("fs");
+var import_path14 = require("path");
 function handleStripLegacyIntegrations(input) {
   const { projectRoot } = input;
-  const ymlPath = (0, import_path13.join)(projectRoot, "stackwright.yml");
-  const yamlPath = (0, import_path13.join)(projectRoot, "stackwright.yaml");
-  if (!(0, import_fs13.existsSync)(ymlPath)) {
-    if ((0, import_fs13.existsSync)(yamlPath)) {
+  const ymlPath = (0, import_path14.join)(projectRoot, "stackwright.yml");
+  const yamlPath = (0, import_path14.join)(projectRoot, "stackwright.yaml");
+  if (!(0, import_fs14.existsSync)(ymlPath)) {
+    if ((0, import_fs14.existsSync)(yamlPath)) {
       return {
         changed: false,
         removedEntries: 0,
@@ -7435,7 +7650,7 @@ function handleStripLegacyIntegrations(input) {
       message: "stackwright.yml not found \u2014 no-op."
     };
   }
-  const raw = (0, import_fs13.readFileSync)(ymlPath, "utf-8");
+  const raw = (0, import_fs14.readFileSync)(ymlPath, "utf-8");
   const isCRLF = raw.includes("\r\n");
   const content = isCRLF ? raw.replace(/\r\n/g, "\n") : raw;
   const lines = content.split("\n");
@@ -7465,7 +7680,7 @@ function handleStripLegacyIntegrations(input) {
     outputContent += "\n";
   }
   const outputRaw = isCRLF ? outputContent.replace(/\n/g, "\r\n") : outputContent;
-  (0, import_fs13.writeFileSync)(ymlPath, outputRaw, "utf-8");
+  (0, import_fs14.writeFileSync)(ymlPath, outputRaw, "utf-8");
   return {
     changed: true,
     removedEntries,
@@ -7490,15 +7705,15 @@ function registerStripLegacyIntegrationsTool(server2) {
 
 // src/tools/emitters.ts
 var import_zod22 = require("zod");
-var import_fs14 = require("fs");
-var import_path14 = require("path");
-var import_js_yaml3 = __toESM(require("js-yaml"));
+var import_fs15 = require("fs");
+var import_path15 = require("path");
+var import_js_yaml4 = __toESM(require("js-yaml"));
 var import_emitters = require("@stackwright-pro/emitters");
 function readIntegrations(cwd) {
-  const filePath = (0, import_path14.join)(cwd, "stackwright.integrations.yml");
-  if (!(0, import_fs14.existsSync)(filePath)) return [];
+  const filePath = (0, import_path15.join)(cwd, "stackwright.integrations.yml");
+  if (!(0, import_fs15.existsSync)(filePath)) return [];
   try {
-    const raw = import_js_yaml3.default.load((0, import_fs14.readFileSync)(filePath, "utf-8"));
+    const raw = import_js_yaml4.default.load((0, import_fs15.readFileSync)(filePath, "utf-8"));
     if (!raw?.integrations || !Array.isArray(raw.integrations)) return [];
     return raw.integrations.filter((i) => typeof i.name === "string").map((i) => ({
       name: i.name,
@@ -7509,15 +7724,15 @@ function readIntegrations(cwd) {
   }
 }
 function readServiceTokenRefs(cwd) {
-  const servicesDir = (0, import_path14.join)(cwd, "services");
-  if (!(0, import_fs14.existsSync)(servicesDir)) return [];
+  const servicesDir = (0, import_path15.join)(cwd, "services");
+  if (!(0, import_fs15.existsSync)(servicesDir)) return [];
   try {
-    const files = (0, import_fs14.readdirSync)(servicesDir).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+    const files = (0, import_fs15.readdirSync)(servicesDir).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
     const refs = [];
     for (const file of files) {
       try {
-        const raw = import_js_yaml3.default.load(
-          (0, import_fs14.readFileSync)((0, import_path14.join)(servicesDir, file), "utf-8")
+        const raw = import_js_yaml4.default.load(
+          (0, import_fs15.readFileSync)((0, import_path15.join)(servicesDir, file), "utf-8")
         );
         if (raw?.tokenEnv && typeof raw.tokenEnv === "string") {
           refs.push({
@@ -7667,12 +7882,12 @@ This is the third concrete instance of the swp-zf9y deterministic emitter patter
 
 // src/tools/list-specs.ts
 var import_zod23 = require("zod");
-var import_fs15 = require("fs");
-var import_path15 = require("path");
+var import_fs16 = require("fs");
+var import_path16 = require("path");
 var STRIP_SUFFIXES = ["-openapi", "-asyncapi", "-api", "-spec"];
 var ALLOWED_EXTS = /* @__PURE__ */ new Set([".yaml", ".yml", ".json"]);
 function deriveIntegrationName(fileName) {
-  let name = (0, import_path15.basename)(fileName, (0, import_path15.extname)(fileName));
+  let name = (0, import_path16.basename)(fileName, (0, import_path16.extname)(fileName));
   for (const suffix of STRIP_SUFFIXES) {
     if (name.endsWith(suffix)) {
       name = name.slice(0, -suffix.length);
@@ -7690,29 +7905,29 @@ function detectFormat(snippet) {
 }
 function handleListSpecs(input) {
   const { projectRoot } = input;
-  const specsDir = (0, import_path15.join)(projectRoot, "specs");
+  const specsDir = (0, import_path16.join)(projectRoot, "specs");
   const empty = { projectRoot, specs: [], totalCount: 0 };
-  if (!(0, import_fs15.existsSync)(specsDir)) return empty;
+  if (!(0, import_fs16.existsSync)(specsDir)) return empty;
   let entries;
   try {
-    entries = (0, import_fs15.readdirSync)(specsDir);
+    entries = (0, import_fs16.readdirSync)(specsDir);
   } catch {
     return empty;
   }
   const specs = [];
   for (const entry of entries) {
-    const fullPath = (0, import_path15.join)(specsDir, entry);
+    const fullPath = (0, import_path16.join)(specsDir, entry);
     let stat;
     try {
-      stat = (0, import_fs15.statSync)(fullPath);
+      stat = (0, import_fs16.statSync)(fullPath);
     } catch {
       continue;
     }
     if (!stat.isFile()) continue;
-    if (!ALLOWED_EXTS.has((0, import_path15.extname)(entry).toLowerCase())) continue;
+    if (!ALLOWED_EXTS.has((0, import_path16.extname)(entry).toLowerCase())) continue;
     let snippet = "";
     try {
-      snippet = (0, import_fs15.readFileSync)(fullPath, "utf-8").slice(0, 2048);
+      snippet = (0, import_fs16.readFileSync)(fullPath, "utf-8").slice(0, 2048);
     } catch {
     }
     specs.push({
@@ -7744,14 +7959,14 @@ function registerListSpecsTool(server2) {
 
 // src/tools/consolidate-integrations.ts
 var import_zod24 = require("zod");
-var import_fs16 = require("fs");
+var import_fs17 = require("fs");
 var import_proper_lockfile2 = require("proper-lockfile");
-var import_path16 = require("path");
-var import_js_yaml4 = __toESM(require("js-yaml"));
+var import_path17 = require("path");
+var import_js_yaml5 = __toESM(require("js-yaml"));
 var BASE_MOCK_PORT = 4011;
 var STRIP_SUFFIXES2 = ["-openapi", "-asyncapi", "-api", "-spec"];
 function deriveNameFromFilename(filename) {
-  const base = (0, import_path16.basename)(filename, ".json").replace(/^api-config-/, "");
+  const base = (0, import_path17.basename)(filename, ".json").replace(/^api-config-/, "");
   for (const suffix of STRIP_SUFFIXES2) {
     if (base.endsWith(suffix)) return base.slice(0, -suffix.length);
   }
@@ -7759,13 +7974,13 @@ function deriveNameFromFilename(filename) {
 }
 function handleConsolidateIntegrations(input) {
   const { projectRoot } = input;
-  const artifactsDir = (0, import_path16.join)(projectRoot, ".stackwright", "artifacts");
-  if (!(0, import_fs16.existsSync)(artifactsDir)) {
+  const artifactsDir = (0, import_path17.join)(projectRoot, ".stackwright", "artifacts");
+  if (!(0, import_fs17.existsSync)(artifactsDir)) {
     return { written: false, integrationCount: 0, reason: "no per-spec artifacts found" };
   }
   let entries;
   try {
-    entries = (0, import_fs16.readdirSync)(artifactsDir).filter(
+    entries = (0, import_fs17.readdirSync)(artifactsDir).filter(
       (f) => f.startsWith("api-config-") && f.endsWith(".json") && f !== "api-config.json"
     );
   } catch {
@@ -7779,7 +7994,7 @@ function handleConsolidateIntegrations(input) {
   entries.forEach((filename, index) => {
     let artifact = {};
     try {
-      const raw = (0, import_fs16.readFileSync)((0, import_path16.join)(artifactsDir, filename), "utf-8");
+      const raw = (0, import_fs17.readFileSync)((0, import_path17.join)(artifactsDir, filename), "utf-8");
       artifact = JSON.parse(raw);
     } catch {
     }
@@ -7805,20 +8020,20 @@ function handleConsolidateIntegrations(input) {
   });
   const integrations = Array.from(integrationsByName.values());
   const dedupedCount = entries.length - integrations.length;
-  const integrationsYmlPath = (0, import_path16.join)(projectRoot, "stackwright.integrations.yml");
+  const integrationsYmlPath = (0, import_path17.join)(projectRoot, "stackwright.integrations.yml");
   let existing = {};
-  if ((0, import_fs16.existsSync)(integrationsYmlPath)) {
+  if ((0, import_fs17.existsSync)(integrationsYmlPath)) {
     try {
-      const raw = (0, import_fs16.readFileSync)(integrationsYmlPath, "utf-8");
-      existing = import_js_yaml4.default.load(raw) ?? {};
+      const raw = (0, import_fs17.readFileSync)(integrationsYmlPath, "utf-8");
+      existing = import_js_yaml5.default.load(raw) ?? {};
     } catch {
       existing = {};
     }
   }
   const merged = { ...existing, integrations };
-  (0, import_fs16.mkdirSync)((0, import_path16.join)(projectRoot), { recursive: true });
-  if (!(0, import_fs16.existsSync)(integrationsYmlPath)) {
-    (0, import_fs16.writeFileSync)(integrationsYmlPath, "", "utf-8");
+  (0, import_fs17.mkdirSync)((0, import_path17.join)(projectRoot), { recursive: true });
+  if (!(0, import_fs17.existsSync)(integrationsYmlPath)) {
+    (0, import_fs17.writeFileSync)(integrationsYmlPath, "", "utf-8");
   }
   const release = (0, import_proper_lockfile2.lockSync)(integrationsYmlPath, {
     realpath: false,
@@ -7827,8 +8042,8 @@ function handleConsolidateIntegrations(input) {
   try {
     const header = `# stackwright.integrations.yml \u2014 Auto-generated by stackwright_pro_consolidate_integrations
 `;
-    const body = import_js_yaml4.default.dump(merged, { lineWidth: 120, noRefs: true });
-    (0, import_fs16.writeFileSync)(integrationsYmlPath, header + body, "utf-8");
+    const body = import_js_yaml5.default.dump(merged, { lineWidth: 120, noRefs: true });
+    (0, import_fs17.writeFileSync)(integrationsYmlPath, header + body, "utf-8");
   } finally {
     release();
   }
@@ -7910,7 +8125,7 @@ var package_default = {
     "test:coverage": "vitest run --coverage"
   },
   name: "@stackwright-pro/mcp",
-  version: "0.2.0-alpha.105",
+  version: "0.2.0-alpha.106",
   description: "MCP tools for Stackwright Pro - Data Explorer, Security, ISR, and Dashboard generation",
   license: "SEE LICENSE IN LICENSE",
   main: "./dist/server.js",