@cementic/cementic-test 0.2.6 → 0.2.7

package/dist/cli.js

@@ -5,7 +5,7 @@ import {
 
 // src/cli.ts
 import { Command as Command9 } from "commander";
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 
 // src/commands/new.ts
 import { Command } from "commander";
@@ -17,6 +17,7 @@ import { dirname } from "path";
 import { platform, release } from "os";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
+var LEGACY_MACOS_DARWIN_MAJOR = 23;
 function resolveTemplatePath(templateDir) {
   const candidates = [
     resolve(__dirname, `templates/${templateDir}`),
@@ -61,25 +62,22 @@ Examples:
       }
     }
     copyRecursive(templatePath, projectPath);
-    if (platform() === "darwin") {
-      const osRelease = release();
-      const majorVersion = parseInt(osRelease.split(".")[0], 10);
-      if (majorVersion < 23) {
-        console.log("\u{1F34E} Detected macOS 13 or older. Adjusting versions for compatibility...");
-        const pkgJsonPath = join(projectPath, "package.json");
-        if (existsSync(pkgJsonPath)) {
-          try {
-            const pkgContent = readFileSync(pkgJsonPath, "utf-8");
-            const pkg = JSON.parse(pkgContent);
-            if (pkg.devDependencies) {
-              pkg.devDependencies["@playwright/test"] = "^1.48.2";
-              pkg.devDependencies["allure-playwright"] = "^2.15.1";
-              writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2));
-              console.log("\u2705 Downgraded @playwright/test and allure-playwright for legacy macOS support.");
-            }
-          } catch (err) {
-            console.warn("\u26A0\uFE0F Failed to adjust package.json for OS compatibility:", err);
+    const legacyMacOs = isLegacyMacOs();
+    if (legacyMacOs) {
+      console.log("\u{1F34E} Detected macOS 13 or older. Adjusting versions for compatibility...");
+      const pkgJsonPath = join(projectPath, "package.json");
+      if (existsSync(pkgJsonPath)) {
+        try {
+          const pkgContent = readFileSync(pkgJsonPath, "utf-8");
+          const pkg = JSON.parse(pkgContent);
+          if (pkg.devDependencies) {
+            pkg.devDependencies["@playwright/test"] = "^1.48.2";
+            pkg.devDependencies["allure-playwright"] = "^2.15.1";
+            writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2));
+            console.log("\u2705 Pinned Playwright packages for legacy macOS compatibility.");
           }
+        } catch (err) {
+          console.warn("\u26A0\uFE0F Failed to adjust package.json for OS compatibility:", err);
         }
       }
     }
@@ -93,17 +91,27 @@ Examples:
       console.warn("\u26A0\uFE0F Failed to initialize git repository.");
     }
     console.log("\u{1F4E6} Installing dependencies...");
+    let dependenciesInstalled = false;
     try {
       execSync("npm install", { cwd: projectPath, stdio: "inherit" });
+      dependenciesInstalled = true;
     } catch (e) {
       console.error('\u274C Failed to install dependencies. Please run "npm install" manually.');
     }
-    if (opts.browsers !== false) {
+    if (opts.browsers !== false && dependenciesInstalled) {
       console.log("\u{1F310} Installing Playwright browsers...");
       try {
-        execSync("npx playwright install", { cwd: projectPath, stdio: "inherit" });
+        if (legacyMacOs) {
+          console.log("\u26A0\uFE0F WebKit is not supported on this macOS version. Installing Chromium only...");
+          execSync("npx playwright install chromium", { cwd: projectPath, stdio: "inherit" });
+          console.log("\u2705 Chromium installed successfully.");
+        } else {
+          execSync("npx playwright install", { cwd: projectPath, stdio: "inherit" });
+          console.log("\u2705 Playwright browsers installed successfully.");
+        }
       } catch (e) {
-        console.warn('\u26A0\uFE0F Failed to install browsers. Run "npx playwright install" manually.');
+        console.warn("\u26A0\uFE0F Browser installation did not complete. You can finish setup with:");
+        console.warn("  npx playwright install chromium");
       }
     }
     console.log(`
@@ -118,6 +126,11 @@ Happy testing! \u{1F9EA}`);
   });
   return cmd;
 }
+function isLegacyMacOs() {
+  if (platform() !== "darwin") return false;
+  const majorVersion = parseInt(release().split(".")[0], 10);
+  return Number.isFinite(majorVersion) && majorVersion < LEGACY_MACOS_DARWIN_MAJOR;
+}
 
 // src/commands/normalize.ts
 import { Command as Command2 } from "commander";
