Voyager

questions:
  - question: "Please select an E2E test framework. Which one would you like to use?"
    header: "Framework"
    options:
      - label: "Playwright (Recommended)"
        description: "Fast, stable, cross-browser support, auto-waiting"
      - label: "Cypress"
        description: "Great DX, real-time reload, rich plugin ecosystem"
      - label: "Use existing framework"
        description: "Continue with framework already in use"
    multiSelect: false

questions:
  - question: "Please select critical paths to cover with E2E tests."
    header: "Test Target"
    options:
      - label: "Authentication flow (Recommended)"
        description: "Signup, login, password reset"
      - label: "Core features"
        description: "Main value-delivering features of the app"
      - label: "Payment/checkout flow"
        description: "Cart, checkout, payment"
      - label: "All of the above"
        description: "Cover all critical paths"
    multiSelect: true

questions:
  - question: "A flaky test has been detected. How would you like to handle it?"
    header: "Flaky Test"
    options:
      - label: "Improve wait strategy (Recommended)"
        description: "Add appropriate waitFor to stabilize"
      - label: "Add retry configuration"
        description: "Set up retry as a temporary workaround"
      - label: "Split the test"
        description: "Break test into smaller parts to isolate issue"
    multiSelect: false

// playwright.config.ts
import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  testDir: './e2e',
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 4 : undefined,
  reporter: [
    ['html', { outputFolder: 'playwright-report' }],
    ['json', { outputFile: 'test-results.json' }],
    process.env.CI ? ['github'] : ['list'],
  ],
  use: {
    baseURL: process.env.BASE_URL || 'http://localhost:3000',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
    video: 'on-first-retry',
  },
  projects: [
    // Setup project for authentication
    { name: 'setup', testMatch: /.*\.setup\.ts/ },

    // Desktop browsers
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] },
      dependencies: ['setup'],
    },
    {
      name: 'firefox',
      use: { ...devices['Desktop Firefox'] },
      dependencies: ['setup'],
    },
    {
      name: 'webkit',
      use: { ...devices['Desktop Safari'] },
      dependencies: ['setup'],
    },

    // Mobile browsers
    {
      name: 'mobile-chrome',
      use: { ...devices['Pixel 5'] },
      dependencies: ['setup'],
    },
    {
      name: 'mobile-safari',
      use: { ...devices['iPhone 12'] },
      dependencies: ['setup'],
    },
  ],
  webServer: {
    command: 'npm run dev',
    url: 'http://localhost:3000',
    reuseExistingServer: !process.env.CI,
  },
});

e2e/
├── fixtures/
│   ├── test-data.ts        # テストデータファクトリ
│   └── index.ts            # カスタムフィクスチャ
├── pages/
│   ├── base.page.ts        # ベースページクラス
│   ├── login.page.ts       # ログインページ
│   ├── home.page.ts        # ホームページ
│   └── checkout.page.ts    # チェックアウトページ
├── tests/
│   ├── auth/
│   │   ├── login.spec.ts
│   │   └── signup.spec.ts
│   ├── checkout/
│   │   └── purchase.spec.ts
│   └── smoke.spec.ts       # スモークテスト
├── utils/
│   ├── api-helpers.ts      # APIヘルパー
│   └── test-helpers.ts     # テストヘルパー
├── auth.setup.ts           # 認証セットアップ
└── global-setup.ts         # グローバルセットアップ

// e2e/pages/base.page.ts
import { Page, Locator, expect } from '@playwright/test';

export abstract class BasePage {
  readonly page: Page;

  constructor(page: Page) {
    this.page = page;
  }

  // Common navigation
  async goto(path: string = '') {
    await this.page.goto(path);
  }

  // Wait for page to be ready
  async waitForPageLoad() {
    await this.page.waitForLoadState('networkidle');
  }

  // Common assertions
  async expectToBeVisible(locator: Locator) {
    await expect(locator).toBeVisible();
  }

  // Screenshot for debugging
  async takeScreenshot(name: string) {
    await this.page.screenshot({ path: `.evidence/${name}.png`, fullPage: true });
  }

  // Get element by test ID (recommended)
  getByTestId(testId: string): Locator {
    return this.page.getByTestId(testId);
  }
}

