@stackwright-pro/mcp 0.2.0-alpha.61 → 0.2.0-alpha.68

package/dist/server.mjs

@@ -1307,6 +1307,13 @@ 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 = z8.object({
   id: z8.string(),
@@ -1341,7 +1348,6 @@ function registerQuestionTools(server2) {
     },
     async ({ phase, questions, answers }) => {
       let resolvedQuestions;
-      const SAFE_PHASE = /^[a-z][a-z0-9-]{0,30}$/;
       if (!SAFE_PHASE.test(phase)) {
         return {
           content: [
@@ -1443,7 +1449,6 @@ function registerQuestionTools(server2) {
     "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: z8.string().describe('Phase name e.g. "designer", "api", "auth"') },
     async ({ phase }) => {
-      const SAFE_PHASE = /^[a-z][a-z0-9-]{0,30}$/;
       if (!SAFE_PHASE.test(phase)) {
         return {
           content: [
@@ -1508,7 +1513,6 @@ function registerQuestionTools(server2) {
       answer: z8.string().describe("The user's free-text answer")
     },
     async ({ phase, questionId, answer }) => {
-      const SAFE_PHASE = /^[a-z][a-z0-9-]{0,30}$/;
       if (!SAFE_PHASE.test(phase)) {
         return {
           content: [
@@ -1517,7 +1521,7 @@ function registerQuestionTools(server2) {
           isError: true
         };
       }
-      if (!/^[a-z0-9][a-z0-9-]{0,63}$/i.test(questionId)) {
+      if (!SAFE_QUESTION_ID.test(questionId)) {
         return {
           content: [
             { type: "text", text: JSON.stringify({ error: "Invalid questionId" }) }
@@ -1670,14 +1674,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 = join2(cwd, ".stackwright", "answers");
   const filePath = join2(dir, `${input.phase}.json`);
   try {
     mkdirSync2(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] ?? ""])
@@ -1704,7 +1772,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
     };
@@ -1851,15 +1920,31 @@ function registerOrchestrationTools(server2) {
       rawAnswers: jsonCoerce(
         z9.array(
           z9.object({
-            question_header: z9.string(),
-            selected_options: z9.array(z9.string()),
+            question_header: z9.string().min(1, "question_header must not be empty"),
+            selected_options: z9.array(z9.string()).min(1, "selected_options must have at least one entry"),
             other_text: z9.string().nullable().optional()
           })
         )
       ).describe(
         "Answers as returned by ask_user_question \u2014 pass the native array, not a JSON string"
       ),
-      questions: jsonCoerce(z9.array(z9.any()).optional()).describe(
+      questions: jsonCoerce(
+        z9.array(
+          z9.object({
+            id: z9.string(),
+            question: z9.string(),
+            type: z9.string(),
+            options: z9.array(z9.object({ label: z9.string(), value: z9.string() })).optional(),
+            required: z9.boolean().optional(),
+            default: z9.union([z9.string(), z9.boolean(), z9.array(z9.string())]).optional(),
+            help: z9.string().optional(),
+            dependsOn: z9.object({
+              questionId: z9.string(),
+              value: z9.union([z9.string(), z9.array(z9.string())])
+            }).optional()
+          }).passthrough()
+        ).optional()
+      ).describe(
         "Original manifest questions for label\u2192value reverse-mapping \u2014 pass the native array, not a JSON string"
       )
     },
@@ -2277,12 +2362,13 @@ var PHASE_DEPENDENCIES = {
   // workflow states as trigger sources. Produces OpenAPI specs consumed
   // by pages and dashboard for typed data wiring.
   services: ["api", "workflow"],
-  // pages/dashboard: now also depend on services for typed endpoint wiring
-  // via the OpenAPI specs that services produces.
-  // 'api' is still transitive through 'data'; auth removed — page-otter has
-  // graceful fallback and reads role names from workflow artifacts instead
-  pages: ["designer", "theme", "data", "services"],
-  dashboard: ["designer", "theme", "data", "services"],
+  // 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
@@ -2318,7 +2404,7 @@ var PHASE_TO_OTTER2 = {
   polish: "stackwright-pro-polish-otter",
   geo: "stackwright-pro-geo-otter"
 };
-function isValidPhase(phase) {
+function isValidPhase2(phase) {
   return PHASE_ORDER.includes(phase);
 }
 function defaultPhaseStatus() {
@@ -2414,7 +2500,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,
@@ -2433,6 +2519,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) {
@@ -2452,6 +2560,16 @@ 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) {
@@ -2461,7 +2579,7 @@ function handleSetPipelineState(input) {
 function handleCheckExecutionReady(_cwd, phase) {
   const cwd = _cwd ?? process.cwd();
   if (phase) {
-    if (!isValidPhase(phase)) {
+    if (!isValidPhase2(phase)) {
       return {
         text: JSON.stringify({
           error: true,
@@ -2609,7 +2727,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
@@ -2667,7 +2785,7 @@ 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
@@ -2760,6 +2878,18 @@ ${JSON.stringify(content, null, 2)}`
     if (buildContextText) {
       parts.push("BUILD_CONTEXT:", buildContextText, "");
     }
+    if (phase === "auth") {
+      const initContextPath = join4(cwd, ".stackwright", "init-context.json");
+      if (existsSync5(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);
@@ -3042,6 +3172,12 @@ var PHASE_ARTIFACT_SCHEMA = {
         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,
@@ -3053,7 +3189,12 @@ var PHASE_ARTIFACT_SCHEMA = {
       generatedBy: "stackwright-pro-polish-otter",
       landingPage: { slug: "", rewritten: true },
       navigation: { itemCount: 5, items: ["/dashboard", "/equipment", "/workflows"] },
-      gettingStarted: "<rewritten|redirected|not-found>"
+      gettingStarted: "<rewritten|redirected|not-found>",
+      scaffoldCleanup: {
+        deleted: ["content/posts/getting-started.yaml"],
+        rewritten: ["app/not-found.tsx"],
+        skipped: []
+      }
     },
     null,
     2
@@ -3062,7 +3203,7 @@ var PHASE_ARTIFACT_SCHEMA = {
 function handleValidateArtifact(input) {
   const cwd = input._cwd ?? process.cwd();
   const { phase, responseText, artifact: directArtifact } = input;
-  if (!isValidPhase(phase)) {
+  if (!isValidPhase2(phase)) {
     return {
       text: JSON.stringify({ error: true, message: `Unknown phase: ${phase}` }),
       isError: true
@@ -3210,7 +3351,16 @@ function registerPipelineTools(server2) {
       status: z11.enum(["setup", "questions", "execution", "done"]).optional().describe("Top-level status override"),
       incrementRetry: boolCoerce(z11.boolean().optional()).describe(
         "Bump retryCount by 1 \u2014 must be a JSON boolean"
-      )
+      ),
+      updates: jsonCoerce(
+        z11.array(
+          z11.object({
+            phase: z11.string(),
+            field: z11.enum(["questionsCollected", "answered", "executed", "artifactWritten"]),
+            value: z11.boolean()
+          })
+        ).optional()
+      ).describe("Batch updates \u2014 apply multiple field changes in one atomic read\u2192modify\u2192write")
     },
     async (args) => res(
       handleSetPipelineState({
@@ -3218,7 +3368,8 @@ 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 } : {}
       })
     )
   );
@@ -3254,7 +3405,6 @@ function registerPipelineTools(server2) {
     },
     async ({ phase, responseText, questions }) => {
       if (phase && questions && Array.isArray(questions)) {
-        const SAFE_PHASE = /^[a-z][a-z0-9-]{0,30}$/;
         if (!SAFE_PHASE.test(phase)) {
           return {
             content: [
@@ -3317,7 +3467,7 @@ function registerPipelineTools(server2) {
 
 // src/tools/safe-write.ts
 import { z as z12 } from "zod";
-import { writeFileSync as writeFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync5, lstatSync as lstatSync6 } from "fs";
+import { writeFileSync as writeFileSync5, readFileSync as readFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync5, lstatSync as lstatSync6 } from "fs";
 import { normalize, isAbsolute, dirname, join as join5 } from "path";
 var OTTER_WRITE_ALLOWLISTS = {
   "stackwright-pro-designer-otter": [
@@ -3339,6 +3489,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": [
@@ -3376,7 +3536,8 @@ var OTTER_WRITE_ALLOWLISTS = {
     },
     { 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: ".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" },
@@ -3396,7 +3557,9 @@ var PROTECTED_PATH_PREFIXES = [
   ".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;
@@ -3410,6 +3573,58 @@ function getMaxBytesForPath(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 = 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 = join5(cwd, PAGE_REGISTRY_FILE);
+  if (!existsSync6(regPath)) return {};
+  try {
+    const stat = lstatSync6(regPath);
+    if (stat.isSymbolicLink()) return {};
+    return JSON.parse(readFileSync5(regPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writePageRegistry(cwd, registry) {
+  const dir = join5(cwd, ".stackwright");
+  mkdirSync5(dir, { recursive: true });
+  const regPath = join5(cwd, PAGE_REGISTRY_FILE);
+  if (existsSync6(regPath)) {
+    const stat = lstatSync6(regPath);
+    if (stat.isSymbolicLink()) {
+      throw new Error("Refusing to write page registry through symlink");
+    }
+  }
+  writeFileSync5(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 = normalize(filePath);
   if (normalized.includes("..")) {
@@ -3451,6 +3666,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 };
     }
   }
@@ -3576,11 +3801,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) {
       mkdirSync5(dirname(fullPath), { recursive: true });
     }
     writeFileSync5(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 {
+      }
+    }
     const result = {
       success: true,
       path: normalized,
@@ -3627,7 +3879,7 @@ function registerSafeWriteTools(server2) {
 
 // src/tools/auth.ts
 import { z as z13 } from "zod";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync6, existsSync as existsSync7 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync7, mkdirSync as mkdirSync6 } from "fs";
 import { join as join6 } from "path";
 function buildHierarchy(roles) {
   const h = {};
@@ -3847,10 +4099,232 @@ ${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 generateDevOnlyYamlBlock(method, params, roles, defaultRole, hierarchy, auditEnabled, auditRetentionDays, protectedRoutes) {
+  const rbacSection = `  rbac:
+    roles:
+${rolesToYaml(roles, "      ")}
+    defaultRole: ${defaultRole}
+    hierarchy:
+${hierarchyToYaml(hierarchy, "      ")}`;
+  const auditSection = `  audit:
+    enabled: ${auditEnabled}
+    retentionDays: ${auditRetentionDays}`;
+  const 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}  middleware: ./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}  middleware: ./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}  middleware: ./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,
@@ -3880,7 +4354,16 @@ async function configureAuthHandler(params, cwd) {
   }
   const filesWritten = [];
   try {
-    const middlewareContent = generateMiddlewareContent(
+    const middlewareContent = devOnly ? generateDevOnlyMiddlewareContent(
+      method,
+      params,
+      roles,
+      defaultRole,
+      hierarchy,
+      auditEnabled,
+      auditRetentionDays,
+      protectedRoutes
+    ) : generateMiddlewareContent(
       method,
       params,
       roles,
@@ -3904,30 +4387,87 @@ async function configureAuthHandler(params, cwd) {
       isError: true
     };
   }
-  try {
-    const envBlock = generateEnvBlock(method, params);
-    const envPath = join6(cwd, ".env.example");
-    if (existsSync7(envPath)) {
-      const existing = readFileSync5(envPath, "utf8");
-      writeFileSync6(envPath, existing.trimEnd() + "\n\n" + envBlock, "utf8");
-    } else {
-      writeFileSync6(envPath, envBlock, "utf8");
+  if (!devOnly) {
+    try {
+      const envBlock = generateEnvBlock(method, params);
+      const envPath = join6(cwd, ".env.example");
+      if (existsSync7(envPath)) {
+        const existing = readFileSync6(envPath, "utf8");
+        writeFileSync6(envPath, existing.trimEnd() + "\n\n" + envBlock, "utf8");
+      } else {
+        writeFileSync6(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 = join6(cwd, "lib");
+      mkdirSync6(mockAuthDir, { recursive: true });
+      const mockAuthContent = generateMockAuthContent(roles, mockUsers);
+      writeFileSync6(join6(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 = join6(cwd, "package.json");
+      if (existsSync7(pkgPath)) {
+        const existingPkg = readFileSync6(pkgPath, "utf8");
+        const updatedPkg = updatePackageJsonScripts(existingPkg, roles, mockUsers);
+        writeFileSync6(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,
+      defaultRole,
+      hierarchy,
+      auditEnabled,
+      auditRetentionDays,
+      protectedRoutes
+    ) : generateYamlBlock(
       method,
       params,
       roles,
@@ -3941,7 +4481,7 @@ async function configureAuthHandler(params, cwd) {
     if (!existsSync7(ymlPath)) {
       writeFileSync6(ymlPath, authYaml, "utf8");
     } else {
-      const existing = readFileSync5(ymlPath, "utf8");
+      const existing = readFileSync6(ymlPath, "utf8");
       writeFileSync6(ymlPath, upsertAuthBlock(existing, authYaml), "utf8");
     }
     filesWritten.push("stackwright.yml");
@@ -3970,7 +4510,21 @@ async function configureAuthHandler(params, cwd) {
           rbacDefaultRole: defaultRole,
           protectedRoutesCount: protectedRoutes.length,
           filesWritten,
-          securityWarning
+          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."
+              }
+            }
+          } : {}
         })
       }
     ]
@@ -4009,7 +4563,9 @@ function registerAuthTools(server2) {
       // Routes
       protectedRoutes: jsonCoerce(z13.array(z13.string()).optional()),
       // Injection for tests
-      _cwd: z13.string().optional()
+      _cwd: z13.string().optional(),
+      devOnly: boolCoerce(z13.boolean().optional()),
+      mockUsers: jsonCoerce(z13.array(z13.object({ name: z13.string(), email: z13.string() })).optional())
     },
     async (params) => {
       const cwd = params._cwd ?? process.cwd();
@@ -4020,7 +4576,7 @@ function registerAuthTools(server2) {
 
 // src/integrity.ts
 import { createHash as createHash4, timingSafeEqual as timingSafeEqual2 } from "crypto";
-import { readFileSync as readFileSync6, readdirSync as readdirSync2, lstatSync as lstatSync7 } from "fs";
+import { readFileSync as readFileSync7, readdirSync as readdirSync2, lstatSync as lstatSync7 } from "fs";
 import { join as join7, basename } from "path";
 var _checksums = /* @__PURE__ */ new Map([
   [
@@ -4029,15 +4585,15 @@ var _checksums = /* @__PURE__ */ new Map([
   ],
   [
     "stackwright-pro-auth-otter.json",
-    "8a6ee02cfe7fede3ca708d05b8b46824eb71f60c7f474b6edf9599da77f779b2"
+    "c3be215f05cc48ec51ed75541184b89a8ac123463b80fe02f2adb6c1b5163853"
   ],
   [
     "stackwright-pro-dashboard-otter.json",
-    "f5a83b74ad7c44edc6f39b45a568fa122d82aa4788f741ce14614da56d4e29a4"
+    "9c319d311801730e8dc9bc142eebb8fc5a7f48da48fa0b8d8c3b7431652447be"
   ],
   [
     "stackwright-pro-data-otter.json",
-    "c406e1c775bcb1f2b038b40a92d9bd23172b40d774fc0fa50bad4c9714f53445"
+    "4d9369277685a4acc484116920c9622ad8a1838012a493fcfe42a6ae5abe53cf"
   ],
   [
     "stackwright-pro-designer-otter.json",
@@ -4045,35 +4601,35 @@ var _checksums = /* @__PURE__ */ new Map([
   ],
   [
     "stackwright-pro-domain-expert-otter.json",
-    "bfe5c167d73fef3f2ef280fff56dcb552073c218e1394a43ecf983a03169ed55"
+    "41e3a5838f05f6a51ed272860dd2d5b1df1f20bfc847eb8f39be109b89738e99"
   ],
   [
     "stackwright-pro-foreman-otter.json",
-    "ab38ef53b95ec610a38b2866d78a135cbec16d257a9b35d7e46e2fee2d4de235"
+    "5f18e37ee3f2064c62a2d01dfc541285f27e5762d0b1011e2a37a48af96c74c8"
   ],
   [
     "stackwright-pro-geo-otter.json",
-    "6eb7ecf97254dbd79c09ad24348bf16001423cce9585c14bef81afd67b7b901b"
+    "ff1191af8108cc70c09afe6a99b008dcb46f71e20f884da1ee424e431868a1b6"
   ],
   [
     "stackwright-pro-page-otter.json",
-    "9a5672f0758c81539337d86955e2892cd412547b4f111c2aa098eed1e62d7626"
+    "1dcdf866be76d18f3aa2a9e56b8bf57a3d43477b43c410eb6d1feac0e7683658"
   ],
   [
     "stackwright-pro-polish-otter.json",
-    "d31116995fdb417798af6056efd03bb1c71e0891371aba1774d283c03c9d77e8"
+    "72a52901b4781c9f0be97024ba6e19415cdfbd92369d9274aa3abe7efd208bc8"
   ],
   [
     "stackwright-pro-theme-otter.json",
-    "08bb04009fdfb8743b10ac4d503cbaddaf8d7c804ba9b606aaed9cc516fd8e93"
+    "e8530a1146abc57eb31d2f036ba057d5eae7d4a2d9dca00e415d1c352ef4c5b5"
   ],
   [
     "stackwright-pro-workflow-otter.json",
-    "c90d6773b2287aa9a640c2715ca0e75f44c13e99fddcfb89ced36603f38930ce"
+    "e02c1a5f492dd6b11f68e293d92f5f661dbb22e57570dcf133a9d0ffc7a8be7d"
   ],
   [
     "stackwright-services-otter.json",
-    "4893a596d187110124f78336ee91184a51b3c8d980c455382fe481adb9b487b5"
+    "b8a252d6a2c5090138899925d3ea95bf3339b6e49adc276a1f5f7304b4ae5134"
   ]
 ]);
 Object.freeze(_checksums);
@@ -4120,7 +4676,7 @@ function verifyOtterFile(filePath) {
   }
   let raw;
   try {
-    raw = readFileSync6(filePath);
+    raw = readFileSync7(filePath);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { verified: false, filename, error: `Cannot read file: ${msg}` };
@@ -4290,7 +4846,7 @@ function registerIntegrityTools(server2) {
 
 // src/tools/domain.ts
 import { z as z14 } from "zod";
-import { readFileSync as readFileSync7, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync8 } from "fs";
 import { join as join8 } from "path";
 function handleListCollections(input) {
   const cwd = input._cwd ?? process.cwd();
@@ -4315,7 +4871,7 @@ function handleListCollections(input) {
   for (const { path: path3, source, parse } of sources) {
     if (!existsSync8(path3)) continue;
     try {
-      const collections = parse(readFileSync7(path3, "utf8"));
+      const collections = parse(readFileSync8(path3, "utf8"));
       return {
         text: JSON.stringify({ collections, source, collectionCount: collections.length }),
         isError: false
@@ -4476,7 +5032,7 @@ function handleValidateWorkflow(input) {
       ]);
     }
     try {
-      raw = JSON.parse(readFileSync7(artifactPath, "utf8"));
+      raw = JSON.parse(readFileSync8(artifactPath, "utf8"));
     } catch (err) {
       return fail([{ code: "INVALID_JSON", message: `Failed to parse workflow artifact: ${err}` }]);
     }
@@ -4783,6 +5339,191 @@ function registerTypeSchemasTool(server2) {
   );
 }
 
+// src/tools/scaffold-cleanup.ts
+import {
+  existsSync as existsSync9,
+  lstatSync as lstatSync8,
+  unlinkSync as unlinkSync2,
+  readFileSync as readFileSync9,
+  writeFileSync as writeFileSync7,
+  readdirSync as readdirSync3,
+  rmdirSync,
+  mkdirSync as mkdirSync7
+} from "fs";
+import { join as join9, dirname as dirname2 } from "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 = join9(cwd, ".stackwright", "artifacts", "theme-tokens.json");
+  if (!existsSync9(tokenPath)) return { ...FALLBACK_COLORS };
+  const stat = lstatSync8(tokenPath);
+  if (stat.isSymbolicLink()) return { ...FALLBACK_COLORS };
+  try {
+    const raw = JSON.parse(readFileSync9(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 (!existsSync9(fullPath)) return true;
+  const stat = lstatSync8(fullPath);
+  return !stat.isSymbolicLink();
+}
+function isDirEmpty(dirPath) {
+  if (!existsSync9(dirPath)) return false;
+  const stat = lstatSync8(dirPath);
+  if (!stat.isDirectory()) return false;
+  return readdirSync3(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 = join9(cwd, relPath);
+    if (!existsSync9(fullPath)) {
+      result.skipped.push(relPath);
+      continue;
+    }
+    if (!isSafePath(fullPath)) {
+      result.errors.push(`Refusing to delete symlink: ${relPath}`);
+      continue;
+    }
+    try {
+      unlinkSync2(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 = join9(cwd, relDir);
+    if (!existsSync9(fullDir)) continue;
+    if (!isSafePath(fullDir)) {
+      result.errors.push(`Refusing to prune symlink directory: ${relDir}`);
+      continue;
+    }
+    if (isDirEmpty(fullDir)) {
+      try {
+        rmdirSync(fullDir);
+        result.prunedDirs.push(relDir);
+      } catch (err) {
+        result.errors.push(`Failed to prune directory ${relDir}: ${String(err)}`);
+      }
+    }
+  }
+  {
+    const fullPath = join9(cwd, NOT_FOUND_PATH);
+    if (!existsSync9(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 = dirname2(fullPath);
+        mkdirSync7(dir, { recursive: true });
+        writeFileSync7(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
+      };
+    }
+  );
+}
+
 // package.json
 var package_default = {
   dependencies: {
@@ -4806,7 +5547,7 @@ var package_default = {
     "test:coverage": "vitest run --coverage"
   },
   name: "@stackwright-pro/mcp",
-  version: "0.2.0-alpha.61",
+  version: "0.2.0-alpha.68",
   description: "MCP tools for Stackwright Pro - Data Explorer, Security, ISR, and Dashboard generation",
   license: "SEE LICENSE IN LICENSE",
   main: "./dist/server.js",
@@ -4860,6 +5601,7 @@ registerIntegrityTools(server);
 registerArtifactSigningTools(server);
 registerDomainTools(server);
 registerTypeSchemasTool(server);
+registerScaffoldCleanupTools(server);
 async function main() {
   const transport = new StdioServerTransport();
   try {