@@ -339,7 +352,7 @@ function testCmd() {
 // src/commands/tc.ts
 import { Command as Command4 } from "commander";
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { createInterface } from "readline/promises";
 import { stdin as input, stdout as output } from "process";
 
@@ -393,6 +406,97 @@ function inferPrefix(params) {
   return "TC";
 }
 
+// src/core/llm-provider.ts
+var PROVIDER_ORDER = ["deepseek", "anthropic", "gemini", "qwen", "kimi", "openai"];
+function resolveLlmProvider(env = process.env) {
+  const explicitProvider = (env.CT_LLM_PROVIDER ?? "").trim().toLowerCase();
+  const providers = buildProviderConfigs(env);
+  if (explicitProvider) {
+    if (!(explicitProvider in providers)) {
+      throw new Error(
+        `Unsupported CT_LLM_PROVIDER="${explicitProvider}". Use deepseek, anthropic, gemini, qwen, kimi, or openai.`
+      );
+    }
+    const selected = providers[explicitProvider];
+    if (!selected.apiKey) {
+      throw new Error(
+        `CT_LLM_PROVIDER=${explicitProvider} is set but the matching API key is missing.
+${buildProviderSetupHelp()}`
+      );
+    }
+    return selected;
+  }
+  for (const providerName of PROVIDER_ORDER) {
+    if (providers[providerName].apiKey) return providers[providerName];
+  }
+  throw new Error(`No LLM API key found.
+${buildProviderSetupHelp()}`);
+}
+function buildProviderSetupHelp() {
+  return [
+    "  OpenAI:     export OPENAI_API_KEY=your-key",
+    "  Anthropic:  export ANTHROPIC_API_KEY=your-key",
+    "  Gemini:     export GEMINI_API_KEY=your-key",
+    "  DeepSeek:   export DEEPSEEK_API_KEY=your-key",
+    "  Qwen:       export QWEN_API_KEY=your-key",
+    "  Kimi:       export KIMI_API_KEY=your-key",
+    "  Generic:    export CT_LLM_API_KEY=your-key",
+    "              export CT_LLM_BASE_URL=https://your-openai-compatible-endpoint/v1"
+  ].join("\n");
+}
+function buildProviderConfigs(env) {
+  return {
+    deepseek: {
+      provider: "deepseek",
+      displayName: "DeepSeek",
+      apiKey: env.DEEPSEEK_API_KEY ?? env.CT_DEEPSEEK_API_KEY ?? "",
+      model: env.CT_LLM_MODEL ?? env.DEEPSEEK_MODEL ?? "deepseek-chat",
+      baseUrl: env.DEEPSEEK_BASE_URL ?? "https://api.deepseek.com/v1",
+      transport: "openai-compatible"
+    },
+    anthropic: {
+      provider: "anthropic",
+      displayName: "Claude",
+      apiKey: env.ANTHROPIC_API_KEY ?? env.CT_ANTHROPIC_API_KEY ?? "",
+      model: env.CT_LLM_MODEL ?? env.ANTHROPIC_MODEL ?? "claude-sonnet-4-5",
+      baseUrl: "https://api.anthropic.com",
+      transport: "anthropic"
+    },
+    gemini: {
+      provider: "gemini",
+      displayName: "Gemini",
+      apiKey: env.GEMINI_API_KEY ?? env.GOOGLE_API_KEY ?? "",
+      model: env.CT_LLM_MODEL ?? env.GEMINI_MODEL ?? "gemini-2.5-flash",
+      baseUrl: env.GEMINI_BASE_URL ?? "https://generativelanguage.googleapis.com/v1beta/openai",
+      transport: "openai-compatible"
+    },
+    qwen: {
+      provider: "qwen",
+      displayName: "Qwen",
+      apiKey: env.QWEN_API_KEY ?? "",
+      model: env.CT_LLM_MODEL ?? env.QWEN_MODEL ?? "qwen-plus",
+      baseUrl: env.QWEN_BASE_URL ?? "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+      transport: "openai-compatible"
+    },
+    kimi: {
+      provider: "kimi",
+      displayName: "Kimi",
+      apiKey: env.KIMI_API_KEY ?? env.MOONSHOT_API_KEY ?? "",
+      model: env.CT_LLM_MODEL ?? env.KIMI_MODEL ?? "moonshot-v1-8k",
+      baseUrl: env.KIMI_BASE_URL ?? "https://api.moonshot.ai/v1",
+      transport: "openai-compatible"
+    },
+    openai: {
+      provider: "openai",
+      displayName: env.CT_LLM_API_KEY && env.CT_LLM_BASE_URL ? "OpenAI-compatible" : "OpenAI",
+      apiKey: env.CT_LLM_API_KEY ?? env.OPENAI_API_KEY ?? "",
+      model: env.CT_LLM_MODEL ?? env.OPENAI_MODEL ?? "gpt-4o-mini",
+      baseUrl: env.CT_LLM_BASE_URL ?? "https://api.openai.com/v1",
+      transport: "openai-compatible"
+    }
+  };
+}
+
 // src/core/llm.ts
 function buildSystemMessage() {
   return `
@@ -472,35 +576,6 @@ function buildUserMessage(ctx) {
   lines.push(`Output ONLY the test cases. No explanation, no preamble.`);
   return lines.join("\n");
 }
-function detectProvider() {
-  const anthropicKey = process.env.ANTHROPIC_API_KEY ?? process.env.CT_ANTHROPIC_API_KEY ?? "";
-  const openaiKey = process.env.CT_LLM_API_KEY ?? process.env.OPENAI_API_KEY ?? "";
-  const explicitProvider = (process.env.CT_LLM_PROVIDER ?? "").toLowerCase();
-  if (explicitProvider === "anthropic" || anthropicKey && explicitProvider !== "openai") {
-    if (!anthropicKey) {
-      throw new Error(
-        "CT_LLM_PROVIDER=anthropic but no ANTHROPIC_API_KEY found.\nSet ANTHROPIC_API_KEY=your-key or switch to OPENAI_API_KEY."
-      );
-    }
-    return {
-      provider: "anthropic",
-      apiKey: anthropicKey,
-      model: process.env.CT_LLM_MODEL ?? "claude-sonnet-4-5",
-      baseUrl: "https://api.anthropic.com"
-    };
-  }
-  if (openaiKey) {
-    return {
-      provider: "openai",
-      apiKey: openaiKey,
-      model: process.env.CT_LLM_MODEL ?? "gpt-4o-mini",
-      baseUrl: process.env.CT_LLM_BASE_URL ?? "https://api.openai.com/v1"
-    };
-  }
-  throw new Error(
-    "No LLM API key found.\n  For Claude:  export ANTHROPIC_API_KEY=your-key\n  For OpenAI:  export OPENAI_API_KEY=your-key\n  Any OpenAI-compatible endpoint: set CT_LLM_API_KEY + CT_LLM_BASE_URL"
-  );
-}
 async function callAnthropic(apiKey, model, system, user) {
   const response = await fetch("https://api.anthropic.com/v1/messages", {
     method: "POST",
@@ -525,7 +600,7 @@ async function callAnthropic(apiKey, model, system, user) {
   if (!content) throw new Error("Anthropic response had no content");
   return content;
 }
-async function callOpenAi(apiKey, model, baseUrl, system, user) {
+async function callOpenAiCompatible(apiKey, model, baseUrl, displayName, system, user) {
   const response = await fetch(`${baseUrl}/chat/completions`, {
     method: "POST",
     headers: {
@@ -543,7 +618,7 @@ async function callOpenAi(apiKey, model, baseUrl, system, user) {
   });
   if (!response.ok) {
     const text = await response.text();
-    throw new Error(`OpenAI API error ${response.status}: ${text}`);
+    throw new Error(`${displayName} API error ${response.status}: ${text}`);
   }
   const json = await response.json();
   const content = json.choices?.[0]?.message?.content?.trim() ?? "";
@@ -551,90 +626,42 @@ async function callOpenAi(apiKey, model, baseUrl, system, user) {
   return content;
 }
 async function generateTcMarkdownWithAi(ctx) {
-  const { provider, apiKey, model, baseUrl } = detectProvider();
+  const providerConfig = resolveLlmProvider();
   const system = buildSystemMessage();
   const user = buildUserMessage(ctx);
-  console.log(`\u{1F916} Using ${provider === "anthropic" ? "Claude" : "OpenAI-compatible"} (${model})`);
-  if (provider === "anthropic") {
-    return callAnthropic(apiKey, model, system, user);
+  console.log(`\u{1F916} Using ${providerConfig.displayName} (${providerConfig.model})`);
+  if (providerConfig.transport === "anthropic") {
+    return callAnthropic(providerConfig.apiKey, providerConfig.model, system, user);
   }
-  return callOpenAi(apiKey, model, baseUrl, system, user);
+  return callOpenAiCompatible(
+    providerConfig.apiKey,
+    providerConfig.model,
+    providerConfig.baseUrl ?? "https://api.openai.com/v1",
+    providerConfig.displayName,
+    system,
+    user
+  );
 }
 
 // src/core/analyse.ts
 async function analyseElements(elementMap, options = {}) {
   const { verbose = false } = options;
-  const { provider, displayName, apiKey, model, baseUrl } = detectProvider2();
+  const providerConfig = resolveLlmProvider();
   log(verbose, `
-[analyse] Sending capture to ${displayName} (${model})`);
+[analyse] Sending capture to ${providerConfig.displayName} (${providerConfig.model})`);
   const systemPrompt = buildSystemPrompt();
   const userPrompt = buildUserPrompt(elementMap);
-  const rawResponse = provider === "anthropic" ? await callAnthropic2(apiKey, model, systemPrompt, userPrompt) : await callOpenAi2(apiKey, model, baseUrl ?? "https://api.openai.com/v1", systemPrompt, userPrompt);
+  const rawResponse = providerConfig.transport === "anthropic" ? await callAnthropic2(providerConfig.apiKey, providerConfig.model, systemPrompt, userPrompt) : await callOpenAiCompatible2(
+    providerConfig.apiKey,
+    providerConfig.model,
+    providerConfig.baseUrl ?? "https://api.openai.com/v1",
+    providerConfig.displayName,
+    systemPrompt,
+    userPrompt
+  );
   const parsed = parseAnalysisJson(rawResponse);
   return sanitizeAnalysis(parsed, elementMap);
 }
