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

package/dist/server.mjs

@@ -1999,9 +1999,9 @@ function registerOrchestrationTools(server2) {
 
 // src/tools/pipeline.ts
 import { z as z13 } from "zod";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync5, mkdirSync as mkdirSync4, lstatSync as lstatSync6 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync6, mkdirSync as mkdirSync4, lstatSync as lstatSync6 } from "fs";
 import { lockSync } from "proper-lockfile";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { createHash as createHash3 } from "crypto";
 
 // src/artifact-signing.ts
@@ -2342,6 +2342,208 @@ function registerArtifactSigningTools(server2) {
   );
 }
 
+// src/tools/validate-pulse-content.ts
+import { load as yamlLoad } from "js-yaml";
+import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync, existsSync as existsSync5 } from "fs";
+import { join as join4, relative } from "path";
+import { PULSE_CONTENT_SCHEMAS, ColumnSchema } from "@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(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 PULSE_CONTENT_SCHEMAS) {
+    counter.checked++;
+    const schema = 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 (!existsSync5(dir)) return results;
+  for (const entry of readdirSync2(dir)) {
+    const fullPath = join4(dir, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      results.push(...findContentYamlFiles(fullPath));
+    } else if (entry === "content.yml") {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function validatePulseContent(projectRoot) {
+  const pagesDir = join4(projectRoot, "pages");
+  const contentFiles = findContentYamlFiles(pagesDir);
+  const violations = [];
+  const counter = { checked: 0 };
+  for (const absolutePath of contentFiles) {
+    const relPath = relative(projectRoot, absolutePath);
+    let parsed;
+    try {
+      const raw = readFileSync4(absolutePath, "utf-8");
+      parsed = yamlLoad(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
 import { WorkflowFileSchema, authConfigSchema as authConfigSchema3 } from "@stackwright-pro/types";
 
@@ -2357,7 +2559,7 @@ import {
 
 // src/tools/validate-yaml-fragment.ts
 import { z as z11 } from "zod";
-import { load as yamlLoad } from "js-yaml";
+import { load as yamlLoad2 } from "js-yaml";
 import {
   WorkflowStepSchema,
   WorkflowDefinitionSchema,
@@ -2465,7 +2667,7 @@ function handleValidateYamlFragment(input) {
   const name = schemaName;
   let parsed;
   try {
-    parsed = yamlLoad(yaml3);
+    parsed = yamlLoad2(yaml3);
   } catch (err) {
     return {
       valid: false,
@@ -2692,8 +2894,8 @@ function registerGetSchemaTool(server2) {
 }
 
 // src/tools/pipeline-graph.ts
-import { readFileSync as readFileSync4, readdirSync as readdirSync2, lstatSync as lstatSync5 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync5, readdirSync as readdirSync3, lstatSync as lstatSync5 } from "fs";
+import { join as join5 } from "path";
 var MANIFEST_NAME_TO_PHASE = {
   "stackwright-pro-designer-otter": "designer",
   "stackwright-pro-theme-otter": "theme",
@@ -2722,8 +2924,8 @@ var OTTER_SEARCH_PATHS = [
 ];
 function resolveOtterDirFromCwd() {
   const cwd = process.cwd();
-  for (const relative of OTTER_SEARCH_PATHS) {
-    const candidate = join4(cwd, relative);
+  for (const relative2 of OTTER_SEARCH_PATHS) {
+    const candidate = join5(cwd, relative2);
     try {
       lstatSync5(candidate);
       return candidate;
@@ -2735,14 +2937,14 @@ function resolveOtterDirFromCwd() {
   );
 }
 function loadOtterManifestsFromDir(otterDir) {
-  const entries = readdirSync2(otterDir);
+  const entries = readdirSync3(otterDir);
   const manifests = [];
   for (const filename of entries) {
     if (!filename.endsWith("-otter.json")) continue;
-    const filePath = join4(otterDir, filename);
+    const filePath = join5(otterDir, filename);
     if (lstatSync5(filePath).isSymbolicLink()) continue;
     try {
-      const raw = readFileSync4(filePath, "utf-8");
+      const raw = readFileSync5(filePath, "utf-8");
       const manifest = JSON.parse(raw);
       manifests.push(manifest);
     } catch (err) {
@@ -2847,19 +3049,19 @@ var DISTRIBUTED_NAMESPACES = ["@stackwright-pro", "@stackwright"];
 function loadDistributedOtterManifests(cwd) {
   const results = [];
   for (const namespace of DISTRIBUTED_NAMESPACES) {
-    const nsDir = join4(cwd, "node_modules", namespace);
+    const nsDir = join5(cwd, "node_modules", namespace);
     let pkgDirNames;
     try {
-      pkgDirNames = readdirSync2(nsDir);
+      pkgDirNames = readdirSync3(nsDir);
     } catch {
       continue;
     }
     for (const pkgDirName of pkgDirNames) {
-      const pkgDir = join4(nsDir, pkgDirName);
+      const pkgDir = join5(nsDir, pkgDirName);
       const packageName = `${namespace}/${pkgDirName}`;
       let otterRelPaths;
       try {
-        const raw = readFileSync4(join4(pkgDir, "package.json"), "utf-8");
+        const raw = readFileSync5(join5(pkgDir, "package.json"), "utf-8");
         const pkgJson = JSON.parse(raw);
         const declared = pkgJson.stackwright?.otters;
         if (!Array.isArray(declared) || declared.length === 0) continue;
@@ -2868,9 +3070,9 @@ function loadDistributedOtterManifests(cwd) {
         continue;
       }
       for (const relPath of otterRelPaths) {
-        const otterFilePath = join4(pkgDir, relPath);
+        const otterFilePath = join5(pkgDir, relPath);
         try {
-          const raw = readFileSync4(otterFilePath, "utf-8");
+          const raw = readFileSync5(otterFilePath, "utf-8");
           const manifest = JSON.parse(raw);
           results.push({ manifest, packageName });
         } catch (err) {
@@ -2911,6 +3113,7 @@ function loadPipelineGraph() {
 
 // src/tools/pipeline.ts
 import { emit } from "@stackwright-pro/telemetry";
+var PULSE_CONTENT_PHASES = /* @__PURE__ */ new Set(["pages", "dashboard", "geo", "workflow"]);
 var PHASE_ORDER = [
   "designer",
   "theme",
@@ -2987,11 +3190,11 @@ function createDefaultState() {
   };
 }
 function statePath(cwd) {
-  return join5(cwd, ".stackwright", "pipeline-state.json");
+  return join6(cwd, ".stackwright", "pipeline-state.json");
 }
 function readState(cwd) {
   const p = statePath(cwd);
-  if (!existsSync5(p)) return createDefaultState();
+  if (!existsSync6(p)) return createDefaultState();
   const raw = JSON.parse(safeReadSync(p));
   if (typeof raw !== "object" || raw === null || raw.version !== "1.0") {
     return createDefaultState();
@@ -2999,7 +3202,7 @@ function readState(cwd) {
   return raw;
 }
 function safeWriteSync(filePath, content) {
-  if (existsSync5(filePath)) {
+  if (existsSync6(filePath)) {
     const stat = lstatSync6(filePath);
     if (stat.isSymbolicLink()) {
       throw new Error(`Refusing to write to symlink: ${filePath}`);
@@ -3008,25 +3211,25 @@ function safeWriteSync(filePath, content) {
   writeFileSync4(filePath, content);
 }
 function safeReadSync(filePath) {
-  if (existsSync5(filePath)) {
+  if (existsSync6(filePath)) {
     const stat = lstatSync6(filePath);
     if (stat.isSymbolicLink()) {
       throw new Error(`Refusing to read symlink: ${filePath}`);
     }
   }
-  return readFileSync5(filePath, "utf-8");
+  return readFileSync6(filePath, "utf-8");
 }
 function writeState(cwd, state) {
-  const dir = join5(cwd, ".stackwright");
+  const dir = join6(cwd, ".stackwright");
   mkdirSync4(dir, { recursive: true });
   state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   safeWriteSync(statePath(cwd), JSON.stringify(state, null, 2) + "\n");
 }
 function updateStateAtomic(cwd, mutator) {
-  const dir = join5(cwd, ".stackwright");
+  const dir = join6(cwd, ".stackwright");
   mkdirSync4(dir, { recursive: true });
   const path5 = statePath(cwd);
-  if (!existsSync5(path5)) {
+  if (!existsSync6(path5)) {
     safeWriteSync(path5, JSON.stringify(createDefaultState(), null, 2) + "\n");
   }
   const release = lockSync(path5, {
@@ -3060,8 +3263,8 @@ function handleGetPipelineState(_cwd) {
   const cwd = _cwd ?? process.cwd();
   try {
     const state = readState(cwd);
-    const keyPath = join5(cwd, ".stackwright", "pipeline-keys.json");
-    if (!existsSync5(keyPath)) {
+    const keyPath = join6(cwd, ".stackwright", "pipeline-keys.json");
+    if (!existsSync6(keyPath)) {
       try {
         const { fingerprint } = initPipelineKeys(cwd);
         state["signingKeyFingerprint"] = fingerprint;
@@ -3192,8 +3395,8 @@ function handleCheckExecutionReady(_cwd, phase) {
         isError: true
       };
     }
-    const answerFile = join5(cwd, ".stackwright", "answers", `${phase}.json`);
-    if (!existsSync5(answerFile)) {
+    const answerFile = join6(cwd, ".stackwright", "answers", `${phase}.json`);
+    if (!existsSync6(answerFile)) {
       return {
         text: JSON.stringify({ ready: false, phase, reason: "Answer file not found" }),
         isError: false
@@ -3217,12 +3420,12 @@ function handleCheckExecutionReady(_cwd, phase) {
     }
   }
   try {
-    const answersDir = join5(cwd, ".stackwright", "answers");
+    const answersDir = join6(cwd, ".stackwright", "answers");
     const answeredPhases = [];
     const missingPhases = [];
     for (const phase2 of PHASE_ORDER) {
-      const answerFile = join5(answersDir, `${phase2}.json`);
-      if (existsSync5(answerFile)) {
+      const answerFile = join6(answersDir, `${phase2}.json`);
+      if (existsSync6(answerFile)) {
         try {
           const raw = safeReadSync(answerFile);
           const parsed = JSON.parse(raw);
@@ -3291,7 +3494,7 @@ function handleGetReadyPhases(_cwd) {
 function handleListArtifacts(_cwd) {
   const cwd = _cwd ?? process.cwd();
   try {
-    const artifactsDir = join5(cwd, ".stackwright", "artifacts");
+    const artifactsDir = join6(cwd, ".stackwright", "artifacts");
     let manifest = null;
     try {
       manifest = loadSignatureManifest(cwd);
@@ -3301,8 +3504,8 @@ function handleListArtifacts(_cwd) {
     let completedCount = 0;
     for (const phase of PHASE_ORDER) {
       const expectedFile = PHASE_ARTIFACT[phase];
-      const fullPath = join5(artifactsDir, expectedFile);
-      const exists = existsSync5(fullPath);
+      const fullPath = join6(artifactsDir, expectedFile);
+      const exists = existsSync6(fullPath);
       if (exists) completedCount++;
       let signed = false;
       let signatureValid = null;
@@ -3355,9 +3558,9 @@ function handleWritePhaseQuestions(input) {
       }
     } catch {
     }
-    const questionsDir = join5(cwd, ".stackwright", "questions");
+    const questionsDir = join6(cwd, ".stackwright", "questions");
     mkdirSync4(questionsDir, { recursive: true });
-    const filePath = join5(questionsDir, `${phase}.json`);
+    const filePath = join6(questionsDir, `${phase}.json`);
     const payload = {
       version: "1.0",
       phase,
@@ -3397,14 +3600,14 @@ function handleBuildSpecialistPrompt(input) {
     };
   }
   try {
-    const answersPath = join5(cwd, ".stackwright", "answers", `${phase}.json`);
+    const answersPath = join6(cwd, ".stackwright", "answers", `${phase}.json`);
     let answers = {};
-    if (existsSync5(answersPath)) {
+    if (existsSync6(answersPath)) {
       answers = JSON.parse(safeReadSync(answersPath));
     }
     let buildContextText = "";
-    const buildContextPath = join5(cwd, ".stackwright", "build-context.json");
-    if (existsSync5(buildContextPath)) {
+    const buildContextPath = join6(cwd, ".stackwright", "build-context.json");
+    if (existsSync6(buildContextPath)) {
       try {
         const bcRaw = JSON.parse(safeReadSync(buildContextPath));
         if (typeof bcRaw.buildContext === "string" && bcRaw.buildContext.trim().length > 0) {
@@ -3419,8 +3622,8 @@ function handleBuildSpecialistPrompt(input) {
     const missingDependencies = [];
     for (const dep of deps) {
       const artifactFile = PHASE_ARTIFACT[dep];
-      const artifactPath = join5(cwd, ".stackwright", "artifacts", artifactFile);
-      if (existsSync5(artifactPath)) {
+      const artifactPath = join6(cwd, ".stackwright", "artifacts", artifactFile);
+      if (existsSync6(artifactPath)) {
         const rawContent = safeReadSync(artifactPath);
         const rawBytes = Buffer.from(rawContent, "utf-8");
         const content = JSON.parse(rawContent);
@@ -3485,8 +3688,8 @@ ${JSON.stringify(content, null, 2)}`
       parts.push("BUILD_CONTEXT:", buildContextText, "");
     }
     if (phase === "auth") {
-      const initContextPath = join5(cwd, ".stackwright", "init-context.json");
-      if (existsSync5(initContextPath)) {
+      const initContextPath = join6(cwd, ".stackwright", "init-context.json");
+      if (existsSync6(initContextPath)) {
         try {
           const initContext = JSON.parse(safeReadSync(initContextPath));
           if (initContext.devOnly === true || initContext.nonInteractive === true) {
@@ -3991,13 +4194,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 = join5(cwd, ".stackwright", "artifacts", "workflow-config.json");
-      if (!existsSync5(workflowArtifactPath)) {
+      const workflowArtifactPath = join6(cwd, ".stackwright", "artifacts", "workflow-config.json");
+      if (!existsSync6(workflowArtifactPath)) {
         return { success: true };
       }
       let workflowArtifact;
       try {
-        workflowArtifact = JSON.parse(readFileSync5(workflowArtifactPath, "utf-8"));
+        workflowArtifact = JSON.parse(readFileSync6(workflowArtifactPath, "utf-8"));
       } catch {
         return { success: true };
       }
@@ -4067,11 +4270,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 = join5(cwd, ".stackwright", "artifacts");
+    const artifactsDir = join6(cwd, ".stackwright", "artifacts");
     mkdirSync4(artifactsDir, { recursive: true });
     const artifactFile = phase === "api" && input.integrationName ? `api-config-${input.integrationName}.json` : PHASE_ARTIFACT[phase];
-    const artifactPath = join5(artifactsDir, artifactFile);
+    const artifactPath = join6(artifactsDir, artifactFile);
     const serialized = JSON.stringify(artifact, null, 2) + "\n";
     const artifactBytes = Buffer.from(serialized, "utf-8");
     safeWriteSync(artifactPath, serialized);
@@ -4290,9 +4505,9 @@ function registerPipelineTools(server2) {
             isError: true
           };
         }
-        const questionsDir = join5(process.cwd(), ".stackwright", "questions");
+        const questionsDir = join6(process.cwd(), ".stackwright", "questions");
         mkdirSync4(questionsDir, { recursive: true });
-        const outPath = join5(questionsDir, `${phase}.json`);
+        const outPath = join6(questionsDir, `${phase}.json`);
         writeFileSync4(
           outPath,
           JSON.stringify({ phase, questions, writtenAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)
@@ -4380,8 +4595,8 @@ function registerPipelineTools(server2) {
 
 // src/tools/safe-write.ts
 import { z as z14 } from "zod";
-import { writeFileSync as writeFileSync5, readFileSync as readFileSync6, existsSync as existsSync6, mkdirSync as mkdirSync5, lstatSync as lstatSync7 } from "fs";
-import { normalize, isAbsolute, dirname, join as join6 } from "path";
+import { writeFileSync as writeFileSync5, readFileSync as readFileSync7, existsSync as existsSync7, mkdirSync as mkdirSync5, lstatSync as lstatSync7 } from "fs";
+import { normalize, isAbsolute, dirname, join as join7 } from "path";
 import { emit as emit2 } from "@stackwright-pro/telemetry";
 var OTTER_WRITE_ALLOWLISTS = {
   "stackwright-pro-designer-otter": [
@@ -4563,21 +4778,21 @@ function extractContentTypes(yamlContent) {
   return types.length > 0 ? types : ["unknown"];
 }
 function readPageRegistry(cwd) {
-  const regPath = join6(cwd, PAGE_REGISTRY_FILE);
-  if (!existsSync6(regPath)) return {};
+  const regPath = join7(cwd, PAGE_REGISTRY_FILE);
+  if (!existsSync7(regPath)) return {};
   try {
     const stat = lstatSync7(regPath);
     if (stat.isSymbolicLink()) return {};
-    return JSON.parse(readFileSync6(regPath, "utf-8"));
+    return JSON.parse(readFileSync7(regPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function writePageRegistry(cwd, registry) {
-  const dir = join6(cwd, ".stackwright");
+  const dir = join7(cwd, ".stackwright");
   mkdirSync5(dir, { recursive: true });
-  const regPath = join6(cwd, PAGE_REGISTRY_FILE);
-  if (existsSync6(regPath)) {
+  const regPath = join7(cwd, PAGE_REGISTRY_FILE);
+  if (existsSync7(regPath)) {
     const stat = lstatSync7(regPath);
     if (stat.isSymbolicLink()) {
       throw new Error("Refusing to write page registry through symlink");
@@ -4749,8 +4964,8 @@ function _safeWriteInner(input) {
     return { text: JSON.stringify(result), isError: true };
   }
   const normalized = normalize(filePath);
-  const fullPath = join6(cwd, normalized);
-  if (existsSync6(fullPath)) {
+  const fullPath = join7(cwd, normalized);
+  if (existsSync7(fullPath)) {
     try {
       const stat = lstatSync7(fullPath);
       if (stat.isSymbolicLink()) {
@@ -4880,8 +5095,8 @@ function registerSafeWriteTools(server2) {
 
 // src/tools/auth.ts
 import { z as z15 } from "zod";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync7, mkdirSync as mkdirSync6 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync6 } from "fs";
+import { join as join8 } from "path";
 function buildHierarchy(roles) {
   const h = {};
   for (let i = 0; i < roles.length - 1; i++) {
@@ -4908,9 +5123,9 @@ ${indent}  requiredRole: ${r.requiredRole}`).join("\n");
 }
 function detectNextMajorVersion(cwd) {
   try {
-    const pkgPath = join7(cwd, "package.json");
-    if (!existsSync7(pkgPath)) return null;
-    const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
+    const pkgPath = join8(cwd, "package.json");
+    if (!existsSync8(pkgPath)) return null;
+    const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
     const nextVersion = pkg.dependencies?.next ?? pkg.devDependencies?.next;
     if (!nextVersion) return null;
     const match = nextVersion.match(/(\d+)/);
@@ -5574,7 +5789,7 @@ async function configureAuthHandler(params, cwd) {
       auditRetentionDays,
       normalizedRoutes
     );
-    writeFileSync6(join7(cwd, conventionFile), authFileContent, "utf8");
+    writeFileSync6(join8(cwd, conventionFile), authFileContent, "utf8");
     filesWritten.push(conventionFile);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -5594,9 +5809,9 @@ async function configureAuthHandler(params, cwd) {
   if (!devOnly) {
     try {
       const envBlock = generateEnvBlock(effectiveMethod, params);
-      const envPath = join7(cwd, ".env.example");
-      if (existsSync7(envPath)) {
-        const existing = readFileSync7(envPath, "utf8");
+      const envPath = join8(cwd, ".env.example");
+      if (existsSync8(envPath)) {
+        const existing = readFileSync8(envPath, "utf8");
         writeFileSync6(envPath, existing.trimEnd() + "\n\n" + envBlock, "utf8");
       } else {
         writeFileSync6(envPath, envBlock, "utf8");
@@ -5617,10 +5832,10 @@ async function configureAuthHandler(params, cwd) {
   }
   if (devOnly) {
     try {
-      const mockAuthDir = join7(cwd, "lib");
+      const mockAuthDir = join8(cwd, "lib");
       mkdirSync6(mockAuthDir, { recursive: true });
       const mockAuthContent = generateMockAuthContent(roles, mockUsers);
-      writeFileSync6(join7(mockAuthDir, "mock-auth.ts"), mockAuthContent, "utf8");
+      writeFileSync6(join8(mockAuthDir, "mock-auth.ts"), mockAuthContent, "utf8");
       filesWritten.push("lib/mock-auth.ts");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -5638,9 +5853,9 @@ async function configureAuthHandler(params, cwd) {
       };
     }
     try {
-      const pkgPath = join7(cwd, "package.json");
-      if (existsSync7(pkgPath)) {
-        const existingPkg = readFileSync7(pkgPath, "utf8");
+      const pkgPath = join8(cwd, "package.json");
+      if (existsSync8(pkgPath)) {
+        const existingPkg = readFileSync8(pkgPath, "utf8");
         const updatedPkg = updatePackageJsonScripts(existingPkg, roles, mockUsers);
         writeFileSync6(pkgPath, updatedPkg, "utf8");
         filesWritten.push("package.json");
@@ -5683,7 +5898,7 @@ async function configureAuthHandler(params, cwd) {
       normalizedRoutes,
       useProxy
     );
-    writeFileSync6(join7(cwd, "stackwright.auth.yml"), authYaml, "utf8");
+    writeFileSync6(join8(cwd, "stackwright.auth.yml"), authYaml, "utf8");
     filesWritten.push("stackwright.auth.yml");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -5796,8 +6011,8 @@ function registerAuthTools(server2) {
 
 // src/integrity.ts
 import { createHash as createHash4, timingSafeEqual as timingSafeEqual2 } from "crypto";
-import { readFileSync as readFileSync8, readdirSync as readdirSync3, lstatSync as lstatSync8 } from "fs";
-import { join as join8, basename } from "path";
+import { readFileSync as readFileSync9, readdirSync as readdirSync4, lstatSync as lstatSync8 } from "fs";
+import { join as join9, basename } from "path";
 var _checksums = /* @__PURE__ */ new Map([
   [
     "stackwright-pro-api-otter.json",
@@ -5905,7 +6120,7 @@ function verifyOtterFile(filePath) {
   }
   let raw;
   try {
-    raw = readFileSync8(filePath);
+    raw = readFileSync9(filePath);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { verified: false, filename, error: `Cannot read file: ${msg}` };
@@ -5955,7 +6170,7 @@ function verifyAllOtters(otterDir) {
   const unknown = [];
   let entries;
   try {
-    entries = readdirSync3(otterDir);
+    entries = readdirSync4(otterDir);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return {
@@ -5966,7 +6181,7 @@ function verifyAllOtters(otterDir) {
   }
   const otterFiles = entries.filter((f) => f.endsWith("-otter.json"));
   for (const filename of otterFiles) {
-    const filePath = join8(otterDir, filename);
+    const filePath = join9(otterDir, filename);
     try {
       if (lstatSync8(filePath).isSymbolicLink()) {
         failed.push({ filename, error: "Skipped: symlink" });
@@ -5993,8 +6208,8 @@ 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 = join8(cwd, relative);
+  for (const relative2 of DEFAULT_SEARCH_PATHS) {
+    const candidate = join9(cwd, relative2);
     try {
       lstatSync8(candidate);
       return candidate;
@@ -6075,13 +6290,13 @@ function registerIntegrityTools(server2) {
 
 // src/tools/domain.ts
 import { z as z16 } from "zod";
-import { readFileSync as readFileSync9, existsSync as existsSync8 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync10, existsSync as existsSync9 } from "fs";
+import { join as join10 } from "path";
 function handleListCollections(input) {
   const cwd = input._cwd ?? process.cwd();
   const sources = [
     {
-      path: join9(cwd, ".stackwright", "artifacts", "data-config.json"),
+      path: join10(cwd, ".stackwright", "artifacts", "data-config.json"),
       source: "data-config.json",
       parse: (raw) => {
         const parsed = JSON.parse(raw);
@@ -6092,15 +6307,15 @@ function handleListCollections(input) {
       }
     },
     {
-      path: join9(cwd, "stackwright.yml"),
+      path: join10(cwd, "stackwright.yml"),
       source: "stackwright.yml",
       parse: extractCollectionsFromYaml
     }
   ];
   for (const { path: path5, source, parse } of sources) {
-    if (!existsSync8(path5)) continue;
+    if (!existsSync9(path5)) continue;
     try {
-      const collections = parse(readFileSync9(path5, "utf8"));
+      const collections = parse(readFileSync10(path5, "utf8"));
       return {
         text: JSON.stringify({ collections, source, collectionCount: collections.length }),
         isError: false
@@ -6251,8 +6466,8 @@ function handleValidateWorkflow(input) {
   if (input.workflow && Object.keys(input.workflow).length > 0) {
     raw = input.workflow;
   } else {
-    const artifactPath = join9(cwd, ".stackwright", "artifacts", "workflow-config.json");
-    if (!existsSync8(artifactPath)) {
+    const artifactPath = join10(cwd, ".stackwright", "artifacts", "workflow-config.json");
+    if (!existsSync9(artifactPath)) {
       return fail([
         {
           code: "NO_WORKFLOW",
@@ -6261,7 +6476,7 @@ function handleValidateWorkflow(input) {
       ]);
     }
     try {
-      raw = JSON.parse(readFileSync9(artifactPath, "utf8"));
+      raw = JSON.parse(readFileSync10(artifactPath, "utf8"));
     } catch (err) {
       return fail([{ code: "INVALID_JSON", message: `Failed to parse workflow artifact: ${err}` }]);
     }
@@ -6573,7 +6788,7 @@ import * as fs2 from "fs";
 import * as os from "os";
 import * as path3 from "path";
 import { z as z18 } from "zod";
-import { load as yamlLoad2, dump as yamlDump } from "js-yaml";
+import { load as yamlLoad3, dump as yamlDump } from "js-yaml";
 import { writePage, resolvePagesDir } from "@stackwright/cli";
 import { isProContentType, isOssTypeWithProExtension } from "@stackwright-pro/types";
 var BCP47_RE = /^[a-z]{2}(-[A-Z]{2})?$/;
@@ -6627,7 +6842,7 @@ function handleProWritePage(input) {
   }
   let parsed;
   try {
-    parsed = yamlLoad2(content);
+    parsed = yamlLoad3(content);
   } catch (err) {
     return {
       isError: true,
@@ -6699,16 +6914,16 @@ function registerProPageTools(server2) {
 
 // src/tools/scaffold-cleanup.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   lstatSync as lstatSync9,
   unlinkSync as unlinkSync2,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   writeFileSync as writeFileSync8,
-  readdirSync as readdirSync4,
+  readdirSync as readdirSync5,
   rmdirSync,
   mkdirSync as mkdirSync8
 } from "fs";
-import { join as join11, dirname as dirname3 } from "path";
+import { join as join12, dirname as dirname3 } from "path";
 var SCAFFOLD_FILES_TO_DELETE = [
   "content/posts/getting-started.yaml",
   "content/posts/hello-world.yaml"
@@ -6733,12 +6948,12 @@ var FALLBACK_COLORS = {
   mutedForeground: "#737373"
 };
 function readThemeColors(cwd) {
-  const tokenPath = join11(cwd, ".stackwright", "artifacts", "theme-tokens.json");
-  if (!existsSync10(tokenPath)) return { ...FALLBACK_COLORS };
+  const tokenPath = join12(cwd, ".stackwright", "artifacts", "theme-tokens.json");
+  if (!existsSync11(tokenPath)) return { ...FALLBACK_COLORS };
   const stat = lstatSync9(tokenPath);
   if (stat.isSymbolicLink()) return { ...FALLBACK_COLORS };
   try {
-    const raw = JSON.parse(readFileSync10(tokenPath, "utf-8"));
+    const raw = JSON.parse(readFileSync11(tokenPath, "utf-8"));
     const css = raw?.cssVariables ?? {};
     const toHsl = (hslValue) => {
       if (!hslValue || typeof hslValue !== "string") return null;
@@ -6798,15 +7013,15 @@ function generateNotFoundPage(colors) {
 `;
 }
 function isSafePath(fullPath) {
-  if (!existsSync10(fullPath)) return true;
+  if (!existsSync11(fullPath)) return true;
   const stat = lstatSync9(fullPath);
   return !stat.isSymbolicLink();
 }
 function isDirEmpty(dirPath) {
-  if (!existsSync10(dirPath)) return false;
+  if (!existsSync11(dirPath)) return false;
   const stat = lstatSync9(dirPath);
   if (!stat.isDirectory()) return false;
-  return readdirSync4(dirPath).length === 0;
+  return readdirSync5(dirPath).length === 0;
 }
 function handleCleanupScaffold(_cwd) {
   const cwd = _cwd ?? process.cwd();
@@ -6819,8 +7034,8 @@ function handleCleanupScaffold(_cwd) {
     cleanupWarnings: []
   };
   for (const relPath of SCAFFOLD_FILES_TO_DELETE) {
-    const fullPath = join11(cwd, relPath);
-    if (!existsSync10(fullPath)) {
+    const fullPath = join12(cwd, relPath);
+    if (!existsSync11(fullPath)) {
       result.skipped.push(relPath);
       continue;
     }
@@ -6837,13 +7052,13 @@ function handleCleanupScaffold(_cwd) {
   }
   {
     const relPath = "pages/getting-started/content.yml";
-    const fullPath = join11(cwd, relPath);
-    if (!existsSync10(fullPath)) {
+    const fullPath = join12(cwd, relPath);
+    if (!existsSync11(fullPath)) {
       result.skipped.push(relPath);
     } else if (!isSafePath(fullPath)) {
       result.errors.push(`Refusing to delete symlink: ${relPath}`);
     } else {
-      const content = readFileSync10(fullPath, "utf-8");
+      const content = readFileSync11(fullPath, "utf-8");
       const isScaffoldDefault = GETTING_STARTED_SCAFFOLD_FINGERPRINTS.some(
         (marker) => content.includes(marker)
       );
@@ -6863,16 +7078,16 @@ function handleCleanupScaffold(_cwd) {
   }
   {
     const relPath = `content/posts/${POSTS_COLLECTION_FILE}`;
-    const fullPath = join11(cwd, relPath);
-    const postsDir = join11(cwd, "content/posts");
-    if (!existsSync10(fullPath)) {
+    const fullPath = join12(cwd, relPath);
+    const postsDir = join12(cwd, "content/posts");
+    if (!existsSync11(fullPath)) {
       result.skipped.push(relPath);
     } else if (!isSafePath(fullPath)) {
       result.errors.push(`Refusing to delete symlink: ${relPath}`);
-    } else if (!existsSync10(postsDir)) {
+    } else if (!existsSync11(postsDir)) {
       result.skipped.push(relPath);
     } else {
-      const userPostFiles = readdirSync4(postsDir).filter(
+      const userPostFiles = readdirSync5(postsDir).filter(
         (f) => f !== POSTS_COLLECTION_FILE && POST_FILE_EXTENSIONS.some((ext) => f.endsWith(ext))
       );
       if (userPostFiles.length === 0) {
@@ -6890,8 +7105,8 @@ function handleCleanupScaffold(_cwd) {
     }
   }
   for (const relDir of SCAFFOLD_DIRS_TO_PRUNE) {
-    const fullDir = join11(cwd, relDir);
-    if (!existsSync10(fullDir)) continue;
+    const fullDir = join12(cwd, relDir);
+    if (!existsSync11(fullDir)) continue;
     if (!isSafePath(fullDir)) {
       result.errors.push(`Refusing to prune symlink directory: ${relDir}`);
       continue;
@@ -6906,8 +7121,8 @@ function handleCleanupScaffold(_cwd) {
     }
   }
   {
-    const fullPath = join11(cwd, NOT_FOUND_PATH);
-    if (!existsSync10(fullPath)) {
+    const fullPath = join12(cwd, NOT_FOUND_PATH);
+    if (!existsSync11(fullPath)) {
       result.skipped.push(NOT_FOUND_PATH);
     } else if (!isSafePath(fullPath)) {
       result.errors.push(`Refusing to rewrite symlink: ${NOT_FOUND_PATH}`);
@@ -7428,14 +7643,14 @@ ${results.join("\n")}`;
 
 // src/tools/strip-legacy-integrations.ts
 import { z as z21 } from "zod";
-import { existsSync as existsSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
+import { join as join13 } from "path";
 function handleStripLegacyIntegrations(input) {
   const { projectRoot } = input;
-  const ymlPath = join12(projectRoot, "stackwright.yml");
-  const yamlPath = join12(projectRoot, "stackwright.yaml");
-  if (!existsSync11(ymlPath)) {
-    if (existsSync11(yamlPath)) {
+  const ymlPath = join13(projectRoot, "stackwright.yml");
+  const yamlPath = join13(projectRoot, "stackwright.yaml");
+  if (!existsSync12(ymlPath)) {
+    if (existsSync12(yamlPath)) {
       return {
         changed: false,
         removedEntries: 0,
@@ -7448,7 +7663,7 @@ function handleStripLegacyIntegrations(input) {
       message: "stackwright.yml not found \u2014 no-op."
     };
   }
-  const raw = readFileSync11(ymlPath, "utf-8");
+  const raw = readFileSync12(ymlPath, "utf-8");
   const isCRLF = raw.includes("\r\n");
   const content = isCRLF ? raw.replace(/\r\n/g, "\n") : raw;
   const lines = content.split("\n");
@@ -7503,15 +7718,15 @@ function registerStripLegacyIntegrationsTool(server2) {
 
 // src/tools/emitters.ts
 import { z as z22 } from "zod";
-import { readFileSync as readFileSync12, existsSync as existsSync12, readdirSync as readdirSync5 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync13, readdirSync as readdirSync6 } from "fs";
+import { join as join14 } from "path";
 import yaml from "js-yaml";
 import { emitEnvLocal, emitProvidersFile, emitMockPorts } from "@stackwright-pro/emitters";
 function readIntegrations(cwd) {
-  const filePath = join13(cwd, "stackwright.integrations.yml");
-  if (!existsSync12(filePath)) return [];
+  const filePath = join14(cwd, "stackwright.integrations.yml");
+  if (!existsSync13(filePath)) return [];
   try {
-    const raw = yaml.load(readFileSync12(filePath, "utf-8"));
+    const raw = yaml.load(readFileSync13(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,
@@ -7522,15 +7737,15 @@ function readIntegrations(cwd) {
   }
 }
 function readServiceTokenRefs(cwd) {
-  const servicesDir = join13(cwd, "services");
-  if (!existsSync12(servicesDir)) return [];
+  const servicesDir = join14(cwd, "services");
+  if (!existsSync13(servicesDir)) return [];
   try {
-    const files = readdirSync5(servicesDir).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+    const files = readdirSync6(servicesDir).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
     const refs = [];
     for (const file of files) {
       try {
         const raw = yaml.load(
-          readFileSync12(join13(servicesDir, file), "utf-8")
+          readFileSync13(join14(servicesDir, file), "utf-8")
         );
         if (raw?.tokenEnv && typeof raw.tokenEnv === "string") {
           refs.push({
@@ -7680,8 +7895,8 @@ This is the third concrete instance of the swp-zf9y deterministic emitter patter
 
 // src/tools/list-specs.ts
 import { z as z23 } from "zod";
-import { readdirSync as readdirSync6, readFileSync as readFileSync13, statSync, existsSync as existsSync13 } from "fs";
-import { join as join14, extname, basename as basename2 } from "path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync14, statSync as statSync2, existsSync as existsSync14 } from "fs";
+import { join as join15, extname, basename as basename2 } from "path";
 var STRIP_SUFFIXES = ["-openapi", "-asyncapi", "-api", "-spec"];
 var ALLOWED_EXTS = /* @__PURE__ */ new Set([".yaml", ".yml", ".json"]);
 function deriveIntegrationName(fileName) {
@@ -7703,21 +7918,21 @@ function detectFormat(snippet) {
 }
 function handleListSpecs(input) {
   const { projectRoot } = input;
-  const specsDir = join14(projectRoot, "specs");
+  const specsDir = join15(projectRoot, "specs");
   const empty = { projectRoot, specs: [], totalCount: 0 };
-  if (!existsSync13(specsDir)) return empty;
+  if (!existsSync14(specsDir)) return empty;
   let entries;
   try {
-    entries = readdirSync6(specsDir);
+    entries = readdirSync7(specsDir);
   } catch {
     return empty;
   }
   const specs = [];
   for (const entry of entries) {
-    const fullPath = join14(specsDir, entry);
+    const fullPath = join15(specsDir, entry);
     let stat;
     try {
-      stat = statSync(fullPath);
+      stat = statSync2(fullPath);
     } catch {
       continue;
     }
@@ -7725,7 +7940,7 @@ function handleListSpecs(input) {
     if (!ALLOWED_EXTS.has(extname(entry).toLowerCase())) continue;
     let snippet = "";
     try {
-      snippet = readFileSync13(fullPath, "utf-8").slice(0, 2048);
+      snippet = readFileSync14(fullPath, "utf-8").slice(0, 2048);
     } catch {
     }
     specs.push({
@@ -7757,9 +7972,9 @@ function registerListSpecsTool(server2) {
 
 // src/tools/consolidate-integrations.ts
 import { z as z24 } from "zod";
-import { readdirSync as readdirSync7, readFileSync as readFileSync14, writeFileSync as writeFileSync10, existsSync as existsSync14, mkdirSync as mkdirSync9 } from "fs";
+import { readdirSync as readdirSync8, readFileSync as readFileSync15, writeFileSync as writeFileSync10, existsSync as existsSync15, mkdirSync as mkdirSync9 } from "fs";
 import { lockSync as lockSync2 } from "proper-lockfile";
-import { join as join15, basename as basename3 } from "path";
+import { join as join16, basename as basename3 } from "path";
 import yaml2 from "js-yaml";
 var BASE_MOCK_PORT = 4011;
 var STRIP_SUFFIXES2 = ["-openapi", "-asyncapi", "-api", "-spec"];
@@ -7772,13 +7987,13 @@ function deriveNameFromFilename(filename) {
 }
 function handleConsolidateIntegrations(input) {
   const { projectRoot } = input;
-  const artifactsDir = join15(projectRoot, ".stackwright", "artifacts");
-  if (!existsSync14(artifactsDir)) {
+  const artifactsDir = join16(projectRoot, ".stackwright", "artifacts");
+  if (!existsSync15(artifactsDir)) {
     return { written: false, integrationCount: 0, reason: "no per-spec artifacts found" };
   }
   let entries;
   try {
-    entries = readdirSync7(artifactsDir).filter(
+    entries = readdirSync8(artifactsDir).filter(
       (f) => f.startsWith("api-config-") && f.endsWith(".json") && f !== "api-config.json"
     );
   } catch {
@@ -7792,7 +8007,7 @@ function handleConsolidateIntegrations(input) {
   entries.forEach((filename, index) => {
     let artifact = {};
     try {
-      const raw = readFileSync14(join15(artifactsDir, filename), "utf-8");
+      const raw = readFileSync15(join16(artifactsDir, filename), "utf-8");
       artifact = JSON.parse(raw);
     } catch {
     }
@@ -7818,19 +8033,19 @@ function handleConsolidateIntegrations(input) {
   });
   const integrations = Array.from(integrationsByName.values());
   const dedupedCount = entries.length - integrations.length;
-  const integrationsYmlPath = join15(projectRoot, "stackwright.integrations.yml");
+  const integrationsYmlPath = join16(projectRoot, "stackwright.integrations.yml");
   let existing = {};
-  if (existsSync14(integrationsYmlPath)) {
+  if (existsSync15(integrationsYmlPath)) {
     try {
-      const raw = readFileSync14(integrationsYmlPath, "utf-8");
+      const raw = readFileSync15(integrationsYmlPath, "utf-8");
       existing = yaml2.load(raw) ?? {};
     } catch {
       existing = {};
     }
   }
   const merged = { ...existing, integrations };
-  mkdirSync9(join15(projectRoot), { recursive: true });
-  if (!existsSync14(integrationsYmlPath)) {
+  mkdirSync9(join16(projectRoot), { recursive: true });
+  if (!existsSync15(integrationsYmlPath)) {
     writeFileSync10(integrationsYmlPath, "", "utf-8");
   }
   const release = lockSync2(integrationsYmlPath, {
@@ -7923,7 +8138,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",