@zibby/core 0.1.48 → 0.2.0

package/dist/templates/browser-test-automation/README.md

@@ -0,0 +1,136 @@
+# Browser Test Automation Workflow
+
+This is YOUR workflow graph. You can customize it however you want!
+
+Works with **Claude** or **Cursor** agents (configured in `.zibby.config.mjs`).
+
+## Default Flow
+
+```
+preflight → execute_live → generate_script
+```
+
+The workflow generates a test title, executes the test live in a **browser** with AI assistance, and generates a Playwright script with stable selectors.
+
+## Customization
+
+### Add Custom Nodes
+
+Create a new file in `nodes/`:
+
+```javascript
+// nodes/send-slack.js
+export const sendSlackNode = {
+  name: 'send_slack',
+  agent: { type: 'openai', model: 'gpt-4o-mini' },
+  prompt: (state) => `Send Slack notification...`,
+  outputSchema: { success: { type: 'boolean', required: true } }
+};
+```
+
+Then add it to your graph in `graph.js`:
+
+```javascript
+import { sendSlackNode } from './nodes/send-slack.js';
+
+buildGraph() {
+  const graph = new WorkflowGraph();
+  // ... existing nodes
+  graph.addNode('send_slack', sendSlackNode);
+  graph.addEdge('verify_script', 'send_slack');
+  return graph;
+}
+```
+
+### Multi-Agent Configuration
+
+Each node can use a different LLM:
+
+```javascript
+graph.addNode('generate_title', {
+  agent: { type: 'claude', model: 'claude-sonnet-4' },
+  prompt: (state) => `Generate title...`
+});
+
+graph.addNode('verify_script', {
+  agent: { type: 'deepseek', model: 'deepseek-coder' }, // Cheap & fast
+  prompt: (state) => `Run test...`
+});
+
+graph.addNode('update_jira', {
+  agent: { type: 'ollama', model: 'llama3' }, // Local for privacy
+  prompt: (state) => `Update Jira...`
+});
+```
+
+### Skip Nodes
+
+Comment out nodes you don't need:
+
+```javascript
+// graph.addNode('verify_script', verifyScriptNode);
+graph.addEdge('generate_script', 'update_jira'); // Skip verification
+```
+
+### Parallel Execution
+
+Run multiple nodes in parallel:
+
+```javascript
+graph.addParallelEdges('verify_script', [
+  'send_slack',
+  'update_jira',
+  'log_datadog'
+]);
+```
+
+## Configuration
+
+Edit `.zibby.config.mjs` to set your default agent and optional per-node model overrides:
+
+```javascript
+export default {
+  agent: {
+    cursor: { model: 'auto' }, // or claude: { model: 'auto' }
+    strictMode: false,
+  },
+  models: {
+    default: 'auto',
+    execute_live: 'auto',
+    generate_script: 'auto',
+  },
+};
+```
+
+## Studio / Scripts tab (code discovery)
+
+Runs write `generate_script/result.json` with a `scriptPath` (often under your repo `tests/`). After the graph finishes, **`BrowserTestResultHandler.ensureStudioCodegenMirror`** copies that file into the session folder under stable names so tools don’t need Studio running at generation time:
+
+| File (under `.zibby/output/sessions/<sessionId>/generate_script/`) | Role |
+|---------------------------------------------------------------------|------|
+| `generated-test.spec.js` | Playwright (`.js`) |
+| `playwright.spec.ts` | Playwright (`.ts` / `.tsx` source) |
+| `test.selenium.py` | Selenium |
+
+**Electron Studio** resolves these via `discoverCodegenArtifactsElectron` (after `session/codegen/`).
+
+**Web Studio** (`VITE_STUDIO_API_ORIGIN`, e.g. `:3847`) should implement `GET /api/sessions/:id/codegen/playwright` (and `/selenium`) by reading, in order:
+
+1. `sessions/<id>/codegen/` legacy JIT names (`test.spec.ts`, `generated-test.spec.js`, …)
+2. **`sessions/<id>/generate_script/`** canonical names above
+3. `scriptPath` from `generate_script/result.json` (resolve relative to session / `cwd` from session meta)
+
+## Documentation
+
+- [Full Graph Framework Design](../../docs/GRAPH_FRAMEWORK_DESIGN.md)
+- [Multi-Agent Patterns](../../docs/FRAMEWORK_CONVERSATION_SUMMARY.md)
+
+## Updates
+
+To get latest template updates:
+
+```bash
+zibby update-graph --merge
+```
+
+This will merge bug fixes while preserving your customizations.