// e2e/pages/login.page.ts
import { Page, Locator, expect } from '@playwright/test';
import { BasePage } from './base.page';

export class LoginPage extends BasePage {
  // Locators
  readonly emailInput: Locator;
  readonly passwordInput: Locator;
  readonly submitButton: Locator;
  readonly errorMessage: Locator;
  readonly forgotPasswordLink: Locator;

  constructor(page: Page) {
    super(page);
    this.emailInput = this.getByTestId('email-input');
    this.passwordInput = this.getByTestId('password-input');
    this.submitButton = this.getByTestId('login-submit');
    this.errorMessage = this.getByTestId('login-error');
    this.forgotPasswordLink = page.getByRole('link', { name: 'パスワードを忘れた' });
  }

  async goto() {
    await super.goto('/login');
  }

  // Actions
  async login(email: string, password: string) {
    await this.emailInput.fill(email);
    await this.passwordInput.fill(password);
    await this.submitButton.click();
  }

  async loginAndWaitForRedirect(email: string, password: string) {
    await this.login(email, password);
    await this.page.waitForURL('**/dashboard');
  }

  // Assertions
  async expectErrorMessage(message: string) {
    await expect(this.errorMessage).toContainText(message);
  }

  async expectLoginSuccess() {
    await expect(this.page).toHaveURL(/.*dashboard/);
  }
}

// e2e/pages/components/header.component.ts
import { Page, Locator } from '@playwright/test';

export class HeaderComponent {
  readonly page: Page;
  readonly userMenu: Locator;
  readonly logoutButton: Locator;
  readonly notificationBell: Locator;

  constructor(page: Page) {
    this.page = page;
    this.userMenu = page.getByTestId('user-menu');
    this.logoutButton = page.getByTestId('logout-button');
    this.notificationBell = page.getByTestId('notification-bell');
  }

  async logout() {
    await this.userMenu.click();
    await this.logoutButton.click();
    await this.page.waitForURL('**/login');
  }

  async openNotifications() {
    await this.notificationBell.click();
  }
}

// e2e/auth.setup.ts
import { test as setup, expect } from '@playwright/test';
import path from 'path';

const authFile = path.join(__dirname, '.auth/user.json');

setup('authenticate', async ({ page }) => {
  // Navigate to login
  await page.goto('/login');

  // Perform login
  await page.getByTestId('email-input').fill(process.env.TEST_USER_EMAIL!);
  await page.getByTestId('password-input').fill(process.env.TEST_USER_PASSWORD!);
  await page.getByTestId('login-submit').click();

  // Wait for successful login
  await page.waitForURL('**/dashboard');

  // Verify logged in state
  await expect(page.getByTestId('user-menu')).toBeVisible();

  // Save storage state
  await page.context().storageState({ path: authFile });
});

// e2e/tests/dashboard.spec.ts
import { test, expect } from '@playwright/test';

// This test uses the authenticated state from setup
test.describe('Dashboard', () => {
  test('shows user information', async ({ page }) => {
    await page.goto('/dashboard');
    await expect(page.getByTestId('user-name')).toBeVisible();
  });
});

// e2e/fixtures/index.ts
import { test as base, Page } from '@playwright/test';
import { LoginPage } from '../pages/login.page';

type TestFixtures = {
  adminPage: Page;
  userPage: Page;
};

export const test = base.extend<TestFixtures>({
  adminPage: async ({ browser }, use) => {
    const context = await browser.newContext({
      storageState: '.auth/admin.json',
    });
    const page = await context.newPage();
    await use(page);
    await context.close();
  },
  userPage: async ({ browser }, use) => {
    const context = await browser.newContext({
      storageState: '.auth/user.json',
    });
    const page = await context.newPage();
    await use(page);
    await context.close();
  },
});

// e2e/utils/api-helpers.ts
import { APIRequestContext } from '@playwright/test';

export class ApiHelpers {
  constructor(private request: APIRequestContext) {}

  async createUser(data: { email: string; name: string }) {
    const response = await this.request.post('/api/users', { data });
    return response.json();
  }

  async createProduct(data: { name: string; price: number }) {
    const response = await this.request.post('/api/products', { data });
    return response.json();
  }