-function detectProvider2() {
-  const explicitProvider = (process.env.CT_LLM_PROVIDER ?? "").toLowerCase();
-  const providers = {
-    deepseek: {
-      provider: "deepseek",
-      displayName: "DeepSeek",
-      apiKey: process.env.DEEPSEEK_API_KEY ?? process.env.CT_DEEPSEEK_API_KEY ?? "",
-      model: process.env.CT_LLM_MODEL ?? process.env.DEEPSEEK_MODEL ?? "deepseek-chat",
-      baseUrl: process.env.DEEPSEEK_BASE_URL ?? "https://api.deepseek.com/v1"
-    },
-    anthropic: {
-      provider: "anthropic",
-      displayName: "Claude",
-      apiKey: process.env.ANTHROPIC_API_KEY ?? process.env.CT_ANTHROPIC_API_KEY ?? "",
-      model: process.env.CT_LLM_MODEL ?? process.env.ANTHROPIC_MODEL ?? "claude-sonnet-4-5"
-    },
-    gemini: {
-      provider: "gemini",
-      displayName: "Gemini",
-      apiKey: process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY ?? "",
-      model: process.env.CT_LLM_MODEL ?? process.env.GEMINI_MODEL ?? "gemini-2.5-flash",
-      baseUrl: process.env.GEMINI_BASE_URL ?? "https://generativelanguage.googleapis.com/v1beta/openai"
-    },
-    qwen: {
-      provider: "qwen",
-      displayName: "Qwen",
-      apiKey: process.env.QWEN_API_KEY ?? "",
-      model: process.env.CT_LLM_MODEL ?? process.env.QWEN_MODEL ?? "qwen-plus",
-      baseUrl: process.env.QWEN_BASE_URL ?? "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
-    },
-    kimi: {
-      provider: "kimi",
-      displayName: "Kimi",
-      apiKey: process.env.KIMI_API_KEY ?? process.env.MOONSHOT_API_KEY ?? "",
-      model: process.env.CT_LLM_MODEL ?? process.env.KIMI_MODEL ?? "moonshot-v1-8k",
-      baseUrl: process.env.KIMI_BASE_URL ?? "https://api.moonshot.ai/v1"
-    },
-    openai: {
-      provider: "openai",
-      displayName: "OpenAI-compatible",
-      apiKey: process.env.OPENAI_API_KEY ?? process.env.CT_LLM_API_KEY ?? "",
-      model: process.env.CT_LLM_MODEL ?? process.env.OPENAI_MODEL ?? "gpt-4o-mini",
-      baseUrl: process.env.CT_LLM_BASE_URL ?? "https://api.openai.com/v1"
-    }
-  };
-  if (explicitProvider) {
-    if (!(explicitProvider in providers)) {
-      throw new Error(`Unsupported CT_LLM_PROVIDER="${explicitProvider}". Use deepseek, anthropic, gemini, qwen, kimi, or openai.`);
-    }
-    const selected = providers[explicitProvider];
-    if (!selected.apiKey) {
-      throw new Error(`CT_LLM_PROVIDER=${explicitProvider} is set but the matching API key is missing.`);
-    }
-    return selected;
-  }
-  for (const providerName of ["deepseek", "anthropic", "gemini", "qwen", "kimi", "openai"]) {
-    if (providers[providerName].apiKey) return providers[providerName];
-  }
-  throw new Error(
-    "No LLM API key found.\n  DeepSeek:   export DEEPSEEK_API_KEY=your-key\n  Anthropic:  export ANTHROPIC_API_KEY=your-key\n  Gemini:     export GEMINI_API_KEY=your-key\n  Qwen:       export QWEN_API_KEY=your-key\n  Kimi:       export KIMI_API_KEY=your-key\n  OpenAI:     export OPENAI_API_KEY=your-key"
-  );
-}
 function buildSystemPrompt() {
   return `
 You are a senior QA automation engineer and Playwright expert working on CementicTest.
@@ -651,6 +678,8 @@ RULES:
 6. Do not invent redirect targets, success pages, error text, password clearing, or security scenarios unless the capture explicitly supports them.
 7. If no status or alert region was captured, avoid scenarios that depend on unseen server-side validation messages.
 8. Prefer 3 to 5 realistic scenarios.
+9. The "selector" field must be the raw selector expression from the ElementMap, such as locator("#username") or getByRole('button', { name: "Login" }). Never wrap selectors in page. or page.locator("...") inside JSON.
+10. If a page clearly contains login or auth fields, do not create submit scenarios that only click the button. Include realistic fill steps for captured username/email and password inputs.
 
 OUTPUT SCHEMA:
 {
@@ -689,6 +718,7 @@ OUTPUT SCHEMA:
 }
 function buildUserPrompt(elementMap) {
   const lines = [];
+  const authElements = detectAuthElements(elementMap);
   lines.push("PAGE INFORMATION");
   lines.push(`URL: ${elementMap.url}`);
   lines.push(`Title: ${elementMap.title}`);
@@ -721,6 +751,10 @@ function buildUserPrompt(elementMap) {
   lines.push(`  - Status or alert regions captured: ${statusCount}`);
   lines.push("  - If no redirect target is explicitly captured, do not assert a destination path.");
   lines.push("  - If no status region was captured, avoid exact server-side credential error claims.");
+  if (authElements.usernameInput && authElements.passwordInput && authElements.submitButton) {
+    lines.push("  - This page contains a captured auth form. Include fill steps for the username/email and password fields in credential-submission scenarios.");
+    lines.push("  - For auth pages without captured post-submit evidence, prefer evidence-backed form-state assertions over invented success redirects.");
+  }
   lines.push("");
   lines.push("Generate only the JSON response.");
   return lines.join("\n");
@@ -748,7 +782,7 @@ async function callAnthropic2(apiKey, model, systemPrompt, userPrompt) {
   if (!content) throw new Error("Anthropic returned empty content");
   return content;
 }
-async function callOpenAi2(apiKey, model, baseUrl, systemPrompt, userPrompt) {
+async function callOpenAiCompatible2(apiKey, model, baseUrl, displayName, systemPrompt, userPrompt) {
   const response = await fetch(`${baseUrl}/chat/completions`, {
     method: "POST",
     headers: {
@@ -765,7 +799,7 @@ async function callOpenAi2(apiKey, model, baseUrl, systemPrompt, userPrompt) {
     })
   });
   if (!response.ok) {
-    throw new Error(`OpenAI API ${response.status}: ${await response.text()}`);
+    throw new Error(`${displayName} API ${response.status}: ${await response.text()}`);
   }
   const json = await response.json();
   const content = json.choices?.[0]?.message?.content?.trim() ?? "";
@@ -786,9 +820,14 @@ ${raw.slice(0, 500)}`
   }
 }
 function sanitizeAnalysis(analysis, elementMap) {
-  const selectors = new Set(elementMap.elements.map((element) => element.selector));
+  const selectors = /* @__PURE__ */ new Set();
+  for (const element of elementMap.elements) {
+    selectors.add(element.selector);
+    for (const alt of element.selectorAlt) selectors.add(alt);
+  }
   const rawScenarios = Array.isArray(analysis.scenarios) ? analysis.scenarios : [];
   const currentUrl = new URL(elementMap.url);
+  const authElements = detectAuthElements(elementMap);
   const knownPaths = /* @__PURE__ */ new Set([
     currentUrl.pathname,
     ...elementMap.elements.filter((element) => element.category === "link").map((element) => {
@@ -801,7 +840,7 @@ function sanitizeAnalysis(analysis, elementMap) {
       }
     }).filter(Boolean)
   ]);
-  const sanitizedScenarios = rawScenarios.map((scenario) => normalizeScenario(scenario, selectors)).filter((scenario) => scenario.steps.length > 0 && scenario.assertions.length > 0).map((scenario) => ({
+  const sanitizedScenarios = rawScenarios.map((scenario) => normalizeScenario(scenario, selectors, elementMap.url)).filter((scenario) => scenario.steps.length > 0 && scenario.assertions.length > 0).map((scenario) => ({
     ...scenario,
     tags: scenario.tags.map(normalizeTag),
     assertions: scenario.assertions.filter((assertion) => {
@@ -812,7 +851,8 @@ function sanitizeAnalysis(analysis, elementMap) {
       return knownPaths.has(pathMatch[0]);
     })
   })).filter((scenario) => scenario.assertions.length > 0).slice(0, 5);
-  const finalScenarios = sanitizedScenarios.length > 0 ? sanitizedScenarios : buildFallbackScenarios(elementMap, analysis.suggestedPrefix || "FLOW");
+  const useAuthFallback = shouldUseAuthFallback(authElements, sanitizedScenarios);
+  const finalScenarios = useAuthFallback ? buildAuthFallbackScenarios(elementMap, analysis.suggestedPrefix || inferPrefix2(elementMap), authElements) : sanitizedScenarios.length > 0 ? sanitizedScenarios : buildFallbackScenarios(elementMap, analysis.suggestedPrefix || "FLOW");
   return {
     ...analysis,
     url: analysis.url || elementMap.url,
@@ -821,22 +861,53 @@ function sanitizeAnalysis(analysis, elementMap) {
     scenarios: finalScenarios,
     analysisNotes: [
       analysis.analysisNotes,
+      useAuthFallback ? "Replaced low-evidence auth scenarios with deterministic evidence-backed auth coverage." : "",
       `Sanitized to ${finalScenarios.length} evidence-backed scenario(s) from ${rawScenarios.length} raw scenario(s).`
     ].filter(Boolean).join(" "),
     audioSummary: analysis.audioSummary || buildAudioSummary(analysis.feature || inferFeatureName(elementMap), finalScenarios)
   };
 }
-function normalizeScenario(candidate, selectors) {
+function normalizeScenario(candidate, selectors, url) {
+  const steps = Array.isArray(candidate?.steps) ? candidate.steps.map((step) => normalizeStep(step, selectors)).filter(Boolean) : [];
+  const assertions = Array.isArray(candidate?.assertions) ? candidate.assertions.map((assertion) => normalizeAssertion(assertion, selectors)).filter(Boolean) : [];
+  const normalizedSteps = ensureNavigateStep(steps, url);
   return {
     id: candidate?.id ?? "FLOW-001",
     title: candidate?.title ?? "Captured page flow",
     tags: Array.isArray(candidate?.tags) ? candidate.tags : [],
-    steps: Array.isArray(candidate?.steps) ? candidate.steps.filter((step) => step?.selector === "page" || selectors.has(step?.selector)) : [],
-    assertions: Array.isArray(candidate?.assertions) ? candidate.assertions.filter((assertion) => assertion?.selector === "page" || selectors.has(assertion?.selector)) : [],
+    steps: normalizedSteps,
+    assertions,
     narrator: candidate?.narrator ?? "Let us run this captured test flow.",
     codeLevel: candidate?.codeLevel ?? "beginner"
   };
 }
+function normalizeStep(candidate, selectors) {
+  if (!candidate) return null;
+  const selector = String(candidate.selector ?? "").trim();
+  if (selector !== "page" && !selectors.has(selector)) return null;
+  const action = String(candidate.action ?? "").trim();
+  if (!["navigate", "fill", "click", "select", "check", "keyboard", "hover"].includes(action)) return null;
+  return {
+    action,
+    selector,
+    value: String(candidate.value ?? ""),
+    human: String(candidate.human ?? "").trim() || defaultStepHuman(action, selector, String(candidate.value ?? ""))
+  };
+}
+function normalizeAssertion(candidate, selectors) {
+  if (!candidate) return null;
+  const selector = String(candidate.selector ?? "").trim();
+  if (selector !== "page" && !selectors.has(selector)) return null;
+  const assertion = {
+    type: String(candidate.type ?? "visible").trim() || "visible",
+    selector,
+    expected: String(candidate.expected ?? "").trim(),
+    human: String(candidate.human ?? "").trim() || "Expected state is verified",
+    playwright: String(candidate.playwright ?? "").trim()
+  };
+  assertion.playwright = normalizePlaywrightAssertion(assertion);
+  return assertion;
+}
 function buildFallbackScenarios(elementMap, prefix) {
   const heading = elementMap.elements.find((element) => element.category === "heading");
   const emailInput = elementMap.elements.find((element) => element.category === "input" && (element.attributes.type === "email" || /email/.test(`${element.name ?? ""} ${String(element.attributes.label ?? "")}`.toLowerCase())));
@@ -918,6 +989,163 @@ function buildFallbackScenarios(elementMap, prefix) {
   }
   return scenarios.slice(0, 5);
 }
+function buildAuthFallbackScenarios(elementMap, prefix, authElements) {
+  const { usernameInput, passwordInput, submitButton, heading } = authElements;
+  if (!usernameInput || !passwordInput || !submitButton) {
+    return buildFallbackScenarios(elementMap, prefix);
+  }
+  const scenarios = [];
+  const tag = (value) => normalizeTag(value);
+  const nextId = (index) => `${prefix}-${String(index).padStart(3, "0")}`;
+  const usernameValue = inferAuthValue(usernameInput, "username");
+  const passwordValue = inferAuthValue(passwordInput, "password");
+  scenarios.push({
+    id: nextId(1),
+    title: "Login form renders expected controls",
+    tags: [tag("smoke"), tag("auth")],
+    steps: [
+      {
+        action: "navigate",
+        selector: "page",
+        value: elementMap.url,
+        human: "Navigate to the login page"
+      }
+    ],
+    assertions: [
+      ...heading ? [{
+        type: "visible",
+        selector: heading.selector,
+        expected: "visible",
+        human: `${heading.name || "Login heading"} is visible`,
+        playwright: visibleAssertion(heading.selector)
+      }] : [],
+      {
+        type: "visible",
+        selector: usernameInput.selector,
+        expected: "visible",
+        human: `${usernameInput.name || "Username field"} is visible`,
+        playwright: visibleAssertion(usernameInput.selector)
+      },
+      {
+        type: "visible",
+        selector: passwordInput.selector,
+        expected: "visible",
+        human: `${passwordInput.name || "Password field"} is visible`,
+        playwright: visibleAssertion(passwordInput.selector)
+      },
+      {
+        type: "visible",
+        selector: submitButton.selector,
+        expected: "visible",
+        human: `${submitButton.name || "Submit button"} is visible`,
+        playwright: visibleAssertion(submitButton.selector)
+      }
+    ],
+    narrator: "We first confirm that the captured login form is present and interactive.",
+    codeLevel: "beginner"
+  });
+  scenarios.push({
+    id: nextId(2),
+    title: "User can enter credentials before submission",
+    tags: [tag("auth"), tag("happy-path")],
+    steps: [
+      {
+        action: "navigate",
+        selector: "page",
+        value: elementMap.url,
+        human: "Navigate to the login page"
+      },
+      {
+        action: "fill",
+        selector: usernameInput.selector,
+        value: usernameValue,
+        human: "Fill in the username field"
+      },
+      {
+        action: "fill",
+        selector: passwordInput.selector,
+        value: passwordValue,
+        human: "Fill in the password field"
+      }
+    ],
+    assertions: [
+      {
+        type: "value",
+        selector: usernameInput.selector,
+        expected: usernameValue,
+        human: "Username input contains the entered value",
+        playwright: valueAssertion(usernameInput.selector, usernameValue)
+      },
+      {
+        type: "value",
+        selector: passwordInput.selector,
+        expected: passwordValue,
+        human: "Password input contains the entered value",
+        playwright: valueAssertion(passwordInput.selector, passwordValue)
+      },
+      {
+        type: "visible",
+        selector: submitButton.selector,
+        expected: "visible",
+        human: `${submitButton.name || "Submit button"} remains visible`,
+        playwright: visibleAssertion(submitButton.selector)
+      }
+    ],
+    narrator: "Next we verify that both credential fields accept input before we submit the form.",
+    codeLevel: "beginner"
+  });
+  scenarios.push({
+    id: nextId(3),
+    title: "Submitting without a password keeps the login form visible",
+    tags: [tag("auth"), tag("negative")],
+    steps: [
+      {
+        action: "navigate",
+        selector: "page",
+        value: elementMap.url,
+        human: "Navigate to the login page"
+      },
+      {
+        action: "fill",
+        selector: usernameInput.selector,
+        value: usernameValue,
+        human: "Fill in the username field"
+      },
+      {
+        action: "click",
+        selector: submitButton.selector,
+        value: "",
+        human: "Click the login button"
+      }
+    ],
+    assertions: [
+      {
+        type: "url",
+        selector: "page",
+        expected: elementMap.url,
+        human: "User remains on the same login URL",
+        playwright: `await expect(page).toHaveURL('${elementMap.url}');`
+      },
+      {
+        type: "visible",
+        selector: passwordInput.selector,
+        expected: "visible",
+        human: "Password field remains visible for correction",
+        playwright: visibleAssertion(passwordInput.selector)
+      },
+      {
+        type: "visible",
+        selector: submitButton.selector,
+        expected: "visible",
+        human: `${submitButton.name || "Login button"} remains visible`,
+        playwright: visibleAssertion(submitButton.selector)
+      }
+    ],
+    narrator: "Finally we submit incomplete credentials and confirm the captured login form remains available for correction.",
+    codeLevel: "beginner"
+  });
+  return scenarios;
+}
 function inferFeatureName(elementMap) {
   const heading = elementMap.elements.find((element) => element.category === "heading" && element.name);
   return heading?.name || elementMap.title || "Captured page";
@@ -936,29 +1164,206 @@ function normalizeTag(value) {
   const cleaned = String(value ?? "").trim().replace(/^@+/, "");
   return cleaned ? `@${cleaned}` : "@ui";
 }
+function detectAuthElements(elementMap) {
+  const usernameInput = elementMap.elements.find((element) => element.category === "input" && /user(name)?|email|login/.test(`${element.name ?? ""} ${String(element.attributes.label ?? "")} ${String(element.attributes.name ?? "")}`.toLowerCase()));
+  const passwordInput = elementMap.elements.find((element) => element.category === "input" && String(element.attributes.type ?? "").toLowerCase() === "password");
+  const submitButton = elementMap.elements.find((element) => element.category === "button" && /login|log in|sign in|submit|continue/.test((element.name ?? "").toLowerCase())) ?? elementMap.elements.find((element) => element.category === "button");
+  const heading = elementMap.elements.find((element) => element.category === "heading" && /login|sign in|auth/.test((element.name ?? "").toLowerCase())) ?? elementMap.elements.find((element) => element.category === "heading");
+  return { usernameInput, passwordInput, submitButton, heading };
+}
+function shouldUseAuthFallback(authElements, scenarios) {
+  if (!authElements.usernameInput || !authElements.passwordInput || !authElements.submitButton) return false;
+  if (scenarios.length === 0) return true;
+  const hasCredentialEntry = scenarios.some((scenario) => {
+    const filledSelectors = new Set(
+      scenario.steps.filter((step) => step.action === "fill").map((step) => step.selector)
+    );
+    return filledSelectors.has(authElements.usernameInput.selector) && filledSelectors.has(authElements.passwordInput.selector);
+  });
+  const hasBrokenLocatorWrapper = scenarios.some((scenario) => scenario.assertions.some((assertion) => /page\.locator\((['"])(getBy|locator\()/i.test(assertion.playwright)));
+  return hasBrokenLocatorWrapper || !hasCredentialEntry;
+}
+function defaultStepHuman(action, selector, value) {
+  if (action === "navigate") return `Navigate to ${value || "the page"}`;
+  if (action === "fill") return `Fill the field ${selector}`;
+  if (action === "click") return `Click ${selector}`;
+  if (action === "select") return `Select ${value} in ${selector}`;
+  if (action === "check") return `Check ${selector}`;
+  if (action === "keyboard") return `Press ${value}`;
+  return `Interact with ${selector}`;
+}
+function normalizePlaywrightAssertion(assertion) {
+  const repaired = scopeBareSelectorsInAssertion(unwrapWrappedSelectorAssertion(assertion.playwright));
+  if (repaired) return ensureStatement(repaired);
+  const built = buildPlaywrightAssertion(assertion);
+  if (built) return built;
+  return ensureStatement(assertion.playwright);
+}
+function unwrapWrappedSelectorAssertion(playwright) {
+  const trimmed = String(playwright ?? "").trim();
+  if (!trimmed) return "";
+  return trimmed.replace(
+    /page\.locator\((["'])(getBy(?:Role|Text|Label|Placeholder|TestId)\((?:\\.|(?!\1).)*?\)|locator\((?:\\.|(?!\1).)*?\))\1\)/g,
+    "page.$2"
+  );
+}
+function scopeBareSelectorsInAssertion(playwright) {
+  const trimmed = String(playwright ?? "").trim();
+  if (!trimmed) return "";
+  return trimmed.replace(
+    /\bexpect\((getByRole|getByText|getByLabel|getByPlaceholder|getByTestId|locator)\(/g,
+    "expect(page.$1("
+  );
+}
+function buildPlaywrightAssertion(assertion) {
+  if (assertion.selector === "page") {
+    if (assertion.type === "url" && assertion.expected) {
+      return `await expect(page).toHaveURL(${JSON.stringify(assertion.expected)});`;
+    }
+    return "";
+  }
+  const target = selectorTarget(assertion.selector);
+  if (!target) return "";
+  if (assertion.type === "value" && assertion.expected) {
+    return `await expect(${target}).toHaveValue(${JSON.stringify(assertion.expected)});`;
+  }
+  const combined = `${assertion.expected} ${assertion.human} ${assertion.playwright}`.toLowerCase();
+  if (/hidden|not visible|no longer visible|disappear/.test(combined)) {
+    return `await expect(${target}).not.toBeVisible();`;
+  }
+  return `await expect(${target}).toBeVisible();`;
+}
+function selectorTarget(selector) {
+  const trimmed = String(selector ?? "").trim();
+  if (!trimmed || trimmed === "page") return "page";
+  if (trimmed.startsWith("page.")) return trimmed;
+  return `page.${trimmed}`;
+}
+function visibleAssertion(selector) {
+  return `await expect(${selectorTarget(selector)}).toBeVisible();`;
+}
+function valueAssertion(selector, value) {
+  return `await expect(${selectorTarget(selector)}).toHaveValue(${JSON.stringify(value)});`;
+}
+function inferAuthValue(element, kind) {
+  if (kind === "password") return "Secret123!";
+  const haystack = `${element.name ?? ""} ${String(element.attributes.label ?? "")} ${String(element.attributes.name ?? "")}`.toLowerCase();
+  if (/email/.test(haystack)) return "user@example.com";
+  return "testuser";
+}
+function ensureStatement(value) {
+  const trimmed = String(value ?? "").trim();
+  if (!trimmed) return "";
+  return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
+}
+function ensureNavigateStep(steps, url) {
+  if (!url || steps.length === 0) return steps;
+  if (steps.some((step) => step.action === "navigate")) return steps;
+  return [
+    {
+      action: "navigate",
+      selector: "page",
+      value: url,
+      human: `Navigate to ${url}`
+    },
+    ...steps
+  ];
+}
 function log(verbose, message) {
   if (verbose) console.log(message);
 }
 
+// src/core/playwright.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname2, join as join3, resolve as resolve3 } from "path";
+import { createRequire } from "module";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
+var require2 = createRequire(import.meta.url);
+var moduleDir = dirname2(fileURLToPath2(import.meta.url));
+async function resolvePlaywrightChromium(cwd = process.cwd()) {
+  const searchRoots = buildSearchRoots(cwd);
+  for (const packageName of ["@playwright/test", "playwright-core"]) {
+    for (const searchRoot of searchRoots) {
+      const resolvedPath = resolveFromRoot(packageName, searchRoot);
+      if (!resolvedPath) continue;
+      const imported = await import(pathToFileURL(resolvedPath).href);
+      const chromium = imported.chromium ?? imported.default?.chromium;
+      if (chromium) {
+        return {
+          packageName,
+          resolvedPath,
+          searchRoot,
+          chromium
+        };
+      }
+    }
+  }
+  throw new Error(
+    "Playwright runtime not found in this project.\nTry:\n  npm install\n  npx playwright install chromium"
+  );
+}
+function buildSearchRoots(cwd) {
+  const roots = [resolve3(cwd)];
+  const projectRoot = findNearestProjectRoot(cwd);
+  if (projectRoot && projectRoot !== roots[0]) {
+    roots.push(projectRoot);
+  }
+  roots.push(moduleDir);
+  return Array.from(new Set(roots));
+}
+function findNearestProjectRoot(startDir) {
+  let currentDir = resolve3(startDir);
+  while (true) {
+    if (existsSync2(join3(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    const parentDir = dirname2(currentDir);
+    if (parentDir === currentDir) return void 0;
+    currentDir = parentDir;
+  }
+}
+function resolveFromRoot(packageName, searchRoot) {
+  try {
+    return require2.resolve(packageName, { paths: [searchRoot] });
+  } catch {
+    return void 0;
+  }
+}
+
 // src/core/capture.ts
 var SETTLE_MS = 1200;
 var DEFAULT_TIMEOUT_MS = 3e4;
 var MAX_PER_CATEGORY = 50;
+var CaptureRuntimeError = class extends Error {
+  constructor(code, message, options) {
+    super(message);
+    this.name = "CaptureRuntimeError";
+    this.code = code;
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
 async function captureElements(url, options = {}) {
   const {
     headless = true,
     timeoutMs = DEFAULT_TIMEOUT_MS,
     verbose = false,
-    userAgent = "Mozilla/5.0 (compatible; CementicTest/0.2.5 capture)"
+    userAgent = "Mozilla/5.0 (compatible; CementicTest/0.2.7 capture)"
   } = options;
   const chromium = await loadChromium();
   const mode = headless ? "headless" : "headed";
   log2(verbose, `
 [capture] Starting ${mode} capture: ${url}`);
-  const browser = await chromium.launch({
-    headless,
-    slowMo: headless ? 0 : 150
-  });
+  let browser;
+  try {
+    browser = await chromium.launch({
+      headless,
+      slowMo: headless ? 0 : 150
+    });
+  } catch (error) {
+    throw classifyCaptureError(error);
+  }
   const context = await browser.newContext({
     userAgent,
     viewport: { width: 1280, height: 800 },
@@ -967,10 +1372,18 @@ async function captureElements(url, options = {}) {
   const page = await context.newPage();
   try {
     log2(verbose, `  -> Navigating (timeout: ${timeoutMs}ms)`);
-    await page.goto(url, {
-      waitUntil: "domcontentloaded",
-      timeout: timeoutMs
-    });
+    try {
+      await page.goto(url, {
+        waitUntil: "domcontentloaded",
+        timeout: timeoutMs
+      });
+    } catch (error) {
+      throw new CaptureRuntimeError(
+        "PAGE_LOAD_FAILED",
+        `Page load failed for ${url}. ${error?.message ?? error}`,
+        { cause: error }
+      );
+    }
     log2(verbose, `  -> Waiting ${SETTLE_MS}ms for page settle`);
     await page.waitForTimeout(SETTLE_MS);
     log2(verbose, "  -> Extracting accessibility snapshot");
@@ -999,8 +1412,10 @@ async function captureElements(url, options = {}) {
     };
     log2(verbose, `  -> Captured ${elements.length} testable elements from "${title}"`);
     return result;
+  } catch (error) {
+    throw classifyCaptureError(error);
   } finally {
-    await browser.close();
+    await browser?.close();
   }
 }
 function toPageSummary(elementMap) {
@@ -1024,16 +1439,15 @@ function toPageSummary(elementMap) {
 }
 async function loadChromium() {
   try {
-    return (await import("playwright-core")).chromium;
-  } catch {
-  }
-  try {
-    return (await import("@playwright/test")).chromium;
-  } catch {
+    const resolution = await resolvePlaywrightChromium(process.cwd());
+    return resolution.chromium;
+  } catch (error) {
+    throw new CaptureRuntimeError(
+      "PLAYWRIGHT_NOT_FOUND",
+      error?.message ?? "Playwright runtime not found in this project.\nTry:\n  npm install\n  npx playwright install chromium",
+      { cause: error }
+    );
   }
-  throw new Error(
-    'Playwright is required for live page capture. Install it in the target project with "npm install -D @playwright/test" and "npx playwright install chromium".'
-  );
 }
 function extractDomData() {
   const localMaxPerCategory = 50;
@@ -1353,10 +1767,71 @@ async function getAccessibilitySnapshot(page, verbose) {
 function asString(value) {
   return typeof value === "string" ? value : void 0;
 }
+function formatCaptureFailure(error) {
+  const resolved = classifyCaptureError(error);
+  if (resolved.code === "PLAYWRIGHT_NOT_FOUND") {
+    return [
+      "Playwright not resolvable.",
+      "Playwright runtime not found in this project.",
+      "Try:",
+      "  npm install",
+      "  npx playwright install chromium"
+    ];
+  }
+  if (resolved.code === "BROWSER_NOT_INSTALLED") {
+    return [
+      "Browser not installed.",
+      "Playwright resolved, but Chromium is not installed for this project.",
+      "Try:",
+      "  npx playwright install chromium"
+    ];
+  }
+  if (resolved.code === "PAGE_LOAD_FAILED") {
+    return [
+      "Page load failed.",
+      resolved.message
+    ];
+  }
+  return [
+    "Capture failed.",
+    resolved.message
+  ];
+}
+function classifyCaptureError(error) {
+  if (error instanceof CaptureRuntimeError) {
+    return error;
+  }
+  const message = errorMessage(error);
+  if (isBrowserInstallError(message)) {
+    return new CaptureRuntimeError(
+      "BROWSER_NOT_INSTALLED",
+      "Playwright resolved, but Chromium is not installed for this project.",
+      { cause: error }
+    );
+  }
+  if (isPlaywrightNotFoundError(message)) {
+    return new CaptureRuntimeError(
+      "PLAYWRIGHT_NOT_FOUND",
+      "Playwright runtime not found in this project.",
+      { cause: error }
+    );
+  }
+  return new CaptureRuntimeError("CAPTURE_FAILED", message || "Unknown capture failure.", { cause: error });
+}
+function isBrowserInstallError(message) {
+  return /Executable doesn't exist|browserType\.launch: Executable doesn't exist|Please run the following command|playwright install/i.test(message);
+}
+function isPlaywrightNotFoundError(message) {
+  return /Playwright runtime not found|Cannot find package ['"](?:@playwright\/test|playwright-core)['"]/i.test(message);
+}
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error ?? "");
+}
 
 // src/core/report.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 function printCaptureReport(elementMap, analysis) {
   console.log("");
   console.log("=".repeat(60));
@@ -1388,10 +1863,10 @@ function printCaptureReport(elementMap, analysis) {
 function saveCaptureJson(elementMap, analysis, outputDir = ".cementic/capture") {
   mkdirSync3(outputDir, { recursive: true });
   const fileName = `capture-${slugify(elementMap.url)}-${Date.now()}.json`;
-  const filePath = join3(outputDir, fileName);
+  const filePath = join4(outputDir, fileName);
   writeFileSync3(filePath, JSON.stringify({
     _meta: {
-      version: "0.2.5",
+      version: "0.2.7",
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       tool: "@cementic/cementic-test"
     },
@@ -1430,7 +1905,7 @@ function buildCasesMarkdown(analysis) {
 function saveCasesMarkdown(analysis, outputDir = "cases", fileName) {
   mkdirSync3(outputDir, { recursive: true });
   const resolvedFileName = fileName ?? `${slugify(analysis.feature || analysis.url)}.md`;
-  const filePath = join3(outputDir, resolvedFileName);
+  const filePath = join4(outputDir, resolvedFileName);
   writeFileSync3(filePath, buildCasesMarkdown(analysis));
   return filePath;
 }
@@ -1438,7 +1913,7 @@ function saveSpecPreview(analysis, outputDir = "tests/preview") {
   if (analysis.scenarios.length === 0) return null;
   mkdirSync3(outputDir, { recursive: true });
   const fileName = `spec-preview-${slugify(analysis.url)}-${Date.now()}.spec.cjs`;
-  const filePath = join3(outputDir, fileName);
+  const filePath = join4(outputDir, fileName);
   const lines = [];
   lines.push("/**");
   lines.push(" * CementicTest Capture Preview");
@@ -1465,7 +1940,7 @@ function saveSpecPreview(analysis, outputDir = "tests/preview") {
       if (step.action === "hover") lines.push(`  await ${selector}.hover();`);
     }
     for (const assertion of scenario.assertions) {
-      lines.push(`  ${ensureStatement(assertion.playwright)}`);
+      lines.push(`  ${ensureStatement2(assertion.playwright)}`);
     }
     lines.push("});");
     lines.push("");
@@ -1484,7 +1959,7 @@ function normalizeTag2(value) {
 function sanitizeComment(value) {
   return String(value ?? "").replace(/-->/g, "-- >");
 }
-function ensureStatement(value) {
+function ensureStatement2(value) {
   const trimmed = String(value ?? "").trim();
   if (!trimmed) return "// TODO: add assertion";
   return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
@@ -1562,10 +2037,10 @@ async function runTcInteractive(params) {
   });
   mkdirSync4("cases", { recursive: true });
   const fileName = `${prefix.toLowerCase()}-${slugify2(feature)}.md`;
-  const fullPath = join4("cases", fileName);
+  const fullPath = join5("cases", fileName);
   let markdown;
+  let pageSummary = void 0;
   if (params.useAi) {
-    let pageSummary = void 0;
     if (url) {
       try {
         console.log(`\u{1F50D} Capturing page: ${url}`);
@@ -1576,6 +2051,7 @@ async function runTcInteractive(params) {
         printCaptureReport(elementMap);
         const jsonPath = saveCaptureJson(elementMap);
         console.log(`\u{1F4C4} Saved capture JSON \u2192 ${jsonPath}`);
+        pageSummary = toPageSummary(elementMap);
         if (params.captureOnly) {
           console.log("Capture-only mode requested. No test cases were generated.");
           return;
@@ -1594,20 +2070,14 @@ async function runTcInteractive(params) {
         console.log("  ct test");
         return;
       } catch (e) {
-        console.warn(`\u26A0\uFE0F  Capture flow failed (${e?.message ?? e}). Falling back to the legacy AI case writer.`);
+        printWarningBlock(formatCaptureFailure(e));
+        console.warn("\u26A0\uFE0F Falling back to AI text generation without capture context.");
         if (params.captureOnly) {
           return;
         }
       }
     }
     try {
-      if (pageSummary === void 0 && url) {
-        const elementMap = await captureElements(url, {
-          headless: true,
-          verbose: false
-        });
-        pageSummary = toPageSummary(elementMap);
-      }
       markdown = await generateTcMarkdownWithAi({
         appDescription: appDescription || void 0,
         feature,
@@ -1620,7 +2090,10 @@ async function runTcInteractive(params) {
       markdown = injectUrlMetadata(markdown, url);
       console.log("\u2705 AI generated test cases.");
     } catch (err) {
-      console.warn(`\u26A0\uFE0F  AI generation failed (${err?.message ?? err}). Falling back to manual templates.`);
+      printWarningBlock([
+        "AI generation failed.",
+        err?.message ?? String(err)
+      ]);
       markdown = buildManualCasesMarkdown({ prefix, feature, url, numCases, startIndex: 1 });
       console.log("\u{1F4DD} Generated manual test case templates instead.");
     }
@@ -1635,6 +2108,13 @@ async function runTcInteractive(params) {
   console.log("  ct normalize ./cases --and-gen --lang ts");
   console.log("  ct test");
 }
+function printWarningBlock(lines) {
+  if (lines.length === 0) return;
+  console.warn(`\u26A0\uFE0F ${lines[0]}`);
+  for (const line of lines.slice(1)) {
+    console.warn(line);
+  }
+}
 function addSharedOptions(cmd) {
   return cmd.option("--ai", "Use AI to generate test cases (requires API key)").option("--prefix <prefix>", "Explicit ID prefix, e.g. AUTH, DASH, CART").option("--feature <name>", "Feature name \u2014 skips interactive prompt").option("--desc <text>", "App description \u2014 skips interactive prompt").option("--count <n>", "Number of cases (1\u201310)", parseInt);
 }
@@ -1711,15 +2191,15 @@ function reportCmd() {
 // src/commands/serve.ts
 import { Command as Command6 } from "commander";
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { join as join6 } from "path";
 function serveCmd() {
   const cmd = new Command6("serve").description("Serve the Allure report").action(() => {
     console.log("\u{1F4CA} Serving Allure report...");
-    const localAllureBin = join5(process.cwd(), "node_modules", "allure-commandline", "bin", "allure");
+    const localAllureBin = join6(process.cwd(), "node_modules", "allure-commandline", "bin", "allure");
     let executable = "npx";
     let args = ["allure", "serve", "./allure-results"];
-    if (existsSync2(localAllureBin)) {
+    if (existsSync3(localAllureBin)) {
       executable = "node";
       args = [localAllureBin, "serve", "./allure-results"];
     }
@@ -1742,9 +2222,9 @@ function serveCmd() {
 // src/commands/flow.ts
 import { Command as Command7 } from "commander";
 import { spawn as spawn4 } from "child_process";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 function runStep(cmd, args, stepName) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     console.log(`
 \u{1F30A} Flow Step: ${stepName}`);
     console.log(`> ${cmd} ${args.join(" ")}`);
@@ -1754,7 +2234,7 @@ function runStep(cmd, args, stepName) {
     });
     child.on("exit", (code) => {
       if (code === 0) {
-        resolve4();
+        resolve5();
       } else {
         reject(new Error(`${stepName} failed with exit code ${code}`));
       }
@@ -1763,7 +2243,7 @@ function runStep(cmd, args, stepName) {
 }
 function flowCmd() {
   const cmd = new Command7("flow").description("End-to-end flow: Normalize -> Generate -> Run Tests").argument("[casesDir]", "Directory containing test cases", "./cases").option("--lang <lang>", "Target language (ts|js)", "ts").option("--no-run", "Skip running tests").action(async (casesDir, opts) => {
-    const cliBin = resolve3(process.argv[1]);
+    const cliBin = resolve4(process.argv[1]);
     try {
       await runStep(process.execPath, [cliBin, "normalize", casesDir], "Normalize Cases");
       await runStep(process.execPath, [cliBin, "gen", "--lang", opts.lang], "Generate Tests");
@@ -1784,8 +2264,8 @@ function flowCmd() {
 
 // src/commands/ci.ts
 import { Command as Command8 } from "commander";
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, existsSync as existsSync3 } from "fs";
-import { join as join6 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, existsSync as existsSync4 } from "fs";
+import { join as join7 } from "path";
 var WORKFLOW_CONTENT = `name: Playwright Tests
 on:
   push:
@@ -1816,15 +2296,15 @@ jobs:
 `;
 function ciCmd() {
   const cmd = new Command8("ci").description("Generate GitHub Actions workflow for CI").action(() => {
-    const githubDir = join6(process.cwd(), ".github");
-    const workflowsDir = join6(githubDir, "workflows");
-    const workflowFile = join6(workflowsDir, "cementic.yml");
+    const githubDir = join7(process.cwd(), ".github");
+    const workflowsDir = join7(githubDir, "workflows");
+    const workflowFile = join7(workflowsDir, "cementic.yml");
     console.log("\u{1F916} Setting up CI/CD workflow...");
-    if (!existsSync3(workflowsDir)) {
+    if (!existsSync4(workflowsDir)) {
       mkdirSync5(workflowsDir, { recursive: true });
       console.log(`Created directory: ${workflowsDir}`);
     }
-    if (existsSync3(workflowFile)) {
+    if (existsSync4(workflowFile)) {
       console.warn(`\u26A0\uFE0F  Workflow file already exists at ${workflowFile}. Skipping.`);
       return;
     }
@@ -1838,8 +2318,8 @@ function ciCmd() {
 }
 
 // src/cli.ts
-var require2 = createRequire(import.meta.url);
-var { version } = require2("../package.json");
+var require3 = createRequire2(import.meta.url);
+var { version } = require3("../package.json");
 var program = new Command9();
 program.name("ct").description("CementicTest CLI: cases \u2192 normalized \u2192 POM tests \u2192 Playwright").version(version);
 program.addCommand(newCmd());