package/dist/templates/browser-test-automation/chat.mjs

@@ -0,0 +1,36 @@
+/**
+ * Zibby Chat Agent
+ *
+ * Interactive conversational node that acts as the default entry point
+ * when users type `zibby` with no subcommand.
+ *
+ * This is a plain chat bot — no MCP servers, no middleware, no structured output.
+ * Just streamed text conversation with the AI agent.
+ *
+ * The skill-installer skill injects its promptFragment so the LLM knows which
+ * skills are available and can install/uninstall them via natural conversation.
+ * Users can customize this file after `zibby init` copies it to .zibby/chat.mjs
+ */
+
+import { SKILLS } from '@zibby/core';
+
+export const CHAT_CONFIG = {
+  name: 'zibby_chat',
+  skills: [SKILLS.CORE_TOOLS, SKILLS.SKILL_INSTALLER, SKILLS.CHAT_MEMORY, SKILLS.WORKFLOW_BUILDER],
+  timeout: 0,
+
+  systemPrompt: `You are Zibby, a helpful AI assistant. Capabilities come from installed skills.
+
+## How you work
+1. When you need data, call tools. You can chain up to 5 calls per turn.
+2. After each tool result, decide: "Would I be embarrassed to give this answer to a coworker?" If yes, call another tool.
+3. Only respond once you have something genuinely useful.
+4. Never claim you did something without actually calling the tool.
+5. After EVERY response, self-evaluate: is the user's goal fully achieved? Is anything still pending or running? If yes, DO NOT ASK — autonomously poll: call wait (you decide how long), then check status, then respond with an update. Repeat until done or the user interrupts.
+
+## How you talk
+- Talk like a teammate in Slack, not a report generator.
+- Summarize and paraphrase. Never copy-paste field values or list raw steps verbatim.
+- Short paragraphs, not numbered lists (unless the user specifically asks for steps).
+- Match the user's tone and energy. Be concise.`,
+};

package/dist/templates/browser-test-automation/graph.mjs

@@ -0,0 +1,54 @@
+/**
+ * Test Automation Workflow Graph
+ * 
+ * buildGraph() - define nodes, edges, routing
+ * onComplete(result) - post-processing after graph finishes (save artifacts, etc.)
+ */
+
+import { WorkflowAgent, WorkflowGraph } from '@zibby/core';
+import { 
+  preflightNode, 
+  executeLiveNode, 
+  generateScriptNode,
+} from './nodes/index.mjs';
+import { BrowserTestResultHandler } from './result-handler.mjs';
+
+export class BrowserTestAutomationAgent extends WorkflowAgent {
+  buildGraph() {
+    const graph = new WorkflowGraph();
+
+    graph.addNode('preflight', preflightNode);
+    graph.addNode('execute_live', executeLiveNode);
+    graph.addNode('generate_script', generateScriptNode);
+            
+    graph.setEntryPoint('preflight');
+    graph.addEdge('preflight', 'execute_live');
+    
+    graph.addConditionalEdges('execute_live', (state) => {
+      const result = state.execute_live;
+      const hasExecution = (result?.steps?.length > 0) || (result?.actions?.length > 0);
+      return hasExecution ? 'generate_script' : 'END';
+    });
+    
+    graph.addEdge('generate_script', 'END');
+    return graph;
+  }
+
+  async onComplete(result) {
+    const cwd = result.state.cwd || process.cwd();
+    BrowserTestResultHandler.saveTitle(result, cwd);
+    await BrowserTestResultHandler.saveExecutionData(result);
+    BrowserTestResultHandler.ensureStudioCodegenMirror(
+      result.state?.sessionPath,
+      result.state?.cwd || cwd,
+    );
+
+    // Memory end-run hook (if @zibby/memory is installed)
+    try {
+      const { memoryEndRun, memorySyncPush } = await import('@zibby/memory');
+      const sessionId = result.state.sessionPath?.split('/').pop();
+      memoryEndRun(cwd, { sessionId, passed: result.success !== false });
+      memorySyncPush(cwd);
+    } catch { /* @zibby/memory not available */ }
+  }
+}

package/dist/templates/browser-test-automation/nodes/execute-live.mjs

