@stackwright-pro/mcp 0.2.0-alpha.7 → 0.2.0-alpha.72

package/dist/server.js

@@ -27,15 +27,44 @@ var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 // src/tools/data-explorer.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 var import_cli_data_explorer = require("@stackwright-pro/cli-data-explorer");
+
+// src/coerce.ts
+var import_zod = require("zod");
+function jsonCoerce(schema) {
+  return import_zod.z.preprocess((v) => {
+    if (typeof v === "string") {
+      try {
+        return JSON.parse(v);
+      } catch {
+        return v;
+      }
+    }
+    return v;
+  }, schema);
+}
+function boolCoerce(schema) {
+  return import_zod.z.preprocess((v) => v === "true" ? true : v === "false" ? false : v, schema);
+}
+function numCoerce(schema) {
+  return import_zod.z.preprocess((v) => {
+    if (typeof v === "string" && v.trim() !== "") {
+      const n = Number(v);
+      if (!Number.isNaN(n)) return n;
+    }
+    return v;
+  }, schema);
+}
+
+// src/tools/data-explorer.ts
 function registerDataExplorerTools(server2) {
   server2.tool(
     "stackwright_pro_list_entities",
     "List all available API entities from OpenAPI specs or generated Zod schemas. Use this to discover what entities are available before generating endpoint filters. Returns entity names, endpoints, and field counts. Part of the Pro Otter Raft for building API-integrated Stackwright applications.",
     {
-      specPath: import_zod.z.string().optional().describe("Path to OpenAPI spec file (YAML or JSON)"),
-      projectRoot: import_zod.z.string().optional().describe("Project root directory (auto-detected if omitted)")
+      specPath: import_zod2.z.string().optional().describe("Path to OpenAPI spec file (YAML or JSON)"),
+      projectRoot: import_zod2.z.string().optional().describe("Project root directory (auto-detected if omitted)")
     },
     async ({ specPath, projectRoot }) => {
       const result = (0, import_cli_data_explorer.listEntities)({
@@ -83,9 +112,13 @@ function registerDataExplorerTools(server2) {
     "stackwright_pro_generate_filter",
     "Generate endpoint filter configuration from selected entities. Creates include/exclude patterns for stackwright.yml OpenAPI integration. Use this after stackwright_pro_list_entities to select which API endpoints the application needs. Only selected endpoints will generate client code, reducing bundle size and improving security.",
     {
-      selectedEntities: import_zod.z.array(import_zod.z.string()).describe('Entity slugs to include (e.g., ["equipment", "supplies"])'),
-      excludePatterns: import_zod.z.array(import_zod.z.string()).optional().describe('Glob patterns to exclude (e.g., ["/admin/**", "/reports/**"])'),
-      projectRoot: import_zod.z.string().optional().describe("Project root directory")
+      selectedEntities: jsonCoerce(import_zod2.z.array(import_zod2.z.string())).describe(
+        'Entity slugs to include (e.g., ["equipment", "supplies"])'
+      ),
+      excludePatterns: jsonCoerce(import_zod2.z.array(import_zod2.z.string()).optional()).describe(
+        'Glob patterns to exclude (e.g., ["/admin/**", "/reports/**"])'
+      ),
+      projectRoot: import_zod2.z.string().optional().describe("Project root directory")
     },
     async ({ selectedEntities, excludePatterns, projectRoot }) => {
       const result = (0, import_cli_data_explorer.generateFilter)({
@@ -141,7 +174,7 @@ function registerDataExplorerTools(server2) {
 }
 
 // src/tools/security.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var import_crypto = require("crypto");
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
@@ -150,8 +183,8 @@ function registerSecurityTools(server2) {
     "stackwright_pro_validate_spec",
     "Validate an OpenAPI spec against the enterprise approved-specs configuration. Checks if the spec URL is on the allowlist and verifies SHA-256 hash integrity. Use this in enterprise environments where only pre-approved API specs are allowed. Fails build if spec is not approved or has been modified.",
     {
-      specPath: import_zod2.z.string().describe("URL or file path to the OpenAPI spec to validate"),
-      configPath: import_zod2.z.string().optional().describe("Path to stackwright.yml with prebuild.security config")
+      specPath: import_zod3.z.string().describe("URL or file path to the OpenAPI spec to validate"),
+      configPath: import_zod3.z.string().optional().describe("Path to stackwright.yml with prebuild.security config")
     },
     async ({ specPath, configPath }) => {
       let securityEnabled = false;
@@ -259,16 +292,15 @@ Status: Valid (${allowlist.length} specs on allowlist)`
     "stackwright_pro_add_approved_spec",
     "Add an OpenAPI spec to the approved-specs allowlist in stackwright.yml. Computes the SHA-256 hash of the spec and adds it to the security configuration. Use this when onboarding a new API in enterprise environments.",
     {
-      name: import_zod2.z.string().describe("Human-readable name for the spec"),
-      url: import_zod2.z.string().describe("URL or file path to the OpenAPI spec"),
-      configPath: import_zod2.z.string().optional().describe("Path to stackwright.yml")
+      name: import_zod3.z.string().describe("Human-readable name for the spec"),
+      url: import_zod3.z.string().describe("URL or file path to the OpenAPI spec"),
+      configPath: import_zod3.z.string().optional().describe("Path to stackwright.yml")
     },
     async ({ name, url, configPath }) => {
       const configFile = configPath || import_path.default.join(process.cwd(), "stackwright.yml");
       let sha256 = "<computed-at-build>";
       try {
         if (url.startsWith("http://") || url.startsWith("https://")) {
-          sha256 = "<computed-at-build>";
         } else if (import_fs.default.existsSync(url)) {
           const specContent = import_fs.default.readFileSync(url, "utf8");
           sha256 = (0, import_crypto.createHash)("sha256").update(specContent).digest("hex");
@@ -315,7 +347,7 @@ SHA-256 computed: ${sha256}`
     "stackwright_pro_list_approved_specs",
     "List all specs currently on the approved-specs allowlist. Shows spec names, URLs, and hash prefixes. Use this to audit what APIs are approved in the project.",
     {
-      configPath: import_zod2.z.string().optional().describe("Path to stackwright.yml")
+      configPath: import_zod3.z.string().optional().describe("Path to stackwright.yml")
     },
     async ({ configPath }) => {
       const configFile = configPath || import_path.default.join(process.cwd(), "stackwright.yml");
@@ -384,16 +416,18 @@ SHA-256 computed: ${sha256}`
 }
 
 // src/tools/isr.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 function registerIsrTools(server2) {
   server2.tool(
     "stackwright_pro_configure_isr",
     "Configure Incremental Static Regeneration (ISR) for an API-backed collection. ISR allows API data to be cached and refreshed on a schedule, providing real-time data with the performance of static generation. Use this after stackwright_pro_generate_filter to set revalidation intervals.",
     {
-      collection: import_zod3.z.string().describe('Collection name (e.g., "equipment", "supplies")'),
-      revalidateSeconds: import_zod3.z.number().optional().describe("Revalidation interval in seconds (default: 60)"),
-      fallback: import_zod3.z.enum(["blocking", "true", "false"]).optional().describe("Fallback behavior for new pages"),
-      configPath: import_zod3.z.string().optional().describe("Path to stackwright.yml")
+      collection: import_zod4.z.string().describe('Collection name (e.g., "equipment", "supplies")'),
+      revalidateSeconds: numCoerce(import_zod4.z.number().optional()).describe(
+        "Revalidation interval in seconds (default: 60)"
+      ),
+      fallback: import_zod4.z.enum(["blocking", "true", "false"]).optional().describe("Fallback behavior for new pages"),
+      configPath: import_zod4.z.string().optional().describe("Path to stackwright.yml")
     },
     async ({ collection, revalidateSeconds = 60, fallback = "blocking", configPath }) => {
       const revalidate = revalidateSeconds;
@@ -404,7 +438,7 @@ function registerIsrTools(server2) {
     isr:
       revalidate: ${revalidate}
       fallback: ${fallback}`;
-      let description = "";
+      let description;
       if (revalidate < 60) {
         description = "\u26A1 Very fresh data (revalidate every " + revalidate + "s)";
       } else if (revalidate < 300) {
@@ -436,14 +470,16 @@ ${yamlSnippet}
     "stackwright_pro_configure_isr_batch",
     "Configure ISR for multiple collections at once. More efficient than calling stackwright_pro_configure_isr multiple times. Provide different revalidation intervals based on data freshness requirements.",
     {
-      collections: import_zod3.z.array(
-        import_zod3.z.object({
-          name: import_zod3.z.string().describe("Collection name"),
-          revalidateSeconds: import_zod3.z.number().optional().describe("Revalidation interval")
-        })
+      collections: jsonCoerce(
+        import_zod4.z.array(
+          import_zod4.z.object({
+            name: import_zod4.z.string().describe("Collection name"),
+            revalidateSeconds: numCoerce(import_zod4.z.number().optional()).describe("Revalidation interval")
+          })
+        )
       ).describe("Array of collection configurations"),
-      defaultFallback: import_zod3.z.enum(["blocking", "true", "false"]).optional().describe("Default fallback behavior"),
-      configPath: import_zod3.z.string().optional().describe("Path to stackwright.yml")
+      defaultFallback: import_zod4.z.enum(["blocking", "true", "false"]).optional().describe("Default fallback behavior"),
+      configPath: import_zod4.z.string().optional().describe("Path to stackwright.yml")
     },
     async ({ collections, defaultFallback = "blocking", configPath }) => {
       const lines = [`\u2699\uFE0F Batch ISR Configuration:
@@ -471,17 +507,17 @@ Fallback: ${defaultFallback}`);
 }
 
 // src/tools/dashboard.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 var import_cli_data_explorer2 = require("@stackwright-pro/cli-data-explorer");
 function registerDashboardTools(server2) {
   server2.tool(
     "stackwright_pro_generate_dashboard",
     "Generate a dashboard page configuration for displaying API data. Creates YAML content for a Stackwright page with grid, metric_card, data_table, and collection_list content types. Use this after stackwright_pro_generate_filter to create pages for your API collections.",
     {
-      entities: import_zod4.z.array(import_zod4.z.string()).describe("Entity slugs to include in dashboard"),
-      layout: import_zod4.z.enum(["grid", "table", "mixed"]).optional().describe("Dashboard layout style"),
-      pageTitle: import_zod4.z.string().optional().describe("Page title"),
-      specPath: import_zod4.z.string().optional().describe("Path to OpenAPI spec for entity details")
+      entities: jsonCoerce(import_zod5.z.array(import_zod5.z.string())).describe("Entity slugs to include in dashboard"),
+      layout: import_zod5.z.enum(["grid", "table", "mixed"]).optional().describe("Dashboard layout style"),
+      pageTitle: import_zod5.z.string().optional().describe("Page title"),
+      specPath: import_zod5.z.string().optional().describe("Path to OpenAPI spec for entity details")
     },
     async ({ entities, layout = "mixed", pageTitle, specPath }) => {
       let entityDetails = [];
@@ -567,9 +603,9 @@ ${yaml}
     "stackwright_pro_generate_detail_page",
     "Generate a detail view page for a single API entity. Creates YAML content for displaying all fields of an individual record. Use this to create detail pages that complement collection listing pages.",
     {
-      entity: import_zod4.z.string().describe('Entity slug (e.g., "equipment")'),
-      slugField: import_zod4.z.string().optional().describe('Field to use as URL slug (default: "id")'),
-      specPath: import_zod4.z.string().optional().describe("Path to OpenAPI spec for field details")
+      entity: import_zod5.z.string().describe('Entity slug (e.g., "equipment")'),
+      slugField: import_zod5.z.string().optional().describe('Field to use as URL slug (default: "id")'),
+      specPath: import_zod5.z.string().optional().describe("Path to OpenAPI spec for field details")
     },
     async ({ entity, slugField = "id", specPath }) => {
       let fields = [];
@@ -592,39 +628,49 @@ ${yaml}
         `    title: "${entityName} Details | {{ ${entity}.${slugField} }}"`,
         "",
         "  content_items:",
-        "    - main:",
-        '        label: "detail-header"',
-        "        heading:",
-        `          text: "{{ ${entity}.${slugField} }}"`,
-        '          textSize: "h1"',
-        "        textBlocks:",
-        `          - text: "Details for this ${entity}"`,
-        '            textSize: "body1"',
-        '        background: "primary"',
-        '        color: "text"',
+        "    - type: text_block",
+        '      label: "detail-header"',
+        "      heading:",
+        `        text: "{{ ${entity}.${slugField} }}"`,
+        '        textSize: "h1"',
+        "      textBlocks:",
+        `        - text: "Details for this ${entity}"`,
+        '          textSize: "body1"',
         "",
-        "    - grid:",
-        '        label: "detail-fields"',
-        "        columns: 2",
-        "        items:"
+        "    - type: grid",
+        '      label: "detail-fields"',
+        "      columns:"
       ];
       const displayFields = fields.length > 0 ? fields.slice(0, 8) : [
         { name: slugField, type: "string" },
         { name: "created_at", type: "datetime" },
         { name: "updated_at", type: "datetime" }
       ];
-      for (const field of displayFields) {
-        const label = field.name.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
-        yamlLines.push(`          - card:`);
-        yamlLines.push(`              label: "${field.name}-field"`);
-        yamlLines.push(`              heading:`);
-        yamlLines.push(`                text: "${label}"`);
-        yamlLines.push(`                textSize: "h4"`);
-        yamlLines.push(`              content:`);
-        yamlLines.push(`                - text: "{{ ${entity}.${field.name} }}"`);
-        yamlLines.push(`                  textSize: "body1"`);
-      }
-      yamlLines.push('        background: "background"');
+      const mid = Math.ceil(displayFields.length / 2);
+      const col1 = displayFields.slice(0, mid);
+      const col2 = displayFields.slice(mid);
+      for (const [colIndex, colFields] of [col1, col2].entries()) {
+        yamlLines.push("        - width: 1");
+        yamlLines.push("          content_items:");
+        for (const field of colFields) {
+          const label = field.name.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
+          yamlLines.push("            - type: text_block");
+          yamlLines.push(`              label: "${field.name}-field"`);
+          yamlLines.push("              heading:");
+          yamlLines.push(`                text: "${label}"`);
+          yamlLines.push('                textSize: "h4"');
+          yamlLines.push("              textBlocks:");
+          yamlLines.push(`                - text: "{{ ${entity}.${field.name} }}"`);
+          yamlLines.push('                  textSize: "body1"');
+        }
+      }
+      yamlLines.push("");
+      yamlLines.push("    - type: action_bar");
+      yamlLines.push("      actions:");
+      yamlLines.push(`        - label: "<- Back to ${entityName}"`);
+      yamlLines.push("          action: navigate");
+      yamlLines.push(`          href: "/${entity}"`);
+      yamlLines.push("          style: secondary");
       const yaml = yamlLines.join("\n");
       return {
         content: [
@@ -645,7 +691,7 @@ ${yaml}
 }
 
 // src/tools/clarification.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 var CONTRADICTION_PATTERNS = [
   {
     keywords: ["minimal", "clean", "simple"],
@@ -733,12 +779,14 @@ function registerClarificationTools(server2) {
     "stackwright_pro_clarify",
     "Ask the user for clarification when a specialist otter encounters ambiguity. This is for MID-EXECUTION questions, NOT upfront question collection (use the Question Manifest Protocol for that). Returns a structured response for the foreman to present to the user via ask_user_question (closed_choice) or directly (open_text).",
     {
-      context: import_zod5.z.string().optional().describe("Context about what the otter is trying to do"),
-      question_type: import_zod5.z.enum(["closed_choice", "open_text"]).describe("Type of question being asked"),
-      question: import_zod5.z.string().describe("The clarification question to ask the user"),
-      choices: import_zod5.z.array(import_zod5.z.string()).optional().describe("Options for closed_choice questions"),
-      priority: import_zod5.z.enum(["blocking", "preferred", "optional"]).optional().default("preferred").describe("How critical is this clarification? Default: preferred"),
-      target_field: import_zod5.z.string().optional().describe("What field/config does this clarify?")
+      context: import_zod6.z.string().optional().describe("Context about what the otter is trying to do"),
+      question_type: import_zod6.z.enum(["closed_choice", "open_text"]).describe("Type of question being asked"),
+      question: import_zod6.z.string().describe("The clarification question to ask the user"),
+      choices: jsonCoerce(import_zod6.z.array(import_zod6.z.string()).optional()).describe(
+        "Options for closed_choice questions"
+      ),
+      priority: import_zod6.z.enum(["blocking", "preferred", "optional"]).optional().default("preferred").describe("How critical is this clarification? Default: preferred"),
+      target_field: import_zod6.z.string().optional().describe("What field/config does this clarify?")
     },
     async ({ context, question_type, question, choices, priority, target_field }) => {
       const result = handleClarify({
@@ -767,8 +815,10 @@ function registerClarificationTools(server2) {
     "stackwright_pro_detect_conflict",
     "Detect when a user's stated preference conflicts with their selected choices. Uses keyword heuristics against known contradiction patterns (minimal vs vibrant, dark vs light, etc). Returns conflict details and resolution options.",
     {
-      stated_preference: import_zod5.z.string().describe("What the user said they wanted"),
-      selected_values: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string()).describe("What the user actually selected (field \u2192 value)")
+      stated_preference: import_zod6.z.string().describe("What the user said they wanted"),
+      selected_values: jsonCoerce(import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string())).describe(
+        "What the user actually selected (field \u2192 value)"
+      )
     },
     async ({ stated_preference, selected_values }) => {
       const result = handleDetectConflict({ stated_preference, selected_values });
@@ -813,7 +863,7 @@ ${result.resolution_options?.map((o) => `  \u2022 ${o}`).join("\n")}
 }
 
 // src/tools/packages.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 var import_fs2 = require("fs");
 var import_child_process = require("child_process");
 var import_path2 = __toESM(require("path"));
@@ -834,17 +884,23 @@ function registerPackageTools(server2) {
     "Ensures pro packages are present in a project's package.json. Safe to call multiple times \u2014 never overwrites existing version pins. Use this to bootstrap dependencies before specialist otters run. Pass includeBaseline: true to automatically include all required @stackwright-pro/* baseline dependencies. Safe to call on existing projects \u2014 never overwrites pinned versions.",
     {
       // FIX 3 (B-new-1): Zod v4 requires two-arg z.record(keySchema, valueSchema)
-      packages: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).describe(
-        'Dependencies to add. Record<packageName, version>. e.g. { "@stackwright-pro/auth": "latest" }'
+      packages: jsonCoerce(import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional().default({})).describe(
+        'Dependencies to add. Record<packageName, version>. e.g. { "@stackwright-pro/auth": "latest" }. Omit or pass {} when using includeBaseline: true.'
+      ),
+      devPackages: jsonCoerce(import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional()).describe(
+        "devDependencies to add. Same format as packages."
       ),
-      devPackages: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional().describe("devDependencies to add. Same format as packages."),
-      scripts: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional().describe("npm scripts to add. Only adds if key does not already exist."),
-      targetDir: import_zod6.z.string().optional().describe(
+      scripts: jsonCoerce(import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional()).describe(
+        "npm scripts to add. Only adds if key does not already exist."
+      ),
+      targetDir: import_zod7.z.string().optional().describe(
         "Project directory containing package.json. Defaults to process.cwd(). Must be an absolute path within the current working directory."
       ),
-      runInstall: import_zod6.z.boolean().optional().default(true).describe("Run pnpm install after writing package.json. Defaults to true."),
-      includeBaseline: import_zod6.z.boolean().optional().default(false).describe(
-        "When true, automatically merges BASELINE_DEPS and BASELINE_DEV_DEPS before applying packages/devPackages args. Safe to call on existing projects \u2014 never overwrites pinned versions."
+      runInstall: boolCoerce(import_zod7.z.boolean().optional().default(true)).describe(
+        "Run pnpm install after writing package.json. Defaults to true. Pass boolean true/false."
+      ),
+      includeBaseline: boolCoerce(import_zod7.z.boolean().optional().default(false)).describe(
+        "When true, automatically merges BASELINE_DEPS and BASELINE_DEV_DEPS before applying packages/devPackages args. Safe to call on existing projects \u2014 never overwrites pinned versions. Pass boolean true/false."
       )
     },
     async ({ packages, devPackages, scripts, targetDir, runInstall, includeBaseline }) => {
@@ -1002,11 +1058,11 @@ function setupPackages(opts) {
       }
     }
     const raw = (0, import_fs2.readFileSync)(realPackageJsonPath, "utf8");
-    const PackageJsonSchema = import_zod6.z.object({
+    const PackageJsonSchema = import_zod7.z.object({
       // Zod v4: z.record(keySchema, valueSchema) — two-arg form required
-      dependencies: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional(),
-      devDependencies: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional(),
-      scripts: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional()
+      dependencies: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional(),
+      devDependencies: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional(),
+      scripts: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional()
     }).passthrough();
     const schemaResult = PackageJsonSchema.safeParse(JSON.parse(raw));
     if (!schemaResult.success) {
@@ -1088,8 +1144,9 @@ function setupPackages(opts) {
 
 // src/tools/questions.ts
 var import_promises = require("fs/promises");
+var import_node_fs = require("fs");
 var import_node_path = require("path");
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 
 // src/question-adapter.ts
 function truncate(str, maxLength) {
@@ -1274,23 +1331,30 @@ function answersToManifestFormat(answers, questions) {
   return result;
 }
 
+// src/validation.ts
+var SAFE_PHASE = /^[a-z][a-z0-9-]{0,30}$/;
+var SAFE_QUESTION_ID = /^[a-z0-9][a-z0-9-]{0,63}$/i;
+function isValidPhase(phase) {
+  return SAFE_PHASE.test(phase);
+}
+
 // src/tools/questions.ts
-var ManifestQuestionSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  question: import_zod7.z.string(),
-  type: import_zod7.z.enum(["text", "select", "multi-select", "confirm"]),
-  required: import_zod7.z.boolean().optional(),
-  options: import_zod7.z.array(
-    import_zod7.z.object({
-      label: import_zod7.z.string(),
-      value: import_zod7.z.string()
+var ManifestQuestionSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  question: import_zod8.z.string(),
+  type: import_zod8.z.enum(["text", "select", "multi-select", "confirm"]),
+  required: import_zod8.z.boolean().optional(),
+  options: import_zod8.z.array(
+    import_zod8.z.object({
+      label: import_zod8.z.string(),
+      value: import_zod8.z.string()
     })
   ).optional(),
-  default: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.boolean(), import_zod7.z.array(import_zod7.z.string())]).optional(),
-  help: import_zod7.z.string().optional(),
-  dependsOn: import_zod7.z.object({
-    questionId: import_zod7.z.string(),
-    value: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.array(import_zod7.z.string())])
+  default: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.boolean(), import_zod8.z.array(import_zod8.z.string())]).optional(),
+  help: import_zod8.z.string().optional(),
+  dependsOn: import_zod8.z.object({
+    questionId: import_zod8.z.string(),
+    value: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.array(import_zod8.z.string())])
   }).optional()
 });
 function registerQuestionTools(server2) {
@@ -1298,15 +1362,16 @@ function registerQuestionTools(server2) {
     "stackwright_pro_present_phase_questions",
     "Adapt manifest-format questions from a specialist otter and present them to the user via ask_user_question. Pass only the phase name \u2014 this tool reads questions from .stackwright/question-manifest.json automatically. The questions parameter is optional and only needed if the manifest has not been written yet. Use this instead of calling ask_user_question directly \u2014 it handles label truncation (50-char limit), header generation, confirm/text defaults, and correct array formatting automatically. IMPORTANT: This is the ONLY approved way to prepare questions before calling ask_user_question. Never call ask_user_question with raw manifest questions. Never retry ask_user_question validation errors by calling it directly \u2014 always re-call this tool.",
     {
-      phase: import_zod7.z.string().describe('Phase name for display context, e.g. "designer", "api", "auth"'),
-      questions: import_zod7.z.array(ManifestQuestionSchema).optional().describe(
+      phase: import_zod8.z.string().describe('Phase name for display context, e.g. "designer", "api", "auth"'),
+      questions: jsonCoerce(import_zod8.z.array(ManifestQuestionSchema).optional()).describe(
         "Questions in Question Manifest format. If omitted, questions are read from .stackwright/question-manifest.json using the phase name."
       ),
-      answers: import_zod7.z.record(import_zod7.z.union([import_zod7.z.string(), import_zod7.z.array(import_zod7.z.string()), import_zod7.z.boolean()])).optional().describe("Previously collected answers used to resolve dependsOn conditions")
+      answers: jsonCoerce(
+        import_zod8.z.record(import_zod8.z.string(), import_zod8.z.union([import_zod8.z.string(), import_zod8.z.array(import_zod8.z.string()), import_zod8.z.boolean()])).optional()
+      ).describe("Previously collected answers used to resolve dependsOn conditions")
     },
     async ({ phase, questions, answers }) => {
       let resolvedQuestions;
-      const SAFE_PHASE = /^[a-z][a-z0-9-]{0,30}$/;
       if (!SAFE_PHASE.test(phase)) {
         return {
           content: [
@@ -1353,17 +1418,36 @@ function registerQuestionTools(server2) {
         }
       }
       const adapted = adaptQuestions(resolvedQuestions, answers ?? {});
+      const labelSchema = import_zod8.z.string().max(50, "Value should have at most 50 characters");
+      for (const q of adapted) {
+        for (const opt of q.options) {
+          const check = labelSchema.safeParse(opt.label);
+          if (!check.success) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    error: `Option label for phase "${phase}" exceeds 50 characters: ${check.error.issues[0]?.message ?? "label too long"}. Truncate option labels to \u226450 characters before calling this tool.`
+                  })
+                }
+              ],
+              isError: true
+            };
+          }
+        }
+      }
       if (adapted.length === 0) {
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify({
-                phase,
-                skipped: true,
-                reason: "No questions to present (all filtered by dependsOn conditions)",
-                answers: []
-              })
+              text: `Phase "${phase}" has no questions to present. Do NOT call ask_user_question. Call stackwright_pro_save_phase_answers({ phase: "${phase}", rawAnswers: [] }) directly, then proceed to the execution step for this phase.`
+            },
+            {
+              type: "text",
+              // Empty array — second block always present so the foreman's two-block contract holds
+              text: JSON.stringify([])
             }
           ],
           isError: false
@@ -1384,10 +1468,146 @@ function registerQuestionTools(server2) {
       };
     }
   );
+  server2.tool(
+    "stackwright_pro_get_next_question",
+    "Returns the next unanswered question for a phase as a plain JSON object \u2014 one question at a time. Returns { done: true } when all questions are answered or the phase has no questions. Call this in a loop: present the question in plain chat, get user reply, call record_answer, repeat.",
+    { phase: import_zod8.z.string().describe('Phase name e.g. "designer", "api", "auth"') },
+    async ({ phase }) => {
+      if (!SAFE_PHASE.test(phase)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ error: `Invalid phase name: "${phase.slice(0, 50)}"` })
+            }
+          ],
+          isError: true
+        };
+      }
+      const cwd = process.cwd();
+      const questionsPath = (0, import_node_path.join)(cwd, ".stackwright", "questions", `${phase}.json`);
+      let questions = [];
+      try {
+        const raw = await (0, import_promises.readFile)(questionsPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        questions = parsed.questions ?? [];
+      } catch {
+        return { content: [{ type: "text", text: JSON.stringify({ done: true }) }] };
+      }
+      if (questions.length === 0) {
+        return { content: [{ type: "text", text: JSON.stringify({ done: true }) }] };
+      }
+      const answersPath = (0, import_node_path.join)(cwd, ".stackwright", "answers", `${phase}.json`);
+      let answeredIds = /* @__PURE__ */ new Set();
+      try {
+        const raw = await (0, import_promises.readFile)(answersPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        answeredIds = new Set(Object.keys(parsed.answers ?? {}));
+      } catch {
+      }
+      const next = questions.find((q) => !answeredIds.has(q.id));
+      if (!next) {
+        return { content: [{ type: "text", text: JSON.stringify({ done: true }) }] };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              done: false,
+              questionId: next.id,
+              question: next.question,
+              type: next.type,
+              options: next.options ?? null,
+              help: next.help ?? null,
+              index: questions.indexOf(next) + 1,
+              total: questions.length
+            })
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "stackwright_pro_record_answer",
+    "Records a single answer to a phase question. Appends to .stackwright/answers/{phase}.json incrementally. Idempotent \u2014 calling twice for the same questionId overwrites. Call after receiving each user reply in the conversational question loop.",
+    {
+      phase: import_zod8.z.string().describe('Phase name e.g. "designer"'),
+      questionId: import_zod8.z.string().describe('The question ID from get_next_question, e.g. "designer-1"'),
+      answer: import_zod8.z.string().describe("The user's free-text answer")
+    },
+    async ({ phase, questionId, answer }) => {
+      if (!SAFE_PHASE.test(phase)) {
+        return {
+          content: [
+            { type: "text", text: JSON.stringify({ error: "Invalid phase name" }) }
+          ],
+          isError: true
+        };
+      }
+      if (!SAFE_QUESTION_ID.test(questionId)) {
+        return {
+          content: [
+            { type: "text", text: JSON.stringify({ error: "Invalid questionId" }) }
+          ],
+          isError: true
+        };
+      }
+      const safeAnswer = answer.slice(0, 2e3);
+      const cwd = process.cwd();
+      const answersDir = (0, import_node_path.join)(cwd, ".stackwright", "answers");
+      const answersPath = (0, import_node_path.join)(answersDir, `${phase}.json`);
+      if ((0, import_node_fs.existsSync)(answersDir) && (0, import_node_fs.lstatSync)(answersDir).isSymbolicLink()) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ error: "answers dir is a symlink \u2014 refusing to write" })
+            }
+          ],
+          isError: true
+        };
+      }
+      (0, import_node_fs.mkdirSync)(answersDir, { recursive: true });
+      let existing = {
+        version: "1.0",
+        phase,
+        answers: {}
+      };
+      try {
+        if ((0, import_node_fs.existsSync)(answersPath)) {
+          if ((0, import_node_fs.lstatSync)(answersPath).isSymbolicLink()) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({ error: "answers file is a symlink \u2014 refusing to write" })
+                }
+              ],
+              isError: true
+            };
+          }
+          const raw = await (0, import_promises.readFile)(answersPath, "utf-8");
+          existing = JSON.parse(raw);
+        }
+      } catch {
+      }
+      existing.answers[questionId] = safeAnswer;
+      existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const tmp = `${answersPath}.tmp`;
+      await (0, import_promises.writeFile)(tmp, JSON.stringify(existing, null, 2), "utf-8");
+      (0, import_node_fs.renameSync)(tmp, answersPath);
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ recorded: true, phase, questionId }) }
+        ]
+      };
+    }
+  );
 }
 
 // src/tools/orchestration.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var import_fs3 = require("fs");
 var import_path3 = require("path");
 var OTTER_NAME_TO_PHASE = [
@@ -1398,7 +1618,9 @@ var OTTER_NAME_TO_PHASE = [
   ["dashboard", "dashboard"],
   ["data", "data"],
   ["page", "pages"],
-  ["workflow", "workflow"]
+  ["workflow", "workflow"],
+  ["polish", "polish"],
+  ["geo", "geo"]
 ];
 var PHASE_TO_OTTER = {
   designer: "stackwright-pro-designer-otter",
@@ -1408,7 +1630,9 @@ var PHASE_TO_OTTER = {
   pages: "stackwright-pro-page-otter",
   dashboard: "stackwright-pro-dashboard-otter",
   data: "stackwright-pro-data-otter",
-  workflow: "stackwright-pro-workflow-otter"
+  workflow: "stackwright-pro-workflow-otter",
+  polish: "stackwright-pro-polish-otter",
+  geo: "stackwright-pro-geo-otter"
 };
 function detectPhase(otterName) {
   const lower = otterName.toLowerCase();
@@ -1474,14 +1698,78 @@ function handleSaveManifest(input) {
   }
 }
 function handleSavePhaseAnswers(input) {
+  if (!isValidPhase(input.phase)) {
+    return {
+      text: JSON.stringify({
+        success: false,
+        error: `Invalid phase name: "${input.phase.slice(0, 50)}". Must be lowercase alphanumeric with hyphens, max 31 chars.`
+      }),
+      isError: true
+    };
+  }
+  for (let i = 0; i < input.rawAnswers.length; i++) {
+    const a = input.rawAnswers[i];
+    if (!a.question_header || a.question_header.trim().length === 0) {
+      return {
+        text: JSON.stringify({
+          success: false,
+          error: `rawAnswers[${i}].question_header is empty \u2014 every answer must have a non-empty question_header.`
+        }),
+        isError: true
+      };
+    }
+    if (!a.selected_options || a.selected_options.length === 0) {
+      return {
+        text: JSON.stringify({
+          success: false,
+          error: `rawAnswers[${i}].selected_options is empty for question_header "${a.question_header}" \u2014 every answer must have at least one selected option.`
+        }),
+        isError: true
+      };
+    }
+  }
+  if (input.questions && input.questions.length > 0 && input.rawAnswers.length === 0) {
+    return {
+      text: JSON.stringify({
+        success: false,
+        error: `${input.questions.length} questions provided but rawAnswers is empty \u2014 this is a malformed payload. If the phase truly has no questions, omit the questions parameter.`
+      }),
+      isError: true
+    };
+  }
   const cwd = input._cwd ?? process.cwd();
   const dir = (0, import_path3.join)(cwd, ".stackwright", "answers");
   const filePath = (0, import_path3.join)(dir, `${input.phase}.json`);
   try {
     (0, import_fs3.mkdirSync)(dir, { recursive: true });
+    const warnings = [];
     let answers;
     if (input.questions && input.questions.length > 0) {
-      answers = answersToManifestFormat(input.rawAnswers, input.questions);
+      try {
+        answers = answersToManifestFormat(input.rawAnswers, input.questions);
+      } catch (mapErr) {
+        answers = {};
+        warnings.push(
+          `Reverse-mapping threw (${mapErr instanceof Error ? mapErr.message : String(mapErr)}) \u2014 falling back to direct key mapping.`
+        );
+      }
+      if (Object.keys(answers).length === 0 && input.rawAnswers.length > 0) {
+        answers = Object.fromEntries(
+          input.rawAnswers.map((a) => [
+            a.question_header,
+            a.selected_options.length > 1 ? a.selected_options : a.selected_options[0] ?? ""
+          ])
+        );
+        warnings.push(
+          `Reverse-mapping produced empty answers despite ${input.rawAnswers.length} rawAnswers \u2014 used direct key mapping as fallback. Ensure question_header values match the manifest header format (e.g. "DESI-1", not descriptive keys).`
+        );
+      }
+      const requiredCount = input.questions.filter((q) => q.required !== false).length;
+      if (input.rawAnswers.length < requiredCount) {
+        warnings.push(
+          `Only ${input.rawAnswers.length} answers provided for ${requiredCount} required questions (${input.questions.length} total) \u2014 answers may be incomplete.`
+        );
+      }
     } else {
       answers = Object.fromEntries(
         input.rawAnswers.map((a) => [a.question_header, a.selected_options[0] ?? ""])
@@ -1508,7 +1796,8 @@ function handleSavePhaseAnswers(input) {
       text: JSON.stringify({
         success: true,
         path: filePath,
-        answersCount: Object.keys(answers).length
+        answersCount: Object.keys(answers).length,
+        ...warnings.length > 0 ? { warnings } : {}
       }),
       isError: false
     };
@@ -1555,13 +1844,63 @@ function handleGetOtterName(input) {
     isError: false
   };
 }
+function handleSaveBuildContext(input) {
+  const cwd = input._cwd ?? process.cwd();
+  const dir = (0, import_path3.join)(cwd, ".stackwright");
+  const filePath = (0, import_path3.join)(dir, "build-context.json");
+  try {
+    (0, import_fs3.mkdirSync)(dir, { recursive: true });
+    if ((0, import_fs3.existsSync)(filePath)) {
+      const stat = (0, import_fs3.lstatSync)(filePath);
+      if (stat.isSymbolicLink()) {
+        return {
+          text: JSON.stringify({
+            success: false,
+            error: `Refusing to write to symlink: ${filePath}`
+          }),
+          isError: true
+        };
+      }
+    }
+    const payload = {
+      version: "1.0",
+      savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      buildContext: input.buildContext
+    };
+    (0, import_fs3.writeFileSync)(filePath, JSON.stringify(payload, null, 2) + "\n");
+    return {
+      text: JSON.stringify({ success: true, path: filePath }),
+      isError: false
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      text: JSON.stringify({ success: false, error: message }),
+      isError: true
+    };
+  }
+}
 function registerOrchestrationTools(server2) {
+  server2.tool(
+    "stackwright_pro_save_build_context",
+    `Save the user's initial build description to .stackwright/build-context.json. Call this once at startup after the user answers the opening "what are you building" question. The saved context is automatically prepended to specialist prompts by stackwright_pro_build_specialist_prompt.`,
+    {
+      buildContext: import_zod9.z.string().describe("Free-text description of what the user wants to build")
+    },
+    async ({ buildContext }) => {
+      const { text, isError } = handleSaveBuildContext({ buildContext });
+      return {
+        content: [{ type: "text", text }],
+        isError
+      };
+    }
+  );
   server2.tool(
     "stackwright_pro_parse_otter_response",
     "Parse and validate a specialist otter's QUESTION_COLLECTION_MODE JSON response. Handles JSON extraction from LLM responses (strips markdown, fixes single quotes, trailing commas). Detects the phase from the otter name. Use this immediately after invoke_agent() to get a validated manifest phase object.",
     {
-      otterName: import_zod8.z.string().describe('The agent name, e.g. "stackwright-pro-api-otter"'),
-      responseText: import_zod8.z.string().describe("Raw text response from the otter's QUESTION_COLLECTION_MODE invocation")
+      otterName: import_zod9.z.string().describe('The agent name, e.g. "stackwright-pro-api-otter"'),
+      responseText: import_zod9.z.string().describe("Raw text response from the otter's QUESTION_COLLECTION_MODE invocation")
     },
     async ({ otterName, responseText }) => {
       const { result, isError } = handleParseOtterResponse({ otterName, responseText });
@@ -1575,16 +1914,18 @@ function registerOrchestrationTools(server2) {
     "stackwright_pro_save_manifest",
     "Write the question manifest to .stackwright/question-manifest.json. Call this after collecting and parsing questions from all otters via stackwright_pro_parse_otter_response.",
     {
-      phases: import_zod8.z.array(
-        import_zod8.z.object({
-          phase: import_zod8.z.string(),
-          otter: import_zod8.z.string(),
-          questions: import_zod8.z.array(import_zod8.z.any()),
-          requiredPackages: import_zod8.z.object({
-            dependencies: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).optional(),
-            devPackages: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).optional()
-          }).optional()
-        })
+      phases: jsonCoerce(
+        import_zod9.z.array(
+          import_zod9.z.object({
+            phase: import_zod9.z.string(),
+            otter: import_zod9.z.string(),
+            questions: import_zod9.z.array(import_zod9.z.any()),
+            requiredPackages: import_zod9.z.object({
+              dependencies: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.string()).optional(),
+              devPackages: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.string()).optional()
+            }).optional()
+          })
+        )
       ).describe("Array of parsed phase objects from stackwright_pro_parse_otter_response")
     },
     async ({ phases }) => {
@@ -1599,15 +1940,37 @@ function registerOrchestrationTools(server2) {
     "stackwright_pro_save_phase_answers",
     "Save user answers for a phase to .stackwright/answers/{phase}.json. Pass rawAnswers directly from ask_user_question and the original manifest questions for label-to-value reverse mapping.",
     {
-      phase: import_zod8.z.string().describe('Phase name, e.g. "designer"'),
-      rawAnswers: import_zod8.z.array(
-        import_zod8.z.object({
-          question_header: import_zod8.z.string(),
-          selected_options: import_zod8.z.array(import_zod8.z.string()),
-          other_text: import_zod8.z.string().nullable().optional()
-        })
-      ).describe("Answers as returned by ask_user_question"),
-      questions: import_zod8.z.array(import_zod8.z.any()).optional().describe("Original manifest questions for label\u2192value reverse-mapping")
+      phase: import_zod9.z.string().describe('Phase name, e.g. "designer"'),
+      rawAnswers: jsonCoerce(
+        import_zod9.z.array(
+          import_zod9.z.object({
+            question_header: import_zod9.z.string().min(1, "question_header must not be empty"),
+            selected_options: import_zod9.z.array(import_zod9.z.string()).min(1, "selected_options must have at least one entry"),
+            other_text: import_zod9.z.string().nullable().optional()
+          })
+        )
+      ).describe(
+        "Answers as returned by ask_user_question \u2014 pass the native array, not a JSON string"
+      ),
+      questions: jsonCoerce(
+        import_zod9.z.array(
+          import_zod9.z.object({
+            id: import_zod9.z.string(),
+            question: import_zod9.z.string(),
+            type: import_zod9.z.string(),
+            options: import_zod9.z.array(import_zod9.z.object({ label: import_zod9.z.string(), value: import_zod9.z.string() })).optional(),
+            required: import_zod9.z.boolean().optional(),
+            default: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.boolean(), import_zod9.z.array(import_zod9.z.string())]).optional(),
+            help: import_zod9.z.string().optional(),
+            dependsOn: import_zod9.z.object({
+              questionId: import_zod9.z.string(),
+              value: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.array(import_zod9.z.string())])
+            }).optional()
+          }).passthrough()
+        ).optional()
+      ).describe(
+        "Original manifest questions for label\u2192value reverse-mapping \u2014 pass the native array, not a JSON string"
+      )
     },
     async ({ phase, rawAnswers, questions }) => {
       const { text, isError } = handleSavePhaseAnswers({
@@ -1625,7 +1988,7 @@ function registerOrchestrationTools(server2) {
     "stackwright_pro_read_phase_answers",
     "Read saved answers for a phase from .stackwright/answers/{phase}.json. Returns { missing: true } when no answers exist yet \u2014 use this to skip phases safely in the execution loop.",
     {
-      phase: import_zod8.z.string().describe('Phase name, e.g. "designer"')
+      phase: import_zod9.z.string().describe('Phase name, e.g. "designer"')
     },
     async ({ phase }) => {
       const { text, isError } = handleReadPhaseAnswers({ phase });
@@ -1639,7 +2002,7 @@ function registerOrchestrationTools(server2) {
     "stackwright_pro_get_otter_name",
     "Get the agent name for a phase (e.g. 'designer' \u2192 'stackwright-pro-designer-otter'). Use this in the execution loop to invoke the correct specialist otter without hardcoding names in the prompt.",
     {
-      phase: import_zod8.z.string().describe('Phase name, e.g. "designer", "api", "pages"')
+      phase: import_zod9.z.string().describe('Phase name, e.g. "designer", "api", "pages"')
     },
     async ({ phase }) => {
       const { text, isError } = handleGetOtterName({ phase });
@@ -1652,50 +2015,404 @@ function registerOrchestrationTools(server2) {
 }
 
 // src/tools/pipeline.ts
-var import_zod9 = require("zod");
+var import_zod11 = require("zod");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
+var import_crypto3 = require("crypto");
+
+// src/artifact-signing.ts
+var import_crypto2 = require("crypto");
 var import_fs4 = require("fs");
 var import_path4 = require("path");
-var PHASE_ORDER = [
-  "designer",
-  "theme",
-  "api",
-  "auth",
-  "data",
-  "pages",
-  "dashboard",
-  "workflow"
-];
-var PHASE_DEPENDENCIES = {
-  designer: [],
-  theme: ["designer"],
-  api: [],
-  auth: [],
-  data: ["api"],
-  pages: ["designer", "theme", "api", "data", "auth"],
-  dashboard: ["designer", "theme", "api", "data"],
-  workflow: ["auth"]
-};
-var PHASE_ARTIFACT = {
-  designer: "design-language.json",
-  theme: "theme-tokens.json",
-  api: "api-config.json",
-  auth: "auth-config.json",
-  data: "data-config.json",
-  pages: "pages-manifest.json",
-  dashboard: "dashboard-manifest.json",
-  workflow: "workflow-config.json"
-};
-var PHASE_TO_OTTER2 = {
-  designer: "stackwright-pro-designer-otter",
-  theme: "stackwright-pro-theme-otter",
-  api: "stackwright-pro-api-otter",
-  auth: "stackwright-pro-auth-otter",
-  data: "stackwright-pro-data-otter",
+var import_zod10 = require("zod");
+var ALGORITHM = "ECDSA-P384-SHA384";
+var KEY_FILE = "pipeline-keys.json";
+var KEY_DIR = ".stackwright";
+var SIGNATURE_MANIFEST = "signatures.json";
+var ARTIFACTS_DIR = ".stackwright/artifacts";
+function rejectSymlink(filePath, context) {
+  if (!(0, import_fs4.existsSync)(filePath)) return;
+  const stat = (0, import_fs4.lstatSync)(filePath);
+  if (stat.isSymbolicLink()) {
+    throw new Error(`Security: refusing to follow symlink at ${context}: ${filePath}`);
+  }
+}
+function computeSha384(data) {
+  return (0, import_crypto2.createHash)("sha384").update(data).digest("hex");
+}
+function safeDigestEqual(a, b) {
+  if (a.length !== b.length) return false;
+  return (0, import_crypto2.timingSafeEqual)(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
+}
+function emptyManifest() {
+  return {
+    version: "1.0",
+    algorithm: ALGORITHM,
+    signatures: {}
+  };
+}
+function initPipelineKeys(cwd) {
+  const keyDir = (0, import_path4.join)(cwd, KEY_DIR);
+  const keyPath = (0, import_path4.join)(keyDir, KEY_FILE);
+  rejectSymlink(keyPath, "pipeline-keys.json");
+  (0, import_fs4.mkdirSync)(keyDir, { recursive: true });
+  const { publicKey, privateKey } = (0, import_crypto2.generateKeyPairSync)("ec", {
+    namedCurve: "P-384"
+  });
+  const publicKeyPem = publicKey.export({ type: "spki", format: "pem" });
+  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" });
+  const fingerprint = (0, import_crypto2.createHash)("sha256").update(publicKeyPem).digest("hex");
+  const keyFile = {
+    version: "1.0",
+    algorithm: ALGORITHM,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    publicKeyPem,
+    privateKeyPem
+  };
+  (0, import_fs4.writeFileSync)(keyPath, JSON.stringify(keyFile, null, 2), { encoding: "utf-8" });
+  return { publicKeyPem, fingerprint };
+}
+function loadPipelineKeys(cwd) {
+  const keyPath = (0, import_path4.join)(cwd, KEY_DIR, KEY_FILE);
+  rejectSymlink(keyPath, "pipeline-keys.json");
+  if (!(0, import_fs4.existsSync)(keyPath)) {
+    throw new Error("Pipeline keys not found \u2014 call initPipelineKeys() first");
+  }
+  let raw;
+  try {
+    raw = (0, import_fs4.readFileSync)(keyPath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Cannot read pipeline keys: ${msg}`, { cause: err });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("Pipeline keys file is not valid JSON");
+  }
+  if (typeof parsed.publicKeyPem !== "string" || !parsed.publicKeyPem.includes("-----BEGIN PUBLIC KEY-----")) {
+    throw new Error("Invalid public key PEM in pipeline keys file");
+  }
+  if (typeof parsed.privateKeyPem !== "string" || !parsed.privateKeyPem.includes("-----BEGIN")) {
+    throw new Error("Invalid private key PEM in pipeline keys file");
+  }
+  const publicKey = (0, import_crypto2.createPublicKey)(parsed.publicKeyPem);
+  const privateKey = (0, import_crypto2.createPrivateKey)(parsed.privateKeyPem);
+  return { privateKey, publicKey };
+}
+function signArtifact(artifactBytes, privateKey) {
+  const digest = computeSha384(artifactBytes);
+  const sig = (0, import_crypto2.sign)("SHA384", artifactBytes, privateKey);
+  return {
+    digest,
+    signature: sig.toString("base64"),
+    algorithm: ALGORITHM,
+    signedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function verifyArtifact(artifactBytes, signature, publicKey) {
+  const sigValid = (0, import_crypto2.verify)(
+    "SHA384",
+    artifactBytes,
+    publicKey,
+    Buffer.from(signature.signature, "base64")
+  );
+  if (!sigValid) return false;
+  const actualDigest = computeSha384(artifactBytes);
+  return safeDigestEqual(actualDigest, signature.digest);
+}
+function loadSignatureManifest(cwd) {
+  const manifestPath = (0, import_path4.join)(cwd, ARTIFACTS_DIR, SIGNATURE_MANIFEST);
+  rejectSymlink(manifestPath, "signatures.json");
+  if (!(0, import_fs4.existsSync)(manifestPath)) return emptyManifest();
+  let raw;
+  try {
+    raw = (0, import_fs4.readFileSync)(manifestPath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Cannot read signature manifest: ${msg}`, { cause: err });
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== "1.0" || typeof parsed.signatures !== "object") {
+      throw new Error("Malformed signature manifest: invalid version or missing signatures object");
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("Malformed")) throw err;
+    throw new Error("Signature manifest is not valid JSON", { cause: err });
+  }
+}
+function saveArtifactSignature(cwd, artifactFilename, sig, signerOtter) {
+  const artifactsDir = (0, import_path4.join)(cwd, ARTIFACTS_DIR);
+  const manifestPath = (0, import_path4.join)(artifactsDir, SIGNATURE_MANIFEST);
+  rejectSymlink(manifestPath, "signatures.json (save)");
+  (0, import_fs4.mkdirSync)(artifactsDir, { recursive: true });
+  const manifest = loadSignatureManifest(cwd);
+  manifest.signatures[artifactFilename] = {
+    ...sig,
+    signedBy: signerOtter
+  };
+  (0, import_fs4.writeFileSync)(manifestPath, JSON.stringify(manifest, null, 2), { encoding: "utf-8" });
+}
+function getArtifactSignature(cwd, artifactFilename) {
+  const manifest = loadSignatureManifest(cwd);
+  const entry = manifest.signatures[artifactFilename];
+  if (!entry) return null;
+  return {
+    digest: entry.digest,
+    signature: entry.signature,
+    algorithm: entry.algorithm,
+    signedAt: entry.signedAt
+  };
+}
+function emitSignatureAuditEvent(params) {
+  const record = JSON.stringify({
+    level: "AUDIT",
+    event: "ARTIFACT_SIGNATURE_FAIL",
+    timestamp: params.timestamp,
+    source: params.source,
+    artifactFilename: params.artifactFilename,
+    expectedDigest: params.expectedDigest,
+    actualDigest: params.actualDigest,
+    phase: params.phase
+  });
+  process.stderr.write(`ARTIFACT_SIGNATURE_FAIL ${record}
+`);
+}
+function registerArtifactSigningTools(server2) {
+  server2.tool(
+    "stackwright_pro_verify_artifact_signatures",
+    "Verify ECDSA P-384 signatures for all pipeline artifacts in .stackwright/artifacts/. Auto-discovers keys from .stackwright/pipeline-keys.json. Returns per-artifact verification status.",
+    {
+      cwd: import_zod10.z.string().optional().describe("Project root directory. Defaults to process.cwd().")
+    },
+    async ({ cwd: cwdParam }) => {
+      const cwd = cwdParam ?? process.cwd();
+      let publicKey;
+      try {
+        const keys = loadPipelineKeys(cwd);
+        publicKey = keys.publicKey;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: true,
+                message: `Cannot load pipeline keys: ${msg}`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      let manifest;
+      try {
+        manifest = loadSignatureManifest(cwd);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: true,
+                message: `Cannot load signature manifest: ${msg}`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const artifactsPath = (0, import_path4.join)(cwd, ARTIFACTS_DIR);
+      let artifactFiles = [];
+      try {
+        if ((0, import_fs4.existsSync)(artifactsPath)) {
+          artifactFiles = (0, import_fs4.readdirSync)(artifactsPath).filter(
+            (f) => f.endsWith(".json") && f !== SIGNATURE_MANIFEST
+          );
+        }
+      } catch {
+      }
+      const results = [];
+      let hasFailure = false;
+      for (const filename of artifactFiles) {
+        const filePath = (0, import_path4.join)(artifactsPath, filename);
+        try {
+          rejectSymlink(filePath, `artifact ${filename}`);
+        } catch {
+          results.push({
+            filename,
+            verified: false,
+            error: "Refusing to verify symlink"
+          });
+          hasFailure = true;
+          continue;
+        }
+        let artifactBytes;
+        try {
+          artifactBytes = (0, import_fs4.readFileSync)(filePath);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          results.push({
+            filename,
+            verified: false,
+            error: `Cannot read artifact: ${msg}`
+          });
+          hasFailure = true;
+          continue;
+        }
+        const entry = manifest.signatures[filename];
+        if (!entry) {
+          results.push({
+            filename,
+            verified: false,
+            error: "No signature found in manifest"
+          });
+          hasFailure = true;
+          continue;
+        }
+        const sig = {
+          digest: entry.digest,
+          signature: entry.signature,
+          algorithm: entry.algorithm,
+          signedAt: entry.signedAt
+        };
+        const verified = verifyArtifact(artifactBytes, sig, publicKey);
+        if (!verified) {
+          const actualDigest = computeSha384(artifactBytes);
+          emitSignatureAuditEvent({
+            artifactFilename: filename,
+            expectedDigest: sig.digest,
+            actualDigest,
+            phase: entry.signedBy ?? "unknown",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            source: "stackwright_pro_verify_artifact_signatures"
+          });
+          results.push({
+            filename,
+            verified: false,
+            error: `Signature verification failed \u2014 artifact may have been tampered with`,
+            signedBy: entry.signedBy,
+            signedAt: entry.signedAt
+          });
+          hasFailure = true;
+        } else {
+          results.push({
+            filename,
+            verified: true,
+            signedBy: entry.signedBy,
+            signedAt: entry.signedAt
+          });
+        }
+      }
+      for (const manifestFilename of Object.keys(manifest.signatures)) {
+        if (!artifactFiles.includes(manifestFilename)) {
+          results.push({
+            filename: manifestFilename,
+            verified: false,
+            error: "Artifact referenced in manifest but missing from disk"
+          });
+          hasFailure = true;
+        }
+      }
+      const verifiedCount = results.filter((r) => r.verified).length;
+      const failedCount = results.filter((r) => !r.verified).length;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              totalArtifacts: artifactFiles.length,
+              verifiedCount,
+              failedCount,
+              results,
+              ...hasFailure ? {
+                error: "SIGNATURE VERIFICATION FAILED: One or more artifact signatures are invalid. Do not proceed \u2014 artifacts may have been tampered with."
+              } : {}
+            })
+          }
+        ],
+        isError: hasFailure
+      };
+    }
+  );
+}
+
+// src/tools/pipeline.ts
+var import_types = require("@stackwright-pro/types");
+var PHASE_ORDER = [
+  "designer",
+  "theme",
+  "api",
+  "data",
+  "geo",
+  "workflow",
+  "services",
+  "pages",
+  "dashboard",
+  "auth",
+  "polish"
+];
+var PHASE_DEPENDENCIES = {
+  designer: [],
+  theme: ["designer"],
+  api: [],
+  data: ["api"],
+  geo: ["data"],
+  // workflow: no hard deps — uses service: references with Prism mock fallback
+  // when API artifacts aren't available; roles come from user answers
+  workflow: [],
+  // services: needs API endpoints to know what to wire, and optionally
+  // workflow states as trigger sources. Produces OpenAPI specs consumed
+  // by pages and dashboard for typed data wiring.
+  services: ["api", "workflow"],
+  // pages/dashboard: depend on services for typed endpoint wiring (OpenAPI
+  // specs) and on geo so the specialist prompt includes geo-manifest.json
+  // — page/dashboard otters see which page slugs are already claimed and
+  // won't attempt to overwrite them (swp-73c). 'api' is still transitive
+  // through 'data'; auth removed — page-otter has graceful fallback.
+  pages: ["designer", "theme", "data", "services", "geo"],
+  dashboard: ["designer", "theme", "data", "services", "geo"],
+  // auth is the penultimate phase — runs after all content-producing phases
+  // so it can read pages, dashboard, workflow, and geo artifacts for route
+  // protection and RBAC wiring. Skipped upstream phases still satisfy deps
+  // (the foreman marks them executed=true), so auth always runs.
+  auth: ["pages", "dashboard", "workflow", "geo"],
+  // polish is the terminal phase — runs after auth so the landing page and
+  // nav reflect the final set of protected routes and all generated pages.
+  polish: ["auth"]
+};
+var PHASE_ARTIFACT = {
+  designer: "design-language.json",
+  theme: "theme-tokens.json",
+  api: "api-config.json",
+  auth: "auth-config.json",
+  data: "data-config.json",
+  pages: "pages-manifest.json",
+  dashboard: "dashboard-manifest.json",
+  workflow: "workflow-config.json",
+  services: "services-config.json",
+  polish: "polish-manifest.json",
+  geo: "geo-manifest.json"
+};
+var PHASE_TO_OTTER2 = {
+  designer: "stackwright-pro-designer-otter",
+  theme: "stackwright-pro-theme-otter",
+  api: "stackwright-pro-api-otter",
+  auth: "stackwright-pro-auth-otter",
+  data: "stackwright-pro-data-otter",
   pages: "stackwright-pro-page-otter",
   dashboard: "stackwright-pro-dashboard-otter",
-  workflow: "stackwright-pro-workflow-otter"
+  workflow: "stackwright-pro-workflow-otter",
+  services: "stackwright-services-otter",
+  polish: "stackwright-pro-polish-otter",
+  geo: "stackwright-pro-geo-otter"
 };
-function isValidPhase(phase) {
+function isValidPhase2(phase) {
   return PHASE_ORDER.includes(phase);
 }
 function defaultPhaseStatus() {
@@ -1723,11 +2440,11 @@ function createDefaultState() {
   };
 }
 function statePath(cwd) {
-  return (0, import_path4.join)(cwd, ".stackwright", "pipeline-state.json");
+  return (0, import_path5.join)(cwd, ".stackwright", "pipeline-state.json");
 }
 function readState(cwd) {
   const p = statePath(cwd);
-  if (!(0, import_fs4.existsSync)(p)) return createDefaultState();
+  if (!(0, import_fs5.existsSync)(p)) return createDefaultState();
   const raw = JSON.parse(safeReadSync(p));
   if (typeof raw !== "object" || raw === null || raw.version !== "1.0") {
     return createDefaultState();
@@ -1735,26 +2452,26 @@ function readState(cwd) {
   return raw;
 }
 function safeWriteSync(filePath, content) {
-  if ((0, import_fs4.existsSync)(filePath)) {
-    const stat = (0, import_fs4.lstatSync)(filePath);
+  if ((0, import_fs5.existsSync)(filePath)) {
+    const stat = (0, import_fs5.lstatSync)(filePath);
     if (stat.isSymbolicLink()) {
       throw new Error(`Refusing to write to symlink: ${filePath}`);
     }
   }
-  (0, import_fs4.writeFileSync)(filePath, content);
+  (0, import_fs5.writeFileSync)(filePath, content);
 }
 function safeReadSync(filePath) {
-  if ((0, import_fs4.existsSync)(filePath)) {
-    const stat = (0, import_fs4.lstatSync)(filePath);
+  if ((0, import_fs5.existsSync)(filePath)) {
+    const stat = (0, import_fs5.lstatSync)(filePath);
     if (stat.isSymbolicLink()) {
       throw new Error(`Refusing to read symlink: ${filePath}`);
     }
   }
-  return (0, import_fs4.readFileSync)(filePath, "utf-8");
+  return (0, import_fs5.readFileSync)(filePath, "utf-8");
 }
 function writeState(cwd, state) {
-  const dir = (0, import_path4.join)(cwd, ".stackwright");
-  (0, import_fs4.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path5.join)(cwd, ".stackwright");
+  (0, import_fs5.mkdirSync)(dir, { recursive: true });
   state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   safeWriteSync(statePath(cwd), JSON.stringify(state, null, 2) + "\n");
 }
@@ -1775,6 +2492,15 @@ function handleGetPipelineState(_cwd) {
   const cwd = _cwd ?? process.cwd();
   try {
     const state = readState(cwd);
+    const keyPath = (0, import_path5.join)(cwd, ".stackwright", "pipeline-keys.json");
+    if (!(0, import_fs5.existsSync)(keyPath)) {
+      try {
+        const { fingerprint } = initPipelineKeys(cwd);
+        state["signingKeyFingerprint"] = fingerprint;
+        writeState(cwd, state);
+      } catch {
+      }
+    }
     return { text: JSON.stringify(state), isError: false };
   } catch (err) {
     return { text: JSON.stringify({ error: true, message: String(err) }), isError: true };
@@ -1782,7 +2508,7 @@ function handleGetPipelineState(_cwd) {
 }
 function handleSetPipelineState(input) {
   const cwd = input._cwd ?? process.cwd();
-  if (input.phase && !isValidPhase(input.phase)) {
+  if (input.phase && !isValidPhase2(input.phase)) {
     return {
       text: JSON.stringify({
         error: true,
@@ -1801,6 +2527,28 @@ function handleSetPipelineState(input) {
       isError: true
     };
   }
+  if (input.updates && input.updates.length > 0) {
+    for (const update of input.updates) {
+      if (!isValidPhase2(update.phase)) {
+        return {
+          text: JSON.stringify({
+            error: true,
+            message: `Invalid phase in batch update: ${update.phase}. Valid phases are: ${PHASE_ORDER.join(", ")}`
+          }),
+          isError: true
+        };
+      }
+      if (!VALID_FIELDS.includes(update.field)) {
+        return {
+          text: JSON.stringify({
+            error: true,
+            message: `Invalid field in batch update: ${update.field}. Valid fields are: ${VALID_FIELDS.join(", ")}`
+          }),
+          isError: true
+        };
+      }
+    }
+  }
   try {
     const state = readState(cwd);
     if (input.status) {
@@ -1820,34 +2568,78 @@ function handleSetPipelineState(input) {
       }
       state.currentPhase = phase;
     }
+    if (input.updates && input.updates.length > 0) {
+      for (const update of input.updates) {
+        if (!state.phases[update.phase]) {
+          state.phases[update.phase] = defaultPhaseStatus();
+        }
+        const batchPhaseState = state.phases[update.phase];
+        batchPhaseState[update.field] = update.value;
+        state.currentPhase = update.phase;
+      }
+    }
     writeState(cwd, state);
     return { text: JSON.stringify(state), isError: false };
   } catch (err) {
     return { text: JSON.stringify({ error: true, message: String(err) }), isError: true };
   }
 }
-function handleCheckExecutionReady(_cwd) {
+function handleCheckExecutionReady(_cwd, phase) {
   const cwd = _cwd ?? process.cwd();
+  if (phase) {
+    if (!isValidPhase2(phase)) {
+      return {
+        text: JSON.stringify({
+          error: true,
+          message: `Invalid phase: ${phase}. Valid phases are: ${PHASE_ORDER.join(", ")}`
+        }),
+        isError: true
+      };
+    }
+    const answerFile = (0, import_path5.join)(cwd, ".stackwright", "answers", `${phase}.json`);
+    if (!(0, import_fs5.existsSync)(answerFile)) {
+      return {
+        text: JSON.stringify({ ready: false, phase, reason: "Answer file not found" }),
+        isError: false
+      };
+    }
+    try {
+      const raw = safeReadSync(answerFile);
+      const parsed = JSON.parse(raw);
+      if (typeof parsed["version"] !== "string" || typeof parsed["phase"] !== "string" || typeof parsed["answers"] !== "object" || parsed["answers"] === null) {
+        return {
+          text: JSON.stringify({ ready: false, phase, reason: "Answer file is malformed" }),
+          isError: false
+        };
+      }
+      return { text: JSON.stringify({ ready: true, phase }), isError: false };
+    } catch {
+      return {
+        text: JSON.stringify({ ready: false, phase, reason: "Answer file could not be parsed" }),
+        isError: false
+      };
+    }
+  }
   try {
-    const answersDir = (0, import_path4.join)(cwd, ".stackwright", "answers");
+    const answersDir = (0, import_path5.join)(cwd, ".stackwright", "answers");
     const answeredPhases = [];
     const missingPhases = [];
-    for (const phase of PHASE_ORDER) {
-      const answerFile = (0, import_path4.join)(answersDir, `${phase}.json`);
-      if ((0, import_fs4.existsSync)(answerFile)) {
+    for (const phase2 of PHASE_ORDER) {
+      const answerFile = (0, import_path5.join)(answersDir, `${phase2}.json`);
+      if ((0, import_fs5.existsSync)(answerFile)) {
         try {
           const raw = safeReadSync(answerFile);
           const parsed = JSON.parse(raw);
           if (typeof parsed["version"] !== "string" || typeof parsed["phase"] !== "string" || typeof parsed["answers"] !== "object" || parsed["answers"] === null) {
-            missingPhases.push(phase);
+            missingPhases.push(phase2);
             continue;
           }
-          answeredPhases.push(phase);
+          answeredPhases.push(phase2);
         } catch {
-          missingPhases.push(phase);
+          missingPhases.push(phase2);
         }
       } else {
-        missingPhases.push(phase);
+        missingPhases.push(phase2);
       }
     }
     return {
@@ -1863,18 +2655,74 @@ function handleCheckExecutionReady(_cwd) {
     return { text: JSON.stringify({ error: true, message: String(err) }), isError: true };
   }
 }
+function handleGetReadyPhases(_cwd) {
+  const cwd = _cwd ?? process.cwd();
+  try {
+    const state = readState(cwd);
+    const completed = [];
+    const ready = [];
+    const blocked = [];
+    for (const phase of PHASE_ORDER) {
+      const ps = state.phases[phase];
+      if (ps?.executed) {
+        completed.push(phase);
+        continue;
+      }
+      const deps = PHASE_DEPENDENCIES[phase];
+      const unmetDeps = deps.filter((dep) => !state.phases[dep]?.executed);
+      if (unmetDeps.length === 0) {
+        ready.push(phase);
+      } else {
+        blocked.push(phase);
+      }
+    }
+    return {
+      text: JSON.stringify({
+        readyPhases: ready,
+        completedPhases: completed,
+        blockedPhases: blocked,
+        waveSize: ready.length,
+        allComplete: ready.length === 0 && blocked.length === 0
+      }),
+      isError: false
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { text: JSON.stringify({ error: true, message }), isError: true };
+  }
+}
 function handleListArtifacts(_cwd) {
   const cwd = _cwd ?? process.cwd();
   try {
-    const artifactsDir = (0, import_path4.join)(cwd, ".stackwright", "artifacts");
+    const artifactsDir = (0, import_path5.join)(cwd, ".stackwright", "artifacts");
+    let manifest = null;
+    try {
+      manifest = loadSignatureManifest(cwd);
+    } catch {
+    }
     const artifacts = [];
     let completedCount = 0;
     for (const phase of PHASE_ORDER) {
       const expectedFile = PHASE_ARTIFACT[phase];
-      const fullPath = (0, import_path4.join)(artifactsDir, expectedFile);
-      const exists = (0, import_fs4.existsSync)(fullPath);
+      const fullPath = (0, import_path5.join)(artifactsDir, expectedFile);
+      const exists = (0, import_fs5.existsSync)(fullPath);
       if (exists) completedCount++;
-      artifacts.push({ phase, expectedFile, exists, path: fullPath });
+      let signed = false;
+      let signatureValid = null;
+      if (exists && manifest) {
+        const entry = manifest.signatures[expectedFile];
+        if (entry) {
+          signed = true;
+          try {
+            const rawBytes = Buffer.from(safeReadSync(fullPath), "utf-8");
+            const { publicKey } = loadPipelineKeys(cwd);
+            signatureValid = verifyArtifact(rawBytes, entry, publicKey);
+          } catch {
+            signatureValid = null;
+          }
+        }
+      }
+      artifacts.push({ phase, expectedFile, exists, path: fullPath, signed, signatureValid });
     }
     return {
       text: JSON.stringify({ artifacts, completedCount, totalCount: PHASE_ORDER.length }),
@@ -1887,7 +2735,7 @@ function handleListArtifacts(_cwd) {
 function handleWritePhaseQuestions(input) {
   const cwd = input._cwd ?? process.cwd();
   const { phase, responseText } = input;
-  if (!isValidPhase(phase)) {
+  if (!isValidPhase2(phase)) {
     return {
       text: JSON.stringify({ error: true, message: `Unknown phase: ${phase}` }),
       isError: true
@@ -1910,9 +2758,9 @@ function handleWritePhaseQuestions(input) {
       }
     } catch {
     }
-    const questionsDir = (0, import_path4.join)(cwd, ".stackwright", "questions");
-    (0, import_fs4.mkdirSync)(questionsDir, { recursive: true });
-    const filePath = (0, import_path4.join)(questionsDir, `${phase}.json`);
+    const questionsDir = (0, import_path5.join)(cwd, ".stackwright", "questions");
+    (0, import_fs5.mkdirSync)(questionsDir, { recursive: true });
+    const filePath = (0, import_path5.join)(questionsDir, `${phase}.json`);
     const payload = {
       version: "1.0",
       phase,
@@ -1945,43 +2793,88 @@ function handleWritePhaseQuestions(input) {
 function handleBuildSpecialistPrompt(input) {
   const cwd = input._cwd ?? process.cwd();
   const { phase } = input;
-  if (!isValidPhase(phase)) {
+  if (!isValidPhase2(phase)) {
     return {
       text: JSON.stringify({ error: true, message: `Unknown phase: ${phase}` }),
       isError: true
     };
   }
   try {
-    const answersPath = (0, import_path4.join)(cwd, ".stackwright", "answers", `${phase}.json`);
+    const answersPath = (0, import_path5.join)(cwd, ".stackwright", "answers", `${phase}.json`);
     let answers = {};
-    if ((0, import_fs4.existsSync)(answersPath)) {
+    if ((0, import_fs5.existsSync)(answersPath)) {
       answers = JSON.parse(safeReadSync(answersPath));
     }
+    let buildContextText = "";
+    const buildContextPath = (0, import_path5.join)(cwd, ".stackwright", "build-context.json");
+    if ((0, import_fs5.existsSync)(buildContextPath)) {
+      try {
+        const bcRaw = JSON.parse(safeReadSync(buildContextPath));
+        if (typeof bcRaw.buildContext === "string" && bcRaw.buildContext.trim().length > 0) {
+          buildContextText = bcRaw.buildContext.trim();
+        }
+      } catch {
+      }
+    }
     const deps = PHASE_DEPENDENCIES[phase];
     const artifactSections = [];
     const missingDependencies = [];
     for (const dep of deps) {
       const artifactFile = PHASE_ARTIFACT[dep];
-      const artifactPath = (0, import_path4.join)(cwd, ".stackwright", "artifacts", artifactFile);
-      if ((0, import_fs4.existsSync)(artifactPath)) {
-        const content = JSON.parse(safeReadSync(artifactPath));
+      const artifactPath = (0, import_path5.join)(cwd, ".stackwright", "artifacts", artifactFile);
+      if ((0, import_fs5.existsSync)(artifactPath)) {
+        const rawContent = safeReadSync(artifactPath);
+        const rawBytes = Buffer.from(rawContent, "utf-8");
+        const content = JSON.parse(rawContent);
+        let signatureVerified = false;
+        let signatureAvailable = false;
+        try {
+          const sig = getArtifactSignature(cwd, artifactFile);
+          if (sig) {
+            signatureAvailable = true;
+            const { publicKey } = loadPipelineKeys(cwd);
+            signatureVerified = verifyArtifact(rawBytes, sig, publicKey);
+            if (!signatureVerified) {
+              const actualDigest = (0, import_crypto3.createHash)("sha384").update(rawBytes).digest("hex");
+              emitSignatureAuditEvent({
+                artifactFilename: artifactFile,
+                expectedDigest: sig.digest,
+                actualDigest,
+                phase: dep,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                source: "stackwright_pro_build_specialist_prompt"
+              });
+              missingDependencies.push(dep);
+              artifactSections.push(
+                `[${artifactFile}]:
+(integrity check failed: ECDSA-P384 signature verification failed \u2014 artifact may have been tampered with)`
+              );
+              continue;
+            }
+          }
+        } catch {
+        }
         const expectedOtter = PHASE_TO_OTTER2[dep];
         const artifactOtter = content["generatedBy"];
+        const normalizedOtter = artifactOtter?.replace(/-[a-f0-9]{6}$/, "");
         if (!artifactOtter) {
           missingDependencies.push(dep);
           artifactSections.push(
             `[${artifactFile}]:
 (integrity check failed: missing generatedBy field)`
           );
-        } else if (artifactOtter !== expectedOtter) {
+        } else if (normalizedOtter !== expectedOtter) {
           missingDependencies.push(dep);
           artifactSections.push(
             `[${artifactFile}]:
 (integrity check failed: artifact claims generatedBy="${artifactOtter}" but expected="${expectedOtter}")`
           );
         } else {
-          artifactSections.push(`[${artifactFile}]:
-${JSON.stringify(content, null, 2)}`);
+          const sigStatus = signatureAvailable ? signatureVerified ? " [signature verified]" : " [signature check skipped]" : " [unsigned]";
+          artifactSections.push(
+            `[${artifactFile}]${sigStatus}:
+${JSON.stringify(content, null, 2)}`
+          );
         }
       } else {
         missingDependencies.push(dep);
@@ -1989,10 +2882,29 @@ ${JSON.stringify(content, null, 2)}`);
 (not yet available)`);
       }
     }
-    const parts = ["ANSWERS:", JSON.stringify(answers, null, 2)];
+    const parts = [];
+    if (buildContextText) {
+      parts.push("BUILD_CONTEXT:", buildContextText, "");
+    }
+    if (phase === "auth") {
+      const initContextPath = (0, import_path5.join)(cwd, ".stackwright", "init-context.json");
+      if ((0, import_fs5.existsSync)(initContextPath)) {
+        try {
+          const initContext = JSON.parse(safeReadSync(initContextPath));
+          if (initContext.devOnly === true || initContext.nonInteractive === true) {
+            answers["devOnly"] = true;
+          }
+        } catch {
+        }
+      }
+    }
+    parts.push("ANSWERS:", JSON.stringify(answers, null, 2));
     if (artifactSections.length > 0) {
       parts.push("", "UPSTREAM ARTIFACTS:", "", ...artifactSections);
     }
+    const artifactSchema = PHASE_ARTIFACT_SCHEMA[phase];
+    parts.push("", "REQUIRED_ARTIFACT_SCHEMA:");
+    parts.push(artifactSchema);
     parts.push("", "Execute using these answers and the upstream artifacts provided.");
     const prompt = parts.join("\n");
     const dependenciesSatisfied = missingDependencies.length === 0;
@@ -2027,49 +2939,323 @@ var OFF_SCRIPT_PATTERNS = [
 var PHASE_REQUIRED_KEYS = {
   designer: ["designLanguage", "themeTokenSeeds"],
   theme: ["tokens"],
-  api: ["entities"],
+  api: ["entities", "version", "generatedBy"],
   auth: ["version", "generatedBy"],
-  data: ["version", "generatedBy"],
+  data: ["version", "generatedBy", "strategy", "collections"],
   pages: ["version", "generatedBy"],
   dashboard: ["version", "generatedBy"],
-  workflow: ["version", "generatedBy"]
+  workflow: ["version", "generatedBy"],
+  services: ["version", "generatedBy", "flows"],
+  polish: ["version", "generatedBy"],
+  geo: ["version", "generatedBy", "geoCollections"]
 };
-function handleValidateArtifact(input) {
-  const cwd = input._cwd ?? process.cwd();
-  const { phase, responseText } = input;
-  if (!isValidPhase(phase)) {
-    return {
-      text: JSON.stringify({ error: true, message: `Unknown phase: ${phase}` }),
-      isError: true
-    };
-  }
-  for (const { pattern, label } of OFF_SCRIPT_PATTERNS) {
-    if (pattern.test(responseText)) {
-      const result = {
-        valid: false,
-        phase,
-        violation: "off-script",
-        retryPrompt: `You returned code output (detected: ${label}). Return ONLY a JSON artifact \u2014 no code, no files.`
-      };
-      return { text: JSON.stringify(result), isError: false };
-    }
-  }
-  let artifact;
-  try {
-    artifact = extractJsonFromResponse(responseText);
-  } catch {
-    const result = {
-      valid: false,
-      phase,
-      violation: "invalid-json",
-      retryPrompt: "Your response did not contain valid JSON. Return a single JSON object with no surrounding text."
-    };
-    return { text: JSON.stringify(result), isError: false };
-  }
-  if (!artifact.version || !artifact.generatedBy) {
-    const result = {
-      valid: false,
-      phase,
+var PHASE_ARTIFACT_SCHEMA = {
+  designer: JSON.stringify(
+    {
+      version: "1.0",
+      generatedBy: "stackwright-pro-designer-otter",
+      application: {
+        type: "<operational|data-explorer|admin|logistics|general>",
+        environment: "<workstation|field|control-room|mixed>",
+        density: "<compact|balanced|spacious>",
+        accessibility: "<wcag-aa|section-508|none>",
+        colorScheme: "<light|dark|both>"
+      },
+      designLanguage: {
+        rationale: "<design rationale>",
+        spacingScale: { base: 8, scale: [0, 4, 8, 16, 24, 32, 48, 64] },
+        colorSemantics: { primary: "#1a365d", accent: "#e53e3e" },
+        typography: {
+          dataFont: "Inter",
+          headingFont: "Inter",
+          monoFont: "monospace",
+          dataSizePx: 12,
+          bodySizePx: 14
+        },
+        contrastRatio: "4.5",
+        borderRadius: "4",
+        shadowElevation: "standard"
+      },
+      themeTokenSeeds: {
+        light: {
+          background: "#ffffff",
+          foreground: "#1a1a1a",
+          primary: "#1a365d",
+          surface: "#f7f7f7",
+          border: "#e2e8f0"
+        },
+        dark: {
+          background: "#1a1a1a",
+          foreground: "#ffffff",
+          primary: "#90cdf4",
+          surface: "#2d2d2d",
+          border: "#4a5568"
+        }
+      },
+      conformsTo: null,
+      operationalNotes: []
+    },
+    null,
+    2
+  ),
+  theme: JSON.stringify(
+    {
+      version: "1.0",
+      generatedBy: "stackwright-pro-theme-otter",
+      componentLibrary: "shadcn",
+      colorScheme: "<light|dark|both>",
+      tokens: {
+        colors: { "primary-500": "#1a365d", background: "#ffffff" },
+        spacing: { "spacing-1": "8px", "spacing-2": "16px" },
+        typography: { "font-data": "Inter", "text-sm": "12px" },
+        shape: { "radius-sm": "4px", "radius-md": "8px" },
+        shadows: { "shadow-sm": "0 1px 2px rgba(0,0,0,0.08)" }
+      },
+      cssVariables: {
+        "--background": "0 0% 100%",
+        "--foreground": "222.2 84% 4.9%",
+        "--primary": "222.2 47.4% 11.2%",
+        "--primary-foreground": "210 40% 98%",
+        "--surface": "210 40% 98%",
+        "--border": "214.3 31.8% 91.4%"
+      },
+      dark: { "--background": "222.2 84% 4.9%", "--foreground": "210 40% 98%" }
+    },
+    null,
+    2
+  ),
+  api: JSON.stringify(
+    {
+      version: "1.0",
+      generatedBy: "stackwright-pro-api-otter",
+      entities: [
+        {
+          name: "Shipment",
+          endpoint: "/shipments",
+          method: "GET",
+          revalidate: 60,
+          mutationType: null
+        }
+      ],
+      skipped: [
+        {
+          spec: "ais-message-models.yaml",
+          format: "asyncapi",
+          reason: "AsyncAPI spec \u2014 WebSocket/event integration required (no REST endpoints)"
+        }
+      ],
+      auth: { type: "bearer", header: "Authorization", envVar: "API_TOKEN" },
+      baseUrl: "https://api.example.mil/v2",
+      specPath: "./specs/api.yaml"
+    },
+    null,
+    2
+  ),
+  data: JSON.stringify(
+    {
+      version: "1.0",
+      generatedBy: "stackwright-pro-data-otter",
+      strategy: "<pulse-fast|isr-fast|isr-standard|isr-slow>",
+      pulseMode: false,
+      collections: [{ name: "equipment", revalidate: 60, pulse: false }],
+      endpoints: { included: ["/equipment/**"], excluded: ["/admin/**"] },
+      requiredPackages: { dependencies: {}, devPackages: {} }
+    },
+    null,
+    2
+  ),
+  geo: JSON.stringify(
+    {
+      version: "1.0",
+      generatedBy: "stackwright-pro-geo-otter",
+      geoCollections: [
+        {
+          collection: "vessels",
+          latField: "latitude",
+          lngField: "longitude",
+          labelField: "vesselName",
+          colorField: "navigationStatus"
+        }
+      ],
+      pages: [
+        {
+          slug: "fleet-tracker",
+          type: "<tracker|zone|route|combined>",
+          collections: ["vessels"],
+          hasLayers: false
+        }
+      ]
+    },
+    null,
+    2
+  ),
+  workflow: JSON.stringify(
+    {
+      version: "1.0",
+      generatedBy: "stackwright-pro-workflow-otter",
+      workflowConfig: {
+        id: "procurement-approval",
+        route: "/procurement",
+        files: ["workflows/procurement-approval.yml"],
+        serviceDependencies: ["service:workflow-state"],
+        warnings: []
+      }
+    },
+    null,
+    2
+  ),
+  services: JSON.stringify(
+    {
+      version: "1.0",
+      generatedBy: "stackwright-services-otter",
+      flows: [
+        {
+          name: "at-risk-patients",
+          trigger: "<http|event|schedule|queue>",
+          steps: 3,
+          outputSpec: "at-risk-patients.openapi.json"
+        }
+      ],
+      workflows: [
+        {
+          name: "evacuation-coordination",
+          states: 4,
+          transitions: 5
+        }
+      ],
+      openApiSpecs: ["at-risk-patients.openapi.json"],
+      capabilitiesUsed: ["service.call", "collection.join", "collection.filter"]
+    },
+    null,
+    2
+  ),
+  pages: JSON.stringify(
+    {
+      version: "1.0",
+      generatedBy: "stackwright-pro-page-otter",
+      pages: [
+        {
+          slug: "catalog",
+          type: "collection_listing",
+          collection: "products",
+          themeApplied: true,
+          authRequired: false
+        },
+        {
+          slug: "admin",
+          type: "protected",
+          collection: null,
+          themeApplied: true,
+          authRequired: true
+        }
+      ]
+    },
+    null,
+    2
+  ),
+  dashboard: JSON.stringify(
+    {
+      version: "1.0",
+      generatedBy: "stackwright-pro-dashboard-otter",
+      pages: [
+        {
+          slug: "dashboard",
+          layout: "<grid|table|mixed>",
+          collections: ["equipment", "supplies"],
+          mode: "<ISR|Pulse>"
+        }
+      ]
+    },
+    null,
+    2
+  ),
+  // type: 'pki' = CAC/DoD certificate auth | 'oidc' = enterprise SSO
+  // For dev-only mock auth: use type: 'oidc' with devOnly: true (Zod strips devOnly — it's a convention only)
+  auth: JSON.stringify(
+    {
+      version: "1.0",
+      generatedBy: "stackwright-pro-auth-otter",
+      authConfig: {
+        type: "<pki|oidc>",
+        // OIDC-only fields (omit for pki):
+        provider: "<azure_ad|okta|cognito|auth0|authentik|keycloak|custom>",
+        discoveryUrl: "<IdP OIDC discovery URL>",
+        clientId: "<OIDC client ID>",
+        clientSecret: "<OIDC client secret>",
+        rbacRoles: ["ADMIN", "ANALYST"],
+        rbacDefaultRole: "ANALYST",
+        protectedRoutes: ["/dashboard/:path*", "/procurement/:path*"],
+        auditEnabled: true,
+        auditRetentionDays: 90
+      },
+      // devScripts is OPTIONAL — only present when devOnly: true was used
+      // Polish otter and foreman MUST check devScripts.written before referencing scripts
+      devScripts: {
+        written: true,
+        scripts: { "dev:admin": "MOCK_USER=admin next dev" }
+      }
+    },
+    null,
+    2
+  ),
+  polish: JSON.stringify(
+    {
+      version: "1.0",
+      generatedBy: "stackwright-pro-polish-otter",
+      landingPage: { slug: "", rewritten: true },
+      navigation: { itemCount: 5, items: ["/dashboard", "/equipment", "/workflows"] },
+      gettingStarted: "<rewritten|redirected|not-found>",
+      scaffoldCleanup: {
+        deleted: ["content/posts/getting-started.yaml"],
+        rewritten: ["app/not-found.tsx"],
+        skipped: []
+      }
+    },
+    null,
+    2
+  )
+};
+function handleValidateArtifact(input) {
+  const cwd = input._cwd ?? process.cwd();
+  const { phase, responseText, artifact: directArtifact } = input;
+  if (!isValidPhase2(phase)) {
+    return {
+      text: JSON.stringify({ error: true, message: `Unknown phase: ${phase}` }),
+      isError: true
+    };
+  }
+  let artifact;
+  if (directArtifact) {
+    artifact = directArtifact;
+  } else {
+    const text = responseText ?? "";
+    for (const { pattern, label } of OFF_SCRIPT_PATTERNS) {
+      if (pattern.test(text)) {
+        const result = {
+          valid: false,
+          phase,
+          violation: "off-script",
+          retryPrompt: `You returned code output (detected: ${label}). Return ONLY a JSON artifact \u2014 no code, no files.`
+        };
+        return { text: JSON.stringify(result), isError: false };
+      }
+    }
+    try {
+      artifact = extractJsonFromResponse(text);
+    } catch {
+      const result = {
+        valid: false,
+        phase,
+        violation: "invalid-json",
+        retryPrompt: "Your response did not contain valid JSON. Return a single JSON object with no surrounding text."
+      };
+      return { text: JSON.stringify(result), isError: false };
+    }
+  }
+  if (!artifact.version || !artifact.generatedBy) {
+    const result = {
+      valid: false,
+      phase,
       violation: "missing-fields",
       retryPrompt: 'Your JSON artifact is missing required fields. Every artifact MUST include "version" and "generatedBy" at the top level.'
     };
@@ -2086,12 +3272,58 @@ function handleValidateArtifact(input) {
     };
     return { text: JSON.stringify(result), isError: false };
   }
+  const PHASE_ZOD_VALIDATORS = {
+    workflow: (artifact2) => {
+      const workflowConfig = artifact2["workflowConfig"];
+      if (!workflowConfig) return { success: true };
+      const result = import_types.WorkflowFileSchema.safeParse(workflowConfig);
+      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 } };
+      }
+      return { success: true };
+    },
+    auth: (artifact2) => {
+      const authConfig = artifact2["authConfig"];
+      if (!authConfig) return { success: true };
+      const result = import_types.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 } };
+      }
+      return { success: true };
+    }
+  };
+  const zodValidator = PHASE_ZOD_VALIDATORS[phase];
+  if (zodValidator) {
+    const zodResult = zodValidator(artifact);
+    if (!zodResult.success) {
+      const result = {
+        valid: false,
+        phase,
+        violation: "schema-mismatch",
+        retryPrompt: `Your artifact failed schema validation: ${zodResult.error?.message}. Fix these fields and return the corrected JSON artifact.`
+      };
+      return { text: JSON.stringify(result), isError: false };
+    }
+  }
   try {
-    const artifactsDir = (0, import_path4.join)(cwd, ".stackwright", "artifacts");
-    (0, import_fs4.mkdirSync)(artifactsDir, { recursive: true });
+    const artifactsDir = (0, import_path5.join)(cwd, ".stackwright", "artifacts");
+    (0, import_fs5.mkdirSync)(artifactsDir, { recursive: true });
     const artifactFile = PHASE_ARTIFACT[phase];
-    const artifactPath = (0, import_path4.join)(artifactsDir, artifactFile);
-    safeWriteSync(artifactPath, JSON.stringify(artifact, null, 2) + "\n");
+    const artifactPath = (0, import_path5.join)(artifactsDir, artifactFile);
+    const serialized = JSON.stringify(artifact, null, 2) + "\n";
+    const artifactBytes = Buffer.from(serialized, "utf-8");
+    safeWriteSync(artifactPath, serialized);
+    let signed = false;
+    try {
+      const { privateKey } = loadPipelineKeys(cwd);
+      const sig = signArtifact(artifactBytes, privateKey);
+      const signerOtter = PHASE_TO_OTTER2[phase];
+      saveArtifactSignature(cwd, artifactFile, sig, signerOtter);
+      signed = true;
+    } catch {
+    }
     const state = readState(cwd);
     if (!state.phases[phase]) state.phases[phase] = defaultPhaseStatus();
     const ps = state.phases[phase];
@@ -2102,7 +3334,7 @@ function handleValidateArtifact(input) {
       valid: true,
       phase,
       artifactPath,
-      summary: `Wrote ${artifactFile} (keys: ${topKeys}${Object.keys(artifact).length > 5 ? ", ..." : ""})`
+      summary: `Wrote ${artifactFile} (keys: ${topKeys}${Object.keys(artifact).length > 5 ? ", ..." : ""})${signed ? " [signed]" : ""}`
     };
     return { text: JSON.stringify(result), isError: false };
   } catch (err) {
@@ -2126,11 +3358,24 @@ function registerPipelineTools(server2) {
     "stackwright_pro_set_pipeline_state",
     `Atomic read\u2192modify\u2192write pipeline state. ${DESC}`,
     {
-      phase: import_zod9.z.string().optional().describe('Phase to update, e.g. "designer"'),
-      field: import_zod9.z.enum(["questionsCollected", "answered", "executed", "artifactWritten"]).optional().describe("Boolean field to set"),
-      value: import_zod9.z.boolean().optional().describe("Value for the field"),
-      status: import_zod9.z.enum(["setup", "questions", "execution", "done"]).optional().describe("Top-level status override"),
-      incrementRetry: import_zod9.z.boolean().optional().describe("Bump retryCount by 1")
+      phase: import_zod11.z.string().optional().describe('Phase to update, e.g. "designer"'),
+      field: import_zod11.z.enum(["questionsCollected", "answered", "executed", "artifactWritten"]).optional().describe("Boolean field to set"),
+      value: boolCoerce(import_zod11.z.boolean().optional()).describe(
+        'Value for the field \u2014 must be a JSON boolean (true/false), NOT the string "true"/"false"'
+      ),
+      status: import_zod11.z.enum(["setup", "questions", "execution", "done"]).optional().describe("Top-level status override"),
+      incrementRetry: boolCoerce(import_zod11.z.boolean().optional()).describe(
+        "Bump retryCount by 1 \u2014 must be a JSON boolean"
+      ),
+      updates: jsonCoerce(
+        import_zod11.z.array(
+          import_zod11.z.object({
+            phase: import_zod11.z.string(),
+            field: import_zod11.z.enum(["questionsCollected", "answered", "executed", "artifactWritten"]),
+            value: import_zod11.z.boolean()
+          })
+        ).optional()
+      ).describe("Batch updates \u2014 apply multiple field changes in one atomic read\u2192modify\u2192write")
     },
     async (args) => res(
       handleSetPipelineState({
@@ -2138,15 +3383,24 @@ function registerPipelineTools(server2) {
         ...args.field != null ? { field: args.field } : {},
         ...args.value != null ? { value: args.value } : {},
         ...args.status != null ? { status: args.status } : {},
-        ...args.incrementRetry != null ? { incrementRetry: args.incrementRetry } : {}
+        ...args.incrementRetry != null ? { incrementRetry: args.incrementRetry } : {},
+        ...args.updates != null ? { updates: args.updates } : {}
       })
     )
   );
   server2.tool(
     "stackwright_pro_check_execution_ready",
-    `Check all phases have answer files in .stackwright/answers/. ${DESC}`,
+    `Check all phases have answer files in .stackwright/answers/. If phase is provided, check only that phase. ${DESC}`,
+    {
+      phase: import_zod11.z.string().optional().describe("If provided, check only this phase's readiness. Omit to check all phases.")
+    },
+    async ({ phase }) => res(handleCheckExecutionReady(void 0, phase))
+  );
+  server2.tool(
+    "stackwright_pro_get_ready_phases",
+    `Return phases whose dependencies are all satisfied (executed=true). Use to determine which phases can run next \u2014 enables wave-based execution. ${DESC}`,
     {},
-    async () => res(handleCheckExecutionReady())
+    async () => res(handleGetReadyPhases())
   );
   server2.tool(
     "stackwright_pro_list_artifacts",
@@ -2156,40 +3410,91 @@ function registerPipelineTools(server2) {
   );
   server2.tool(
     "stackwright_pro_write_phase_questions",
-    `Parse otter question-collection response \u2192 .stackwright/questions/{phase}.json. ${DESC}`,
+    `Parse otter question-collection response \u2192 .stackwright/questions/{phase}.json. Specialists may also call this directly with a parsed questions array. ${DESC}`,
     {
-      phase: import_zod9.z.string().describe('Phase name, e.g. "designer"'),
-      responseText: import_zod9.z.string().describe("Raw LLM response from QUESTION_COLLECTION_MODE")
+      phase: import_zod11.z.string().optional().describe('Phase name, e.g. "designer" (required for direct write)'),
+      responseText: import_zod11.z.string().optional().describe("Raw LLM response from QUESTION_COLLECTION_MODE"),
+      questions: jsonCoerce(import_zod11.z.array(import_zod11.z.any()).optional()).describe(
+        "Questions array for direct specialist write"
+      )
     },
-    async ({ phase, responseText }) => res(handleWritePhaseQuestions({ phase, responseText }))
+    async ({ phase, responseText, questions }) => {
+      if (phase && questions && Array.isArray(questions)) {
+        if (!SAFE_PHASE.test(phase)) {
+          return {
+            content: [
+              { type: "text", text: JSON.stringify({ error: `Invalid phase name` }) }
+            ],
+            isError: true
+          };
+        }
+        const questionsDir = (0, import_path5.join)(process.cwd(), ".stackwright", "questions");
+        (0, import_fs5.mkdirSync)(questionsDir, { recursive: true });
+        const outPath = (0, import_path5.join)(questionsDir, `${phase}.json`);
+        (0, import_fs5.writeFileSync)(
+          outPath,
+          JSON.stringify({ phase, questions, writtenAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                written: true,
+                phase,
+                count: questions.length
+              })
+            }
+          ]
+        };
+      }
+      return res(
+        handleWritePhaseQuestions({ phase: phase ?? "", responseText: responseText ?? "" })
+      );
+    }
   );
   server2.tool(
     "stackwright_pro_build_specialist_prompt",
     `Assemble execution prompt from answers + upstream artifacts. Foreman passes verbatim. ${DESC}`,
-    { phase: import_zod9.z.string().describe('Phase to build prompt for, e.g. "pages"') },
+    { phase: import_zod11.z.string().describe('Phase to build prompt for, e.g. "pages"') },
     async ({ phase }) => res(handleBuildSpecialistPrompt({ phase }))
   );
   server2.tool(
     "stackwright_pro_validate_artifact",
-    `Validate specialist response + write artifact to .stackwright/artifacts/. Returns retryPrompt on failure. ${DESC}`,
+    `Validate and write artifact to .stackwright/artifacts/. Returns retryPrompt on failure. ${DESC}`,
     {
-      phase: import_zod9.z.string().describe('Phase that produced this artifact, e.g. "designer"'),
-      responseText: import_zod9.z.string().describe("Raw response text from the specialist otter")
+      phase: import_zod11.z.string().describe('Phase that produced this artifact, e.g. "designer"'),
+      responseText: import_zod11.z.string().optional().describe("Raw response text from the specialist otter (Foreman-mediated path, legacy)"),
+      artifact: jsonCoerce(import_zod11.z.record(import_zod11.z.string(), import_zod11.z.unknown()).optional()).describe(
+        "Artifact object to validate and write directly (specialist direct path \u2014 skips off-script detection and JSON parsing)"
+      )
     },
-    async ({ phase, responseText }) => res(handleValidateArtifact({ phase, responseText }))
+    async ({ phase, responseText, artifact }) => {
+      if (artifact) {
+        return res(
+          handleValidateArtifact({ phase, artifact })
+        );
+      }
+      return res(handleValidateArtifact({ phase, responseText: responseText ?? "" }));
+    }
   );
 }
 
 // src/tools/safe-write.ts
-var import_zod10 = require("zod");
-var import_fs5 = require("fs");
-var import_path5 = require("path");
+var import_zod12 = require("zod");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
 var OTTER_WRITE_ALLOWLISTS = {
   "stackwright-pro-designer-otter": [
     { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Design language artifact" }
   ],
   "stackwright-pro-theme-otter": [
-    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Theme tokens artifact" }
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Theme tokens artifact" },
+    {
+      prefix: "stackwright.theme.",
+      suffix: ".yml",
+      description: "Theme config YAML (merged at build time)"
+    }
   ],
   "stackwright-pro-auth-otter": [
     { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Auth config artifact" },
@@ -2199,6 +3504,16 @@ var OTTER_WRITE_ALLOWLISTS = {
       prefix: ".env",
       suffix: "",
       description: "Dotenv files (.env, .env.local, .env.production, etc.)"
+    },
+    {
+      prefix: "lib/mock-auth",
+      suffix: ".ts",
+      description: "Mock auth module (DEV_ONLY_MODE role updates)"
+    },
+    {
+      prefix: "package.json",
+      suffix: ".json",
+      description: "Project package.json (DEV_ONLY_MODE script cleanup)"
     }
   ],
   "stackwright-pro-data-otter": [
@@ -2222,19 +3537,115 @@ var OTTER_WRITE_ALLOWLISTS = {
   ],
   "stackwright-pro-api-otter": [
     { prefix: ".stackwright/artifacts/", suffix: ".json", description: "API config artifact" }
+  ],
+  "stackwright-pro-geo-otter": [
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Geo manifest artifact" },
+    { prefix: "pages/", suffix: "/content.yml", description: "Map page content" },
+    { prefix: "pages/", suffix: "/content.yaml", description: "Map page content" }
+  ],
+  "stackwright-pro-polish-otter": [
+    {
+      prefix: "stackwright.yml",
+      suffix: "",
+      description: "Stackwright config (navigation updates)"
+    },
+    { prefix: "pages/", suffix: "/content.yml", description: "Landing page content" },
+    { prefix: "pages/", suffix: "/content.yaml", description: "Landing page content" },
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Polish artifact" },
+    { prefix: "README.md", suffix: "", description: "Project README rewrite" }
+  ],
+  "stackwright-services-otter": [
+    { prefix: ".stackwright/artifacts/", suffix: ".json", description: "Services config artifact" },
+    { prefix: "services/", suffix: ".ts", description: "Service implementation files" },
+    { prefix: "services/", suffix: ".yaml", description: "Service flow definitions" },
+    { prefix: "services/", suffix: ".yml", description: "Service flow definitions" },
+    { prefix: "lib/seeds/", suffix: ".ts", description: "Seed data files" },
+    { prefix: "specs/", suffix: ".json", description: "Generated OpenAPI specs" },
+    { prefix: "specs/", suffix: ".yaml", description: "Generated OpenAPI specs" },
+    { prefix: "stackwright-generated/", suffix: ".json", description: "Services manifest" }
   ]
 };
 var PROTECTED_PATH_PREFIXES = [
   ".stackwright/pipeline-state.json",
+  ".stackwright/pipeline-keys.json",
+  // ephemeral signing keys
+  ".stackwright/artifacts/signatures.json",
+  // artifact signature manifest
   ".stackwright/questions/",
-  ".stackwright/answers/"
+  ".stackwright/answers/",
+  ".stackwright/page-registry.json"
+  // page ownership — managed by safe_write internally
 ];
+var MAX_SAFE_WRITE_BYTES_JSON = 512 * 1024;
+var MAX_SAFE_WRITE_BYTES_YAML = 256 * 1024;
+var MAX_SAFE_WRITE_BYTES_ENV = 4 * 1024;
+var MAX_SAFE_WRITE_BYTES_DEFAULT = 256 * 1024;
+function getMaxBytesForPath(filePath) {
+  if (filePath.endsWith(".json")) return { limit: MAX_SAFE_WRITE_BYTES_JSON, label: "JSON" };
+  if (filePath.endsWith(".yml") || filePath.endsWith(".yaml"))
+    return { limit: MAX_SAFE_WRITE_BYTES_YAML, label: "YAML" };
+  if (filePath === ".env" || /^\.env\.[a-zA-Z0-9]+/.test(filePath))
+    return { limit: MAX_SAFE_WRITE_BYTES_ENV, label: "env" };
+  return { limit: MAX_SAFE_WRITE_BYTES_DEFAULT, label: "default" };
+}
+var PAGE_REGISTRY_FILE = ".stackwright/page-registry.json";
+function extractPageSlug(filePath) {
+  const match = (0, import_path6.normalize)(filePath).match(/^pages\/(.+?)\/content\.ya?ml$/);
+  return match?.[1] ?? null;
+}
+function extractContentTypes(yamlContent) {
+  const typePattern = /^\s*-?\s*type:\s*(\S+)/gm;
+  const types = [];
+  let m;
+  while ((m = typePattern.exec(yamlContent)) !== null) {
+    const typeName = m[1];
+    if (typeName && !types.includes(typeName)) {
+      types.push(typeName);
+    }
+  }
+  return types.length > 0 ? types : ["unknown"];
+}
+function readPageRegistry(cwd) {
+  const regPath = (0, import_path6.join)(cwd, PAGE_REGISTRY_FILE);
+  if (!(0, import_fs6.existsSync)(regPath)) return {};
+  try {
+    const stat = (0, import_fs6.lstatSync)(regPath);
+    if (stat.isSymbolicLink()) return {};
+    return JSON.parse((0, import_fs6.readFileSync)(regPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writePageRegistry(cwd, registry) {
+  const dir = (0, import_path6.join)(cwd, ".stackwright");
+  (0, import_fs6.mkdirSync)(dir, { recursive: true });
+  const regPath = (0, import_path6.join)(cwd, PAGE_REGISTRY_FILE);
+  if ((0, import_fs6.existsSync)(regPath)) {
+    const stat = (0, import_fs6.lstatSync)(regPath);
+    if (stat.isSymbolicLink()) {
+      throw new Error("Refusing to write page registry through symlink");
+    }
+  }
+  (0, import_fs6.writeFileSync)(regPath, JSON.stringify(registry, null, 2) + "\n", { encoding: "utf-8" });
+}
+function checkPageOwnership(cwd, slug, callerOtter) {
+  const registry = readPageRegistry(cwd);
+  const existing = registry[slug];
+  if (!existing || existing.claimedBy === callerOtter) {
+    return { allowed: true };
+  }
+  return {
+    allowed: false,
+    owner: existing.claimedBy,
+    contentTypes: existing.contentTypes
+  };
+}
 function checkPathAllowed(callerOtter, filePath) {
-  const normalized = (0, import_path5.normalize)(filePath);
+  const normalized = (0, import_path6.normalize)(filePath);
   if (normalized.includes("..")) {
     return { allowed: false, error: 'Path traversal detected: ".." segments are not allowed' };
   }
-  if ((0, import_path5.isAbsolute)(normalized)) {
+  if ((0, import_path6.isAbsolute)(normalized)) {
     return {
       allowed: false,
       error: "Absolute paths are not allowed \u2014 use paths relative to project root"
@@ -2270,6 +3681,16 @@ function checkPathAllowed(callerOtter, filePath) {
           continue;
         }
       }
+      if (rule.prefix === "lib/mock-auth" && rule.suffix === ".ts") {
+        if (normalized !== "lib/mock-auth.ts") {
+          continue;
+        }
+      }
+      if (rule.prefix === "package.json" && rule.suffix === ".json") {
+        if (normalized !== "package.json") {
+          continue;
+        }
+      }
       return { allowed: true, rule: rule.description };
     }
   }
@@ -2354,11 +3775,23 @@ function handleSafeWrite(input) {
     };
     return { text: JSON.stringify(result), isError: true };
   }
-  const normalized = (0, import_path5.normalize)(filePath);
-  const fullPath = (0, import_path5.join)(cwd, normalized);
-  if ((0, import_fs5.existsSync)(fullPath)) {
+  const contentBytes = Buffer.byteLength(content, "utf-8");
+  const { limit: maxBytes, label: fileTypeLabel } = getMaxBytesForPath(filePath);
+  if (contentBytes > maxBytes) {
+    const result = {
+      success: false,
+      error: `Content size ${contentBytes} bytes exceeds ${fileTypeLabel} limit of ${maxBytes} bytes (${maxBytes / 1024} KB)`,
+      callerOtter,
+      attemptedPath: filePath,
+      allowedPaths: []
+    };
+    return { text: JSON.stringify(result), isError: true };
+  }
+  const normalized = (0, import_path6.normalize)(filePath);
+  const fullPath = (0, import_path6.join)(cwd, normalized);
+  if ((0, import_fs6.existsSync)(fullPath)) {
     try {
-      const stat = (0, import_fs5.lstatSync)(fullPath);
+      const stat = (0, import_fs6.lstatSync)(fullPath);
       if (stat.isSymbolicLink()) {
         const result = {
           success: false,
@@ -2383,11 +3816,38 @@ function handleSafeWrite(input) {
     };
     return { text: JSON.stringify(result), isError: true };
   }
+  const pageSlug = extractPageSlug(normalized);
+  if (pageSlug) {
+    const ownership = checkPageOwnership(cwd, pageSlug, callerOtter);
+    if (!ownership.allowed) {
+      const result = {
+        success: false,
+        error: `Page slug "${pageSlug}" is already claimed by ${ownership.owner} (content types: ${ownership.contentTypes.join(", ")}). Use a different slug or coordinate with the owning otter.`,
+        callerOtter,
+        attemptedPath: filePath,
+        allowedPaths: []
+      };
+      return { text: JSON.stringify(result), isError: true };
+    }
+  }
   try {
     if (createDirectories) {
-      (0, import_fs5.mkdirSync)((0, import_path5.dirname)(fullPath), { recursive: true });
+      (0, import_fs6.mkdirSync)((0, import_path6.dirname)(fullPath), { recursive: true });
+    }
+    (0, import_fs6.writeFileSync)(fullPath, content, { encoding: "utf-8" });
+    if (pageSlug) {
+      try {
+        const registry = readPageRegistry(cwd);
+        registry[pageSlug] = {
+          slug: pageSlug,
+          claimedBy: callerOtter,
+          contentTypes: extractContentTypes(content),
+          writtenAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        writePageRegistry(cwd, registry);
+      } catch {
+      }
     }
-    (0, import_fs5.writeFileSync)(fullPath, content, { encoding: "utf-8" });
     const result = {
       success: true,
       path: normalized,
@@ -2413,10 +3873,12 @@ function registerSafeWriteTools(server2) {
     "stackwright_pro_safe_write",
     DESC,
     {
-      callerOtter: import_zod10.z.string().describe('The otter agent name requesting the write, e.g. "stackwright-pro-page-otter"'),
-      filePath: import_zod10.z.string().describe('Relative path from project root, e.g. "pages/dashboard/content.yml"'),
-      content: import_zod10.z.string().describe("File content to write"),
-      createDirectories: import_zod10.z.boolean().optional().describe("Create parent directories if they don't exist. Default: true")
+      callerOtter: import_zod12.z.string().describe('The otter agent name requesting the write, e.g. "stackwright-pro-page-otter"'),
+      filePath: import_zod12.z.string().describe('Relative path from project root, e.g. "pages/dashboard/content.yml"'),
+      content: import_zod12.z.string().describe("File content to write"),
+      createDirectories: boolCoerce(import_zod12.z.boolean().optional().default(true)).describe(
+        "Create parent directories if they don't exist. Default: true"
+      )
     },
     async ({ callerOtter, filePath, content, createDirectories }) => {
       const result = handleSafeWrite({
@@ -2431,9 +3893,9 @@ function registerSafeWriteTools(server2) {
 }
 
 // src/tools/auth.ts
-var import_zod11 = require("zod");
-var import_fs6 = require("fs");
-var import_path6 = require("path");
+var import_zod13 = require("zod");
+var import_fs7 = require("fs");
+var import_path7 = require("path");
 function buildHierarchy(roles) {
   const h = {};
   for (let i = 0; i < roles.length - 1; i++) {
@@ -2554,6 +4016,91 @@ ${auditBlock}
 ${routesBlock}
 });
 
+${configBlock}
+`;
+}
+function generateProxyContent(method, params, roles, defaultRole, hierarchy, auditEnabled, auditRetentionDays, protectedRoutes) {
+  const rbacBlock = `  rbac: {
+    roles: ${JSON.stringify(roles)},
+    defaultRole: '${defaultRole}',
+    hierarchy: ${JSON.stringify(hierarchy, null, 4)},
+  },`;
+  const auditBlock = `  audit: {
+    enabled: ${auditEnabled},
+    retentionDays: ${auditRetentionDays},
+  },`;
+  const routesBlock = `  protectedRoutes: ${JSON.stringify(protectedRoutes)},`;
+  const configBlock = `export const config = {
+  matcher: ${JSON.stringify(protectedRoutes)},
+};`;
+  if (method === "cac") {
+    const caBundle = params.cacCaBundle ?? "./certs/dod-ca-bundle.pem";
+    const edipiLookup = params.cacEdipiLookup ?? "./config/edipi-lookup.json";
+    const ocspEndpoint = params.cacOcspEndpoint ?? "https://ocsp.disa.mil";
+    const certHeader = params.cacCertHeader ?? "X-SSL-Client-Cert";
+    return `// proxy.ts \u2014 generated by @stackwright-pro/auth (Next.js >=16)
+//   SECURITY REVIEW REQUIRED \u2014 CAC/PKI certificate validation
+// DoD security officer review required before production deployment.
+// Verify: CA bundle completeness, EDIPI lookup endpoint, OCSP accessibility.
+import { createAuthProxy } from '@stackwright-pro/auth-nextjs';
+
+export const proxy = createAuthProxy({
+  method: 'cac',
+  cac: {
+    caBundle: process.env.CAC_CA_BUNDLE ?? '${caBundle}',
+    edipiLookup: '${edipiLookup}',
+    ocspEndpoint: process.env.CAC_OCSP_ENDPOINT ?? '${ocspEndpoint}',
+    certHeader: '${certHeader}',
+  },
+${rbacBlock}
+${auditBlock}
+${routesBlock}
+});
+
+${configBlock}
+`;
+  }
+  if (method === "oidc") {
+    const scopes2 = params.oidcScopes ?? "openid profile email";
+    const roleClaim = params.oidcRoleClaim ?? "roles";
+    return `// proxy.ts \u2014 generated by @stackwright-pro/auth (Next.js >=16)
+import { createAuthProxy } from '@stackwright-pro/auth-nextjs';
+
+export const proxy = createAuthProxy({
+  method: 'oidc',
+  oidc: {
+    discoveryUrl: process.env.OIDC_DISCOVERY_URL!,
+    clientId: process.env.OIDC_CLIENT_ID!,
+    clientSecret: process.env.OIDC_CLIENT_SECRET!,
+    scopes: '${scopes2}',
+    roleClaim: '${roleClaim}',
+  },
+${rbacBlock}
+${auditBlock}
+${routesBlock}
+});
+
+${configBlock}
+`;
+  }
+  const scopes = params.oauth2Scopes ?? "read write";
+  return `// proxy.ts \u2014 generated by @stackwright-pro/auth (Next.js >=16)
+import { createAuthProxy } from '@stackwright-pro/auth-nextjs';
+
+export const proxy = createAuthProxy({
+  method: 'oauth2',
+  oauth2: {
+    authorizationUrl: process.env.OAUTH2_AUTH_URL!,
+    tokenUrl: process.env.OAUTH2_TOKEN_URL!,
+    clientId: process.env.OAUTH2_CLIENT_ID!,
+    clientSecret: process.env.OAUTH2_CLIENT_SECRET!,
+    scopes: '${scopes}',
+  },
+${rbacBlock}
+${auditBlock}
+${routesBlock}
+});
+
 ${configBlock}
 `;
 }
@@ -2583,7 +4130,7 @@ OAUTH2_CLIENT_ID=your-client-id
 OAUTH2_CLIENT_SECRET=your-client-secret
 `;
 }
-function generateYamlBlock(method, params, roles, defaultRole, hierarchy, auditEnabled, auditRetentionDays, protectedRoutes) {
+function generateYamlBlock(method, params, roles, defaultRole, hierarchy, auditEnabled, auditRetentionDays, protectedRoutes, useProxy) {
   const rbacSection = `  rbac:
     roles:
 ${rolesToYaml(roles, "      ")}
@@ -2606,7 +4153,7 @@ ${routesToYaml(protectedRoutes, "    ", defaultRole)}`.replace(/\n\s+,/g, "");
     const certHeader = params.cacCertHeader ?? "X-SSL-Client-Cert";
     return `auth:
   method: cac
-${providerLine}  middleware: ./middleware.ts
+${providerLine}  ${useProxy ? "proxy" : "middleware"}: ./${useProxy ? "proxy" : "middleware"}.ts
   cac:
     caBundle: \${CAC_CA_BUNDLE}
     edipiLookup: ${edipiLookup}
@@ -2623,7 +4170,7 @@ ${auditSection}
     const roleClaim = params.oidcRoleClaim ?? "roles";
     return `auth:
   method: oidc
-${providerLine}  middleware: ./middleware.ts
+${providerLine}  ${useProxy ? "proxy" : "middleware"}: ./${useProxy ? "proxy" : "middleware"}.ts
   oidc:
     discoveryUrl: \${OIDC_DISCOVERY_URL}
     clientId: \${OIDC_CLIENT_ID}
@@ -2639,7 +4186,7 @@ ${auditSection}
   const scopes = params.oauth2Scopes ?? "read write";
   return `auth:
   method: oauth2
-${providerLine}  middleware: ./middleware.ts
+${providerLine}  ${useProxy ? "proxy" : "middleware"}: ./${useProxy ? "proxy" : "middleware"}.ts
   oauth2:
     authorizationUrl: \${OAUTH2_AUTH_URL}
     tokenUrl: \${OAUTH2_TOKEN_URL}
@@ -2652,10 +4199,321 @@ ${routeLines}
 ${auditSection}
 `;
 }
+function generateDevOnlyMiddlewareContent(method, params, roles, defaultRole, hierarchy, auditEnabled, auditRetentionDays, protectedRoutes) {
+  const rbacBlock = `  rbac: {
+    roles: ${JSON.stringify(roles)},
+    defaultRole: '${defaultRole}',
+    hierarchy: ${JSON.stringify(hierarchy, null, 4)},
+  },`;
+  const auditBlock = `  audit: {
+    enabled: ${auditEnabled},
+    retentionDays: ${auditRetentionDays},
+  },`;
+  const routesBlock = `  protectedRoutes: ${JSON.stringify(protectedRoutes)},`;
+  const configBlock = `export const config = {
+  matcher: ${JSON.stringify(protectedRoutes)},
+};`;
+  const devHeader = [
+    "// middleware.ts \u2014 generated by @stackwright-pro/auth-nextjs (dev-only mock)",
+    "//   DEV ONLY \u2014 uses mock authentication from lib/mock-auth.ts",
+    "// Do NOT deploy to production.",
+    "import { createProMiddleware } from '@stackwright-pro/auth-nextjs';",
+    "import { mockAuthProvider } from './lib/mock-auth';"
+  ].join("\n");
+  if (method === "cac") {
+    const caBundle = params.cacCaBundle ?? "./certs/dod-ca-bundle.pem";
+    const edipiLookup = params.cacEdipiLookup ?? "./config/edipi-lookup.json";
+    const ocspEndpoint = params.cacOcspEndpoint ?? "https://ocsp.disa.mil";
+    const certHeader = params.cacCertHeader ?? "X-SSL-Client-Cert";
+    return `${devHeader}
+
+export const middleware = createProMiddleware({
+  method: 'cac',
+  cac: {
+    caBundle: '${caBundle}',
+    edipiLookup: '${edipiLookup}',
+    ocspEndpoint: '${ocspEndpoint}',
+    certHeader: '${certHeader}',
+    provider: mockAuthProvider,
+  },
+${rbacBlock}
+${auditBlock}
+${routesBlock}
+});
+
+${configBlock}
+`;
+  }
+  if (method === "oidc") {
+    const scopes2 = params.oidcScopes ?? "openid profile email";
+    const roleClaim = params.oidcRoleClaim ?? "roles";
+    return `${devHeader}
+
+export const middleware = createProMiddleware({
+  method: 'oidc',
+  oidc: {
+    discoveryUrl: 'https://dev-mock-oidc/.well-known/openid-configuration',
+    clientId: 'dev-mock-client',
+    clientSecret: 'dev-mock-secret',
+    scopes: '${scopes2}',
+    roleClaim: '${roleClaim}',
+    provider: mockAuthProvider,
+  },
+${rbacBlock}
+${auditBlock}
+${routesBlock}
+});
+
+${configBlock}
+`;
+  }
+  const scopes = params.oauth2Scopes ?? "read write";
+  return `${devHeader}
+
+export const middleware = createProMiddleware({
+  method: 'oauth2',
+  oauth2: {
+    authorizationUrl: 'https://dev-mock-oauth2/authorize',
+    tokenUrl: 'https://dev-mock-oauth2/token',
+    clientId: 'dev-mock-client',
+    clientSecret: 'dev-mock-secret',
+    scopes: '${scopes}',
+    provider: mockAuthProvider,
+  },
+${rbacBlock}
+${auditBlock}
+${routesBlock}
+});
+
+${configBlock}
+`;
+}
+function generateDevOnlyProxyContent(method, params, roles, defaultRole, hierarchy, auditEnabled, auditRetentionDays, protectedRoutes) {
+  const rbacBlock = `  rbac: {
+    roles: ${JSON.stringify(roles)},
+    defaultRole: '${defaultRole}',
+    hierarchy: ${JSON.stringify(hierarchy, null, 4)},
+  },`;
+  const auditBlock = `  audit: {
+    enabled: ${auditEnabled},
+    retentionDays: ${auditRetentionDays},
+  },`;
+  const routesBlock = `  protectedRoutes: ${JSON.stringify(protectedRoutes)},`;
+  const configBlock = `export const config = {
+  matcher: ${JSON.stringify(protectedRoutes)},
+};`;
+  const devHeader = [
+    "// proxy.ts -- generated by @stackwright-pro/auth (Next.js >=16, dev-only mock)",
+    "//   DEV ONLY -- uses mock authentication from lib/mock-auth.ts",
+    "// Do NOT deploy to production.",
+    "import { createAuthProxy } from '@stackwright-pro/auth-nextjs';",
+    "import { mockAuthProvider } from './lib/mock-auth';"
+  ].join("\n");
+  if (method === "cac") {
+    const caBundle = params.cacCaBundle ?? "./certs/dod-ca-bundle.pem";
+    const edipiLookup = params.cacEdipiLookup ?? "./config/edipi-lookup.json";
+    const ocspEndpoint = params.cacOcspEndpoint ?? "https://ocsp.disa.mil";
+    const certHeader = params.cacCertHeader ?? "X-SSL-Client-Cert";
+    return `${devHeader}
+
+export const proxy = createAuthProxy({
+  method: 'cac',
+  cac: {
+    caBundle: '${caBundle}',
+    edipiLookup: '${edipiLookup}',
+    ocspEndpoint: '${ocspEndpoint}',
+    certHeader: '${certHeader}',
+    provider: mockAuthProvider,
+  },
+${rbacBlock}
+${auditBlock}
+${routesBlock}
+});
+
+${configBlock}
+`;
+  }
+  if (method === "oidc") {
+    const scopes2 = params.oidcScopes ?? "openid profile email";
+    const roleClaim = params.oidcRoleClaim ?? "roles";
+    return `${devHeader}
+
+export const proxy = createAuthProxy({
+  method: 'oidc',
+  oidc: {
+    discoveryUrl: 'https://dev-mock-oidc/.well-known/openid-configuration',
+    clientId: 'dev-mock-client',
+    clientSecret: 'dev-mock-secret',
+    scopes: '${scopes2}',
+    roleClaim: '${roleClaim}',
+    provider: mockAuthProvider,
+  },
+${rbacBlock}
+${auditBlock}
+${routesBlock}
+});
+
+${configBlock}
+`;
+  }
+  const scopes = params.oauth2Scopes ?? "read write";
+  return `${devHeader}
+
+export const proxy = createAuthProxy({
+  method: 'oauth2',
+  oauth2: {
+    authorizationUrl: 'https://dev-mock-oauth2/authorize',
+    tokenUrl: 'https://dev-mock-oauth2/token',
+    clientId: 'dev-mock-client',
+    clientSecret: 'dev-mock-secret',
+    scopes: '${scopes}',
+    provider: mockAuthProvider,
+  },
+${rbacBlock}
+${auditBlock}
+${routesBlock}
+});
+
+${configBlock}
+`;
+}
+function generateDevOnlyYamlBlock(method, params, roles, defaultRole, hierarchy, auditEnabled, auditRetentionDays, protectedRoutes, useProxy) {
+  const rbacSection = `  rbac:
+    roles:
+${rolesToYaml(roles, "      ")}
+    defaultRole: ${defaultRole}
+    hierarchy:
+${hierarchyToYaml(hierarchy, "      ")}`;
+  const auditSection = `  audit:
+    enabled: ${auditEnabled}
+    retentionDays: ${auditRetentionDays}`;
+  const routeLines = protectedRoutes.map((r) => `    - pattern: ${r}
+      requiredRole: ${defaultRole}`).join("\n");
+  const providerLine = params.provider ? `  provider: ${params.provider}
+` : "";
+  if (method === "cac") {
+    const caBundle = params.cacCaBundle ?? "./certs/dod-ca-bundle.pem";
+    const edipiLookup = params.cacEdipiLookup ?? "./config/edipi-lookup.json";
+    const ocspEndpoint = params.cacOcspEndpoint ?? "https://ocsp.disa.mil";
+    const certHeader = params.cacCertHeader ?? "X-SSL-Client-Cert";
+    return `auth:
+  method: cac
+  devOnly: true
+${providerLine}  ${useProxy ? "proxy" : "middleware"}: ./${useProxy ? "proxy" : "middleware"}.ts
+  cac:
+    caBundle: ${caBundle}
+    edipiLookup: ${edipiLookup}
+    ocspEndpoint: ${ocspEndpoint}
+    certHeader: ${certHeader}
+${rbacSection}
+  protectedRoutes:
+${routeLines}
+${auditSection}
+`;
+  }
+  if (method === "oidc") {
+    const scopes2 = params.oidcScopes ?? "openid profile email";
+    const roleClaim = params.oidcRoleClaim ?? "roles";
+    return `auth:
+  method: oidc
+  devOnly: true
+${providerLine}  ${useProxy ? "proxy" : "middleware"}: ./${useProxy ? "proxy" : "middleware"}.ts
+  oidc:
+    discoveryUrl: https://dev-mock-oidc/.well-known/openid-configuration
+    clientId: dev-mock-client
+    clientSecret: dev-mock-secret
+    scopes: ${scopes2}
+    roleClaim: ${roleClaim}
+${rbacSection}
+  protectedRoutes:
+${routeLines}
+${auditSection}
+`;
+  }
+  const scopes = params.oauth2Scopes ?? "read write";
+  return `auth:
+  method: oauth2
+  devOnly: true
+${providerLine}  ${useProxy ? "proxy" : "middleware"}: ./${useProxy ? "proxy" : "middleware"}.ts
+  oauth2:
+    authorizationUrl: https://dev-mock-oauth2/authorize
+    tokenUrl: https://dev-mock-oauth2/token
+    clientId: dev-mock-client
+    clientSecret: dev-mock-secret
+    scopes: ${scopes}
+${rbacSection}
+  protectedRoutes:
+${routeLines}
+${auditSection}
+`;
+}
+function deriveDevKey(roleName) {
+  const segment = roleName.split("_")[0];
+  return (segment ?? roleName).toLowerCase();
+}
+function generateMockAuthContent(roles, mockUsers) {
+  const entries = [];
+  const scriptLines = [];
+  for (let i = 0; i < roles.length; i++) {
+    const role = roles[i];
+    const devKey = deriveDevKey(role);
+    const persona = mockUsers?.[i];
+    const name = persona?.name ?? `Dev ${role}`;
+    const email = persona?.email ?? `dev-${devKey}@example.mil`;
+    const edipi = String(i + 1).padStart(10, "0");
+    entries.push(`  ${devKey}: {
+    id: 'mock-${devKey}-${String(i + 1).padStart(3, "0")}',
+    name: '${name}',
+    email: '${email}',
+    roles: ['${role}'],
+    edipi: '${edipi}',
+  }`);
+    scriptLines.push(` *   pnpm dev:${devKey}   \u2014 ${name}`);
+  }
+  return `/**
+ * Mock authentication for development mode.
+ *
+ * DEV_ONLY_MODE \u2014 no real auth provider. Select a persona via MOCK_USER env var
+ * or use the convenience scripts in package.json:
+${scriptLines.join("\n")}
+ */
+
+export const MOCK_USERS = {
+${entries.join(",\n")}
+} as const;
+
+export type MockRole = keyof typeof MOCK_USERS;
+
+export function getMockUser(role?: string) {
+  const key = (role ?? process.env.MOCK_USER) as MockRole | undefined;
+  if (!key) return null;
+  return MOCK_USERS[key] ?? null;
+}
+
+export function mockAuthProvider() {
+  return getMockUser();
+}
+`;
+}
+function updatePackageJsonScripts(existingJson, roles, mockUsers) {
+  const pkg = JSON.parse(existingJson);
+  const scripts = pkg.scripts ?? {};
+  delete scripts["dev:admin"];
+  delete scripts["dev:analyst"];
+  delete scripts["dev:viewer"];
+  for (let i = 0; i < roles.length; i++) {
+    const devKey = deriveDevKey(roles[i]);
+    scripts[`dev:${devKey}`] = `MOCK_USER=${devKey} next dev`;
+  }
+  pkg.scripts = scripts;
+  return JSON.stringify(pkg, null, 2) + "\n";
+}
 async function configureAuthHandler(params, cwd) {
   const {
     method,
     provider,
+    devOnly = false,
+    mockUsers,
     rbacRoles = ["SUPER_ADMIN", "ADMIN", "ANALYST"],
     auditEnabled = true,
     auditRetentionDays = 90,
@@ -2664,6 +4522,8 @@ async function configureAuthHandler(params, cwd) {
   const roles = rbacRoles;
   const defaultRole = params.rbacDefaultRole ?? roles[roles.length - 1];
   const hierarchy = buildHierarchy(roles);
+  const useProxy = (params.nextMajorVersion ?? 0) >= 16;
+  const conventionFile = useProxy ? "proxy.ts" : "middleware.ts";
   if (method === "none") {
     return {
       content: [
@@ -2685,7 +4545,34 @@ async function configureAuthHandler(params, cwd) {
   }
   const filesWritten = [];
   try {
-    const middlewareContent = generateMiddlewareContent(
+    const authFileContent = devOnly ? useProxy ? generateDevOnlyProxyContent(
+      method,
+      params,
+      roles,
+      defaultRole,
+      hierarchy,
+      auditEnabled,
+      auditRetentionDays,
+      protectedRoutes
+    ) : generateDevOnlyMiddlewareContent(
+      method,
+      params,
+      roles,
+      defaultRole,
+      hierarchy,
+      auditEnabled,
+      auditRetentionDays,
+      protectedRoutes
+    ) : useProxy ? generateProxyContent(
+      method,
+      params,
+      roles,
+      defaultRole,
+      hierarchy,
+      auditEnabled,
+      auditRetentionDays,
+      protectedRoutes
+    ) : generateMiddlewareContent(
       method,
       params,
       roles,
@@ -2695,44 +4582,95 @@ async function configureAuthHandler(params, cwd) {
       auditRetentionDays,
       protectedRoutes
     );
-    (0, import_fs6.writeFileSync)((0, import_path6.join)(cwd, "middleware.ts"), middlewareContent, "utf8");
-    filesWritten.push("middleware.ts");
+    (0, import_fs7.writeFileSync)((0, import_path7.join)(cwd, conventionFile), authFileContent, "utf8");
+    filesWritten.push(conventionFile);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify({ success: false, error: `Failed writing middleware.ts: ${msg}` })
+          text: JSON.stringify({
+            success: false,
+            error: `Failed writing ${conventionFile}: ${msg}`
+          })
         }
       ],
       isError: true
     };
   }
-  try {
-    const envBlock = generateEnvBlock(method, params);
-    const envPath = (0, import_path6.join)(cwd, ".env.example");
-    if ((0, import_fs6.existsSync)(envPath)) {
-      const existing = (0, import_fs6.readFileSync)(envPath, "utf8");
-      (0, import_fs6.writeFileSync)(envPath, existing.trimEnd() + "\n\n" + envBlock, "utf8");
-    } else {
-      (0, import_fs6.writeFileSync)(envPath, envBlock, "utf8");
+  if (!devOnly) {
+    try {
+      const envBlock = generateEnvBlock(method, params);
+      const envPath = (0, import_path7.join)(cwd, ".env.example");
+      if ((0, import_fs7.existsSync)(envPath)) {
+        const existing = (0, import_fs7.readFileSync)(envPath, "utf8");
+        (0, import_fs7.writeFileSync)(envPath, existing.trimEnd() + "\n\n" + envBlock, "utf8");
+      } else {
+        (0, import_fs7.writeFileSync)(envPath, envBlock, "utf8");
+      }
+      filesWritten.push(".env.example");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: false, error: `Failed writing .env.example: ${msg}` })
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+  if (devOnly) {
+    try {
+      const mockAuthDir = (0, import_path7.join)(cwd, "lib");
+      (0, import_fs7.mkdirSync)(mockAuthDir, { recursive: true });
+      const mockAuthContent = generateMockAuthContent(roles, mockUsers);
+      (0, import_fs7.writeFileSync)((0, import_path7.join)(mockAuthDir, "mock-auth.ts"), mockAuthContent, "utf8");
+      filesWritten.push("lib/mock-auth.ts");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              success: false,
+              error: `Failed writing lib/mock-auth.ts: ${msg}`
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    try {
+      const pkgPath = (0, import_path7.join)(cwd, "package.json");
+      if ((0, import_fs7.existsSync)(pkgPath)) {
+        const existingPkg = (0, import_fs7.readFileSync)(pkgPath, "utf8");
+        const updatedPkg = updatePackageJsonScripts(existingPkg, roles, mockUsers);
+        (0, import_fs7.writeFileSync)(pkgPath, updatedPkg, "utf8");
+        filesWritten.push("package.json");
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              success: false,
+              error: `Failed updating package.json: ${msg}`
+            })
+          }
+        ],
+        isError: true
+      };
     }
-    filesWritten.push(".env.example");
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ success: false, error: `Failed writing .env.example: ${msg}` })
-        }
-      ],
-      isError: true
-    };
   }
   try {
-    const authYaml = generateYamlBlock(
+    const authYaml = devOnly ? generateDevOnlyYamlBlock(
       method,
       params,
       roles,
@@ -2740,14 +4678,25 @@ async function configureAuthHandler(params, cwd) {
       hierarchy,
       auditEnabled,
       auditRetentionDays,
-      protectedRoutes
+      protectedRoutes,
+      useProxy
+    ) : generateYamlBlock(
+      method,
+      params,
+      roles,
+      defaultRole,
+      hierarchy,
+      auditEnabled,
+      auditRetentionDays,
+      protectedRoutes,
+      useProxy
     );
-    const ymlPath = (0, import_path6.join)(cwd, "stackwright.yml");
-    if (!(0, import_fs6.existsSync)(ymlPath)) {
-      (0, import_fs6.writeFileSync)(ymlPath, authYaml, "utf8");
+    const ymlPath = (0, import_path7.join)(cwd, "stackwright.yml");
+    if (!(0, import_fs7.existsSync)(ymlPath)) {
+      (0, import_fs7.writeFileSync)(ymlPath, authYaml, "utf8");
     } else {
-      const existing = (0, import_fs6.readFileSync)(ymlPath, "utf8");
-      (0, import_fs6.writeFileSync)(ymlPath, upsertAuthBlock(existing, authYaml), "utf8");
+      const existing = (0, import_fs7.readFileSync)(ymlPath, "utf8");
+      (0, import_fs7.writeFileSync)(ymlPath, upsertAuthBlock(existing, authYaml), "utf8");
     }
     filesWritten.push("stackwright.yml");
   } catch (err) {
@@ -2775,7 +4724,23 @@ async function configureAuthHandler(params, cwd) {
           rbacDefaultRole: defaultRole,
           protectedRoutesCount: protectedRoutes.length,
           filesWritten,
-          securityWarning
+          convention: useProxy ? "proxy" : "middleware",
+          nextMajorVersion: params.nextMajorVersion ?? null,
+          securityWarning,
+          ...devOnly ? {
+            devScripts: {
+              written: filesWritten.includes("package.json"),
+              scripts: filesWritten.includes("package.json") ? Object.fromEntries(
+                roles.map((r) => {
+                  const k = deriveDevKey(r);
+                  return [`dev:${k}`, `MOCK_USER=${k} next dev`];
+                })
+              ) : {},
+              ...filesWritten.includes("package.json") ? {} : {
+                warning: "package.json not found \u2014 dev scripts were not written. Run the auth phase again after scaffolding creates package.json."
+              }
+            }
+          } : {}
         })
       }
     ]
@@ -2786,35 +4751,38 @@ function registerAuthTools(server2) {
     "stackwright_pro_configure_auth",
     "Generate authentication middleware and configuration for a Next.js Stackwright application. Writes `middleware.ts` from a secure template, appends/updates the `auth:` section in `stackwright.yml`, and generates `.env.example` with required environment variables. \u26A0\uFE0F For CAC/PKI: generated `middleware.ts` carries a SECURITY REVIEW REQUIRED comment \u2014 certificate chain validation must be verified by a DoD security officer before production deployment. This is the ONLY approved path to generating `middleware.ts`. Never write TypeScript auth files directly.",
     {
-      method: import_zod11.z.enum(["cac", "oidc", "oauth2", "none"]),
-      provider: import_zod11.z.enum(["azure-ad", "okta", "ping", "cognito", "custom"]).optional(),
+      method: import_zod13.z.enum(["cac", "oidc", "oauth2", "none"]),
+      provider: import_zod13.z.enum(["azure-ad", "okta", "ping", "cognito", "custom"]).optional(),
       // CAC
-      cacCaBundle: import_zod11.z.string().optional(),
-      cacEdipiLookup: import_zod11.z.string().optional(),
-      cacOcspEndpoint: import_zod11.z.string().optional(),
-      cacCertHeader: import_zod11.z.string().optional(),
+      cacCaBundle: import_zod13.z.string().optional(),
+      cacEdipiLookup: import_zod13.z.string().optional(),
+      cacOcspEndpoint: import_zod13.z.string().optional(),
+      cacCertHeader: import_zod13.z.string().optional(),
       // OIDC
-      oidcDiscoveryUrl: import_zod11.z.string().optional(),
-      oidcClientId: import_zod11.z.string().optional(),
-      oidcClientSecret: import_zod11.z.string().optional(),
-      oidcScopes: import_zod11.z.string().optional(),
-      oidcRoleClaim: import_zod11.z.string().optional(),
+      oidcDiscoveryUrl: import_zod13.z.string().optional(),
+      oidcClientId: import_zod13.z.string().optional(),
+      oidcClientSecret: import_zod13.z.string().optional(),
+      oidcScopes: import_zod13.z.string().optional(),
+      oidcRoleClaim: import_zod13.z.string().optional(),
       // OAuth2
-      oauth2AuthUrl: import_zod11.z.string().optional(),
-      oauth2TokenUrl: import_zod11.z.string().optional(),
-      oauth2ClientId: import_zod11.z.string().optional(),
-      oauth2ClientSecret: import_zod11.z.string().optional(),
-      oauth2Scopes: import_zod11.z.string().optional(),
+      oauth2AuthUrl: import_zod13.z.string().optional(),
+      oauth2TokenUrl: import_zod13.z.string().optional(),
+      oauth2ClientId: import_zod13.z.string().optional(),
+      oauth2ClientSecret: import_zod13.z.string().optional(),
+      oauth2Scopes: import_zod13.z.string().optional(),
       // RBAC
-      rbacRoles: import_zod11.z.array(import_zod11.z.string()).optional(),
-      rbacDefaultRole: import_zod11.z.string().optional(),
+      rbacRoles: jsonCoerce(import_zod13.z.array(import_zod13.z.string()).optional()),
+      rbacDefaultRole: import_zod13.z.string().optional(),
       // Audit
-      auditEnabled: import_zod11.z.boolean().optional(),
-      auditRetentionDays: import_zod11.z.number().int().positive().optional(),
+      auditEnabled: boolCoerce(import_zod13.z.boolean().optional()),
+      auditRetentionDays: numCoerce(import_zod13.z.number().int().positive().optional()),
       // Routes
-      protectedRoutes: import_zod11.z.array(import_zod11.z.string()).optional(),
+      protectedRoutes: jsonCoerce(import_zod13.z.array(import_zod13.z.string()).optional()),
       // Injection for tests
-      _cwd: import_zod11.z.string().optional()
+      _cwd: import_zod13.z.string().optional(),
+      devOnly: boolCoerce(import_zod13.z.boolean().optional()),
+      mockUsers: jsonCoerce(import_zod13.z.array(import_zod13.z.object({ name: import_zod13.z.string(), email: import_zod13.z.string() })).optional()),
+      nextMajorVersion: numCoerce(import_zod13.z.number().int().positive().optional())
     },
     async (params) => {
       const cwd = params._cwd ?? process.cwd();
@@ -2824,45 +4792,61 @@ function registerAuthTools(server2) {
 }
 
 // src/integrity.ts
-var import_crypto2 = require("crypto");
-var import_fs7 = require("fs");
-var import_path7 = require("path");
+var import_crypto4 = require("crypto");
+var import_fs8 = require("fs");
+var import_path8 = require("path");
 var _checksums = /* @__PURE__ */ new Map([
   [
     "stackwright-pro-api-otter.json",
-    "f1cc9edf2dd1df3ebcea1d0ab33d17a358faaf8aa97ee232cd7994042f2eac0d"
+    "c21f127b9bed477b1d7b66949926e00e1b93de081e792293ebfffc88b70d9424"
   ],
   [
     "stackwright-pro-auth-otter.json",
-    "a19e06c503209a8a35fe321d30448623545b36b48c47a6ec064d13406ad1f725"
+    "6d4d4d50f52be84a796c2a43ed997f00b41b42ed8c5f046e1defb2e423933588"
   ],
   [
     "stackwright-pro-dashboard-otter.json",
-    "b3cb3d7554f2e9eed3b57d5e0e3bf85d6ba5b4db5d3af5514391cf0575fcc001"
+    "9c319d311801730e8dc9bc142eebb8fc5a7f48da48fa0b8d8c3b7431652447be"
   ],
   [
     "stackwright-pro-data-otter.json",
-    "bfacb87ae82867472a75982215554336a105a658d6cd3dd2c8b819fa1e11d7ac"
+    "4d9369277685a4acc484116920c9622ad8a1838012a493fcfe42a6ae5abe53cf"
   ],
   [
     "stackwright-pro-designer-otter.json",
-    "c58fa7c7ead9e6398074e1c7ce3f31a8ef4eb3679f5fa18cc03cae3a87878c88"
+    "af09ac8f06385bdbac63e2820daa2ff7d38b8ff1ff383c161f07e3fb9d9359c5"
+  ],
+  [
+    "stackwright-pro-domain-expert-otter.json",
+    "41e3a5838f05f6a51ed272860dd2d5b1df1f20bfc847eb8f39be109b89738e99"
   ],
   [
     "stackwright-pro-foreman-otter.json",
-    "d7f469661e26a36e280559626e0cf178c428664e3889cbd6b015ac1bab30715c"
+    "e563a99d647fcf95401508f15f10e032fb14e826577bc6bcff5960bf2981d58d"
+  ],
+  [
+    "stackwright-pro-geo-otter.json",
+    "ff1191af8108cc70c09afe6a99b008dcb46f71e20f884da1ee424e431868a1b6"
   ],
   [
     "stackwright-pro-page-otter.json",
-    "65bec3a3a0dda6b7591bba2de9399f1e3a4fb99cfe1075342f4f4be98d917b67"
+    "cdd878857c1d809c60263693ab0c6cbb45087fd9c3eeda5b4628bd7026d2bded"
+  ],
+  [
+    "stackwright-pro-polish-otter.json",
+    "e5f88d054dd536646f48e5d47cbd64f825f493100002309b90c912fa69ef279e"
   ],
   [
     "stackwright-pro-theme-otter.json",
-    "64ffaeeceacd739922788a1d074f6feaffc3f91d09706c2c104f0c0281677732"
+    "532d9ca7db6911a09ce5029a8c74c89360bdf6cb8ede8c2636866b509cbe06f9"
   ],
   [
     "stackwright-pro-workflow-otter.json",
-    "0eec9d6a731678cf547c2a7b0b6fc338ca143c35501365a1e4e5dd2779dd5510"
+    "e02c1a5f492dd6b11f68e293d92f5f661dbb22e57570dcf133a9d0ffc7a8be7d"
+  ],
+  [
+    "stackwright-services-otter.json",
+    "b8a252d6a2c5090138899925d3ea95bf3339b6e49adc276a1f5f7304b4ae5134"
   ]
 ]);
 Object.freeze(_checksums);
@@ -2877,21 +4861,21 @@ for (const [name, digest] of CANONICAL_CHECKSUMS) {
 }
 var MAX_OTTER_BYTES = 1 * 1024 * 1024;
 function computeSha256(data) {
-  return (0, import_crypto2.createHash)("sha256").update(data).digest("hex");
+  return (0, import_crypto4.createHash)("sha256").update(data).digest("hex");
 }
 function safeEqual(a, b) {
   if (a.length !== b.length) return false;
-  return (0, import_crypto2.timingSafeEqual)(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
+  return (0, import_crypto4.timingSafeEqual)(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
 }
 function verifyOtterFile(filePath) {
-  const filename = (0, import_path7.basename)(filePath);
+  const filename = (0, import_path8.basename)(filePath);
   const expected = CANONICAL_CHECKSUMS.get(filename);
   if (expected === void 0) {
     return { verified: false, filename, error: `Unknown otter file: not in canonical set` };
   }
   let stat;
   try {
-    stat = (0, import_fs7.lstatSync)(filePath);
+    stat = (0, import_fs8.lstatSync)(filePath);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { verified: false, filename, error: `Cannot stat file: ${msg}` };
@@ -2909,7 +4893,7 @@ function verifyOtterFile(filePath) {
   }
   let raw;
   try {
-    raw = (0, import_fs7.readFileSync)(filePath);
+    raw = (0, import_fs8.readFileSync)(filePath);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { verified: false, filename, error: `Cannot read file: ${msg}` };
@@ -2942,12 +4926,24 @@ function verifyOtterFile(filePath) {
   return { verified: true, filename };
 }
 function verifyAllOtters(otterDir) {
+  if (/(?:^|[/\\])\.\.(?:[/\\]|$)/.test(otterDir) || otterDir.includes("..")) {
+    return {
+      verified: [],
+      failed: [
+        {
+          filename: "<directory>",
+          error: `Security: path traversal sequence detected in otter directory parameter`
+        }
+      ],
+      unknown: []
+    };
+  }
   const verified = [];
   const failed = [];
   const unknown = [];
   let entries;
   try {
-    entries = (0, import_fs7.readdirSync)(otterDir);
+    entries = (0, import_fs8.readdirSync)(otterDir);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return {
@@ -2958,9 +4954,9 @@ function verifyAllOtters(otterDir) {
   }
   const otterFiles = entries.filter((f) => f.endsWith("-otter.json"));
   for (const filename of otterFiles) {
-    const filePath = (0, import_path7.join)(otterDir, filename);
+    const filePath = (0, import_path8.join)(otterDir, filename);
     try {
-      if ((0, import_fs7.lstatSync)(filePath).isSymbolicLink()) {
+      if ((0, import_fs8.lstatSync)(filePath).isSymbolicLink()) {
         failed.push({ filename, error: "Skipped: symlink" });
         continue;
       }
@@ -2986,15 +4982,30 @@ var DEFAULT_SEARCH_PATHS = ["node_modules/@stackwright-pro/otters/src/", "packag
 function resolveOtterDir() {
   const cwd = process.cwd();
   for (const relative of DEFAULT_SEARCH_PATHS) {
-    const candidate = (0, import_path7.join)(cwd, relative);
+    const candidate = (0, import_path8.join)(cwd, relative);
     try {
-      (0, import_fs7.lstatSync)(candidate);
+      (0, import_fs8.lstatSync)(candidate);
       return candidate;
     } catch {
     }
   }
   return null;
 }
+function emitIntegrityAuditEvent(params) {
+  const record = JSON.stringify({
+    level: "AUDIT",
+    event: "INTEGRITY_FAIL",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "stackwright_pro_verify_otter_integrity",
+    otterDir: params.otterDir,
+    failedCount: params.failed.length,
+    unknownCount: params.unknown.length,
+    failures: params.failed,
+    unknown: params.unknown
+  });
+  process.stderr.write(`INTEGRITY_FAIL ${record}
+`);
+}
 function registerIntegrityTools(server2) {
   server2.tool(
     "stackwright_pro_verify_otter_integrity",
@@ -3018,6 +5029,13 @@ function registerIntegrityTools(server2) {
       }
       const result = verifyAllOtters(resolved);
       const allGood = result.failed.length === 0 && result.unknown.length === 0;
+      if (!allGood) {
+        emitIntegrityAuditEvent({
+          otterDir: resolved,
+          failed: result.failed,
+          unknown: result.unknown
+        });
+      }
       return {
         content: [
           {
@@ -3030,7 +5048,10 @@ function registerIntegrityTools(server2) {
               unknownCount: result.unknown.length,
               verified: result.verified,
               failed: result.failed,
-              unknown: result.unknown
+              unknown: result.unknown,
+              ...allGood ? {} : {
+                error: "INTEGRITY CHECK FAILED: SHA-256 mismatch detected in otter agent definitions. Do not proceed \u2014 otter files may have been tampered with."
+              }
             })
           }
         ],
@@ -3041,14 +5062,14 @@ function registerIntegrityTools(server2) {
 }
 
 // src/tools/domain.ts
-var import_zod12 = require("zod");
-var import_fs8 = require("fs");
-var import_path8 = require("path");
+var import_zod14 = require("zod");
+var import_fs9 = require("fs");
+var import_path9 = require("path");
 function handleListCollections(input) {
   const cwd = input._cwd ?? process.cwd();
   const sources = [
     {
-      path: (0, import_path8.join)(cwd, ".stackwright", "artifacts", "data-config.json"),
+      path: (0, import_path9.join)(cwd, ".stackwright", "artifacts", "data-config.json"),
       source: "data-config.json",
       parse: (raw) => {
         const parsed = JSON.parse(raw);
@@ -3059,15 +5080,15 @@ function handleListCollections(input) {
       }
     },
     {
-      path: (0, import_path8.join)(cwd, "stackwright.yml"),
+      path: (0, import_path9.join)(cwd, "stackwright.yml"),
       source: "stackwright.yml",
       parse: extractCollectionsFromYaml
     }
   ];
   for (const { path: path3, source, parse } of sources) {
-    if (!(0, import_fs8.existsSync)(path3)) continue;
+    if (!(0, import_fs9.existsSync)(path3)) continue;
     try {
-      const collections = parse((0, import_fs8.readFileSync)(path3, "utf8"));
+      const collections = parse((0, import_fs9.readFileSync)(path3, "utf8"));
       return {
         text: JSON.stringify({ collections, source, collectionCount: collections.length }),
         isError: false
@@ -3218,8 +5239,8 @@ function handleValidateWorkflow(input) {
   if (input.workflow && Object.keys(input.workflow).length > 0) {
     raw = input.workflow;
   } else {
-    const artifactPath = (0, import_path8.join)(cwd, ".stackwright", "artifacts", "workflow-config.json");
-    if (!(0, import_fs8.existsSync)(artifactPath)) {
+    const artifactPath = (0, import_path9.join)(cwd, ".stackwright", "artifacts", "workflow-config.json");
+    if (!(0, import_fs9.existsSync)(artifactPath)) {
       return fail([
         {
           code: "NO_WORKFLOW",
@@ -3228,7 +5249,7 @@ function handleValidateWorkflow(input) {
       ]);
     }
     try {
-      raw = JSON.parse((0, import_fs8.readFileSync)(artifactPath, "utf8"));
+      raw = JSON.parse((0, import_fs9.readFileSync)(artifactPath, "utf8"));
     } catch (err) {
       return fail([{ code: "INVALID_JSON", message: `Failed to parse workflow artifact: ${err}` }]);
     }
@@ -3427,7 +5448,7 @@ function registerDomainTools(server2) {
     "stackwright_pro_resolve_data_strategy",
     "Look up the data freshness strategy configuration from the user's answer. Returns mechanism, revalidation seconds, required packages, and the exact MCP tool call to make. Replaces the strategy table in the data-otter prompt.",
     {
-      strategy: import_zod12.z.string().describe(
+      strategy: import_zod14.z.string().describe(
         'The data-1 answer value: "pulse-fast", "isr-fast", "isr-standard", or "isr-slow"'
       )
     },
@@ -3437,7 +5458,7 @@ function registerDomainTools(server2) {
     "stackwright_pro_validate_workflow",
     "Validate a workflow definition against the Stackwright workflow schema. Checks step ID uniqueness, transition targets, terminal state existence, and service references. Call this after the workflow otter produces output.",
     {
-      workflow: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown()).optional().describe(
+      workflow: jsonCoerce(import_zod14.z.record(import_zod14.z.string(), import_zod14.z.unknown()).optional()).describe(
         "Parsed workflow object. If omitted, reads from .stackwright/artifacts/workflow-config.json"
       )
     },
@@ -3445,18 +5466,524 @@ function registerDomainTools(server2) {
   );
 }
 
+// src/tools/type-schemas.ts
+var import_zod15 = require("zod");
+function buildTypeSchemaSummary() {
+  return {
+    version: "1.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    domains: {
+      workflow: {
+        description: "Workflow DSL \u2014 step definitions, auth blocks, field types, conditions",
+        schemas: [
+          "WorkflowFileSchema",
+          "WorkflowDefinitionSchema",
+          "WorkflowStepSchema",
+          "WorkflowStepTypeSchema",
+          "WorkflowFieldSchema",
+          "WorkflowActionSchema",
+          "WorkflowAuthSchema",
+          "WorkflowThemeSchema",
+          "TransitionConditionSchema",
+          "PersistenceSchema"
+        ],
+        otter: "stackwright-pro-workflow-otter",
+        artifactKey: "workflowConfig"
+      },
+      auth: {
+        description: "Authentication providers \u2014 PKI/CAC, OIDC, RBAC configuration",
+        schemas: [
+          "authConfigSchema",
+          "pkiConfigSchema",
+          "oidcConfigSchema",
+          "rbacConfigSchema",
+          "componentAuthSchema",
+          "authUserSchema",
+          "authSessionSchema"
+        ],
+        otter: "stackwright-pro-auth-otter",
+        artifactKey: "authConfig"
+      },
+      openapi: {
+        description: "OpenAPI spec integration \u2014 collection config, endpoint filters, actions",
+        interfaces: [
+          "OpenAPIConfig",
+          "ActionConfig",
+          "EndpointFilter",
+          "ApprovedSpec",
+          "PrebuildSecurityConfig",
+          "SiteConfig",
+          "ValidationResult"
+        ],
+        otter: "stackwright-pro-api-otter",
+        artifactKey: "apiConfig"
+      },
+      pulse: {
+        description: "Real-time data polling \u2014 source-agnostic polling options and states",
+        interfaces: ["PulseOptions", "PulseMeta", "PulseState"],
+        note: "React-bound types (PulseProps, PulseIndicatorProps) remain in @stackwright-pro/pulse"
+      },
+      enterprise: {
+        description: "Enterprise collection access \u2014 multi-tenant provider extension",
+        interfaces: [
+          "EnterpriseCollectionProvider",
+          "CollectionProvider",
+          "CollectionEntry",
+          "CollectionListOptions",
+          "CollectionListResult",
+          "TenantFilter",
+          "Collection"
+        ],
+        note: "CollectionProvider, CollectionEntry, CollectionListOptions, and CollectionListResult are re-exported from @stackwright/types (^1.5.0). EnterpriseCollectionProvider, TenantFilter, and Collection are Pro-only extensions."
+      }
+    }
+  };
+}
+function registerTypeSchemasTool(server2) {
+  server2.tool(
+    "stackwright_pro_get_type_schemas",
+    "Returns a structured summary of all canonical @stackwright-pro/types schemas, organized by domain. Use this to determine which otter owns a given schema and what artifact key to expect.",
+    {
+      format: import_zod15.z.enum(["full", "domains-only"]).optional().default("full").describe("full = complete summary with all fields; domains-only = just domain names")
+    },
+    async ({ format }) => {
+      const summary = buildTypeSchemaSummary();
+      const output = format === "domains-only" ? Object.keys(summary.domains) : summary;
+      return {
+        content: [{ type: "text", text: JSON.stringify(output, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/scaffold-cleanup.ts
+var import_fs10 = require("fs");
+var import_path10 = require("path");
+var SCAFFOLD_FILES_TO_DELETE = [
+  "content/posts/getting-started.yaml",
+  "content/posts/hello-world.yaml"
+];
+var SCAFFOLD_DIRS_TO_PRUNE = [
+  "content/posts"
+  // Don't prune 'content' — user may have other content directories
+];
+var NOT_FOUND_PATH = "app/not-found.tsx";
+var FALLBACK_COLORS = {
+  background: "#ffffff",
+  foreground: "#171717",
+  primary: "#525252",
+  mutedForeground: "#737373"
+};
+function readThemeColors(cwd) {
+  const tokenPath = (0, import_path10.join)(cwd, ".stackwright", "artifacts", "theme-tokens.json");
+  if (!(0, import_fs10.existsSync)(tokenPath)) return { ...FALLBACK_COLORS };
+  const stat = (0, import_fs10.lstatSync)(tokenPath);
+  if (stat.isSymbolicLink()) return { ...FALLBACK_COLORS };
+  try {
+    const raw = JSON.parse((0, import_fs10.readFileSync)(tokenPath, "utf-8"));
+    const css = raw?.cssVariables ?? {};
+    const toHsl = (hslValue) => {
+      if (!hslValue || typeof hslValue !== "string") return null;
+      return `hsl(${hslValue})`;
+    };
+    return {
+      background: toHsl(css["--background"]) ?? FALLBACK_COLORS.background,
+      foreground: toHsl(css["--foreground"]) ?? FALLBACK_COLORS.foreground,
+      primary: toHsl(css["--primary"]) ?? FALLBACK_COLORS.primary,
+      mutedForeground: toHsl(css["--muted-foreground"]) ?? FALLBACK_COLORS.mutedForeground
+    };
+  } catch {
+    return { ...FALLBACK_COLORS };
+  }
+}
+function generateNotFoundPage(colors) {
+  return `export default function NotFound() {
+  return (
+    <div
+      style={{
+        display: 'flex',
+        flexDirection: 'column',
+        alignItems: 'center',
+        justifyContent: 'center',
+        minHeight: '100vh',
+        backgroundColor: '${colors.background}',
+        color: '${colors.foreground}',
+        fontFamily: 'system-ui, -apple-system, sans-serif',
+        padding: '2rem',
+        textAlign: 'center',
+      }}
+    >
+      <h1 style={{ fontSize: '4rem', fontWeight: 700, margin: 0, color: '${colors.primary}' }}>
+        404
+      </h1>
+      <p style={{ fontSize: '1.25rem', color: '${colors.mutedForeground}', marginTop: '0.5rem' }}>
+        Page not found
+      </p>
+      <a
+        href="/"
+        style={{
+          marginTop: '2rem',
+          padding: '0.75rem 1.5rem',
+          backgroundColor: '${colors.primary}',
+          color: '${colors.background}',
+          borderRadius: '0.5rem',
+          textDecoration: 'none',
+          fontSize: '0.875rem',
+          fontWeight: 500,
+        }}
+      >
+        Go Home
+      </a>
+    </div>
+  );
+}
+`;
+}
+function isSafePath(fullPath) {
+  if (!(0, import_fs10.existsSync)(fullPath)) return true;
+  const stat = (0, import_fs10.lstatSync)(fullPath);
+  return !stat.isSymbolicLink();
+}
+function isDirEmpty(dirPath) {
+  if (!(0, import_fs10.existsSync)(dirPath)) return false;
+  const stat = (0, import_fs10.lstatSync)(dirPath);
+  if (!stat.isDirectory()) return false;
+  return (0, import_fs10.readdirSync)(dirPath).length === 0;
+}
+function handleCleanupScaffold(_cwd) {
+  const cwd = _cwd ?? process.cwd();
+  const result = {
+    deleted: [],
+    rewritten: [],
+    skipped: [],
+    errors: [],
+    prunedDirs: []
+  };
+  for (const relPath of SCAFFOLD_FILES_TO_DELETE) {
+    const fullPath = (0, import_path10.join)(cwd, relPath);
+    if (!(0, import_fs10.existsSync)(fullPath)) {
+      result.skipped.push(relPath);
+      continue;
+    }
+    if (!isSafePath(fullPath)) {
+      result.errors.push(`Refusing to delete symlink: ${relPath}`);
+      continue;
+    }
+    try {
+      (0, import_fs10.unlinkSync)(fullPath);
+      result.deleted.push(relPath);
+    } catch (err) {
+      result.errors.push(`Failed to delete ${relPath}: ${String(err)}`);
+    }
+  }
+  for (const relDir of SCAFFOLD_DIRS_TO_PRUNE) {
+    const fullDir = (0, import_path10.join)(cwd, relDir);
+    if (!(0, import_fs10.existsSync)(fullDir)) continue;
+    if (!isSafePath(fullDir)) {
+      result.errors.push(`Refusing to prune symlink directory: ${relDir}`);
+      continue;
+    }
+    if (isDirEmpty(fullDir)) {
+      try {
+        (0, import_fs10.rmdirSync)(fullDir);
+        result.prunedDirs.push(relDir);
+      } catch (err) {
+        result.errors.push(`Failed to prune directory ${relDir}: ${String(err)}`);
+      }
+    }
+  }
+  {
+    const fullPath = (0, import_path10.join)(cwd, NOT_FOUND_PATH);
+    if (!(0, import_fs10.existsSync)(fullPath)) {
+      result.skipped.push(NOT_FOUND_PATH);
+    } else if (!isSafePath(fullPath)) {
+      result.errors.push(`Refusing to rewrite symlink: ${NOT_FOUND_PATH}`);
+    } else {
+      try {
+        const colors = readThemeColors(cwd);
+        const content = generateNotFoundPage(colors);
+        const dir = (0, import_path10.dirname)(fullPath);
+        (0, import_fs10.mkdirSync)(dir, { recursive: true });
+        (0, import_fs10.writeFileSync)(fullPath, content, "utf-8");
+        result.rewritten.push(NOT_FOUND_PATH);
+      } catch (err) {
+        result.errors.push(`Failed to rewrite ${NOT_FOUND_PATH}: ${String(err)}`);
+      }
+    }
+  }
+  return {
+    text: JSON.stringify(result),
+    isError: false
+  };
+}
+function registerScaffoldCleanupTools(server2) {
+  const DESC = "Deterministic scaffold remnant cleanup \u2014 removes stale OSS scaffold files after raft run.";
+  server2.tool(
+    "stackwright_pro_cleanup_scaffold",
+    `Remove/rewrite stale scaffold files (blog posts, hardcoded not-found page) after the raft pipeline completes. ${DESC}`,
+    {},
+    async () => {
+      const r = handleCleanupScaffold();
+      return {
+        content: [{ type: "text", text: r.text }],
+        isError: r.isError
+      };
+    }
+  );
+}
+
+// src/tools/contrast.ts
+var import_zod16 = 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);
+}
+function relativeLuminance(r, g, b) {
+  return 0.2126 * linearizeChannel(r) + 0.7152 * linearizeChannel(g) + 0.0722 * linearizeChannel(b);
+}
+function contrastRatioFromLuminance(l1, l2) {
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function parseHex(hex) {
+  const clean = hex.replace("#", "").trim().toLowerCase();
+  if (clean.length === 3) {
+    const r = parseInt(clean.charAt(0) + clean.charAt(0), 16);
+    const g = parseInt(clean.charAt(1) + clean.charAt(1), 16);
+    const b = parseInt(clean.charAt(2) + clean.charAt(2), 16);
+    if (isNaN(r) || isNaN(g) || isNaN(b)) return null;
+    return [r, g, b];
+  }
+  if (clean.length === 6) {
+    const r = parseInt(clean.slice(0, 2), 16);
+    const g = parseInt(clean.slice(2, 4), 16);
+    const b = parseInt(clean.slice(4, 6), 16);
+    if (isNaN(r) || isNaN(g) || isNaN(b)) return null;
+    return [r, g, b];
+  }
+  return null;
+}
+function hslToRgb(h, s, l) {
+  const hn = h / 360;
+  const sn = s / 100;
+  const ln = l / 100;
+  const hue2rgb = (p, q, t) => {
+    let tt = t;
+    if (tt < 0) tt += 1;
+    if (tt > 1) tt -= 1;
+    if (tt < 1 / 6) return p + (q - p) * 6 * tt;
+    if (tt < 1 / 2) return q;
+    if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6;
+    return p;
+  };
+  let r, g, b;
+  if (sn === 0) {
+    r = g = b = ln;
+  } else {
+    const q = ln < 0.5 ? ln * (1 + sn) : ln + sn - ln * sn;
+    const p = 2 * ln - q;
+    r = hue2rgb(p, q, hn + 1 / 3);
+    g = hue2rgb(p, q, hn);
+    b = hue2rgb(p, q, hn - 1 / 3);
+  }
+  return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+}
+function parseHsl(hsl) {
+  let str = hsl.replace(/^hsl\s*\(\s*/i, "").replace(/\s*\)$/, "").trim();
+  str = str.replace(/%/g, "");
+  const parts = str.split(/[\s,]+/).filter(Boolean);
+  if (parts.length !== 3) return null;
+  const h = parseFloat(parts[0]);
+  const s = parseFloat(parts[1]);
+  const l = parseFloat(parts[2]);
+  if (isNaN(h) || isNaN(s) || isNaN(l)) return null;
+  return hslToRgb(h, s, l);
+}
+function parseColor(color) {
+  const trimmed = color.trim();
+  if (trimmed.startsWith("#")) return parseHex(trimmed);
+  if (/^hsl\s*\(/i.test(trimmed)) return parseHsl(trimmed);
+  if (/^\d[\d.]*[\s,]+\d[\d.]*%?[\s,]+\d[\d.]*%?$/.test(trimmed)) return parseHsl(trimmed);
+  return null;
+}
+function rgbToHex(r, g, b) {
+  return "#" + [r, g, b].map(
+    (c) => Math.max(0, Math.min(255, Math.round(c))).toString(16).padStart(2, "0")
+  ).join("");
+}
+function handleCheckContrast(fg, bg) {
+  const fgRgb = parseColor(fg);
+  const bgRgb = parseColor(bg);
+  if (!fgRgb) throw new Error(`Cannot parse foreground color: "${fg}"`);
+  if (!bgRgb) throw new Error(`Cannot parse background color: "${bg}"`);
+  const fgL = relativeLuminance(...fgRgb);
+  const bgL = relativeLuminance(...bgRgb);
+  const ratio = parseFloat(contrastRatioFromLuminance(fgL, bgL).toFixed(2));
+  return {
+    fgHex: rgbToHex(...fgRgb),
+    bgHex: rgbToHex(...bgRgb),
+    ratio,
+    aa: ratio >= 4.5,
+    aaLarge: ratio >= 3,
+    aaa: ratio >= 7,
+    aaaLarge: ratio >= 4.5
+  };
+}
+function handleDeriveAccessiblePalette(seed, targetRatio) {
+  const seedRgb = parseColor(seed);
+  if (!seedRgb) throw new Error(`Cannot parse seed color: "${seed}"`);
+  const seedHex = rgbToHex(...seedRgb);
+  const seedL = relativeLuminance(...seedRgb);
+  const whiteRatio = parseFloat(contrastRatioFromLuminance(1, seedL).toFixed(2));
+  const blackRatio = parseFloat(contrastRatioFromLuminance(0, seedL).toFixed(2));
+  const whiteWorks = whiteRatio >= targetRatio;
+  const blackWorks = blackRatio >= targetRatio;
+  let strategy;
+  let foreground;
+  let ratio;
+  let alternativeForeground;
+  let alternativeRatio;
+  if (blackWorks && whiteWorks) {
+    if (blackRatio >= whiteRatio) {
+      strategy = "black";
+      foreground = "#000000";
+      ratio = blackRatio;
+      alternativeForeground = "#ffffff";
+      alternativeRatio = whiteRatio;
+    } else {
+      strategy = "white";
+      foreground = "#ffffff";
+      ratio = whiteRatio;
+      alternativeForeground = "#000000";
+      alternativeRatio = blackRatio;
+    }
+  } else if (blackWorks) {
+    strategy = "black";
+    foreground = "#000000";
+    ratio = blackRatio;
+    alternativeForeground = "#ffffff";
+    alternativeRatio = whiteRatio;
+  } else if (whiteWorks) {
+    strategy = "white";
+    foreground = "#ffffff";
+    ratio = whiteRatio;
+    alternativeForeground = "#000000";
+    alternativeRatio = blackRatio;
+  } else {
+    strategy = "unachievable";
+    if (blackRatio >= whiteRatio) {
+      foreground = "#000000";
+      ratio = blackRatio;
+      alternativeForeground = "#ffffff";
+      alternativeRatio = whiteRatio;
+    } else {
+      foreground = "#ffffff";
+      ratio = whiteRatio;
+      alternativeForeground = "#000000";
+      alternativeRatio = blackRatio;
+    }
+  }
+  return {
+    seedHex,
+    foreground,
+    ratio,
+    aa: ratio >= 4.5,
+    aaLarge: ratio >= 3,
+    aaa: ratio >= 7,
+    meetsTarget: ratio >= targetRatio,
+    strategy,
+    alternativeForeground,
+    alternativeRatio
+  };
+}
+var PASS = "[PASS]";
+var FAIL = "[FAIL]";
+var mark = (ok) => ok ? PASS : FAIL;
+function registerContrastTools(server2) {
+  server2.tool(
+    "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_zod16.z.string().describe("Foreground (text) color \u2014 hex or HSL"),
+      bg: import_zod16.z.string().describe("Background color \u2014 hex or HSL")
+    },
+    async ({ fg, bg }) => {
+      let result;
+      try {
+        result = handleCheckContrast(fg, bg);
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }]
+        };
+      }
+      const text = [
+        `WCAG 2.1 Contrast Check`,
+        ``,
+        `  Foreground : ${result.fgHex}`,
+        `  Background : ${result.bgHex}`,
+        `  Ratio      : ${result.ratio}:1`,
+        ``,
+        `  ${mark(result.aa)}  AA  \u2014 normal text  (\u22654.5:1)`,
+        `  ${mark(result.aaLarge)}  AA  \u2014 large text   (\u22653.0:1)`,
+        `  ${mark(result.aaa)}  AAA \u2014 normal text  (\u22657.0:1)`,
+        `  ${mark(result.aaaLarge)}  AAA \u2014 large text   (\u22654.5:1)`
+      ].join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server2.tool(
+    "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_zod16.z.string().describe("Background (seed) color \u2014 hex or HSL"),
+      targetRatio: numCoerce(import_zod16.z.number().default(4.5)).describe(
+        "Minimum required contrast ratio (default 4.5 for WCAG AA)"
+      )
+    },
+    async ({ seed, targetRatio }) => {
+      let result;
+      try {
+        result = handleDeriveAccessiblePalette(seed, targetRatio ?? 4.5);
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }]
+        };
+      }
+      const metLine = result.meetsTarget ? `${PASS} Meets target (${targetRatio}:1)` : `${FAIL} Target (${targetRatio}:1) UNACHIEVABLE with white or black \u2014 best available used`;
+      const altNote = result.alternativeRatio >= (targetRatio ?? 4.5) ? `also passes (${result.alternativeRatio}:1)` : `fails at ${result.alternativeRatio}:1`;
+      const text = [
+        `Accessible Palette Derivation`,
+        ``,
+        `  Background (seed) : ${result.seedHex}`,
+        `  Foreground        : ${result.foreground}  (${result.strategy})`,
+        `  Contrast ratio    : ${result.ratio}:1`,
+        `  ${metLine}`,
+        ``,
+        `  ${mark(result.aa)}  AA  \u2014 normal text  (\u22654.5:1)`,
+        `  ${mark(result.aaLarge)}  AA  \u2014 large text   (\u22653.0:1)`,
+        `  ${mark(result.aaa)}  AAA \u2014 normal text  (\u22657.0:1)`,
+        ``,
+        `  Alternative (${result.alternativeForeground}): ${altNote}`
+      ].join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+  );
+}
+
 // package.json
 var package_default = {
   dependencies: {
+    "@stackwright-pro/types": "workspace:*",
     "@modelcontextprotocol/sdk": "^1.10.0",
     "@stackwright-pro/cli-data-explorer": "workspace:*",
-    zod: "^4.3.6"
+    zod: "^4.4.3"
   },
   devDependencies: {
-    "@types/node": "^24.1.0",
-    tsup: "^8.5.0",
-    typescript: "^5.8.3",
-    vitest: "^4.0.18"
+    "@types/node": "catalog:",
+    tsup: "catalog:",
+    typescript: "catalog:",
+    vitest: "catalog:"
   },
   scripts: {
     prepublishOnly: "node scripts/verify-integrity-sync.js",
@@ -3467,10 +5994,13 @@ var package_default = {
     "test:coverage": "vitest run --coverage"
   },
   name: "@stackwright-pro/mcp",
-  version: "0.2.0-alpha.7",
+  version: "0.2.0-alpha.71",
   description: "MCP tools for Stackwright Pro - Data Explorer, Security, ISR, and Dashboard generation",
-  license: "PROPRIETARY",
+  license: "SEE LICENSE IN LICENSE",
   main: "./dist/server.js",
+  bin: {
+    "stackwright-pro-mcp": "./dist/server.js"
+  },
   module: "./dist/server.mjs",
   types: "./dist/server.d.ts",
   exports: {
@@ -3483,6 +6013,11 @@ var package_default = {
       types: "./dist/integrity.d.ts",
       import: "./dist/integrity.mjs",
       require: "./dist/integrity.js"
+    },
+    "./type-schemas": {
+      types: "./dist/tools/type-schemas.d.ts",
+      import: "./dist/tools/type-schemas.mjs",
+      require: "./dist/tools/type-schemas.js"
     }
   },
   files: [
@@ -3510,9 +6045,22 @@ registerPipelineTools(server);
 registerSafeWriteTools(server);
 registerAuthTools(server);
 registerIntegrityTools(server);
+registerArtifactSigningTools(server);
 registerDomainTools(server);
+registerTypeSchemasTool(server);
+registerScaffoldCleanupTools(server);
+registerContrastTools(server);
 async function main() {
   const transport = new import_stdio.StdioServerTransport();
+  try {
+    const servicesRegisterPkg = "@stackwright-services/mcp/register";
+    const mod = await import(servicesRegisterPkg);
+    if (typeof mod.registerServicesTools === "function") {
+      mod.registerServicesTools(server);
+      console.error("Stackwright Services tools registered on pro MCP");
+    }
+  } catch {
+  }
   await server.connect(transport);
   console.error("Stackwright Pro MCP server running on stdio");
 }