  async deleteUser(userId: string) {
    await this.request.delete(`/api/users/${userId}`);
  }

  async resetDatabase() {
    await this.request.post('/api/test/reset');
  }
}

// e2e/fixtures/test-data.ts
import { faker } from '@faker-js/faker/locale/ja';

export const TestData = {
  user: {
    valid: () => ({
      email: faker.internet.email(),
      password: 'Test1234!',
      name: faker.person.fullName(),
    }),
    invalid: {
      email: 'invalid-email',
      password: '123', // too short
    },
  },
  product: {
    create: () => ({
      name: faker.commerce.productName(),
      price: faker.number.int({ min: 100, max: 10000 }),
      description: faker.commerce.productDescription(),
    }),
  },
  address: {
    japan: () => ({
      postalCode: faker.location.zipCode('###-####'),
      prefecture: faker.location.state(),
      city: faker.location.city(),
      street: faker.location.streetAddress(),
    }),
  },
};

// e2e/tests/checkout/purchase.spec.ts
import { test, expect } from '@playwright/test';
import { ApiHelpers } from '../../utils/api-helpers';
import { TestData } from '../../fixtures/test-data';

test.describe('Checkout Flow', () => {
  let productId: string;
  let api: ApiHelpers;

  test.beforeAll(async ({ request }) => {
    api = new ApiHelpers(request);
    // Create test product via API
    const product = await api.createProduct(TestData.product.create());
    productId = product.id;
  });

  test.afterAll(async () => {
    // Cleanup via API
    await api.deleteProduct(productId);
  });

  test('user can purchase a product', async ({ page }) => {
    await page.goto(`/products/${productId}`);
    await page.getByTestId('add-to-cart').click();
    await page.goto('/cart');
    await page.getByTestId('checkout-button').click();
    // ... continue checkout flow
  });
});

// ✅ GOOD: Wait for specific conditions
// Wait for element to be visible
await expect(page.getByTestId('result')).toBeVisible();

// Wait for element to contain text
await expect(page.getByTestId('status')).toContainText('Complete');

// Wait for URL change
await page.waitForURL('**/confirmation');

// Wait for network to be idle
await page.waitForLoadState('networkidle');

// Wait for specific request
await page.waitForResponse(resp =>
  resp.url().includes('/api/orders') && resp.status() === 200
);

// Wait for element to be enabled
await expect(page.getByTestId('submit')).toBeEnabled();

// ❌ BAD: Arbitrary timeout
await page.waitForTimeout(2000);

// ❌ BAD: Fixed delay before action
await new Promise(r => setTimeout(r, 1000));
await page.click('button');

// e2e/utils/wait-helpers.ts
import { Page, expect } from '@playwright/test';

export async function waitForToast(page: Page, message: string) {
  const toast = page.getByRole('alert');
  await expect(toast).toContainText(message);
  await expect(toast).toBeHidden({ timeout: 5000 }); // Wait for dismiss
}

export async function waitForTableLoad(page: Page, testId: string) {
  const table = page.getByTestId(testId);
  await expect(table.getByRole('row')).toHaveCount.greaterThan(0);
  await expect(table.getByTestId('loading-spinner')).toBeHidden();
}

export async function waitForModalClose(page: Page) {
  await expect(page.getByRole('dialog')).toBeHidden();
}

// playwright.config.ts
export default defineConfig({
  // Fully parallel execution
  fullyParallel: true,

  // Worker configuration
  workers: process.env.CI ? 4 : undefined,

  // Shard configuration (for distributed CI)
  // Run with: npx playwright test --shard=1/4
});

# .github/workflows/e2e.yml
jobs:
  e2e:
    strategy:
      matrix:
        shard: [1, 2, 3, 4]
    steps:
      - name: Run E2E tests
        run: npx playwright test --shard=${{ matrix.shard }}/4

// ✅ GOOD: Tests are independent
test.describe('User Management', () => {
  test('can create user', async ({ page, request }) => {
    // Create unique data for this test
    const user = TestData.user.valid();
    // ... test
    // Cleanup in afterEach or use unique identifiers
  });

  test('can delete user', async ({ page, request }) => {
    // Create own test data, don't depend on previous test
    const api = new ApiHelpers(request);
    const user = await api.createUser(TestData.user.valid());
    // ... test deletion
  });
});