@@ -0,0 +1,222 @@
+/**
+ * Execute Live Node
+ * 
+ * Purpose: Execute test in live browser using MCP Playwright tools
+ * 
+ * Configuration:
+ * - capabilities: Declares ['browser'] — framework injects the appropriate MCP server
+ * - outputSchema: Structured JSON with execution results, actions, assertions
+ * - Model: Configured in .zibby.config.mjs → agent.claude.model or agent.cursor.model
+ */
+
+import { z, SKILLS } from '@zibby/core';
+import { formatAssertionChecklist } from './utils.mjs';
+
+export const executeLiveNode = {
+  name: 'execute_live',
+  skills: [SKILLS.BROWSER, SKILLS.MEMORY],
+  timeout: 600000,
+
+  prompt: (state) => {
+    const ctx = state.context;
+    const contextInfo = ctx ? `
+Domain Knowledge & Environment:
+${ctx.global || ''}
+${ctx.pathBased ? `Test-Specific Info:\n${ctx.pathBased}\n` : ''}
+${ctx.env ? `Environment Config:\n${JSON.stringify(ctx.env, null, 2)}\n` : ''}
+---
+` : '';
+
+    const assertionChecklist = formatAssertionChecklist(state.preflight?.assertions);
+    
+    return `⚠️  CRITICAL: At the END, output ONLY the JSON object. NO explanations after the JSON.
+
+🎯 YOUR GOAL: Execute the test steps and collect evidence for script generation.
+   You don't need perfect verification - just capture the key actions and results.
+   The next node will generate the actual test script from your execution.
+
+${contextInfo}
+${state.testSpec}
+${assertionChecklist ? `
+═══════════════════════════════════════════════════
+🎯 ASSERTION CHECKLIST (MANDATORY - from test spec)
+You MUST include ALL of these in your 'assertions' array.
+Report each as passed: true or passed: false with evidence.
+DO NOT skip any. DO NOT add extras.
+
+${assertionChecklist}
+═══════════════════════════════════════════════════
+` : ''}
+⚠️  CRITICAL RULES (STRICT ENFORCEMENT):
+1. DO NOT get stuck in read loops - if a snapshot is large, move on
+2. DO NOT over-analyze - just execute the steps
+3. **As soon as you complete the test → IMMEDIATELY return JSON**
+4. **NO screenshots required** - just execute and return JSON
+5. **If test is done, STOP - don't try to be perfect**
+6. **USE VALUES FROM THE TEST SPEC** - if the spec provides specific values, use them exactly. Do NOT replace them with random data.
+7. **USE UNIQUE DATA ONLY when CREATING new resources** (e.g., sign-up forms, new accounts) to avoid "already taken" conflicts:
+   - For NEW emails (not provided in test spec): use random digits like "test84729@example.com"
+   - For NEW names (not provided in test spec): append random digits like "John84729"
+   - This does NOT apply to login credentials or test data explicitly provided in the spec
+
+WHEN TO STOP (MANDATORY):
+✓ You've completed the test steps
+✓ Test outcome is visible (even briefly)
+→ **RETURN JSON IMMEDIATELY - DO NOT make any more tool calls**
+
+DO NOT:
+- Navigate to the same URL multiple times
+- Use browser_run_code or browser_evaluate
+- Read large snapshots repeatedly (max 2 snapshots per page)
+- Take screenshots (optional, skip if slowing you down)
+- Try to verify every single detail - focus on the MAIN outcome
+- Click/scroll/interact after seeing the expected result
+- Spend more than 2 minutes on any single page
+- Try to click elements that aren't immediately visible
+
+EXECUTION SEQUENCE (MANDATORY - FOLLOW STRICTLY):
+1. Execute the test steps efficiently (navigate, fill, click)
+   - Max 10-15 actions total
+   - If stuck, move on to next step
+2. Quick verification - check if main result is visible
+   - **If you see expected result → IMMEDIATELY return JSON**
+   - Don't try to make it perfect - good enough is enough
+3. **RETURN JSON AND STOP COMPLETELY**
+   - Format: { "success": true, "steps": ["step 1", ...], "browserClosed": true, "actions": [...] }
+   - MUST include: "success" (boolean), "steps" (array), "browserClosed" (boolean)
+   - Keep JSON CONCISE - short descriptions, no excessive detail
+   - After the closing brace }, DO NOT write ANYTHING
+   - NO commentary, NO explanations, NO additional text
+   - NO second JSON object
+   - Just the JSON, then STOP
+
+IMPORTANT for 'actions' array (STRICT 1:1 MAPPING):
+- Each entry MUST match EXACTLY ONE browser tool call.
+- DO NOT group multiple tool calls into one action.
+- DO NOT combine multiple 'fill' calls into one action.
+- If you call browser_type 3 times for 3 fields, you MUST have 3 actions in the array.
+- Include actual values/URLs in descriptions.
+- Keep descriptions SHORT (5-10 words max).
+
+IMPORTANT for 'assertions' array (USE THE CHECKLIST ABOVE):
+- Your assertions array MUST match the ASSERTION CHECKLIST exactly - one entry per item
+- If you verified it and it passed → "passed": true
+- If you could NOT verify it or it wasn't found → "passed": false with evidence of what you saw instead
+- Each assertion MUST include 'verifiedAfterAction' (0-based action index after which you checked)
+- Format: {"description": "...", "passed": true/false, "verifiedAfterAction": N, "evidence": "..."}
+
+🔍 CRITICAL: CAPTURE ROBUST SELECTORS (for script generation)
+For EACH action, capture multiple selector strategies in priority order:
+
+1. **Role + Name** (Most Robust - Accessibility-first):
+   - Role: button/textbox/link/etc
+   - Name: visible text or aria-label
+   Example: {"role": "button", "name": "Login"}
+
+2. **Stable Attributes** (Good Stability):
+   - name, type, placeholder, aria-label
+   Example: {"attributes": {"name": "username", "type": "text", "placeholder": "Enter username"}}
+
+3. **Partial Match** (For Dynamic Elements):
+   - Use starts-with for dynamic IDs/classes
+   Example: {"partialMatch": {"id": "^user-", "class": "^btn-"}}
+
+4. **Structural** (Fallback):
+   - Tag + position relative to stable landmark
+   Example: {"structure": "form input[type='text']:nth-of-type(1)"}
+
+Format for actions with selectors:
+{
+  "description": "Fill username field with 'joe'",
+  "reasoning": "Need to authenticate user",
+  "type": "fill",
+  "selectors": {
+    "role": {"role": "textbox", "name": "Username"},
+    "attributes": {"name": "username", "type": "text", "placeholder": "请输入账号"},
+    "structure": "form input[type='text']:first-of-type"
+  },
+  "value": "joe"
+}
+
+IMPORTANT for 'evidenceScreenshots' (array) - OPTIONAL:
+- Screenshots are OPTIONAL - only take if helpful
+- If you take screenshots, use descriptive filenames
+- Filename pattern: "{step-number}-{action-or-state}.png"
+- Keep it minimal - test execution is more important than documentation
+`;
+  },
+  
+  outputSchema: z.object({
+    success: z.boolean()
+      .describe('Whether the test execution completed successfully'),
+    
+    steps: z.array(z.string())
+      .describe('Array of test steps executed'),
+    
+    finalUrl: z.string()
+      .nullish()
+      .describe('Final URL after test execution'),
+    
+    actions: z.array(z.object({
+      type: z.string()
+        .describe('Action type: navigate, click, fill, type, select, keypress, hover, drag'),
+      description: z.string()
+        .describe('Human-readable description of the action'),
+      reasoning: z.string().nullish()
+        .describe('Why this action was performed'),
+      selectors: z.object({
+        role: z.object({
+          role: z.string().describe('ARIA role (e.g. button, link, textbox, generic)'),
+          name: z.string().nullish().describe('Accessible name of the element')
+        }).nullish().describe('Role-based selector for fallback matching')
+      }).nullish()
+        .describe('Element selectors captured during the action'),
+      value: z.string().nullish()
+        .describe('Value entered for fill/type actions')
+    }))
+      .nullish()
+      .describe('Detailed array of actions performed with descriptions and reasoning'),
+    
+    assertions: z.array(z.object({
+      description: z.string()
+        .describe('What was verified'),
+      passed: z.boolean()
+        .describe('Whether the assertion passed'),
+      verifiedAfterAction: z.number()
+        .describe('Index of the action after which this was verified (0-based, matches actions array index) - REQUIRED'),
+      evidence: z.string()
+        .nullish()
+        .describe('Brief evidence of what was observed')
+    }))
+      .nullish()
+      .describe('Array of assertions made during test'),
+    
+    waits: z.array(z.object({
+      description: z.string().describe('What the wait is for'),
+      duration: z.number().nullish().describe('Wait duration in milliseconds'),
+      condition: z.string().nullish().describe('Wait condition expression')
+    }))
+      .nullish()
+      .describe('Array of waits needed for proper test execution'),
+    
+    evidenceScreenshots: z.array(z.object({
+      filename: z.string()
+        .describe('Descriptive filename pattern: {step-number}-{action-or-state}.png'),
+      
+      description: z.string()
+        .describe('What the screenshot shows and why it is evidence'),
+      
+      verdict: z.enum(['pass', 'fail', 'info'])
+        .describe('Test verdict: pass/fail for validation points, info for checkpoints')
+    }))
+      .nullish()
+      .describe('Array of screenshots taken at key validation points throughout the test'),
+    
+    browserClosed: z.boolean()
+      .describe('Whether the browser was properly closed (should always be true)'),
+    
+    notes: z.string()
+      .nullish()
+      .describe('Additional notes or observations. REQUIRED when success=false to explain why test failed or could not execute')
+  })
+};

