@stackwright-pro/mcp 0.2.0-alpha.113 → 0.2.0-alpha.115

package/dist/server.js

@@ -2030,9 +2030,9 @@ function registerOrchestrationTools(server2) {
 
 // src/tools/pipeline.ts
 var import_zod14 = require("zod");
-var import_fs8 = require("fs");
+var import_fs12 = require("fs");
 var import_proper_lockfile = require("proper-lockfile");
-var import_path8 = require("path");
+var import_path12 = require("path");
 var import_crypto3 = require("crypto");
 
 // src/artifact-signing.ts
@@ -2559,6 +2559,585 @@ function formatPulseRetryPrompt(result) {
   return lines.join("\n");
 }
 
+// src/tools/validate-theme-tokens.ts
+var import_fs7 = require("fs");
+var import_path7 = require("path");
+var import_js_yaml2 = require("js-yaml");
+
+// src/tools/schema-registry.ts
+var import_zod11 = require("zod");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
+var import_types = require("@stackwright-pro/types");
+var import_pulse2 = require("@stackwright-pro/pulse");
+function getSchemaForEntry(entry, ctx) {
+  if (entry.schema) return entry.schema;
+  if (entry.schemaFactory) {
+    if (ctx) return entry.schemaFactory(ctx);
+    console.warn(
+      "[schema-registry] schemaFactory entry requires projectRoot context. Pass { projectRoot } to get the project-specific schema. Falling back to z.string() (no enforcement)."
+    );
+    return import_zod11.z.string();
+  }
+  return import_zod11.z.unknown();
+}
+var NavigationLinkSchema = import_zod11.z.lazy(
+  () => import_zod11.z.object({
+    label: import_zod11.z.string().min(1),
+    href: import_zod11.z.string().min(1),
+    children: import_zod11.z.array(NavigationLinkSchema).optional()
+  })
+);
+var NavigationSectionSchema = import_zod11.z.object({
+  section: import_zod11.z.string().min(1),
+  items: import_zod11.z.array(NavigationLinkSchema)
+});
+var NavigationItemSchema = import_zod11.z.union([
+  NavigationLinkSchema,
+  NavigationSectionSchema
+]);
+var THEME_TOKENS_PATHS = [
+  (0, import_path6.join)(".stackwright", "artifacts", "theme-tokens.json"),
+  (0, import_path6.join)("public", "stackwright-content", "_theme.json")
+];
+function resolveStatusLadder(projectRoot) {
+  for (const relPath of THEME_TOKENS_PATHS) {
+    const fullPath = (0, import_path6.join)(projectRoot, relPath);
+    if (!(0, import_fs6.existsSync)(fullPath)) continue;
+    try {
+      const raw = (0, import_fs6.readFileSync)(fullPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed["statusLadder"]) && parsed["statusLadder"].length > 0) {
+        return parsed["statusLadder"].filter(
+          (t) => typeof t === "string" && t.startsWith("status-")
+        );
+      }
+      const colors = parsed["tokens"]?.["colors"];
+      if (colors && typeof colors === "object") {
+        const statusKeys = Object.keys(colors).filter((k) => k.startsWith("status-"));
+        if (statusKeys.length > 0) return statusKeys;
+      }
+    } catch {
+    }
+  }
+  return [];
+}
+function buildThemeStatusTokenSchema(ctx) {
+  const ladder = resolveStatusLadder(ctx.projectRoot);
+  if (ladder.length === 0) {
+    return import_zod11.z.string();
+  }
+  return import_zod11.z.enum(ladder);
+}
+var REGISTRY = /* @__PURE__ */ new Map([
+  // ── Workflow schemas ──────────────────────────────────────────────────────
+  [
+    "workflow_step",
+    {
+      schema: import_types.WorkflowStepSchema,
+      synonyms: {
+        label: ["title", "name"],
+        message: ["description"],
+        "theme.variant": ["style"],
+        "on_submit.transition": ["transitions"]
+      },
+      phaseAffinity: ["workflow"]
+    }
+  ],
+  [
+    "workflow_definition",
+    {
+      schema: import_types.WorkflowDefinitionSchema,
+      synonyms: {
+        label: ["title", "name"],
+        id: ["type"]
+      },
+      phaseAffinity: ["workflow"]
+    }
+  ],
+  [
+    "workflow_field",
+    {
+      schema: import_types.WorkflowFieldSchema,
+      synonyms: {
+        name: ["id"],
+        label: ["title", "description"]
+      },
+      phaseAffinity: ["workflow"]
+    }
+  ],
+  [
+    "workflow_action",
+    {
+      schema: import_types.WorkflowActionSchema,
+      synonyms: {
+        label: ["title", "name"],
+        transition: ["then"],
+        "theme.variant": ["style"],
+        action: ["on_click"]
+      },
+      phaseAffinity: ["workflow"]
+    }
+  ],
+  // ── Navigation ────────────────────────────────────────────────────────────
+  [
+    "navigation_item",
+    {
+      schema: NavigationItemSchema,
+      synonyms: {
+        items: ["children"],
+        section: ["label", "title"]
+      },
+      phaseAffinity: ["pages", "dashboard", "polish"]
+    }
+  ],
+  // ── Auth ──────────────────────────────────────────────────────────────────
+  [
+    "auth_config",
+    {
+      schema: import_types.authConfigSchema,
+      synonyms: {
+        type: ["method", "provider_type", "strategy"]
+      },
+      phaseAffinity: ["auth"]
+    }
+  ],
+  // ── Pulse content types ───────────────────────────────────────────────────
+  [
+    "metric_card_pulse",
+    {
+      schema: import_pulse2.MetricCardPulseSchema,
+      synonyms: {
+        field: ["valueField", "valuePath", "dataField", "value"]
+      },
+      phaseAffinity: ["dashboard", "pages"]
+    }
+  ],
+  [
+    "data_table_pulse",
+    {
+      schema: import_pulse2.DataTablePulseSchema,
+      synonyms: {
+        header: ["label"],
+        type: ["renderAs"],
+        colorMap: ["severityMap"]
+      },
+      phaseAffinity: ["dashboard", "pages"]
+    }
+  ],
+  [
+    "status_badge_pulse",
+    {
+      schema: import_pulse2.StatusBadgePulseSchema,
+      synonyms: {},
+      phaseAffinity: ["dashboard", "pages"]
+    }
+  ],
+  [
+    "map_pulse",
+    {
+      schema: import_pulse2.MapPulseSchema,
+      synonyms: {},
+      phaseAffinity: ["geo", "dashboard", "pages"]
+    }
+  ],
+  // ── Workflow container page content type (swp-dvde) ───────────────────────
+  [
+    "workflow_wizard",
+    {
+      schema: import_types.WorkflowWizardContentSchema,
+      synonyms: {
+        workflowFile: ["workflowPath", "file", "path", "yamlFile"],
+        workflowId: ["id", "workflowName", "name"],
+        persistenceKey: ["stateKey", "storageKey"]
+      },
+      phaseAffinity: ["workflow"]
+    }
+  ],
+  // ── Theme schemas (swp-cxwu) ──────────────────────────────────────────────
+  [
+    "theme_tokens",
+    {
+      schema: import_types.themeTokensFileSchema,
+      synonyms: {},
+      phaseAffinity: ["theme"]
+    }
+  ],
+  [
+    "theme_status_token",
+    {
+      // No static schema — this is a project-specific runtime enum.
+      // Call getSchemaForEntry(entry, { projectRoot }) to get the project's ladder.
+      schemaFactory: buildThemeStatusTokenSchema,
+      synonyms: {},
+      phaseAffinity: ["pages", "dashboard", "geo"]
+    }
+  ]
+]);
+var SCHEMA_REGISTRY = REGISTRY;
+var REGISTRY_SCHEMA_NAMES = Array.from(REGISTRY.keys());
+function buildReverseSynonyms(synonyms) {
+  const reverse = {};
+  for (const [correct, wrongs] of Object.entries(synonyms)) {
+    for (const wrong of wrongs) {
+      reverse[wrong] = correct;
+    }
+  }
+  return reverse;
+}
+function buildPhaseSchemaNames() {
+  const phaseMap = {};
+  for (const [name, entry] of REGISTRY.entries()) {
+    for (const phase of entry.phaseAffinity ?? []) {
+      if (!phaseMap[phase]) phaseMap[phase] = [];
+      phaseMap[phase].push(name);
+    }
+  }
+  return phaseMap;
+}
+
+// src/tools/validate-theme-tokens.ts
+var COLOR_FIELD_KEYS = /* @__PURE__ */ new Set([
+  "color",
+  "colorMap",
+  "layerColor",
+  "borderColor",
+  "backgroundColor",
+  "iconColor",
+  "fill",
+  "stroke",
+  "markerColor",
+  "fillColor",
+  "outlineColor",
+  "statusColor",
+  "badgeColor",
+  "tagColor"
+]);
+var LEGACY_OSS_TOKENS = /* @__PURE__ */ new Set(["success", "warning", "danger", "info", "muted"]);
+var LEGACY_MAPPING_HINT = "Suggested mapping: success->status-safe, warning->status-warning, danger->status-critical, info->status-watch, muted->status-at-risk.";
+var HEX_RE = /^#[0-9a-f]{3,8}$/i;
+var STATUS_TOKEN_RE = /^status-[a-z0-9-]+$/;
+function walkYaml(node, fieldName, pathParts, inColorContext, visitor) {
+  if (typeof node === "string") {
+    visitor(node, fieldName, pathParts.join(".") || "(root)", inColorContext);
+    return;
+  }
+  if (Array.isArray(node)) {
+    node.forEach((item, idx) => {
+      walkYaml(item, fieldName, [...pathParts, `[${idx}]`], inColorContext, visitor);
+    });
+    return;
+  }
+  if (node !== null && typeof node === "object") {
+    for (const [key, val] of Object.entries(node)) {
+      const thisIsColorField = COLOR_FIELD_KEYS.has(key);
+      walkYaml(val, key, [...pathParts, key], inColorContext || thisIsColorField, visitor);
+    }
+  }
+}
+function detectViolationsInYaml(yamlContent, ladder, ladderSet, relPath) {
+  const violations = [];
+  walkYaml(yamlContent, null, [], false, (value, fieldName, path5, inColorContext) => {
+    const isColorField = inColorContext || fieldName !== null && COLOR_FIELD_KEYS.has(fieldName);
+    if (STATUS_TOKEN_RE.test(value) && !ladderSet.has(value)) {
+      violations.push({
+        type: "undefined_token",
+        message: `Undefined theme token: "${value}" not in declared theme ladder. Declared tokens: ${ladder.join(", ")}`,
+        file: relPath,
+        path: path5,
+        value
+      });
+      return;
+    }
+    if (!isColorField) return;
+    if (HEX_RE.test(value)) {
+      violations.push({
+        type: "raw_hex",
+        message: `Raw hex color "${value}" in color field "${fieldName ?? "<color context>"}". Use declared theme tokens instead. Available: ${ladder.join(", ")}`,
+        file: relPath,
+        path: path5,
+        value
+      });
+      return;
+    }
+    if (LEGACY_OSS_TOKENS.has(value)) {
+      violations.push({
+        type: "legacy_vocab",
+        message: `Legacy status token "${value}" in color field "${fieldName ?? "<color context>"}". This project's ladder is: ${ladder.join(", ")}. ` + LEGACY_MAPPING_HINT,
+        file: relPath,
+        path: path5,
+        value
+      });
+    }
+  });
+  return violations;
+}
+function findContentFiles(pagesRoot) {
+  if (!(0, import_fs7.existsSync)(pagesRoot)) return [];
+  const files = [];
+  try {
+    const slugDirs = (0, import_fs7.readdirSync)(pagesRoot, { withFileTypes: true });
+    for (const entry of slugDirs) {
+      if (!entry.isDirectory()) continue;
+      const slugDir = (0, import_path7.join)(pagesRoot, entry.name);
+      for (const candidate of ["content.yml", "content.yaml"]) {
+        const p = (0, import_path7.join)(slugDir, candidate);
+        if ((0, import_fs7.existsSync)(p)) files.push(p);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function validateThemeTokenUsage(projectRoot) {
+  const ladder = resolveStatusLadder(projectRoot);
+  if (ladder.length === 0) {
+    return {
+      valid: true,
+      violations: [],
+      skipped: true
+    };
+  }
+  const ladderSet = new Set(ladder);
+  const pagesRoot = (0, import_path7.join)(projectRoot, "pages");
+  const contentFiles = findContentFiles(pagesRoot);
+  const allViolations = [];
+  for (const absPath of contentFiles) {
+    const relPath = (0, import_path7.relative)(projectRoot, absPath);
+    try {
+      const raw = (0, import_fs7.readFileSync)(absPath, "utf-8");
+      const parsed = (0, import_js_yaml2.load)(raw);
+      const fileViolations = detectViolationsInYaml(parsed, ladder, ladderSet, relPath);
+      allViolations.push(...fileViolations);
+    } catch {
+    }
+  }
+  if (allViolations.length === 0) {
+    return { valid: true, violations: [] };
+  }
+  const lines = [
+    `Theme token enforcement found ${allViolations.length} violation(s):`,
+    "",
+    ...allViolations.map((v, i) => {
+      const typeLabel = v.type === "undefined_token" ? "UNDEFINED TOKEN" : v.type === "raw_hex" ? "RAW HEX" : "LEGACY VOCAB";
+      return `  ${i + 1}. [${typeLabel}] ${v.message}
+     Emitted in: ${v.file} at ${v.path}`;
+    }),
+    "",
+    `Fix all violations to use declared theme tokens: ${ladder.join(", ")}`
+  ];
+  return {
+    valid: false,
+    violations: allViolations,
+    retryPrompt: lines.join("\n")
+  };
+}
+
+// src/tools/validate-build-context-globals.ts
+var import_fs8 = require("fs");
+var import_path8 = require("path");
+var import_js_yaml3 = require("js-yaml");
+var DATA_WIDGET_TYPES = /* @__PURE__ */ new Set([
+  "data_table_pulse",
+  "stats_grid",
+  "metric_card_pulse",
+  "map_pulse"
+]);
+function readGlobalDefaults(projectRoot) {
+  const bcPath = (0, import_path8.join)(projectRoot, ".stackwright", "build-context.json");
+  if (!(0, import_fs8.existsSync)(bcPath)) return null;
+  try {
+    const raw = (0, import_fs8.readFileSync)(bcPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const gd = parsed.globalDefaults;
+    if (!gd || typeof gd !== "object") return null;
+    return gd;
+  } catch {
+    return null;
+  }
+}
+function findDataWidgets(node, pathParts, out) {
+  if (node === null || node === void 0 || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    node.forEach((item, idx) => {
+      findDataWidgets(item, [...pathParts, `[${idx}]`], out);
+    });
+    return;
+  }
+  const obj = node;
+  const contentType = typeof obj["type"] === "string" ? obj["type"] : null;
+  if (contentType && DATA_WIDGET_TYPES.has(contentType)) {
+    out.push({
+      type: contentType,
+      label: typeof obj["label"] === "string" ? obj["label"] : void 0,
+      data: obj,
+      path: pathParts.join(".") || "(root)"
+    });
+  }
+  for (const [key, val] of Object.entries(obj)) {
+    findDataWidgets(val, [...pathParts, key], out);
+  }
+}
+function findContentFiles2(pagesRoot) {
+  if (!(0, import_fs8.existsSync)(pagesRoot)) return [];
+  const files = [];
+  try {
+    const slugDirs = (0, import_fs8.readdirSync)(pagesRoot, { withFileTypes: true });
+    for (const entry of slugDirs) {
+      if (!entry.isDirectory()) continue;
+      for (const candidate of ["content.yml", "content.yaml"]) {
+        const p = (0, import_path8.join)(pagesRoot, entry.name, candidate);
+        if ((0, import_fs8.existsSync)(p)) files.push(p);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function validateBuildContextGlobals(projectRoot) {
+  const globalDefaults = readGlobalDefaults(projectRoot);
+  if (!globalDefaults) {
+    return { valid: true, violations: [], skipped: true };
+  }
+  const requiredFields = Object.entries(globalDefaults).filter(([, v]) => v === true).map(([k]) => k);
+  if (requiredFields.length === 0) {
+    return { valid: true, violations: [], skipped: true };
+  }
+  const pagesRoot = (0, import_path8.join)(projectRoot, "pages");
+  const contentFiles = findContentFiles2(pagesRoot);
+  const allViolations = [];
+  for (const absPath of contentFiles) {
+    const relPath = (0, import_path8.relative)(projectRoot, absPath);
+    try {
+      const raw = (0, import_fs8.readFileSync)(absPath, "utf-8");
+      const parsed = (0, import_js_yaml3.load)(raw);
+      const widgets = [];
+      findDataWidgets(parsed, [], widgets);
+      for (const widget of widgets) {
+        for (const field of requiredFields) {
+          if (widget.data[field] !== true) {
+            allViolations.push({
+              field,
+              widgetType: widget.type,
+              widgetLabel: widget.label,
+              file: relPath,
+              path: widget.path
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (allViolations.length === 0) {
+    return { valid: true, violations: [] };
+  }
+  const lines = [
+    `BUILD_CONTEXT global defaults: ${allViolations.length} violation(s) found.`,
+    "",
+    ...allViolations.map((v, i) => {
+      const widgetId = v.widgetLabel ? `"${v.widgetLabel}" (${v.widgetType})` : `${v.widgetType}`;
+      return `  ${i + 1}. BUILD_CONTEXT.${v.field} is globally true but widget ${widgetId} omits it.
+     Set ${v.field}: true on this widget.
+     Emitted in: ${v.file} at ${v.path}`;
+    }),
+    "",
+    `Required global defaults: ${requiredFields.map((f) => `${f}: true`).join(", ")}`
+  ];
+  return {
+    valid: false,
+    violations: allViolations,
+    retryPrompt: lines.join("\n")
+  };
+}
+
+// src/tools/validate-workflow-container-pages.ts
+var import_fs9 = require("fs");
+var import_path9 = require("path");
+var import_js_yaml4 = require("js-yaml");
+function discoverWorkflowIds(projectRoot) {
+  const artifactsDir = (0, import_path9.join)(projectRoot, ".stackwright", "artifacts");
+  if (!(0, import_fs9.existsSync)(artifactsDir)) return [];
+  const entries = [];
+  let files;
+  try {
+    files = (0, import_fs9.readdirSync)(artifactsDir);
+  } catch {
+    return [];
+  }
+  for (const filename of files) {
+    if (filename !== "workflow-config.json" && !filename.startsWith("workflow-config-")) continue;
+    if (!filename.endsWith(".json")) continue;
+    const fullPath = (0, import_path9.join)(artifactsDir, filename);
+    try {
+      const raw = JSON.parse((0, import_fs9.readFileSync)(fullPath, "utf-8"));
+      const workflowData = raw["workflow"] ?? raw["workflowConfig"];
+      const workflowId = typeof workflowData?.["id"] === "string" ? workflowData["id"] : null;
+      if (workflowId && /^[a-z0-9-]+$/.test(workflowId)) {
+        entries.push({ workflowId, sourceFile: filename });
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function hasWorkflowWizardType(filePath) {
+  try {
+    const raw = (0, import_fs9.readFileSync)(filePath, "utf-8");
+    const parsed = (0, import_js_yaml4.load)(raw);
+    if (!parsed) return false;
+    const content = parsed["content"];
+    if (!content) return false;
+    const items = content["content_items"];
+    if (!Array.isArray(items)) return false;
+    return items.some((item) => item["type"] === "workflow_wizard");
+  } catch {
+    return false;
+  }
+}
+function validateWorkflowContainerPages(projectRoot) {
+  const workflows = discoverWorkflowIds(projectRoot);
+  if (workflows.length === 0) {
+    return { valid: true, violations: [], skipped: true };
+  }
+  const violations = [];
+  for (const { workflowId, sourceFile: _sourceFile } of workflows) {
+    const expectedPath = `pages/workflows/${workflowId}/content.yml`;
+    const fullPath = (0, import_path9.join)(projectRoot, expectedPath);
+    if (!(0, import_fs9.existsSync)(fullPath)) {
+      violations.push({ workflowId, expectedPath, reason: "missing-file" });
+      continue;
+    }
+    if (!hasWorkflowWizardType(fullPath)) {
+      violations.push({ workflowId, expectedPath, reason: "missing-workflow-wizard-type" });
+    }
+  }
+  if (violations.length === 0) {
+    return { valid: true, violations: [] };
+  }
+  const lines = [
+    `Workflow container page cross-check failed: ${violations.length} workflow(s) missing container pages.`,
+    "",
+    ...violations.map((v, i) => {
+      const reason = v.reason === "missing-file" ? `File does not exist. Create it via stackwright_pro_write_workflow_container_page.` : `File exists but has no workflow_wizard content item. Must contain type: workflow_wizard.`;
+      return `  ${i + 1}. workflowId "${v.workflowId}"
+     Expected: ${v.expectedPath}
+     Issue: ${reason}`;
+    }),
+    "",
+    "Fix: workflow-otter must call stackwright_pro_write_workflow_container_page immediately",
+    "after writing each workflow YAML. Required args:",
+    '  { workflowId, workflowFile, pageSlug: "workflows/<workflowId>", label, requiredRoles }',
+    "",
+    "Without the container page, the route 404s and auth-reconcile cannot protect it."
+  ];
+  return {
+    valid: false,
+    violations,
+    retryPrompt: lines.join("\n")
+  };
+}
+
 // src/tools/validate-api-integration.ts
 var CANONICAL_API_AUTH_TYPES = ["apiKey", "bearer", "oauth2", "oidc", "none"];
 var CANONICAL_SET = new Set(CANONICAL_API_AUTH_TYPES);
@@ -2751,9 +3330,9 @@ function validateAuthConfig(artifact, artifactPath) {
 }
 
 // src/tools/auth-manifest-aggregator.ts
-var import_fs6 = require("fs");
-var import_path6 = require("path");
-var import_zod11 = require("zod");
+var import_fs10 = require("fs");
+var import_path10 = require("path");
+var import_zod12 = require("zod");
 function computeLowestRole(requiredRoles, rbacRoles) {
   let lowestIndex = -1;
   let lowestRole = requiredRoles[0];
@@ -2773,17 +3352,17 @@ function extractPatternBaseSlug(pattern) {
 }
 function extractManifestSlugs(artifactsDir) {
   const slugs = /* @__PURE__ */ new Set();
-  if (!(0, import_fs6.existsSync)(artifactsDir)) return slugs;
+  if (!(0, import_fs10.existsSync)(artifactsDir)) return slugs;
   let entries;
   try {
-    entries = (0, import_fs6.readdirSync)(artifactsDir);
+    entries = (0, import_fs10.readdirSync)(artifactsDir);
   } catch {
     return slugs;
   }
   for (const entry of entries) {
     if (!entry.endsWith("-manifest.json")) continue;
     try {
-      const content = JSON.parse((0, import_fs6.readFileSync)((0, import_path6.join)(artifactsDir, entry), "utf-8"));
+      const content = JSON.parse((0, import_fs10.readFileSync)((0, import_path10.join)(artifactsDir, entry), "utf-8"));
       const pages = content.pages;
       if (!Array.isArray(pages)) continue;
       for (const page of pages) {
@@ -2826,18 +3405,18 @@ function deriveProtectedRoutes(pages, rbacRoles) {
 }
 function readAllManifestPages(artifactsDir) {
   const allPages = [];
-  if (!(0, import_fs6.existsSync)(artifactsDir)) return allPages;
+  if (!(0, import_fs10.existsSync)(artifactsDir)) return allPages;
   let entries;
   try {
-    entries = (0, import_fs6.readdirSync)(artifactsDir);
+    entries = (0, import_fs10.readdirSync)(artifactsDir);
   } catch {
     return allPages;
   }
   for (const entry of entries) {
     if (entry.endsWith("-manifest.json")) {
-      const filePath = (0, import_path6.join)(artifactsDir, entry);
+      const filePath = (0, import_path10.join)(artifactsDir, entry);
       try {
-        const raw = JSON.parse((0, import_fs6.readFileSync)(filePath, "utf-8"));
+        const raw = JSON.parse((0, import_fs10.readFileSync)(filePath, "utf-8"));
         if (!Array.isArray(raw.pages)) continue;
         for (const page of raw.pages) {
           if (typeof page.slug !== "string" || !page.slug) continue;
@@ -2853,9 +3432,9 @@ function readAllManifestPages(artifactsDir) {
       continue;
     }
     if (entry === "workflow-config.json" || entry.startsWith("workflow-config-")) {
-      const filePath = (0, import_path6.join)(artifactsDir, entry);
+      const filePath = (0, import_path10.join)(artifactsDir, entry);
       try {
-        const raw = JSON.parse((0, import_fs6.readFileSync)(filePath, "utf-8"));
+        const raw = JSON.parse((0, import_fs10.readFileSync)(filePath, "utf-8"));
         const route = raw.workflow?.route;
         if (typeof route !== "string" || !route) continue;
         const slug = route.startsWith("/") ? route.slice(1) : route;
@@ -2877,16 +3456,16 @@ function registerReadAuthManifestsTool(server2) {
     "stackwright_pro_read_auth_manifests",
     "Read ALL route-producing artifacts from the pipeline artifacts directory: *-manifest.json files (pages, dashboard, geo, form-wizard) AND workflow-config.json / workflow-config-*.json (different shape: workflow.route). Deterministically derives protectedRoutes and uncoveredSlugs. Uses the both-forms invariant (swp-n7kk): every authRequired route registers BOTH /{slug} (exact) AND /{slug}/:path* (sub-path). Workflow routes appear in uncoveredSlugs (no requiredRoles declared) for auth-reconcile to resolve via cross-cutting rules from auth-config.json. Extended by swp-hng0 to cover all four manifest types (was: pages+dashboard only).",
     {
-      rbacRoles: import_zod11.z.array(import_zod11.z.string()).describe(
+      rbacRoles: import_zod12.z.array(import_zod12.z.string()).describe(
         'RBAC role hierarchy in descending privilege order, e.g. ["ESF8_COORDINATOR", "HOSPITAL_EM", "OBSERVER"]. Used to compute the lowestRole for each authRequired page.'
       ),
-      artifactsDir: import_zod11.z.string().optional().describe(
+      artifactsDir: import_zod12.z.string().optional().describe(
         "Absolute or relative path to the pipeline artifacts directory. Defaults to .stackwright/artifacts relative to cwd."
       )
     },
     (params) => {
       const cwd = process.cwd();
-      const artifactsDir = params.artifactsDir ? params.artifactsDir : (0, import_path6.join)(cwd, ".stackwright", "artifacts");
+      const artifactsDir = params.artifactsDir ? params.artifactsDir : (0, import_path10.join)(cwd, ".stackwright", "artifacts");
       const allPages = readAllManifestPages(artifactsDir);
       const { protectedRoutes, uncoveredSlugs } = deriveProtectedRoutes(allPages, params.rbacRoles);
       const manifestsRead = [...new Set(allPages.map((p) => p.source))].sort();
@@ -2909,183 +3488,11 @@ function registerReadAuthManifestsTool(server2) {
 }
 
 // src/tools/pipeline.ts
-var import_types3 = require("@stackwright-pro/types");
-
-// src/tools/get-schema.ts
-var import_zod13 = require("zod");
 var import_types2 = require("@stackwright-pro/types");
 
-// src/tools/validate-yaml-fragment.ts
-var import_zod12 = require("zod");
-var import_js_yaml2 = require("js-yaml");
-var import_types = require("@stackwright-pro/types");
-var SUPPORTED_SCHEMA_NAMES = [
-  "workflow_step",
-  "workflow_definition",
-  "workflow_field",
-  "workflow_action",
-  "navigation_item",
-  "auth_config"
-];
-var NavigationLinkSchema = import_zod12.z.lazy(
-  () => import_zod12.z.object({
-    label: import_zod12.z.string().min(1),
-    href: import_zod12.z.string().min(1),
-    children: import_zod12.z.array(NavigationLinkSchema).optional()
-  })
-);
-var NavigationSectionSchema = import_zod12.z.object({
-  section: import_zod12.z.string().min(1),
-  items: import_zod12.z.array(NavigationLinkSchema)
-});
-var NavigationItemSchema = import_zod12.z.union([
-  NavigationLinkSchema,
-  NavigationSectionSchema
-]);
-var FIELD_SYNONYMS = {
-  workflow_step: {
-    title: "label",
-    name: "label (at step level, use label: not name:)",
-    description: "message (use message: for step-level descriptive text)",
-    style: 'theme.variant \u2014 use theme: { variant: "primary" } not style: "primary"',
-    transitions: 'on_submit.transition \u2014 use on_submit: { transition: "next_step" } not transitions: [{then:...}]'
-  },
-  workflow_definition: {
-    title: "label",
-    name: "label (workflow-level label, not name:)",
-    description: "description is valid here \u2014 but message: is not (that is a step field)",
-    type: "id (workflows are identified by id:, not type:)"
-  },
-  workflow_field: {
-    id: "name (field-level identifier is name:, NOT id:)",
-    title: "label (field display text is label:, NOT title:)",
-    description: "placeholder or label (no description field on WorkflowField)"
-  },
-  workflow_action: {
-    style: 'theme.variant \u2014 use theme: { variant: "primary" } not style: "primary"',
-    then: "transition (action-level next-step is transition:, NOT then:)",
-    on_click: 'action: "service:..." (extract the service reference from on_click.action)',
-    title: "label (action display text is label:, NOT title:)",
-    name: "label (action display text is label:, NOT name:)"
-  },
-  navigation_item: {
-    children: "items (NavigationSection uses items: not children: \u2014 also use section: instead of label: for section headers)",
-    label: 'section (if this is a nav group/section, use section: "Title" and items: [...], not label:)',
-    title: "section (NavigationSection header field is section:, NOT title:)"
-  },
-  auth_config: {
-    method: 'type \u2014 auth config discriminates on type: "oidc" | "pki", NOT method:',
-    provider_type: 'type \u2014 use type: "oidc" or type: "pki"',
-    strategy: "type \u2014 top-level discriminator is type:, not strategy:"
-  }
-};
-function getSchema(name) {
-  switch (name) {
-    case "workflow_step":
-      return import_types.WorkflowStepSchema;
-    case "workflow_definition":
-      return import_types.WorkflowDefinitionSchema;
-    case "workflow_field":
-      return import_types.WorkflowFieldSchema;
-    case "workflow_action":
-      return import_types.WorkflowActionSchema;
-    case "navigation_item":
-      return NavigationItemSchema;
-    case "auth_config":
-      return import_types.authConfigSchema;
-  }
-}
-function enrichErrors(issues, synonyms) {
-  return issues.map((issue) => {
-    const pathStr = issue.path.join(".");
-    const lastSegment = issue.path[issue.path.length - 1];
-    const fieldName = typeof lastSegment === "string" ? lastSegment : void 0;
-    const didYouMean = fieldName ? synonyms[fieldName] : void 0;
-    return {
-      path: pathStr || "(root)",
-      message: issue.message,
-      ...didYouMean ? { didYouMean } : {}
-    };
-  });
-}
-function handleValidateYamlFragment(input) {
-  const { schemaName, yaml: yaml4 } = input;
-  if (!SUPPORTED_SCHEMA_NAMES.includes(schemaName)) {
-    return {
-      valid: false,
-      parseError: `Unknown schemaName: "${schemaName}". Supported: ${SUPPORTED_SCHEMA_NAMES.join(", ")}`
-    };
-  }
-  const name = schemaName;
-  let parsed;
-  try {
-    parsed = (0, import_js_yaml2.load)(yaml4);
-  } catch (err) {
-    return {
-      valid: false,
-      parseError: `YAML parse error: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-  const schema = getSchema(name);
-  const result = schema.safeParse(parsed);
-  if (result.success) {
-    return { valid: true };
-  }
-  const synonyms = FIELD_SYNONYMS[name];
-  const errors = enrichErrors(result.error.issues, synonyms);
-  return { valid: false, errors };
-}
-function registerValidateYamlFragmentTool(server2) {
-  server2.tool(
-    "stackwright_pro_validate_yaml_fragment",
-    'Validates a YAML snippet against a canonical Zod schema before writing to disk. Returns actionable errors with "did you mean?" suggestions for common field-name drift (title vs label, id vs name, style vs theme.variant, etc.). Call this before stackwright_pro_safe_write to catch schema violations in-session.',
-    {
-      schemaName: import_zod12.z.enum(SUPPORTED_SCHEMA_NAMES).describe(
-        "Schema to validate against. One of: workflow_step, workflow_definition, workflow_field, workflow_action, navigation_item, auth_config"
-      ),
-      yaml: import_zod12.z.string().describe("YAML string to validate (can also be JSON \u2014 js-yaml parses both)")
-    },
-    async ({ schemaName, yaml: yaml4 }) => {
-      const result = handleValidateYamlFragment({ schemaName, yaml: yaml4 });
-      return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-      };
-    }
-  );
-}
-
 // src/tools/get-schema.ts
-var NavigationLinkSchema2 = import_zod13.z.lazy(
-  () => import_zod13.z.object({
-    label: import_zod13.z.string().min(1),
-    href: import_zod13.z.string().min(1),
-    children: import_zod13.z.array(NavigationLinkSchema2).optional()
-  })
-);
-var NavigationSectionSchema2 = import_zod13.z.object({
-  section: import_zod13.z.string().min(1),
-  items: import_zod13.z.array(NavigationLinkSchema2)
-});
-var NavigationItemSchema2 = import_zod13.z.union([
-  NavigationLinkSchema2,
-  NavigationSectionSchema2
-]);
-function getZodSchema(name) {
-  switch (name) {
-    case "workflow_step":
-      return import_types2.WorkflowStepSchema;
-    case "workflow_definition":
-      return import_types2.WorkflowDefinitionSchema;
-    case "workflow_field":
-      return import_types2.WorkflowFieldSchema;
-    case "workflow_action":
-      return import_types2.WorkflowActionSchema;
-    case "navigation_item":
-      return NavigationItemSchema2;
-    case "auth_config":
-      return import_types2.authConfigSchema;
-  }
-}
+var import_zod13 = require("zod");
+var PHASE_SCHEMA_NAMES = buildPhaseSchemaNames();
 function formatType(node, depth = 0) {
   if (node.const !== void 0) return JSON.stringify(node.const);
   if (node.enum) return node.enum.map((v) => JSON.stringify(v)).join(" | ");
@@ -3112,7 +3519,7 @@ function formatType(node, depth = 0) {
   if (node.maximum !== void 0) constraints.push(`max ${node.maximum}`);
   return constraints.length > 0 ? `${base} (${constraints.join(", ")})` : base;
 }
-function formatObjectSchema(node, schemaName, synonyms) {
+function formatObjectSchema(node, schemaName, reverseSynonyms) {
   const lines = [];
   const displayName = schemaName.split("_").map((w) => w[0].toUpperCase() + w.slice(1)).join("");
   lines.push(`${displayName}:`);
@@ -3126,7 +3533,8 @@ function formatObjectSchema(node, schemaName, synonyms) {
       for (const [field, fieldNode] of Object.entries(branch.properties ?? {})) {
         if (fieldNode.const !== void 0) continue;
         const isRequired = req.has(field);
-        const hint = synonyms[field] ? `  -- WARNING: use ${field}: not ${synonyms[field]}` : "";
+        const correctFor = reverseSynonyms[field];
+        const hint = correctFor ? `  -- WARNING: use ${correctFor}: not ${field}:` : "";
         lines.push(
           `    ${isRequired ? "REQUIRED" : "optional"}: ${field}: ${formatType(fieldNode)}${hint}`
         );
@@ -3134,6 +3542,12 @@ function formatObjectSchema(node, schemaName, synonyms) {
     }
     return lines.join("\n");
   }
+  if (!node.properties && !node.oneOf && !node.anyOf) {
+    const typeStr = formatType(node);
+    lines.push(`  type: ${typeStr}`);
+    if (node.description) lines.push(`  description: ${node.description}`);
+    return lines.join("\n");
+  }
   const required = new Set(node.required ?? []);
   const properties = node.properties ?? {};
   const requiredFields = Object.entries(properties).filter(([k]) => required.has(k));
@@ -3142,8 +3556,7 @@ function formatObjectSchema(node, schemaName, synonyms) {
     lines.push("  REQUIRED:");
     for (const [field, fieldNode] of requiredFields) {
       const typeStr = formatType(fieldNode);
-      const warn = synonyms[field] ? `  -- CAUTION: this schema uses ${field}` : "";
-      lines.push(`    ${field}: ${typeStr}${warn}`);
+      lines.push(`    ${field}: ${typeStr}`);
     }
   }
   if (optionalFields.length > 0) {
@@ -3157,24 +3570,30 @@ function formatObjectSchema(node, schemaName, synonyms) {
 }
 function handleGetSchema(input) {
   const { schemaName } = input;
-  if (!SUPPORTED_SCHEMA_NAMES.includes(schemaName)) {
+  const entry = SCHEMA_REGISTRY.get(schemaName);
+  if (!entry) {
     return {
-      error: `Unknown schemaName: "${schemaName}". Supported: ${SUPPORTED_SCHEMA_NAMES.join(", ")}`
+      error: `Unknown schemaName: "${schemaName}". Supported: ${REGISTRY_SCHEMA_NAMES.join(", ")}`
     };
   }
-  const name = schemaName;
-  const schema = getZodSchema(name);
-  const synonyms = FIELD_SYNONYMS[name];
+  const synonyms = entry.synonyms ?? {};
+  const reverseSynonyms = {};
+  for (const [correct, wrongs] of Object.entries(synonyms)) {
+    for (const wrong of wrongs) {
+      reverseSynonyms[wrong] = correct;
+    }
+  }
+  const ctx = input.projectRoot ? { projectRoot: input.projectRoot } : void 0;
+  const resolvedSchema = getSchemaForEntry(entry, ctx);
   let jsonSchema;
   try {
-    const raw = import_zod13.z.toJSONSchema(schema, { unrepresentable: "any" });
-    jsonSchema = raw;
+    jsonSchema = import_zod13.z.toJSONSchema(resolvedSchema, { unrepresentable: "any" });
   } catch {
     jsonSchema = { type: "object", description: "Schema introspection unavailable for this type" };
   }
-  const summary = formatObjectSchema(jsonSchema, name, synonyms);
+  const summary = formatObjectSchema(jsonSchema, schemaName, reverseSynonyms);
   const synonymWarnings = Object.entries(synonyms).map(
-    ([wrong, correct]) => `  WARNING: use "${correct}" \u2014 NOT "${wrong}"`
+    ([correct, wrongs]) => `  WARNING: use "${correct}" \u2014 NOT ${wrongs.map((w) => `"${w}"`).join(" or ")}`
   );
   const fullText = [
     summary,
@@ -3184,19 +3603,12 @@ function handleGetSchema(input) {
   ].join("\n");
   const tokenEstimate = Math.ceil(fullText.length / 4);
   return {
-    schemaName: name,
+    schemaName,
     summary,
     synonymWarnings,
     tokenEstimate
   };
 }
-var PHASE_SCHEMA_NAMES = {
-  workflow: ["workflow_step", "workflow_definition", "workflow_field", "workflow_action"],
-  pages: ["navigation_item"],
-  dashboard: ["navigation_item"],
-  polish: ["navigation_item"],
-  auth: ["auth_config"]
-};
 function buildSchemaReferenceBlock(phase) {
   const schemaNames = PHASE_SCHEMA_NAMES[phase];
   if (!schemaNames || schemaNames.length === 0) return null;
@@ -3221,12 +3633,13 @@ function registerGetSchemaTool(server2) {
     "stackwright_pro_get_schema",
     'Returns a compact, LLM-friendly summary of a canonical schema derived programmatically from Zod. Includes required/optional fields, types, constraints, and "did you mean?" warnings for common field-name drift. Use before authoring YAML to confirm exact field names.',
     {
-      schemaName: import_zod13.z.enum(SUPPORTED_SCHEMA_NAMES).describe(
-        "Schema to summarize. One of: workflow_step, workflow_definition, workflow_field, workflow_action, navigation_item, auth_config"
+      schemaName: import_zod13.z.string().describe(`Schema to summarize. Available: ${REGISTRY_SCHEMA_NAMES.join(", ")}`),
+      projectRoot: import_zod13.z.string().optional().describe(
+        "Absolute path to the project root. Required for factory schemas like theme_status_token. Defaults to cwd."
       )
     },
-    async ({ schemaName }) => {
-      const result = handleGetSchema({ schemaName });
+    async ({ schemaName, projectRoot }) => {
+      const result = handleGetSchema({ schemaName, projectRoot: projectRoot ?? process.cwd() });
       if ("error" in result) {
         return {
           content: [{ type: "text", text: JSON.stringify({ error: result.error }) }],
@@ -3246,8 +3659,8 @@ function registerGetSchemaTool(server2) {
 }
 
 // src/tools/pipeline-graph.ts
-var import_fs7 = require("fs");
-var import_path7 = require("path");
+var import_fs11 = require("fs");
+var import_path11 = require("path");
 var MANIFEST_NAME_TO_PHASE = {
   "stackwright-pro-designer-otter": "designer",
   "stackwright-pro-theme-otter": "theme",
@@ -3279,10 +3692,10 @@ var OTTER_SEARCH_PATHS = [
 ];
 function resolveOtterDirFromCwd() {
   const cwd = process.cwd();
-  for (const relative2 of OTTER_SEARCH_PATHS) {
-    const candidate = (0, import_path7.join)(cwd, relative2);
+  for (const relative4 of OTTER_SEARCH_PATHS) {
+    const candidate = (0, import_path11.join)(cwd, relative4);
     try {
-      (0, import_fs7.lstatSync)(candidate);
+      (0, import_fs11.lstatSync)(candidate);
       return candidate;
     } catch {
     }
@@ -3292,14 +3705,14 @@ function resolveOtterDirFromCwd() {
   );
 }
 function loadOtterManifestsFromDir(otterDir) {
-  const entries = (0, import_fs7.readdirSync)(otterDir);
+  const entries = (0, import_fs11.readdirSync)(otterDir);
   const manifests = [];
   for (const filename of entries) {
     if (!filename.endsWith("-otter.json")) continue;
-    const filePath = (0, import_path7.join)(otterDir, filename);
-    if ((0, import_fs7.lstatSync)(filePath).isSymbolicLink()) continue;
+    const filePath = (0, import_path11.join)(otterDir, filename);
+    if ((0, import_fs11.lstatSync)(filePath).isSymbolicLink()) continue;
     try {
-      const raw = (0, import_fs7.readFileSync)(filePath, "utf-8");
+      const raw = (0, import_fs11.readFileSync)(filePath, "utf-8");
       const manifest = JSON.parse(raw);
       manifests.push(manifest);
     } catch (err) {
@@ -3404,19 +3817,19 @@ var DISTRIBUTED_NAMESPACES = ["@stackwright-pro", "@stackwright"];
 function loadDistributedOtterManifests(cwd) {
   const results = [];
   for (const namespace of DISTRIBUTED_NAMESPACES) {
-    const nsDir = (0, import_path7.join)(cwd, "node_modules", namespace);
+    const nsDir = (0, import_path11.join)(cwd, "node_modules", namespace);
     let pkgDirNames;
     try {
-      pkgDirNames = (0, import_fs7.readdirSync)(nsDir);
+      pkgDirNames = (0, import_fs11.readdirSync)(nsDir);
     } catch {
       continue;
     }
     for (const pkgDirName of pkgDirNames) {
-      const pkgDir = (0, import_path7.join)(nsDir, pkgDirName);
+      const pkgDir = (0, import_path11.join)(nsDir, pkgDirName);
       const packageName = `${namespace}/${pkgDirName}`;
       let otterRelPaths;
       try {
-        const raw = (0, import_fs7.readFileSync)((0, import_path7.join)(pkgDir, "package.json"), "utf-8");
+        const raw = (0, import_fs11.readFileSync)((0, import_path11.join)(pkgDir, "package.json"), "utf-8");
         const pkgJson = JSON.parse(raw);
         const declared = pkgJson.stackwright?.otters;
         if (!Array.isArray(declared) || declared.length === 0) continue;
@@ -3425,9 +3838,9 @@ function loadDistributedOtterManifests(cwd) {
         continue;
       }
       for (const relPath of otterRelPaths) {
-        const otterFilePath = (0, import_path7.join)(pkgDir, relPath);
+        const otterFilePath = (0, import_path11.join)(pkgDir, relPath);
         try {
-          const raw = (0, import_fs7.readFileSync)(otterFilePath, "utf-8");
+          const raw = (0, import_fs11.readFileSync)(otterFilePath, "utf-8");
           const manifest = JSON.parse(raw);
           results.push({ manifest, packageName });
         } catch (err) {
@@ -3572,45 +3985,45 @@ function createDefaultState() {
   };
 }
 function statePath(cwd) {
-  return (0, import_path8.join)(cwd, ".stackwright", "pipeline-state.json");
+  return (0, import_path12.join)(cwd, ".stackwright", "pipeline-state.json");
 }
 function readState(cwd) {
   const p = statePath(cwd);
-  if (!(0, import_fs8.existsSync)(p)) return createDefaultState();
+  if (!(0, import_fs12.existsSync)(p)) return createDefaultState();
   const raw = JSON.parse(safeReadSync(p));
   const result = PipelineStateSchema.safeParse(raw);
   if (!result.success) return createDefaultState();
   return result.data;
 }
 function safeWriteSync(filePath, content) {
-  if ((0, import_fs8.existsSync)(filePath)) {
-    const stat = (0, import_fs8.lstatSync)(filePath);
+  if ((0, import_fs12.existsSync)(filePath)) {
+    const stat = (0, import_fs12.lstatSync)(filePath);
     if (stat.isSymbolicLink()) {
       throw new Error(`Refusing to write to symlink: ${filePath}`);
     }
   }
-  (0, import_fs8.writeFileSync)(filePath, content);
+  (0, import_fs12.writeFileSync)(filePath, content);
 }
 function safeReadSync(filePath) {
-  if ((0, import_fs8.existsSync)(filePath)) {
-    const stat = (0, import_fs8.lstatSync)(filePath);
+  if ((0, import_fs12.existsSync)(filePath)) {
+    const stat = (0, import_fs12.lstatSync)(filePath);
     if (stat.isSymbolicLink()) {
       throw new Error(`Refusing to read symlink: ${filePath}`);
     }
   }
-  return (0, import_fs8.readFileSync)(filePath, "utf-8");
+  return (0, import_fs12.readFileSync)(filePath, "utf-8");
 }
 function writeState(cwd, state) {
-  const dir = (0, import_path8.join)(cwd, ".stackwright");
-  (0, import_fs8.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path12.join)(cwd, ".stackwright");
+  (0, import_fs12.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_path8.join)(cwd, ".stackwright");
-  (0, import_fs8.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path12.join)(cwd, ".stackwright");
+  (0, import_fs12.mkdirSync)(dir, { recursive: true });
   const path5 = statePath(cwd);
-  if (!(0, import_fs8.existsSync)(path5)) {
+  if (!(0, import_fs12.existsSync)(path5)) {
     safeWriteSync(path5, JSON.stringify(createDefaultState(), null, 2) + "\n");
   }
   const release = (0, import_proper_lockfile.lockSync)(path5, {
@@ -3644,8 +4057,8 @@ function handleGetPipelineState(_cwd) {
   const cwd = _cwd ?? process.cwd();
   try {
     const state = readState(cwd);
-    const keyPath = (0, import_path8.join)(cwd, ".stackwright", "pipeline-keys.json");
-    if (!(0, import_fs8.existsSync)(keyPath)) {
+    const keyPath = (0, import_path12.join)(cwd, ".stackwright", "pipeline-keys.json");
+    if (!(0, import_fs12.existsSync)(keyPath)) {
       try {
         const { fingerprint } = initPipelineKeys(cwd);
         state["signingKeyFingerprint"] = fingerprint;
@@ -3784,8 +4197,8 @@ function handleCheckExecutionReady(_cwd, phase) {
     if (AUTO_EXECUTE_PHASES.has(phase)) {
       return { text: JSON.stringify({ ready: true, phase, autoExecute: true }), isError: false };
     }
-    const answerFile = (0, import_path8.join)(cwd, ".stackwright", "answers", `${phase}.json`);
-    if (!(0, import_fs8.existsSync)(answerFile)) {
+    const answerFile = (0, import_path12.join)(cwd, ".stackwright", "answers", `${phase}.json`);
+    if (!(0, import_fs12.existsSync)(answerFile)) {
       return {
         text: JSON.stringify({ ready: false, phase, reason: "Answer file not found" }),
         isError: false
@@ -3809,7 +4222,7 @@ function handleCheckExecutionReady(_cwd, phase) {
     }
   }
   try {
-    const answersDir = (0, import_path8.join)(cwd, ".stackwright", "answers");
+    const answersDir = (0, import_path12.join)(cwd, ".stackwright", "answers");
     const answeredPhases = [];
     const missingPhases = [];
     for (const phase2 of PHASE_ORDER) {
@@ -3817,8 +4230,8 @@ function handleCheckExecutionReady(_cwd, phase) {
         answeredPhases.push(phase2);
         continue;
       }
-      const answerFile = (0, import_path8.join)(answersDir, `${phase2}.json`);
-      if ((0, import_fs8.existsSync)(answerFile)) {
+      const answerFile = (0, import_path12.join)(answersDir, `${phase2}.json`);
+      if ((0, import_fs12.existsSync)(answerFile)) {
         try {
           const raw = safeReadSync(answerFile);
           const parsed = JSON.parse(raw);
@@ -3887,7 +4300,7 @@ function handleGetReadyPhases(_cwd) {
 function handleListArtifacts(_cwd) {
   const cwd = _cwd ?? process.cwd();
   try {
-    const artifactsDir = (0, import_path8.join)(cwd, ".stackwright", "artifacts");
+    const artifactsDir = (0, import_path12.join)(cwd, ".stackwright", "artifacts");
     let manifest = null;
     try {
       manifest = loadSignatureManifest(cwd);
@@ -3897,8 +4310,8 @@ function handleListArtifacts(_cwd) {
     let completedCount = 0;
     for (const phase of PHASE_ORDER) {
       const expectedFile = PHASE_ARTIFACT[phase];
-      const fullPath = (0, import_path8.join)(artifactsDir, expectedFile);
-      const exists = (0, import_fs8.existsSync)(fullPath);
+      const fullPath = (0, import_path12.join)(artifactsDir, expectedFile);
+      const exists = (0, import_fs12.existsSync)(fullPath);
       if (exists) completedCount++;
       let signed = false;
       let signatureValid = null;
@@ -3951,9 +4364,9 @@ function handleWritePhaseQuestions(input) {
       }
     } catch {
     }
-    const questionsDir = (0, import_path8.join)(cwd, ".stackwright", "questions");
-    (0, import_fs8.mkdirSync)(questionsDir, { recursive: true });
-    const filePath = (0, import_path8.join)(questionsDir, `${phase}.json`);
+    const questionsDir = (0, import_path12.join)(cwd, ".stackwright", "questions");
+    (0, import_fs12.mkdirSync)(questionsDir, { recursive: true });
+    const filePath = (0, import_path12.join)(questionsDir, `${phase}.json`);
     const payload = {
       version: "1.0",
       phase,
@@ -3993,14 +4406,14 @@ function handleBuildSpecialistPrompt(input) {
     };
   }
   try {
-    const answersPath = (0, import_path8.join)(cwd, ".stackwright", "answers", `${phase}.json`);
+    const answersPath = (0, import_path12.join)(cwd, ".stackwright", "answers", `${phase}.json`);
     let answers = {};
-    if ((0, import_fs8.existsSync)(answersPath)) {
+    if ((0, import_fs12.existsSync)(answersPath)) {
       answers = JSON.parse(safeReadSync(answersPath));
     }
     let buildContextText = "";
-    const buildContextPath = (0, import_path8.join)(cwd, ".stackwright", "build-context.json");
-    if ((0, import_fs8.existsSync)(buildContextPath)) {
+    const buildContextPath = (0, import_path12.join)(cwd, ".stackwright", "build-context.json");
+    if ((0, import_fs12.existsSync)(buildContextPath)) {
       try {
         const bcRaw = JSON.parse(safeReadSync(buildContextPath));
         if (typeof bcRaw.buildContext === "string" && bcRaw.buildContext.trim().length > 0) {
@@ -4015,8 +4428,8 @@ function handleBuildSpecialistPrompt(input) {
     const missingDependencies = [];
     for (const dep of deps) {
       const artifactFile = PHASE_ARTIFACT[dep];
-      const artifactPath = (0, import_path8.join)(cwd, ".stackwright", "artifacts", artifactFile);
-      if ((0, import_fs8.existsSync)(artifactPath)) {
+      const artifactPath = (0, import_path12.join)(cwd, ".stackwright", "artifacts", artifactFile);
+      if ((0, import_fs12.existsSync)(artifactPath)) {
         const rawContent = safeReadSync(artifactPath);
         const rawBytes = Buffer.from(rawContent, "utf-8");
         const content = JSON.parse(rawContent);
@@ -4081,8 +4494,8 @@ ${JSON.stringify(content, null, 2)}`
       parts.push("BUILD_CONTEXT:", buildContextText, "");
     }
     if (phase === "auth") {
-      const initContextPath = (0, import_path8.join)(cwd, ".stackwright", "init-context.json");
-      if ((0, import_fs8.existsSync)(initContextPath)) {
+      const initContextPath = (0, import_path12.join)(cwd, ".stackwright", "init-context.json");
+      if ((0, import_fs12.existsSync)(initContextPath)) {
         try {
           const initContext = JSON.parse(safeReadSync(initContextPath));
           if (initContext.devOnly === true || initContext.nonInteractive === true) {
@@ -4223,7 +4636,12 @@ var PHASE_ARTIFACT_SCHEMA = {
         "--surface": "210 40% 98%",
         "--border": "214.3 31.8% 91.4%"
       },
-      dark: { "--background": "222.2 84% 4.9%", "--foreground": "210 40% 98%" }
+      dark: { "--background": "222.2 84% 4.9%", "--foreground": "210 40% 98%" },
+      // Optional — include when design language has status semantics (swp-cxwu).
+      // Array of status-* token names emitted in tokens.colors.
+      // Consumed by validate_artifact theme enforcement to reject unknown status tokens.
+      // OMIT if project has no status-coded data.
+      statusLadder: ["status-ok", "status-warning", "status-error", "status-info"]
     },
     null,
     2
@@ -4650,7 +5068,7 @@ function _validateArtifactInner(input) {
         return { success: true };
       }
       if (typeof workflowData === "object" && workflowData !== null && "workflow" in workflowData) {
-        const result = import_types3.WorkflowFileSchema.safeParse(workflowData);
+        const result = import_types2.WorkflowFileSchema.safeParse(workflowData);
         if (!result.success) {
           const issues = result.error.issues.slice(0, 3).map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
           return { success: false, error: { message: issues } };
@@ -4661,7 +5079,7 @@ function _validateArtifactInner(input) {
     auth: (artifact2) => {
       const authConfig = artifact2["authConfig"];
       if (!authConfig) return { success: true };
-      const result = import_types3.authConfigSchema.safeParse(authConfig);
+      const result = import_types2.authConfigSchema.safeParse(authConfig);
       if (!result.success) {
         const issues = result.error.issues.slice(0, 3).map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
         return { success: false, error: { message: issues } };
@@ -4693,21 +5111,21 @@ function _validateArtifactInner(input) {
     // 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 artifactsDir = (0, import_path8.join)(cwd, ".stackwright", "artifacts");
+      const artifactsDir = (0, import_path12.join)(cwd, ".stackwright", "artifacts");
       const workflowArtifactFiles = [];
-      if ((0, import_fs8.existsSync)(artifactsDir)) {
+      if ((0, import_fs12.existsSync)(artifactsDir)) {
         try {
-          const entries = (0, import_fs8.readdirSync)(artifactsDir);
+          const entries = (0, import_fs12.readdirSync)(artifactsDir);
           for (const entry of entries) {
             if (entry.startsWith("workflow-config-") && entry.endsWith(".json")) {
-              workflowArtifactFiles.push((0, import_path8.join)(artifactsDir, entry));
+              workflowArtifactFiles.push((0, import_path12.join)(artifactsDir, entry));
             }
           }
         } catch {
         }
       }
-      const legacyPath = (0, import_path8.join)(artifactsDir, "workflow-config.json");
-      if ((0, import_fs8.existsSync)(legacyPath)) {
+      const legacyPath = (0, import_path12.join)(artifactsDir, "workflow-config.json");
+      if ((0, import_fs12.existsSync)(legacyPath)) {
         workflowArtifactFiles.push(legacyPath);
       }
       if (workflowArtifactFiles.length === 0) {
@@ -4716,7 +5134,7 @@ function _validateArtifactInner(input) {
       const declaredHooks = [];
       for (const filePath of workflowArtifactFiles) {
         try {
-          const parsed = JSON.parse((0, import_fs8.readFileSync)(filePath, "utf-8"));
+          const parsed = JSON.parse((0, import_fs12.readFileSync)(filePath, "utf-8"));
           if (Array.isArray(parsed.serviceHooks)) {
             declaredHooks.push(...parsed.serviceHooks);
           }
@@ -4806,6 +5224,42 @@ function _validateArtifactInner(input) {
       return { text: JSON.stringify(result), isError: false };
     }
   }
+  if (phase === "pages" || phase === "dashboard" || phase === "geo") {
+    const themeResult = validateThemeTokenUsage(cwd);
+    if (!themeResult.valid && !themeResult.skipped) {
+      const result = {
+        valid: false,
+        phase,
+        violation: "schema-mismatch",
+        retryPrompt: themeResult.retryPrompt
+      };
+      return { text: JSON.stringify(result), isError: false };
+    }
+  }
+  if (phase === "pages" || phase === "dashboard" || phase === "geo") {
+    const globalsResult = validateBuildContextGlobals(cwd);
+    if (!globalsResult.valid && !globalsResult.skipped) {
+      const result = {
+        valid: false,
+        phase,
+        violation: "schema-mismatch",
+        retryPrompt: globalsResult.retryPrompt
+      };
+      return { text: JSON.stringify(result), isError: false };
+    }
+  }
+  if (phase === "pages") {
+    const workflowCrossCheck = validateWorkflowContainerPages(cwd);
+    if (!workflowCrossCheck.valid) {
+      const result = {
+        valid: false,
+        phase,
+        violation: "schema-mismatch",
+        retryPrompt: workflowCrossCheck.retryPrompt
+      };
+      return { text: JSON.stringify(result), isError: false };
+    }
+  }
   if (phase === "api") {
     const apiAuthResult = validateApiIntegration(artifact, input.integrationName);
     if (!apiAuthResult.valid) {
@@ -4834,7 +5288,7 @@ function _validateArtifactInner(input) {
     const authCfg = artifact["authConfig"];
     const routes = authCfg?.["protectedRoutes"];
     if (Array.isArray(routes) && routes.length > 0) {
-      const artifactsDir = (0, import_path8.join)(cwd, ".stackwright", "artifacts");
+      const artifactsDir = (0, import_path12.join)(cwd, ".stackwright", "artifacts");
       const knownSlugs = extractManifestSlugs(artifactsDir);
       const orphanPatterns = [];
       for (const route of routes) {
@@ -4851,10 +5305,10 @@ function _validateArtifactInner(input) {
     }
   }
   try {
-    const artifactsDir = (0, import_path8.join)(cwd, ".stackwright", "artifacts");
-    (0, import_fs8.mkdirSync)(artifactsDir, { recursive: true });
+    const artifactsDir = (0, import_path12.join)(cwd, ".stackwright", "artifacts");
+    (0, import_fs12.mkdirSync)(artifactsDir, { recursive: true });
     const artifactFile = phase === "api" && input.integrationName ? `api-config-${input.integrationName}.json` : phase === "workflow" && input.workflowName ? `workflow-config-${input.workflowName}.json` : PHASE_ARTIFACT[phase];
-    const artifactPath = (0, import_path8.join)(artifactsDir, artifactFile);
+    const artifactPath = (0, import_path12.join)(artifactsDir, artifactFile);
     const serialized = JSON.stringify(artifact, null, 2) + "\n";
     const artifactBytes = Buffer.from(serialized, "utf-8");
     safeWriteSync(artifactPath, serialized);
@@ -5084,10 +5538,10 @@ function registerPipelineTools(server2) {
             isError: true
           };
         }
-        const questionsDir = (0, import_path8.join)(process.cwd(), ".stackwright", "questions");
-        (0, import_fs8.mkdirSync)(questionsDir, { recursive: true });
-        const outPath = (0, import_path8.join)(questionsDir, `${phase}.json`);
-        (0, import_fs8.writeFileSync)(
+        const questionsDir = (0, import_path12.join)(process.cwd(), ".stackwright", "questions");
+        (0, import_fs12.mkdirSync)(questionsDir, { recursive: true });
+        const outPath = (0, import_path12.join)(questionsDir, `${phase}.json`);
+        (0, import_fs12.writeFileSync)(
           outPath,
           JSON.stringify({ phase, questions, writtenAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)
         );
@@ -5179,8 +5633,8 @@ function registerPipelineTools(server2) {
 
 // src/tools/safe-write.ts
 var import_zod15 = require("zod");
-var import_fs9 = require("fs");
-var import_path9 = require("path");
+var import_fs13 = require("fs");
+var import_path13 = require("path");
 var import_telemetry2 = require("@stackwright-pro/telemetry");
 var OTTER_WRITE_ALLOWLISTS = {
   "stackwright-pro-designer-otter": [
@@ -5257,7 +5711,18 @@ var OTTER_WRITE_ALLOWLISTS = {
   "stackwright-pro-form-wizard-otter": [
     { prefix: "workflows/", suffix: ".yml", description: "Workflow definition" },
     { prefix: "workflows/", suffix: ".yaml", description: "Workflow definition" },
-    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Workflow config" }
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Workflow config" },
+    // swp-dvde: workflow-otter owns the container page to prevent the 404 gap
+    {
+      prefix: "pages/workflows/",
+      suffix: "/content.yml",
+      description: "Workflow container page content (swp-dvde)"
+    },
+    {
+      prefix: "pages/workflows/",
+      suffix: "/content.yaml",
+      description: "Workflow container page content (swp-dvde)"
+    }
   ],
   "stackwright-pro-scaffold-otter": [
     { prefix: "app/", suffix: ".tsx", description: "Next.js App Router shell files" },
@@ -5376,7 +5841,7 @@ function getMaxBytesForPath(filePath) {
 }
 var PAGE_REGISTRY_FILE = ".stackwright/page-registry.json";
 function extractPageSlug(filePath) {
-  const match = (0, import_path9.normalize)(filePath).match(/^pages\/(.+?)\/content\.ya?ml$/);
+  const match = (0, import_path13.normalize)(filePath).match(/^pages\/(.+?)\/content\.ya?ml$/);
   return match?.[1] ?? null;
 }
 function extractContentTypes(yamlContent) {
@@ -5392,27 +5857,27 @@ function extractContentTypes(yamlContent) {
   return types.length > 0 ? types : ["unknown"];
 }
 function readPageRegistry(cwd) {
-  const regPath = (0, import_path9.join)(cwd, PAGE_REGISTRY_FILE);
-  if (!(0, import_fs9.existsSync)(regPath)) return {};
+  const regPath = (0, import_path13.join)(cwd, PAGE_REGISTRY_FILE);
+  if (!(0, import_fs13.existsSync)(regPath)) return {};
   try {
-    const stat = (0, import_fs9.lstatSync)(regPath);
+    const stat = (0, import_fs13.lstatSync)(regPath);
     if (stat.isSymbolicLink()) return {};
-    return JSON.parse((0, import_fs9.readFileSync)(regPath, "utf-8"));
+    return JSON.parse((0, import_fs13.readFileSync)(regPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function writePageRegistry(cwd, registry) {
-  const dir = (0, import_path9.join)(cwd, ".stackwright");
-  (0, import_fs9.mkdirSync)(dir, { recursive: true });
-  const regPath = (0, import_path9.join)(cwd, PAGE_REGISTRY_FILE);
-  if ((0, import_fs9.existsSync)(regPath)) {
-    const stat = (0, import_fs9.lstatSync)(regPath);
+  const dir = (0, import_path13.join)(cwd, ".stackwright");
+  (0, import_fs13.mkdirSync)(dir, { recursive: true });
+  const regPath = (0, import_path13.join)(cwd, PAGE_REGISTRY_FILE);
+  if ((0, import_fs13.existsSync)(regPath)) {
+    const stat = (0, import_fs13.lstatSync)(regPath);
     if (stat.isSymbolicLink()) {
       throw new Error("Refusing to write page registry through symlink");
     }
   }
-  (0, import_fs9.writeFileSync)(regPath, JSON.stringify(registry, null, 2) + "\n", { encoding: "utf-8" });
+  (0, import_fs13.writeFileSync)(regPath, JSON.stringify(registry, null, 2) + "\n", { encoding: "utf-8" });
 }
 function checkPageOwnership(cwd, slug, callerOtter) {
   const registry = readPageRegistry(cwd);
@@ -5431,11 +5896,11 @@ function stripNextjsBracketSegments(path5) {
   return path5.replace(NEXTJS_BRACKET_SEGMENT_RE, "");
 }
 function checkPathAllowed(callerOtter, filePath) {
-  const normalized = (0, import_path9.normalize)(filePath);
+  const normalized = (0, import_path13.normalize)(filePath);
   if (stripNextjsBracketSegments(normalized).includes("..")) {
     return { allowed: false, error: 'Path traversal detected: ".." segments are not allowed' };
   }
-  if ((0, import_path9.isAbsolute)(normalized)) {
+  if ((0, import_path13.isAbsolute)(normalized)) {
     return {
       allowed: false,
       error: "Absolute paths are not allowed \u2014 use paths relative to project root"
@@ -5577,11 +6042,11 @@ function _safeWriteInner(input) {
     };
     return { text: JSON.stringify(result), isError: true };
   }
-  const normalized = (0, import_path9.normalize)(filePath);
-  const fullPath = (0, import_path9.join)(cwd, normalized);
-  if ((0, import_fs9.existsSync)(fullPath)) {
+  const normalized = (0, import_path13.normalize)(filePath);
+  const fullPath = (0, import_path13.join)(cwd, normalized);
+  if ((0, import_fs13.existsSync)(fullPath)) {
     try {
-      const stat = (0, import_fs9.lstatSync)(fullPath);
+      const stat = (0, import_fs13.lstatSync)(fullPath);
       if (stat.isSymbolicLink()) {
         const result = {
           success: false,
@@ -5622,9 +6087,9 @@ function _safeWriteInner(input) {
   }
   try {
     if (createDirectories) {
-      (0, import_fs9.mkdirSync)((0, import_path9.dirname)(fullPath), { recursive: true });
+      (0, import_fs13.mkdirSync)((0, import_path13.dirname)(fullPath), { recursive: true });
     }
-    (0, import_fs9.writeFileSync)(fullPath, content, { encoding: "utf-8" });
+    (0, import_fs13.writeFileSync)(fullPath, content, { encoding: "utf-8" });
     if (pageSlug) {
       try {
         const registry = readPageRegistry(cwd);
@@ -5709,8 +6174,8 @@ function registerSafeWriteTools(server2) {
 
 // src/tools/auth.ts
 var import_zod16 = require("zod");
-var import_fs10 = require("fs");
-var import_path10 = require("path");
+var import_fs14 = require("fs");
+var import_path14 = require("path");
 function normalizeProviderSlug(slug) {
   return slug.replace(/-/g, "_");
 }
@@ -5740,9 +6205,9 @@ ${indent}  requiredRole: ${r.requiredRole}`).join("\n");
 }
 function detectNextMajorVersion(cwd) {
   try {
-    const pkgPath = (0, import_path10.join)(cwd, "package.json");
-    if (!(0, import_fs10.existsSync)(pkgPath)) return null;
-    const pkg = JSON.parse((0, import_fs10.readFileSync)(pkgPath, "utf8"));
+    const pkgPath = (0, import_path14.join)(cwd, "package.json");
+    if (!(0, import_fs14.existsSync)(pkgPath)) return null;
+    const pkg = JSON.parse((0, import_fs14.readFileSync)(pkgPath, "utf8"));
     const nextVersion = pkg.dependencies?.next ?? pkg.devDependencies?.next;
     if (!nextVersion) return null;
     const match = nextVersion.match(/(\d+)/);
@@ -6404,7 +6869,7 @@ async function configureAuthHandler(params, cwd) {
       auditRetentionDays,
       normalizedRoutes
     );
-    (0, import_fs10.writeFileSync)((0, import_path10.join)(cwd, conventionFile), authFileContent, "utf8");
+    (0, import_fs14.writeFileSync)((0, import_path14.join)(cwd, conventionFile), authFileContent, "utf8");
     filesWritten.push(conventionFile);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -6424,12 +6889,12 @@ async function configureAuthHandler(params, cwd) {
   if (!devOnly) {
     try {
       const envBlock = generateEnvBlock(effectiveMethod, params);
-      const envPath = (0, import_path10.join)(cwd, ".env.example");
-      if ((0, import_fs10.existsSync)(envPath)) {
-        const existing = (0, import_fs10.readFileSync)(envPath, "utf8");
-        (0, import_fs10.writeFileSync)(envPath, existing.trimEnd() + "\n\n" + envBlock, "utf8");
+      const envPath = (0, import_path14.join)(cwd, ".env.example");
+      if ((0, import_fs14.existsSync)(envPath)) {
+        const existing = (0, import_fs14.readFileSync)(envPath, "utf8");
+        (0, import_fs14.writeFileSync)(envPath, existing.trimEnd() + "\n\n" + envBlock, "utf8");
       } else {
-        (0, import_fs10.writeFileSync)(envPath, envBlock, "utf8");
+        (0, import_fs14.writeFileSync)(envPath, envBlock, "utf8");
       }
       filesWritten.push(".env.example");
     } catch (err) {
@@ -6447,10 +6912,10 @@ async function configureAuthHandler(params, cwd) {
   }
   if (devOnly) {
     try {
-      const mockAuthDir = (0, import_path10.join)(cwd, "lib");
-      (0, import_fs10.mkdirSync)(mockAuthDir, { recursive: true });
+      const mockAuthDir = (0, import_path14.join)(cwd, "lib");
+      (0, import_fs14.mkdirSync)(mockAuthDir, { recursive: true });
       const mockAuthContent = generateMockAuthContent(roles, mockUsers);
-      (0, import_fs10.writeFileSync)((0, import_path10.join)(mockAuthDir, "mock-auth.ts"), mockAuthContent, "utf8");
+      (0, import_fs14.writeFileSync)((0, import_path14.join)(mockAuthDir, "mock-auth.ts"), mockAuthContent, "utf8");
       filesWritten.push("lib/mock-auth.ts");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -6468,11 +6933,11 @@ async function configureAuthHandler(params, cwd) {
       };
     }
     try {
-      const pkgPath = (0, import_path10.join)(cwd, "package.json");
-      if ((0, import_fs10.existsSync)(pkgPath)) {
-        const existingPkg = (0, import_fs10.readFileSync)(pkgPath, "utf8");
+      const pkgPath = (0, import_path14.join)(cwd, "package.json");
+      if ((0, import_fs14.existsSync)(pkgPath)) {
+        const existingPkg = (0, import_fs14.readFileSync)(pkgPath, "utf8");
         const updatedPkg = updatePackageJsonScripts(existingPkg, roles, mockUsers);
-        (0, import_fs10.writeFileSync)(pkgPath, updatedPkg, "utf8");
+        (0, import_fs14.writeFileSync)(pkgPath, updatedPkg, "utf8");
         filesWritten.push("package.json");
       }
     } catch (err) {
@@ -6513,7 +6978,7 @@ async function configureAuthHandler(params, cwd) {
       normalizedRoutes,
       useProxy
     );
-    (0, import_fs10.writeFileSync)((0, import_path10.join)(cwd, "stackwright.auth.yml"), authYaml, "utf8");
+    (0, import_fs14.writeFileSync)((0, import_path14.join)(cwd, "stackwright.auth.yml"), authYaml, "utf8");
     filesWritten.push("stackwright.auth.yml");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -6627,8 +7092,8 @@ function registerAuthTools(server2) {
 
 // src/integrity.ts
 var import_crypto4 = require("crypto");
-var import_fs11 = require("fs");
-var import_path11 = require("path");
+var import_fs15 = require("fs");
+var import_path15 = require("path");
 var _checksums = /* @__PURE__ */ new Map([
   [
     "stackwright-pro-api-otter.json",
@@ -6644,7 +7109,7 @@ var _checksums = /* @__PURE__ */ new Map([
   ],
   [
     "stackwright-pro-dashboard-otter.json",
-    "f55081bf4d6545e5435128919f6f9233956ba37671fc9f85300f240ad2497ab6"
+    "ac0a049da72ee20bfb711f640bac571263bf2b05f80cd22a0c2eb5778c40989c"
   ],
   [
     "stackwright-pro-data-otter.json",
@@ -6664,15 +7129,15 @@ var _checksums = /* @__PURE__ */ new Map([
   ],
   [
     "stackwright-pro-form-wizard-otter.json",
-    "cb350297a0068ead2424e703e8c775d91c0b87249ea6904f43b903baf8a84b79"
+    "941bb11b767530460f96fdd08af638b3ede9f7a1ae6f19de04b7d81c95cc62ad"
   ],
   [
     "stackwright-pro-geo-otter.json",
-    "3032fbd27de36c0cdc0e19e46a32d771208d8e86714482f5a368d46342c8317a"
+    "bee276605a3ae3203f5b6a18476316f615cf0ea6f4c73ecf57dcd627417de7f3"
   ],
   [
     "stackwright-pro-page-otter.json",
-    "cc0db24b00f0130f8b4ec8d385c73ea1bcf5d57ba45aca6b986bcbd5da328930"
+    "8c04dd8a14c6e1aa9b0b6685a71a657547c20d99c25448e3523f73d670f87a4a"
   ],
   [
     "stackwright-pro-polish-otter.json",
@@ -6688,7 +7153,7 @@ var _checksums = /* @__PURE__ */ new Map([
   ],
   [
     "stackwright-pro-theme-otter.json",
-    "afb47f8381907145c0e098bdcaae4dd9f5c4ff825a8e88d00a218d2f6858820b"
+    "e3cb6ef9d9f7cbf662a26f637f3d244ec33cb19cb6a4a55dcd148cbfdaa4d71e"
   ],
   [
     "stackwright-services-otter.json",
@@ -6715,14 +7180,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_path11.basename)(filePath);
+  const filename = (0, import_path15.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_fs11.lstatSync)(filePath);
+    stat = (0, import_fs15.lstatSync)(filePath);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { verified: false, filename, error: `Cannot stat file: ${msg}` };
@@ -6740,7 +7205,7 @@ function verifyOtterFile(filePath) {
   }
   let raw;
   try {
-    raw = (0, import_fs11.readFileSync)(filePath);
+    raw = (0, import_fs15.readFileSync)(filePath);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { verified: false, filename, error: `Cannot read file: ${msg}` };
@@ -6790,7 +7255,7 @@ function verifyAllOtters(otterDir) {
   const unknown = [];
   let entries;
   try {
-    entries = (0, import_fs11.readdirSync)(otterDir);
+    entries = (0, import_fs15.readdirSync)(otterDir);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return {
@@ -6801,9 +7266,9 @@ function verifyAllOtters(otterDir) {
   }
   const otterFiles = entries.filter((f) => f.endsWith("-otter.json"));
   for (const filename of otterFiles) {
-    const filePath = (0, import_path11.join)(otterDir, filename);
+    const filePath = (0, import_path15.join)(otterDir, filename);
     try {
-      if ((0, import_fs11.lstatSync)(filePath).isSymbolicLink()) {
+      if ((0, import_fs15.lstatSync)(filePath).isSymbolicLink()) {
         failed.push({ filename, error: "Skipped: symlink" });
         continue;
       }
@@ -6828,10 +7293,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 relative2 of DEFAULT_SEARCH_PATHS) {
-    const candidate = (0, import_path11.join)(cwd, relative2);
+  for (const relative4 of DEFAULT_SEARCH_PATHS) {
+    const candidate = (0, import_path15.join)(cwd, relative4);
     try {
-      (0, import_fs11.lstatSync)(candidate);
+      (0, import_fs15.lstatSync)(candidate);
       return candidate;
     } catch {
     }
@@ -6910,13 +7375,13 @@ function registerIntegrityTools(server2) {
 
 // src/tools/domain.ts
 var import_zod17 = require("zod");
-var import_fs12 = require("fs");
-var import_path12 = require("path");
+var import_fs16 = require("fs");
+var import_path16 = require("path");
 function handleListCollections(input) {
   const cwd = input._cwd ?? process.cwd();
   const sources = [
     {
-      path: (0, import_path12.join)(cwd, ".stackwright", "artifacts", "data-config.json"),
+      path: (0, import_path16.join)(cwd, ".stackwright", "artifacts", "data-config.json"),
       source: "data-config.json",
       parse: (raw) => {
         const parsed = JSON.parse(raw);
@@ -6927,15 +7392,15 @@ function handleListCollections(input) {
       }
     },
     {
-      path: (0, import_path12.join)(cwd, "stackwright.yml"),
+      path: (0, import_path16.join)(cwd, "stackwright.yml"),
       source: "stackwright.yml",
       parse: extractCollectionsFromYaml
     }
   ];
   for (const { path: path5, source, parse } of sources) {
-    if (!(0, import_fs12.existsSync)(path5)) continue;
+    if (!(0, import_fs16.existsSync)(path5)) continue;
     try {
-      const collections = parse((0, import_fs12.readFileSync)(path5, "utf8"));
+      const collections = parse((0, import_fs16.readFileSync)(path5, "utf8"));
       return {
         text: JSON.stringify({ collections, source, collectionCount: collections.length }),
         isError: false
@@ -7086,8 +7551,8 @@ function handleValidateWorkflow(input) {
   if (input.workflow && Object.keys(input.workflow).length > 0) {
     raw = input.workflow;
   } else {
-    const artifactPath = (0, import_path12.join)(cwd, ".stackwright", "artifacts", "workflow-config.json");
-    if (!(0, import_fs12.existsSync)(artifactPath)) {
+    const artifactPath = (0, import_path16.join)(cwd, ".stackwright", "artifacts", "workflow-config.json");
+    if (!(0, import_fs16.existsSync)(artifactPath)) {
       return fail([
         {
           code: "NO_WORKFLOW",
@@ -7096,7 +7561,7 @@ function handleValidateWorkflow(input) {
       ]);
     }
     try {
-      raw = JSON.parse((0, import_fs12.readFileSync)(artifactPath, "utf8"));
+      raw = JSON.parse((0, import_fs16.readFileSync)(artifactPath, "utf8"));
     } catch (err) {
       return fail([{ code: "INVALID_JSON", message: `Failed to parse workflow artifact: ${err}` }]);
     }
@@ -7403,14 +7868,94 @@ function registerTypeSchemasTool(server2) {
   );
 }
 
+// src/tools/validate-yaml-fragment.ts
+var import_zod19 = require("zod");
+var import_js_yaml5 = require("js-yaml");
+var FIELD_SYNONYMS = Object.fromEntries(
+  Array.from(SCHEMA_REGISTRY.entries()).map(([name, entry]) => [
+    name,
+    buildReverseSynonyms(entry.synonyms ?? {})
+  ])
+);
+function enrichErrors(issues, reverseSynonyms) {
+  return issues.map((issue) => {
+    const pathStr = issue.path.join(".");
+    const lastSegment = issue.path[issue.path.length - 1];
+    const fieldName = typeof lastSegment === "string" ? lastSegment : void 0;
+    const didYouMean = fieldName ? reverseSynonyms[fieldName] : void 0;
+    return {
+      path: pathStr || "(root)",
+      message: issue.message,
+      ...didYouMean ? { didYouMean } : {}
+    };
+  });
+}
+function handleValidateYamlFragment(input) {
+  const { schemaName, yaml: yaml4 } = input;
+  const entry = SCHEMA_REGISTRY.get(schemaName);
+  if (!entry) {
+    return {
+      valid: false,
+      parseError: `Unknown schemaName: "${schemaName}". Supported: ${REGISTRY_SCHEMA_NAMES.join(", ")}`
+    };
+  }
+  let parsed;
+  try {
+    parsed = (0, import_js_yaml5.load)(yaml4);
+  } catch (err) {
+    return {
+      valid: false,
+      parseError: `YAML parse error: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const ctx = input.projectRoot ? { projectRoot: input.projectRoot } : void 0;
+  const resolvedSchema = getSchemaForEntry(entry, ctx);
+  const result = resolvedSchema.safeParse(parsed);
+  if (result.success) {
+    const projectRoot = input.projectRoot ?? process.cwd();
+    const ladder = resolveStatusLadder(projectRoot);
+    if (ladder.length > 0) {
+      const ladderSet = new Set(ladder);
+      const tokenViolations = detectViolationsInYaml(parsed, ladder, ladderSet, "fragment");
+      if (tokenViolations.length > 0) {
+        const tokenErrors = tokenViolations.map((v) => ({
+          path: v.path,
+          message: v.message
+        }));
+        return { valid: false, errors: tokenErrors };
+      }
+    }
+    return { valid: true };
+  }
+  const reverseSynonyms = buildReverseSynonyms(entry.synonyms ?? {});
+  const errors = enrichErrors(result.error.issues, reverseSynonyms);
+  return { valid: false, errors };
+}
+function registerValidateYamlFragmentTool(server2) {
+  server2.tool(
+    "stackwright_pro_validate_yaml_fragment",
+    'Validates a YAML snippet against a canonical Zod schema before writing to disk. Returns actionable errors with "did you mean?" suggestions for common field-name drift (title vs label, id vs name, style vs theme.variant, etc.). Call this before stackwright_pro_safe_write to catch schema violations in-session.',
+    {
+      schemaName: import_zod19.z.string().describe(`Schema to validate against. Available: ${REGISTRY_SCHEMA_NAMES.join(", ")}`),
+      yaml: import_zod19.z.string().describe("YAML string to validate (can also be JSON \u2014 js-yaml parses both)")
+    },
+    async ({ schemaName, yaml: yaml4 }) => {
+      const result = handleValidateYamlFragment({ schemaName, yaml: yaml4 });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
 // src/tools/pages.ts
 var fs2 = __toESM(require("fs"));
 var os = __toESM(require("os"));
 var path3 = __toESM(require("path"));
-var import_zod19 = require("zod");
-var import_js_yaml3 = require("js-yaml");
+var import_zod20 = require("zod");
+var import_js_yaml6 = require("js-yaml");
 var import_cli = require("@stackwright/cli");
-var import_types4 = require("@stackwright-pro/types");
+var import_types3 = require("@stackwright-pro/types");
 var BCP47_RE = /^[a-z]{2}(-[A-Z]{2})?$/;
 var PRO_EXTENSION_STRIP_KEYS = /* @__PURE__ */ new Set(["theme", "auth", "required_roles"]);
 var PRO_TYPE_STUB = {
@@ -7426,10 +7971,10 @@ function sanitizeNode(node) {
     const obj = node;
     const typeVal = obj["type"];
     if (typeof typeVal === "string") {
-      if ((0, import_types4.isProContentType)(typeVal)) {
+      if ((0, import_types3.isProContentType)(typeVal)) {
         return { ...PRO_TYPE_STUB };
       }
-      if ((0, import_types4.isOssTypeWithProExtension)(typeVal)) {
+      if ((0, import_types3.isOssTypeWithProExtension)(typeVal)) {
         const sanitized = {};
         for (const [k, v] of Object.entries(obj)) {
           if (!PRO_EXTENSION_STRIP_KEYS.has(k)) {
@@ -7462,7 +8007,7 @@ function handleProWritePage(input) {
   }
   let parsed;
   try {
-    parsed = (0, import_js_yaml3.load)(content);
+    parsed = (0, import_js_yaml6.load)(content);
   } catch (err) {
     return {
       isError: true,
@@ -7476,7 +8021,7 @@ function handleProWritePage(input) {
   }
   const clone = JSON.parse(JSON.stringify(parsed));
   const sanitized = sanitizeNode(clone);
-  const sanitizedYaml = (0, import_js_yaml3.dump)(sanitized);
+  const sanitizedYaml = (0, import_js_yaml6.dump)(sanitized);
   const tmpDir = fs2.mkdtempSync(path3.join(os.tmpdir(), "sw-pro-validate-"));
   try {
     (0, import_cli.writePage)(path3.join(tmpDir, "pages"), "__validation__", sanitizedYaml);
@@ -7519,10 +8064,10 @@ function registerProPageTools(server2) {
     "stackwright_pro_write_page",
     "Write or update a page's YAML content with Pro content-type awareness. Validates against the Stackwright schema (including Pro types like stats_grid, data_table_pulse, map_pulse, alert_banner). Invalid YAML or schema violations on OSS-type fields are rejected with field-level errors. Use this instead of stackwright_write_page for any page containing Pro content types.",
     {
-      projectRoot: import_zod19.z.string().describe("Absolute path to the Stackwright project root"),
-      slug: import_zod19.z.string().describe('Page slug (e.g. "dashboard/main" or "/dashboard/main")'),
-      content: import_zod19.z.string().describe("Full YAML content for the page (content.yml contents)"),
-      locale: import_zod19.z.string().optional().describe(
+      projectRoot: import_zod20.z.string().describe("Absolute path to the Stackwright project root"),
+      slug: import_zod20.z.string().describe('Page slug (e.g. "dashboard/main" or "/dashboard/main")'),
+      content: import_zod20.z.string().describe("Full YAML content for the page (content.yml contents)"),
+      locale: import_zod20.z.string().optional().describe(
         'BCP 47 locale tag (e.g. "fr", "de"). If provided, writes content.<locale>.yml instead of content.yml.'
       )
     },
@@ -7533,8 +8078,8 @@ function registerProPageTools(server2) {
 }
 
 // src/tools/scaffold-cleanup.ts
-var import_fs13 = require("fs");
-var import_path13 = require("path");
+var import_fs17 = require("fs");
+var import_path17 = require("path");
 var SCAFFOLD_FILES_TO_DELETE = [
   "content/posts/getting-started.yaml",
   "content/posts/hello-world.yaml"
@@ -7559,12 +8104,12 @@ var FALLBACK_COLORS = {
   mutedForeground: "#737373"
 };
 function readThemeColors(cwd) {
-  const tokenPath = (0, import_path13.join)(cwd, ".stackwright", "artifacts", "theme-tokens.json");
-  if (!(0, import_fs13.existsSync)(tokenPath)) return { ...FALLBACK_COLORS };
-  const stat = (0, import_fs13.lstatSync)(tokenPath);
+  const tokenPath = (0, import_path17.join)(cwd, ".stackwright", "artifacts", "theme-tokens.json");
+  if (!(0, import_fs17.existsSync)(tokenPath)) return { ...FALLBACK_COLORS };
+  const stat = (0, import_fs17.lstatSync)(tokenPath);
   if (stat.isSymbolicLink()) return { ...FALLBACK_COLORS };
   try {
-    const raw = JSON.parse((0, import_fs13.readFileSync)(tokenPath, "utf-8"));
+    const raw = JSON.parse((0, import_fs17.readFileSync)(tokenPath, "utf-8"));
     const css = raw?.cssVariables ?? {};
     const toHsl = (hslValue) => {
       if (!hslValue || typeof hslValue !== "string") return null;
@@ -7624,15 +8169,15 @@ function generateNotFoundPage(colors) {
 `;
 }
 function isSafePath(fullPath) {
-  if (!(0, import_fs13.existsSync)(fullPath)) return true;
-  const stat = (0, import_fs13.lstatSync)(fullPath);
+  if (!(0, import_fs17.existsSync)(fullPath)) return true;
+  const stat = (0, import_fs17.lstatSync)(fullPath);
   return !stat.isSymbolicLink();
 }
 function isDirEmpty(dirPath) {
-  if (!(0, import_fs13.existsSync)(dirPath)) return false;
-  const stat = (0, import_fs13.lstatSync)(dirPath);
+  if (!(0, import_fs17.existsSync)(dirPath)) return false;
+  const stat = (0, import_fs17.lstatSync)(dirPath);
   if (!stat.isDirectory()) return false;
-  return (0, import_fs13.readdirSync)(dirPath).length === 0;
+  return (0, import_fs17.readdirSync)(dirPath).length === 0;
 }
 function handleCleanupScaffold(_cwd) {
   const cwd = _cwd ?? process.cwd();
@@ -7645,8 +8190,8 @@ function handleCleanupScaffold(_cwd) {
     cleanupWarnings: []
   };
   for (const relPath of SCAFFOLD_FILES_TO_DELETE) {
-    const fullPath = (0, import_path13.join)(cwd, relPath);
-    if (!(0, import_fs13.existsSync)(fullPath)) {
+    const fullPath = (0, import_path17.join)(cwd, relPath);
+    if (!(0, import_fs17.existsSync)(fullPath)) {
       result.skipped.push(relPath);
       continue;
     }
@@ -7655,7 +8200,7 @@ function handleCleanupScaffold(_cwd) {
       continue;
     }
     try {
-      (0, import_fs13.unlinkSync)(fullPath);
+      (0, import_fs17.unlinkSync)(fullPath);
       result.deleted.push(relPath);
     } catch (err) {
       result.errors.push(`Failed to delete ${relPath}: ${String(err)}`);
@@ -7663,19 +8208,19 @@ function handleCleanupScaffold(_cwd) {
   }
   {
     const relPath = "pages/getting-started/content.yml";
-    const fullPath = (0, import_path13.join)(cwd, relPath);
-    if (!(0, import_fs13.existsSync)(fullPath)) {
+    const fullPath = (0, import_path17.join)(cwd, relPath);
+    if (!(0, import_fs17.existsSync)(fullPath)) {
       result.skipped.push(relPath);
     } else if (!isSafePath(fullPath)) {
       result.errors.push(`Refusing to delete symlink: ${relPath}`);
     } else {
-      const content = (0, import_fs13.readFileSync)(fullPath, "utf-8");
+      const content = (0, import_fs17.readFileSync)(fullPath, "utf-8");
       const isScaffoldDefault = GETTING_STARTED_SCAFFOLD_FINGERPRINTS.some(
         (marker) => content.includes(marker)
       );
       if (isScaffoldDefault) {
         try {
-          (0, import_fs13.unlinkSync)(fullPath);
+          (0, import_fs17.unlinkSync)(fullPath);
           result.deleted.push(relPath);
         } catch (err) {
           result.errors.push(`Failed to delete ${relPath}: ${String(err)}`);
@@ -7689,21 +8234,21 @@ function handleCleanupScaffold(_cwd) {
   }
   {
     const relPath = `content/posts/${POSTS_COLLECTION_FILE}`;
-    const fullPath = (0, import_path13.join)(cwd, relPath);
-    const postsDir = (0, import_path13.join)(cwd, "content/posts");
-    if (!(0, import_fs13.existsSync)(fullPath)) {
+    const fullPath = (0, import_path17.join)(cwd, relPath);
+    const postsDir = (0, import_path17.join)(cwd, "content/posts");
+    if (!(0, import_fs17.existsSync)(fullPath)) {
       result.skipped.push(relPath);
     } else if (!isSafePath(fullPath)) {
       result.errors.push(`Refusing to delete symlink: ${relPath}`);
-    } else if (!(0, import_fs13.existsSync)(postsDir)) {
+    } else if (!(0, import_fs17.existsSync)(postsDir)) {
       result.skipped.push(relPath);
     } else {
-      const userPostFiles = (0, import_fs13.readdirSync)(postsDir).filter(
+      const userPostFiles = (0, import_fs17.readdirSync)(postsDir).filter(
         (f) => f !== POSTS_COLLECTION_FILE && POST_FILE_EXTENSIONS.some((ext) => f.endsWith(ext))
       );
       if (userPostFiles.length === 0) {
         try {
-          (0, import_fs13.unlinkSync)(fullPath);
+          (0, import_fs17.unlinkSync)(fullPath);
           result.deleted.push(relPath);
         } catch (err) {
           result.errors.push(`Failed to delete ${relPath}: ${String(err)}`);
@@ -7716,15 +8261,15 @@ function handleCleanupScaffold(_cwd) {
     }
   }
   for (const relDir of SCAFFOLD_DIRS_TO_PRUNE) {
-    const fullDir = (0, import_path13.join)(cwd, relDir);
-    if (!(0, import_fs13.existsSync)(fullDir)) continue;
+    const fullDir = (0, import_path17.join)(cwd, relDir);
+    if (!(0, import_fs17.existsSync)(fullDir)) continue;
     if (!isSafePath(fullDir)) {
       result.errors.push(`Refusing to prune symlink directory: ${relDir}`);
       continue;
     }
     if (isDirEmpty(fullDir)) {
       try {
-        (0, import_fs13.rmdirSync)(fullDir);
+        (0, import_fs17.rmdirSync)(fullDir);
         result.prunedDirs.push(relDir);
       } catch (err) {
         result.errors.push(`Failed to prune directory ${relDir}: ${String(err)}`);
@@ -7732,8 +8277,8 @@ function handleCleanupScaffold(_cwd) {
     }
   }
   {
-    const fullPath = (0, import_path13.join)(cwd, NOT_FOUND_PATH);
-    if (!(0, import_fs13.existsSync)(fullPath)) {
+    const fullPath = (0, import_path17.join)(cwd, NOT_FOUND_PATH);
+    if (!(0, import_fs17.existsSync)(fullPath)) {
       result.skipped.push(NOT_FOUND_PATH);
     } else if (!isSafePath(fullPath)) {
       result.errors.push(`Refusing to rewrite symlink: ${NOT_FOUND_PATH}`);
@@ -7741,9 +8286,9 @@ function handleCleanupScaffold(_cwd) {
       try {
         const colors = readThemeColors(cwd);
         const content = generateNotFoundPage(colors);
-        const dir = (0, import_path13.dirname)(fullPath);
-        (0, import_fs13.mkdirSync)(dir, { recursive: true });
-        (0, import_fs13.writeFileSync)(fullPath, content, "utf-8");
+        const dir = (0, import_path17.dirname)(fullPath);
+        (0, import_fs17.mkdirSync)(dir, { recursive: true });
+        (0, import_fs17.writeFileSync)(fullPath, content, "utf-8");
         result.rewritten.push(NOT_FOUND_PATH);
       } catch (err) {
         result.errors.push(`Failed to rewrite ${NOT_FOUND_PATH}: ${String(err)}`);
@@ -7771,8 +8316,159 @@ function registerScaffoldCleanupTools(server2) {
   );
 }
 
+// src/tools/write-workflow-container-page.ts
+var import_zod21 = require("zod");
+var import_js_yaml7 = require("js-yaml");
+var import_types4 = require("@stackwright-pro/types");
+var WriteWorkflowContainerPageInputSchema = import_zod21.z.object({
+  /**
+   * Test-only: override process.cwd() for deterministic temp-dir testing.
+   * Never set in production — omit entirely in normal MCP tool calls.
+   */
+  _cwd: import_zod21.z.string().optional(),
+  /**
+   * Kebab-case workflow ID — must match `workflow.id` in the referenced YAML.
+   * Example: `patient-evacuation-authorization`
+   */
+  workflowId: import_zod21.z.string().regex(/^[a-z0-9-]+$/, {
+    message: "workflowId must be kebab-case (lowercase alphanumeric + hyphens)"
+  }),
+  /**
+   * Relative path to the workflow YAML file from project root.
+   * Example: `workflows/patient-evacuation-authorization.yml`
+   */
+  workflowFile: import_zod21.z.string().min(1).regex(/^workflows\/[a-z0-9-]+\.(yml|yaml)$/, {
+    message: "workflowFile must be: workflows/<id>.yml"
+  }),
+  /**
+   * URL slug for the container page route.
+   * Convention: `workflows/<workflowId>` → page at `/workflows/<workflowId>`.
+   * Example: `workflows/patient-evacuation`
+   *
+   * The tool writes to `pages/<pageSlug>/content.yml`.
+   */
+  pageSlug: import_zod21.z.string().min(1).regex(/^workflows\/[a-z0-9-]+$/, {
+    message: 'pageSlug must start with "workflows/" and be kebab-case. Example: workflows/patient-evacuation'
+  }),
+  /**
+   * Human-readable label for the workflow (used in page title + breadcrumbs).
+   * Example: `Patient Evacuation Authorization`
+   */
+  label: import_zod21.z.string().min(1).max(120),
+  /**
+   * Union of required roles across all steps in the workflow YAML.
+   * Consumed by auth-reconcile to build protectedRoutes.
+   * Must be non-empty — workflow pages are always auth-protected.
+   */
+  requiredRoles: import_zod21.z.array(import_zod21.z.string().min(1)).min(1, {
+    message: "requiredRoles must have at least one role \u2014 workflow pages are always auth-protected"
+  }),
+  /**
+   * Persistence key for workflow state (localStorage slot).
+   * Defaults to `workflow-<workflowId>` when omitted.
+   */
+  persistenceKey: import_zod21.z.string().optional(),
+  /**
+   * Layout mode for the container page. Defaults to `app-shell` per Pro convention.
+   * Only override when you have a specific reason — `app-shell` is correct for all
+   * workflow container pages in data-dense Pro apps.
+   */
+  layoutMode: import_zod21.z.enum(["app-shell", "page"]).default("app-shell")
+});
+function handleWriteWorkflowContainerPage(input) {
+  const parsed = WriteWorkflowContainerPageInputSchema.safeParse(input);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    return {
+      text: JSON.stringify({ error: `Invalid input: ${issues}` }),
+      isError: true
+    };
+  }
+  const { workflowId, workflowFile, pageSlug, label, requiredRoles, persistenceKey, layoutMode } = parsed.data;
+  const resolvedPersistenceKey = persistenceKey ?? `workflow-${workflowId}`;
+  const wizardItem = {
+    type: "workflow_wizard",
+    label: workflowId,
+    // slug-form label for the content item (page title comes from meta)
+    workflowFile,
+    workflowId,
+    persistenceKey: resolvedPersistenceKey
+  };
+  const schemaCheck = import_types4.WorkflowWizardContentSchema.safeParse(wizardItem);
+  if (!schemaCheck.success) {
+    const issues = schemaCheck.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    return {
+      text: JSON.stringify({ error: `Internal schema validation failed: ${issues}` }),
+      isError: true
+    };
+  }
+  const pageContent = {
+    layoutMode,
+    meta: {
+      title: `${label} | Workflow`,
+      description: `${label} \u2014 multi-step workflow. Requires authorization.`,
+      authRequired: true,
+      requiredRoles
+    },
+    content: {
+      content_items: [wizardItem]
+    }
+  };
+  const yamlContent = (0, import_js_yaml7.dump)(pageContent, {
+    indent: 2,
+    lineWidth: 120,
+    quotingType: "'",
+    forceQuotes: false
+  });
+  const filePath = `pages/${pageSlug}/content.yml`;
+  const writeResult = handleSafeWrite({
+    callerOtter: "stackwright-pro-form-wizard-otter",
+    filePath,
+    content: yamlContent,
+    createDirectories: true,
+    _cwd: parsed.data._cwd
+  });
+  if (writeResult.isError) {
+    return writeResult;
+  }
+  const result = {
+    written: true,
+    path: filePath,
+    contentTypesEmitted: ["workflow_wizard"],
+    content: yamlContent
+  };
+  return {
+    text: JSON.stringify(result),
+    isError: false
+  };
+}
+function registerWriteWorkflowContainerPageTool(server2) {
+  server2.tool(
+    "stackwright_pro_write_workflow_container_page",
+    [
+      "Create the canonical container page for a workflow at pages/workflows/<workflowId>/content.yml.",
+      "",
+      "ALWAYS call this immediately after writing the workflow YAML via stackwright_pro_safe_write.",
+      "Without it, the route /workflows/<workflowId> 404s at runtime.",
+      "",
+      "The tool deterministically emits:",
+      "  - layoutMode: app-shell",
+      "  - meta.authRequired: true, meta.requiredRoles: <your input>",
+      "  - One workflow_wizard content item binding workflowFile + workflowId",
+      "",
+      "requiredRoles: supply the UNION of required roles from all steps in your workflow YAML.",
+      'pageSlug: convention is "workflows/<workflowId>" \u2014 must start with "workflows/".'
+    ].join("\n"),
+    WriteWorkflowContainerPageInputSchema.shape,
+    async (args) => {
+      const result = handleWriteWorkflowContainerPage(args);
+      return { content: [{ type: "text", text: result.text }] };
+    }
+  );
+}
+
 // src/tools/contrast.ts
-var import_zod20 = require("zod");
+var import_zod22 = require("zod");
 function linearizeChannel(c255) {
   const c = c255 / 255;
   return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
@@ -7944,8 +8640,8 @@ function registerContrastTools(server2) {
     "stackwright_pro_check_contrast",
     'Compute the exact WCAG 2.1 contrast ratio between a foreground and background color. Returns the ratio and AA/AAA pass/fail flags. Use this to verify any foreground/background color pair before writing it to the token set. Accepts #RGB, #RRGGBB, hsl(...), or shadcn HSL format ("H S% L%").',
     {
-      fg: import_zod20.z.string().describe("Foreground (text) color \u2014 hex or HSL"),
-      bg: import_zod20.z.string().describe("Background color \u2014 hex or HSL")
+      fg: import_zod22.z.string().describe("Foreground (text) color \u2014 hex or HSL"),
+      bg: import_zod22.z.string().describe("Background color \u2014 hex or HSL")
     },
     async ({ fg, bg }) => {
       let result;
@@ -7975,8 +8671,8 @@ function registerContrastTools(server2) {
     "stackwright_pro_derive_accessible_palette",
     'Given a seed color (treated as a background), derive the best accessible foreground (text) color that meets the target contrast ratio. Evaluates #ffffff and #000000 against the seed and picks whichever satisfies the target ratio with the highest contrast. Use this for every {name}-foreground token derivation instead of guessing white vs black. Accepts #RGB, #RRGGBB, hsl(...), or shadcn HSL format ("H S% L%").',
     {
-      seed: import_zod20.z.string().describe("Background (seed) color \u2014 hex or HSL"),
-      targetRatio: numCoerce(import_zod20.z.number().default(4.5)).describe(
+      seed: import_zod22.z.string().describe("Background (seed) color \u2014 hex or HSL"),
+      targetRatio: numCoerce(import_zod22.z.number().default(4.5)).describe(
         "Minimum required contrast ratio (default 4.5 for WCAG AA)"
       )
     },
@@ -8011,24 +8707,24 @@ function registerContrastTools(server2) {
 }
 
 // src/tools/compile.ts
-var import_zod21 = require("zod");
-var import_fs14 = __toESM(require("fs"));
-var import_path14 = __toESM(require("path"));
+var import_zod23 = require("zod");
+var import_fs18 = __toESM(require("fs"));
+var import_path18 = __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_path14.default.join(projectRoot, "public", "stackwright-content"),
-    imagesDir: import_path14.default.join(projectRoot, "public", "images"),
+    contentOutDir: import_path18.default.join(projectRoot, "public", "stackwright-content"),
+    imagesDir: import_path18.default.join(projectRoot, "public", "images"),
     siteConfig: loadSiteConfig(projectRoot)
   };
 }
 function loadSiteConfig(projectRoot) {
   try {
-    const sitePath = import_path14.default.join(projectRoot, "public", "stackwright-content", "_site.json");
-    return JSON.parse(import_fs14.default.readFileSync(sitePath, "utf8"));
+    const sitePath = import_path18.default.join(projectRoot, "public", "stackwright-content", "_site.json");
+    return JSON.parse(import_fs18.default.readFileSync(sitePath, "utf8"));
   } catch {
     return {};
   }
@@ -8039,8 +8735,8 @@ function formatDuration(startMs) {
 }
 async function tryOssCompile(fn, ctx, extra) {
   try {
-    const bsPath = import_path14.default.join(ctx.projectRoot, "node_modules", "@stackwright", "build-scripts");
-    if (!import_fs14.default.existsSync(bsPath)) {
+    const bsPath = import_path18.default.join(ctx.projectRoot, "node_modules", "@stackwright", "build-scripts");
+    if (!import_fs18.default.existsSync(bsPath)) {
       return {
         ok: false,
         error: `@stackwright/build-scripts not found at ${bsPath}. Is it installed in your project?`
@@ -8057,7 +8753,7 @@ async function tryOssCompile(fn, ctx, extra) {
   }
 }
 function registerCompileTools(server2) {
-  const projectRootArg = import_zod21.z.string().optional().describe("Absolute path to project root (defaults to cwd)");
+  const projectRootArg = import_zod23.z.string().optional().describe("Absolute path to project root (defaults to cwd)");
   server2.tool(
     "stackwright_pro_compile_collections",
     "Compile stackwright.collections.yml \u2192 public/stackwright-content/_collections.json. Reads and validates the live-collections sidecar config file and emits the JSON sink consumed at runtime by PulseCollectionProvider.",
@@ -8233,7 +8929,7 @@ ${results.join("\n")}`;
     "stackwright_pro_compile_page",
     "Compile a single page by slug. Delegates to compilePage from @stackwright/build-scripts installed in the project.",
     {
-      slug: import_zod21.z.string().describe('Page slug (relative path under pages/, e.g. "dashboard")'),
+      slug: import_zod23.z.string().describe('Page slug (relative path under pages/, e.g. "dashboard")'),
       projectRoot: projectRootArg
     },
     async ({ slug, projectRoot }) => {
@@ -8253,15 +8949,15 @@ ${results.join("\n")}`;
 }
 
 // src/tools/strip-legacy-integrations.ts
-var import_zod22 = require("zod");
-var import_fs15 = require("fs");
-var import_path15 = require("path");
+var import_zod24 = require("zod");
+var import_fs19 = require("fs");
+var import_path19 = require("path");
 function handleStripLegacyIntegrations(input) {
   const { projectRoot } = input;
-  const ymlPath = (0, import_path15.join)(projectRoot, "stackwright.yml");
-  const yamlPath = (0, import_path15.join)(projectRoot, "stackwright.yaml");
-  if (!(0, import_fs15.existsSync)(ymlPath)) {
-    if ((0, import_fs15.existsSync)(yamlPath)) {
+  const ymlPath = (0, import_path19.join)(projectRoot, "stackwright.yml");
+  const yamlPath = (0, import_path19.join)(projectRoot, "stackwright.yaml");
+  if (!(0, import_fs19.existsSync)(ymlPath)) {
+    if ((0, import_fs19.existsSync)(yamlPath)) {
       return {
         changed: false,
         removedEntries: 0,
@@ -8274,7 +8970,7 @@ function handleStripLegacyIntegrations(input) {
       message: "stackwright.yml not found \u2014 no-op."
     };
   }
-  const raw = (0, import_fs15.readFileSync)(ymlPath, "utf-8");
+  const raw = (0, import_fs19.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");
@@ -8304,7 +9000,7 @@ function handleStripLegacyIntegrations(input) {
     outputContent += "\n";
   }
   const outputRaw = isCRLF ? outputContent.replace(/\n/g, "\r\n") : outputContent;
-  (0, import_fs15.writeFileSync)(ymlPath, outputRaw, "utf-8");
+  (0, import_fs19.writeFileSync)(ymlPath, outputRaw, "utf-8");
   return {
     changed: true,
     removedEntries,
@@ -8316,7 +9012,7 @@ function registerStripLegacyIntegrationsTool(server2) {
     "stackwright_pro_strip_legacy_integrations",
     "Removes the deprecated top-level integrations[] block from stackwright.yml. The authoritative source for integration config is stackwright.integrations.yml \u2014 this tool cleans up legacy entries from older raft runs. Idempotent: no-op if no legacy block present. Preserves all other top-level keys, comments, and formatting.",
     {
-      projectRoot: import_zod22.z.string().describe("Absolute path to the project root directory")
+      projectRoot: import_zod24.z.string().describe("Absolute path to the project root directory")
     },
     async ({ projectRoot }) => {
       const result = handleStripLegacyIntegrations({ projectRoot });
@@ -8328,16 +9024,16 @@ function registerStripLegacyIntegrationsTool(server2) {
 }
 
 // src/tools/emitters.ts
-var import_zod23 = require("zod");
-var import_fs16 = require("fs");
-var import_path16 = require("path");
-var import_js_yaml4 = __toESM(require("js-yaml"));
+var import_zod25 = require("zod");
+var import_fs20 = require("fs");
+var import_path20 = require("path");
+var import_js_yaml8 = __toESM(require("js-yaml"));
 var import_emitters = require("@stackwright-pro/emitters");
 function readIntegrations(cwd) {
-  const filePath = (0, import_path16.join)(cwd, "stackwright.integrations.yml");
-  if (!(0, import_fs16.existsSync)(filePath)) return [];
+  const filePath = (0, import_path20.join)(cwd, "stackwright.integrations.yml");
+  if (!(0, import_fs20.existsSync)(filePath)) return [];
   try {
-    const raw = import_js_yaml4.default.load((0, import_fs16.readFileSync)(filePath, "utf-8"));
+    const raw = import_js_yaml8.default.load((0, import_fs20.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,
@@ -8348,15 +9044,15 @@ function readIntegrations(cwd) {
   }
 }
 function readServiceTokenRefs(cwd) {
-  const servicesDir = (0, import_path16.join)(cwd, "services");
-  if (!(0, import_fs16.existsSync)(servicesDir)) return [];
+  const servicesDir = (0, import_path20.join)(cwd, "services");
+  if (!(0, import_fs20.existsSync)(servicesDir)) return [];
   try {
-    const files = (0, import_fs16.readdirSync)(servicesDir).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+    const files = (0, import_fs20.readdirSync)(servicesDir).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
     const refs = [];
     for (const file of files) {
       try {
-        const raw = import_js_yaml4.default.load(
-          (0, import_fs16.readFileSync)((0, import_path16.join)(servicesDir, file), "utf-8")
+        const raw = import_js_yaml8.default.load(
+          (0, import_fs20.readFileSync)((0, import_path20.join)(servicesDir, file), "utf-8")
         );
         if (raw?.tokenEnv && typeof raw.tokenEnv === "string") {
           refs.push({
@@ -8387,7 +9083,7 @@ Call this tool, then write both files with stackwright_pro_safe_write:
 
 Do NOT compose the contents by hand. This emitter is the source of truth. If an env var is missing, update integrations.yml or the emitter \u2014 not the file. This is the first concrete instance of the swp-zf9y deterministic emitter pattern. ${ENV_LOCAL_DESC}`,
     {
-      cwd: import_zod23.z.string().describe(
+      cwd: import_zod25.z.string().describe(
         "Absolute path to the project root containing stackwright.integrations.yml and optionally services/*.yml"
       )
     },
@@ -8434,8 +9130,8 @@ mapProvider options:
 
 This is the second concrete instance of the swp-zf9y deterministic emitter pattern. Refs: swp-57ku, swp-2m89, swp-zf9y, drawer 957. ${PROVIDERS_DESC}`,
     {
-      cwd: import_zod23.z.string().describe("Absolute path to the project root containing stackwright.integrations.yml"),
-      mapProvider: import_zod23.z.enum(["maplibre", "cesium", "none"]).optional().describe(
+      cwd: import_zod25.z.string().describe("Absolute path to the project root containing stackwright.integrations.yml"),
+      mapProvider: import_zod25.z.enum(["maplibre", "cesium", "none"]).optional().describe(
         "Map provider to register (default: cesium for Pro \u2014 3D globe + terrain). Use maplibre for OSS-style 2D dashboards (explicit opt-out). Use none if pages have no map content_items."
       )
     },
@@ -8476,7 +9172,7 @@ Workflow:
 
 This is the third concrete instance of the swp-zf9y deterministic emitter pattern. Refs: swp-phkh, swp-zf9y. ${PORTS_DESC}`,
     {
-      cwd: import_zod23.z.string().describe("Absolute path to the project root containing stackwright.integrations.yml")
+      cwd: import_zod25.z.string().describe("Absolute path to the project root containing stackwright.integrations.yml")
     },
     async ({ cwd }) => {
       const integrations = readIntegrations(cwd);
@@ -8505,13 +9201,13 @@ This is the third concrete instance of the swp-zf9y deterministic emitter patter
 }
 
 // src/tools/list-specs.ts
-var import_zod24 = require("zod");
-var import_fs17 = require("fs");
-var import_path17 = require("path");
+var import_zod26 = require("zod");
+var import_fs21 = require("fs");
+var import_path21 = 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_path17.basename)(fileName, (0, import_path17.extname)(fileName));
+  let name = (0, import_path21.basename)(fileName, (0, import_path21.extname)(fileName));
   for (const suffix of STRIP_SUFFIXES) {
     if (name.endsWith(suffix)) {
       name = name.slice(0, -suffix.length);
@@ -8529,29 +9225,29 @@ function detectFormat(snippet) {
 }
 function handleListSpecs(input) {
   const { projectRoot } = input;
-  const specsDir = (0, import_path17.join)(projectRoot, "specs");
+  const specsDir = (0, import_path21.join)(projectRoot, "specs");
   const empty = { projectRoot, specs: [], totalCount: 0 };
-  if (!(0, import_fs17.existsSync)(specsDir)) return empty;
+  if (!(0, import_fs21.existsSync)(specsDir)) return empty;
   let entries;
   try {
-    entries = (0, import_fs17.readdirSync)(specsDir);
+    entries = (0, import_fs21.readdirSync)(specsDir);
   } catch {
     return empty;
   }
   const specs = [];
   for (const entry of entries) {
-    const fullPath = (0, import_path17.join)(specsDir, entry);
+    const fullPath = (0, import_path21.join)(specsDir, entry);
     let stat;
     try {
-      stat = (0, import_fs17.statSync)(fullPath);
+      stat = (0, import_fs21.statSync)(fullPath);
     } catch {
       continue;
     }
     if (!stat.isFile()) continue;
-    if (!ALLOWED_EXTS.has((0, import_path17.extname)(entry).toLowerCase())) continue;
+    if (!ALLOWED_EXTS.has((0, import_path21.extname)(entry).toLowerCase())) continue;
     let snippet = "";
     try {
-      snippet = (0, import_fs17.readFileSync)(fullPath, "utf-8").slice(0, 2048);
+      snippet = (0, import_fs21.readFileSync)(fullPath, "utf-8").slice(0, 2048);
     } catch {
     }
     specs.push({
@@ -8570,7 +9266,7 @@ function registerListSpecsTool(server2) {
     "stackwright_pro_list_specs",
     "Enumerate OpenAPI/AsyncAPI specs in the project's specs/ directory. Returns one entry per spec with integration name (derived from filename), detected format, and size. Used by the foreman to fan out the api phase with one api-otter invocation per spec.",
     {
-      projectRoot: import_zod24.z.string().describe("Absolute path to the project root directory")
+      projectRoot: import_zod26.z.string().describe("Absolute path to the project root directory")
     },
     async ({ projectRoot }) => {
       const result = handleListSpecs({ projectRoot });
@@ -8582,10 +9278,10 @@ function registerListSpecsTool(server2) {
 }
 
 // src/tools/describe-endpoint.ts
-var import_zod25 = require("zod");
-var import_fs18 = require("fs");
-var import_path18 = require("path");
-var import_js_yaml5 = __toESM(require("js-yaml"));
+var import_zod27 = require("zod");
+var import_fs22 = require("fs");
+var import_path22 = require("path");
+var import_js_yaml9 = __toESM(require("js-yaml"));
 function resolveRef(root, ref) {
   if (!ref.startsWith("#/")) {
     throw new Error(`[describe_endpoint] External $refs not supported: "${ref}"`);
@@ -8616,12 +9312,12 @@ function deref(root, obj) {
   return o;
 }
 function loadSpec(specPath) {
-  const raw = (0, import_fs18.readFileSync)(specPath, "utf-8");
-  const ext = (0, import_path18.extname)(specPath).toLowerCase();
+  const raw = (0, import_fs22.readFileSync)(specPath, "utf-8");
+  const ext = (0, import_path22.extname)(specPath).toLowerCase();
   if (ext === ".json") {
     return JSON.parse(raw);
   }
-  const parsed = import_js_yaml5.default.load(raw);
+  const parsed = import_js_yaml9.default.load(raw);
   if (parsed == null || typeof parsed !== "object") {
     throw new Error(`[describe_endpoint] Spec file "${specPath}" did not parse to an object`);
   }
@@ -8729,9 +9425,9 @@ function registerDescribeEndpointTool(server2) {
       "from required query params and resolved auth query params (swp-8r8i + swp-1l6l)."
     ].join("\n"),
     {
-      specPath: import_zod25.z.string().describe("Absolute path to the OpenAPI spec file (.yaml, .yml, or .json)"),
-      path: import_zod25.z.string().describe('The API path to inspect (e.g. "/stations/{stationId}/observations")'),
-      method: import_zod25.z.string().describe('HTTP method (case-insensitive: "get", "post", "put", etc.)')
+      specPath: import_zod27.z.string().describe("Absolute path to the OpenAPI spec file (.yaml, .yml, or .json)"),
+      path: import_zod27.z.string().describe('The API path to inspect (e.g. "/stations/{stationId}/observations")'),
+      method: import_zod27.z.string().describe('HTTP method (case-insensitive: "get", "post", "put", etc.)')
     },
     async ({ specPath, path: path5, method }) => {
       try {
@@ -8751,15 +9447,15 @@ function registerDescribeEndpointTool(server2) {
 }
 
 // src/tools/consolidate-integrations.ts
-var import_zod26 = require("zod");
-var import_fs19 = require("fs");
+var import_zod28 = require("zod");
+var import_fs23 = require("fs");
 var import_proper_lockfile2 = require("proper-lockfile");
-var import_path19 = require("path");
-var import_js_yaml6 = __toESM(require("js-yaml"));
+var import_path23 = require("path");
+var import_js_yaml10 = __toESM(require("js-yaml"));
 var BASE_MOCK_PORT = 4011;
 var STRIP_SUFFIXES2 = ["-openapi", "-asyncapi", "-api", "-spec"];
 function deriveNameFromFilename(filename) {
-  const base = (0, import_path19.basename)(filename, ".json").replace(/^api-config-/, "");
+  const base = (0, import_path23.basename)(filename, ".json").replace(/^api-config-/, "");
   for (const suffix of STRIP_SUFFIXES2) {
     if (base.endsWith(suffix)) return base.slice(0, -suffix.length);
   }
@@ -8767,13 +9463,13 @@ function deriveNameFromFilename(filename) {
 }
 function handleConsolidateIntegrations(input) {
   const { projectRoot } = input;
-  const artifactsDir = (0, import_path19.join)(projectRoot, ".stackwright", "artifacts");
-  if (!(0, import_fs19.existsSync)(artifactsDir)) {
+  const artifactsDir = (0, import_path23.join)(projectRoot, ".stackwright", "artifacts");
+  if (!(0, import_fs23.existsSync)(artifactsDir)) {
     return { written: false, integrationCount: 0, reason: "no per-spec artifacts found" };
   }
   let entries;
   try {
-    entries = (0, import_fs19.readdirSync)(artifactsDir).filter(
+    entries = (0, import_fs23.readdirSync)(artifactsDir).filter(
       (f) => f.startsWith("api-config-") && f.endsWith(".json") && f !== "api-config.json"
     );
   } catch {
@@ -8788,7 +9484,7 @@ function handleConsolidateIntegrations(input) {
   entries.forEach((filename, index) => {
     let artifact = {};
     try {
-      const raw = (0, import_fs19.readFileSync)((0, import_path19.join)(artifactsDir, filename), "utf-8");
+      const raw = (0, import_fs23.readFileSync)((0, import_path23.join)(artifactsDir, filename), "utf-8");
       artifact = JSON.parse(raw);
     } catch {
     }
@@ -8821,20 +9517,20 @@ function handleConsolidateIntegrations(input) {
   });
   const integrations = Array.from(integrationsByName.values());
   const dedupedCount = entries.length - skippedIntegrationsList.length - integrations.length;
-  const integrationsYmlPath = (0, import_path19.join)(projectRoot, "stackwright.integrations.yml");
+  const integrationsYmlPath = (0, import_path23.join)(projectRoot, "stackwright.integrations.yml");
   let existing = {};
-  if ((0, import_fs19.existsSync)(integrationsYmlPath)) {
+  if ((0, import_fs23.existsSync)(integrationsYmlPath)) {
     try {
-      const raw = (0, import_fs19.readFileSync)(integrationsYmlPath, "utf-8");
-      existing = import_js_yaml6.default.load(raw) ?? {};
+      const raw = (0, import_fs23.readFileSync)(integrationsYmlPath, "utf-8");
+      existing = import_js_yaml10.default.load(raw) ?? {};
     } catch {
       existing = {};
     }
   }
   const merged = { ...existing, integrations };
-  (0, import_fs19.mkdirSync)((0, import_path19.join)(projectRoot), { recursive: true });
-  if (!(0, import_fs19.existsSync)(integrationsYmlPath)) {
-    (0, import_fs19.writeFileSync)(integrationsYmlPath, "", "utf-8");
+  (0, import_fs23.mkdirSync)((0, import_path23.join)(projectRoot), { recursive: true });
+  if (!(0, import_fs23.existsSync)(integrationsYmlPath)) {
+    (0, import_fs23.writeFileSync)(integrationsYmlPath, "", "utf-8");
   }
   const release = (0, import_proper_lockfile2.lockSync)(integrationsYmlPath, {
     realpath: false,
@@ -8843,8 +9539,8 @@ function handleConsolidateIntegrations(input) {
   try {
     const header = `# stackwright.integrations.yml \u2014 Auto-generated by stackwright_pro_consolidate_integrations
 `;
-    const body = import_js_yaml6.default.dump(merged, { lineWidth: 120, noRefs: true });
-    (0, import_fs19.writeFileSync)(integrationsYmlPath, header + body, "utf-8");
+    const body = import_js_yaml10.default.dump(merged, { lineWidth: 120, noRefs: true });
+    (0, import_fs23.writeFileSync)(integrationsYmlPath, header + body, "utf-8");
   } finally {
     release();
   }
@@ -8872,7 +9568,7 @@ function registerConsolidateIntegrationsTool(server2) {
       "no per-spec artifacts are found."
     ].join(" "),
     {
-      projectRoot: import_zod26.z.string().describe("Absolute path to the project root directory")
+      projectRoot: import_zod28.z.string().describe("Absolute path to the project root directory")
     },
     async ({ projectRoot }) => {
       try {
@@ -8930,7 +9626,7 @@ var package_default = {
     "test:coverage": "vitest run --coverage"
   },
   name: "@stackwright-pro/mcp",
-  version: "0.2.0-alpha.113",
+  version: "0.2.0-alpha.115",
   description: "MCP tools for Stackwright Pro - Data Explorer, Security, ISR, and Dashboard generation",
   license: "SEE LICENSE IN LICENSE",
   main: "./dist/server.js",
@@ -8995,6 +9691,7 @@ registerValidateYamlFragmentTool(server);
 registerProPageTools(server);
 registerGetSchemaTool(server);
 registerScaffoldCleanupTools(server);
+registerWriteWorkflowContainerPageTool(server);
 registerContrastTools(server);
 registerCompileTools(server);
 registerStripLegacyIntegrationsTool(server);