# .github/workflows/e2e.yml
name: E2E Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  e2e:
    runs-on: ubuntu-latest
    timeout-minutes: 30

    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Install Playwright browsers
        run: npx playwright install --with-deps

      - name: Build application
        run: npm run build

      - name: Run E2E tests
        run: npx playwright test
        env:
          BASE_URL: http://localhost:3000
          TEST_USER_EMAIL: ${{ secrets.TEST_USER_EMAIL }}
          TEST_USER_PASSWORD: ${{ secrets.TEST_USER_PASSWORD }}

      - name: Upload test results
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: playwright-report
          path: playwright-report/
          retention-days: 30

      - name: Upload test videos
        uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: test-videos
          path: test-results/
          retention-days: 7

# .github/workflows/e2e-sharded.yml
name: E2E Tests (Sharded)

on:
  push:
    branches: [main]

jobs:
  e2e:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        shard: [1, 2, 3, 4]

    steps:
      - uses: actions/checkout@v4

      - name: Setup & Install
        # ... same as above

      - name: Run E2E tests (shard ${{ matrix.shard }}/4)
        run: npx playwright test --shard=${{ matrix.shard }}/4

      - name: Upload shard report
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: playwright-report-${{ matrix.shard }}
          path: playwright-report/

  merge-reports:
    needs: e2e
    runs-on: ubuntu-latest
    steps:
      - name: Download all reports
        uses: actions/download-artifact@v4
        with:
          pattern: playwright-report-*
          merge-multiple: true
          path: all-reports

      - name: Merge reports
        run: npx playwright merge-reports --reporter=html all-reports

// playwright.config.ts
export default defineConfig({
  use: {
    // Video recording options
    video: 'on-first-retry',      // Record only on retry (recommended for CI)
    // video: 'on',               // Always record
    // video: 'off',              // Never record
    // video: 'retain-on-failure', // Keep only failed test videos

    // Video size options
    video: {
      mode: 'on-first-retry',
      size: { width: 1280, height: 720 }, // 720p recommended
    },
  },

  // Output directory for videos
  outputDir: 'test-results/',
});

// Force video for specific test
test('critical checkout flow', async ({ page }) => {
  test.info().annotations.push({ type: 'video', description: 'required' });
  // ... test code
});

// Override video mode for test file
test.use({ video: 'on' });

test.describe('Visual Flow Tests', () => {
  test('user signup journey', async ({ page }) => {
    // This test will always be recorded
  });
});

test.afterEach(async ({ page }, testInfo) => {
  // Attach video to test report (Playwright handles automatically)
  // For custom handling:
  if (testInfo.status !== 'passed') {
    const video = page.video();
    if (video) {
      const path = await video.path();
      console.log(`Test failed. Video: ${path}`);

      // Custom attachment
      await testInfo.attach('failure-video', {
        path: path,
        contentType: 'video/webm',
      });
    }
  }
});

// For fine-grained control over recording
test('with CDP recording', async ({ page }) => {
  const client = await page.context().newCDPSession(page);

  // Start screencast for frame-by-frame control
  await client.send('Page.startScreencast', {
    format: 'jpeg',
    quality: 80,
    everyNthFrame: 1,
  });

  const frames: string[] = [];
  client.on('Page.screencastFrame', async (event) => {
    frames.push(event.data);
    await client.send('Page.screencastFrameAck', {
      sessionId: event.sessionId,
    });
  });

  // Perform test actions
  await page.goto('/');
  await page.click('[data-testid="start"]');

  // Stop recording
  await client.send('Page.stopScreencast');

  // Process frames (e.g., create GIF for specific moments)
  console.log(`Captured ${frames.length} frames`);
});