package/dist/templates/browser-test-automation/nodes/generate-script.mjs

@@ -0,0 +1,97 @@
+import { z, SKILLS } from '@zibby/core';
+import { formatRecordedActions, formatAssertionsWithResults, loadRecordedActions, detectLoginPattern, formatSetupHint } from './utils.mjs';
+
+const GenerateScriptOutputSchema = z.object({
+  success: z.boolean(),
+  scriptPath: z.string(),
+  method: z.string()
+});
+
+export const generateScriptNode = {
+  name: 'generate_script',
+  skills: [SKILLS.MEMORY],
+  outputSchema: GenerateScriptOutputSchema,
+  timeout: 1200000,
+
+  prompt: (state) => {
+    const exec = state.execute_live || {};
+    const preflight = state.preflight || {};
+
+    const actionsBlock = formatRecordedActions(state.sessionPath, exec.actions);
+    const assertionsBlock = formatAssertionsWithResults(
+      preflight.assertions,
+      exec.assertions,
+      exec.notes,
+      exec.finalUrl
+    );
+
+    const recorded = loadRecordedActions(state.sessionPath);
+    const setupHint = formatSetupHint(detectLoginPattern(recorded));
+
+    return `Generate and verify Playwright test at ${state.outputPath}
+
+Test Spec:
+${state.testSpec}
+
+Live Execution Summary:
+- Success: ${exec.success}
+- Steps: ${JSON.stringify(exec.steps)}
+- Final URL: ${exec.finalUrl || 'unknown'}
+${actionsBlock}
+${assertionsBlock}
+${setupHint}
+IMPORTS AND PATTERN:
+\`\`\`javascript
+import { test, expect } from '@playwright/test';
+import { StableIdRuntime } from '@zibby/core';
+
+async function clickSafe(page, stableId, fallback) {
+  try { await StableIdRuntime.clickWithRetry(page, stableId); }
+  catch { await fallback.click(); }
+}
+
+test('Test Name', async ({ page }) => {
+  await page.goto('https://...');
+  await StableIdRuntime.injectStableIds(page);
+  // Elements WITH stable IDs + fallback — use clickSafe:
+  await clickSafe(page, 'zibby-xxxxx', page.getByRole('button', { name: '...' }));
+  await StableIdRuntime.fillWithRetry(page, 'zibby-xxxxx', 'value');
+  // Elements WITHOUT stable IDs (NO_STABLE_ID) — use native Playwright selectors:
+  await page.getByText('visible text').click();
+  await page.getByRole('button', { name: 'Submit' }).click();
+  await page.getByPlaceholder('placeholder text').fill('value');
+  await expect(page).toHaveURL(/expected-url/);
+});
+\`\`\`
+
+RULES:
+1. First navigate → page.goto(), skip subsequent navigates
+2. After goto, call StableIdRuntime.injectStableIds(page)
+3. Selector priority:
+   a. If memory/insights flag a stableId as unreliable → use the fallback selector instead
+   b. If action is marked [DUPLICATE_STABLE_ID] → always use the provided fallback
+   c. Cross-reference stableIds against memory "Reliable Selectors" and "Flaky Selectors" — prefer proven selectors, avoid flaky ones
+   d. Otherwise use EXACT stable IDs from recorded actions
+4. For [NO_STABLE_ID] actions, use the fallback selector (getByText, getByRole, getByPlaceholder)
+5. Skip duplicate consecutive clicks on same stableId
+6. No comments in generated code
+7. Implement ALL assertions from the list above
+8. If an assertion fails after retries, comment it out with a TODO (don't delete it)
+9. Selector failure handling:
+   - When a stableId fails and you switch to a fallback, IMMEDIATELY call memory_save_insight (category: selector_tip) with which stableId failed, which fallback worked, and the page URL
+   - Note the specific Playwright locator strategy that succeeded
+10. Navigation order: always complete setup/login FIRST from the base URL, then navigate to the target page. Never go to a deep URL before setup is done.
+11. The generated test runs in a FRESH browser with no prior state. Even if the live execution skipped setup steps, the test must include them. Check memory insights for any required setup.
+
+WORKFLOW:
+1. Study the codebase FIRST — search tests/ for existing helpers, fixtures, and shared setup files. Read them. Reuse what exists. Do NOT create files that duplicate existing ones.
+2. Write test to ${state.outputPath} (after the run, a copy is mirrored under ${state.sessionPath}/generate_script/ for Studio — you may also write directly there if you prefer)
+3. Verify syntax: run node --check on the file. If it fails, fix and re-check before proceeding.
+4. Run: PLAYWRIGHT_HEADLESS=1 npx playwright test ${state.outputPath} --reporter=line --timeout=60000
+5. If fails: try selectors in order — (a) getByRole (b) getByText (c) getByTestId (d) add waitForSelector. Never retry the same selector twice.
+6. MAX 2 ATTEMPTS then STOP
+
+The test runs in: ${state.cwd || 'project root'}
+`;
+  },
+};