// Browser-level recording for performance analysis
test('performance with recording', async ({ browser }) => {
  const context = await browser.newContext({
    recordVideo: {
      dir: 'test-results/videos/',
      size: { width: 1920, height: 1080 }, // Full HD for detail
    },
  });

  const page = await context.newPage();
  const client = await context.newCDPSession(page);

  // Enable performance domain
  await client.send('Performance.enable');

  // Start trace for detailed analysis
  await client.send('Tracing.start', {
    categories: ['devtools.timeline', 'blink.user_timing'],
  });

  await page.goto('/heavy-page');

  // Stop and collect
  const traceEvents: any[] = [];
  client.on('Tracing.dataCollected', (event) => {
    traceEvents.push(...event.value);
  });
  await client.send('Tracing.end');

  await context.close(); // Finalize video
});

# .github/workflows/e2e.yml
- name: Upload test videos
  uses: actions/upload-artifact@v4
  if: failure()  # Only on failure
  with:
    name: test-videos
    path: test-results/**/*.webm
    retention-days: 7

# For all videos (debugging phase)
- name: Upload all videos
  uses: actions/upload-artifact@v4
  if: always()
  with:
    name: test-videos-all
    path: test-results/**/*.webm
    retention-days: 3

// Record multiple runs to identify flakiness
// npx playwright test --repeat-each=5 flaky.spec.ts

test.describe('Flaky Investigation', () => {
  // Force video recording for all attempts
  test.use({ video: 'on' });

  test('intermittent failure test', async ({ page }, testInfo) => {
    // Log attempt number
    console.log(`Attempt: ${testInfo.retry + 1}`);

    await page.goto('/');

    // Add visual markers in video
    await page.evaluate((attempt) => {
      const marker = document.createElement('div');
      marker.style.cssText = 'position:fixed;top:0;left:0;background:red;color:white;padding:10px;z-index:99999';
      marker.textContent = `Attempt ${attempt}`;
      document.body.appendChild(marker);
    }, testInfo.retry + 1);

    // Test code...
  });
});

// playwright.config.ts
export default defineConfig({
  expect: {
    toHaveScreenshot: {
      maxDiffPixels: 100,           // Allow small differences
      threshold: 0.2,               // Pixel comparison threshold
      animations: 'disabled',       // Disable animations for consistency
    },
  },
  updateSnapshots: process.env.UPDATE_SNAPSHOTS ? 'all' : 'missing',
});

// e2e/tests/visual/homepage.spec.ts
import { test, expect } from '@playwright/test';

test.describe('Visual Regression', () => {
  test('homepage matches snapshot', async ({ page }) => {
    await page.goto('/');
    await page.waitForLoadState('networkidle');

    // Full page screenshot
    await expect(page).toHaveScreenshot('homepage.png', {
      fullPage: true,
    });
  });

  test('login form matches snapshot', async ({ page }) => {
    await page.goto('/login');

    // Element screenshot
    const form = page.getByTestId('login-form');
    await expect(form).toHaveScreenshot('login-form.png');
  });

  test('responsive: mobile view', async ({ page }) => {
    await page.setViewportSize({ width: 375, height: 667 });
    await page.goto('/');

    await expect(page).toHaveScreenshot('homepage-mobile.png');
  });
});

# Update all snapshots
npx playwright test --update-snapshots

# Update specific test snapshots
npx playwright test visual/homepage.spec.ts --update-snapshots

// playwright.config.ts
export default defineConfig({
  // Retry failed tests in CI
  retries: process.env.CI ? 2 : 0,

  // Per-test retry
  use: {
    // Trace on first retry for debugging
    trace: 'on-first-retry',
  },
});

// Run test multiple times to detect flakiness
// npx playwright test --repeat-each=10 tests/checkout.spec.ts

test.describe('Flaky Investigation', () => {
  // Add trace for debugging
  test.use({ trace: 'on' });

  test('potentially flaky test', async ({ page }) => {
    // Add verbose logging
    page.on('console', msg => console.log(msg.text()));

    // ... test code

    // Take screenshot at critical points
    await page.screenshot({ path: 'debug-1.png' });
  });
});

// playwright.config.ts
export default defineConfig({
  projects: [
    // CI: All browsers
    ...(process.env.CI ? [
      { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
      { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
      { name: 'webkit', use: { ...devices['Desktop Safari'] } },
    ] : [
      // Local: Chrome only for speed
      { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
    ]),
  ],
});

// e2e/tests/mobile/responsive.spec.ts
import { test, expect, devices } from '@playwright/test';

test.describe('Mobile', () => {
  test.use({ ...devices['iPhone 12'] });

  test('mobile navigation works', async ({ page }) => {
    await page.goto('/');
    // Mobile menu button should be visible
    await expect(page.getByTestId('mobile-menu')).toBeVisible();
    // Desktop nav should be hidden
    await expect(page.getByTestId('desktop-nav')).toBeHidden();
  });
});

// e2e/tests/with-mocks.spec.ts
import { test, expect } from '@playwright/test';

test.describe('With API Mocks', () => {
  test('handles API error gracefully', async ({ page }) => {
    // Mock API to return error
    await page.route('**/api/products', route =>
      route.fulfill({
        status: 500,
        body: JSON.stringify({ error: 'Server error' }),
      })
    );

    await page.goto('/products');
    await expect(page.getByTestId('error-message')).toContainText('エラーが発生しました');
  });

  test('shows empty state', async ({ page }) => {
    // Mock empty response
    await page.route('**/api/products', route =>
      route.fulfill({
        status: 200,
        body: JSON.stringify([]),
      })
    );

    await page.goto('/products');
    await expect(page.getByTestId('empty-state')).toBeVisible();
  });
});

test('modifies API response', async ({ page }) => {
  await page.route('**/api/user', async route => {
    const response = await route.fetch();
    const json = await response.json();

    // Modify response
    json.isPremium = true;

    await route.fulfill({ response, json });
  });

  await page.goto('/dashboard');
  await expect(page.getByTestId('premium-badge')).toBeVisible();
});

## Voyager → Lens Evidence Request

**Test Failure**: checkout.spec.ts > user can complete purchase
**Error**: Timeout waiting for confirmation page

**Request**:
- Capture failure screenshot
- Record test video
- Generate bug report with reproduction steps

**Artifacts Needed**:
- Final page state screenshot
- Network request log
- Console errors

## Voyager → Radar Coverage Gap

**E2E Finding**: Cart total calculation fails for items with quantity > 10
**Root Cause**: Missing edge case in calculateTotal function

**Request**:
- Add unit test for calculateTotal with large quantities
- Verify boundary conditions (0, 1, 10, 100)
- E2E test is too slow for this level of detail

## Voyager → Fixture Data Request

**E2E Scenario**: Multi-product checkout with various discounts

**Data Needed**:
- 5 products with different categories
- Discount codes (percentage, fixed amount, expired)
- User with saved payment methods

**Format**: API-ready JSON for test setup

## Voyager → Gear CI Request

**Requirement**: E2E tests in CI pipeline

**Needs**:
- Playwright browser installation
- Parallel execution (4 shards)
- Artifact storage (reports, videos)
- Slack notification on failure

## YYYY-MM-DD - [Title]
**Challenge**: [What made E2E difficult]
**Solution**: [How to handle it reliably]
**Impact**: [Which tests benefit]

| YYYY-MM-DD | Voyager | (action) | (files) | (outcome) |

_STEP_COMPLETE:
  Agent: Voyager
  Status: SUCCESS | PARTIAL | BLOCKED | FAILED
  Output: [Test files created / Config updated / CI integrated]
  Next: Lens | Radar | Gear | VERIFY | DONE

## NEXUS_HANDOFF
- Step: [X/Y]
- Agent: Voyager
- Summary: 1-3 lines
- Key findings / decisions:
  - Critical paths identified: [list]
  - Tests implemented: [count]
  - Flakiness status: [stable/needs-work]
- Artifacts (files/commands/links):
  - Test files: [paths]
  - Config: playwright.config.ts
  - CI workflow: .github/workflows/e2e.yml
- Risks / trade-offs:
  - [Flaky tests]
  - [CI execution time]
- Pending Confirmations:
  - Trigger: [INTERACTION_TRIGGER name if any]
  - Question: [Question for user]
  - Options: [Available options]
  - Recommended: [Recommended option]
- User Confirmations:
  - Q: [Previous question] → A: [User's answer]
- Open questions (blocking/non-blocking):
  - [Clarifications needed]
- Suggested next agent: Lens | Radar | Gear
- Next action: CONTINUE (Nexus automatically proceeds)