package/dist/templates/browser-test-automation/nodes/index.mjs

@@ -0,0 +1,3 @@
+export { preflightNode } from './preflight.mjs';
+export { executeLiveNode } from './execute-live.mjs';
+export { generateScriptNode } from './generate-script.mjs';

package/dist/templates/browser-test-automation/nodes/preflight.mjs

@@ -0,0 +1,59 @@
+/**
+ * Preflight Node
+ * 
+ * Pattern: Prompt-only node (no tools)
+ * Purpose: Analyze test spec and extract title + structured assertion checklist
+ * 
+ * This runs before execution to define:
+ * - A concise test title
+ * - The complete list of assertions that must be verified
+ * 
+ * Downstream nodes receive this as their contract:
+ * - execute_live: must report passed/failed for each assertion
+ * - generate_script: must implement each assertion in the test
+ */
+
+import { z } from '@zibby/core';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+
+const AssertionSchema = z.object({
+  description: z.string().describe('What to verify (e.g., "User is redirected to dashboard")'),
+  expected: z.string().describe('What the expected outcome looks like (e.g., "URL contains /dashboard")')
+});
+
+const PreflightOutputSchema = z.object({
+  title: z.string().describe('Concise test title (5-10 words, action-oriented). Prefix with ticket ID if found.'),
+  assertions: z.array(AssertionSchema).describe('Every expected result from the spec as a verifiable assertion')
+});
+
+export const preflightNode = {
+  name: 'preflight',
+
+  async onComplete(state, result) {
+    const sessionPath = state.sessionPath || process.env.ZIBBY_SESSION_PATH;
+    if (sessionPath && result.title) {
+      try {
+        writeFileSync(join(sessionPath, 'title.txt'), result.title, 'utf-8');
+        console.log(`Saved title: "${result.title}"`);
+      } catch (error) {
+        console.warn(`⚠️  Could not save title.txt: ${error.message}`);
+      }
+    }
+    return result;
+  },
+
+  prompt: (state) => `Analyze this test specification and extract:
+1. A concise test title (5-10 words, action-oriented). If you find a ticket ID (e.g., PROJ-123, ACME-456), prefix the title with it.
+2. Every expected result as a verifiable assertion. Each assertion must be something the browser can check after execution.
+
+Test Spec:
+${state.testSpec}
+
+IMPORTANT: You MUST create ONE assertion for EACH expected result in the spec. Do NOT skip any.
+
+Return ONLY this JSON:
+{ "title": "TICKET-ID: Short action title", "assertions": [ { "description": "...", "expected": "..." }, ... ] }`,
+
+  outputSchema: PreflightOutputSchema
+};