@bugzy-ai/bugzy 1.15.0 → 1.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bugzy-ai/bugzy",
-  "version": "1.15.0",
+  "version": "1.15.1",
   "description": "Open-source AI agent configuration for QA automation with Claude Code",
   "publishConfig": {
     "access": "public"

package/templates/init/.bugzy/runtime/handlers/messages/feedback.md

@@ -0,0 +1,178 @@
+# Feedback Message Handler
+
+Instructions for processing bug reports, test observations, and user feedback.
+
+## Detection Criteria
+
+This handler applies when:
+- User reports an issue, bug, or unexpected behavior
+- User shares test results or observations
+- User provides information (not asking a question or requesting action)
+- Keywords present: "found", "issue", "bug", "doesn't work", "broken", "observed", "noticed", "failed", "error"
+- Intent field from LLM layer is `feedback`
+- Re-routed from clarification handler (thread reply with no blocked task)
+
+## Processing Steps
+
+### Step 1: Parse Feedback
+
+Extract the following from the message:
+
+| Field | Description | Examples |
+|-------|-------------|----------|
+| **Type** | Category of feedback | `bug_report`, `test_result`, `observation`, `suggestion`, `general` |
+| **Severity** | Impact level | `critical`, `high`, `medium`, `low` |
+| **Component** | Affected area | "login", "checkout", "search", etc. |
+| **Description** | Core issue description | What happened |
+| **Expected** | What should happen (if stated) | Expected behavior |
+| **Steps** | How to reproduce (if provided) | Reproduction steps |
+
+**Type Detection**:
+- `bug_report`: "bug", "broken", "doesn't work", "error", "crash"
+- `test_result`: "test passed", "test failed", "ran tests", "testing showed"
+- `observation`: "noticed", "observed", "found that", "saw that"
+- `suggestion`: "should", "could we", "what if", "idea"
+- `general`: Default for unclassified feedback
+
+### Step 2: Check for Duplicates
+
+Search the knowledge base for similar entries:
+
+1. Read `.bugzy/runtime/knowledge-base.md`
+2. Search for:
+   - Same component + similar symptoms
+   - Matching keywords from the description
+   - Recent entries (last 30 days) with similar patterns
+3. If duplicate found:
+   - Reference the existing entry
+   - Note any new information provided
+   - Update existing entry if new details are valuable
+
+### Step 3: Update Knowledge Base
+
+Add or update entry in `.bugzy/runtime/knowledge-base.md`:
+
+**For Bug Reports**:
+```markdown
+### Bug Report: [Brief Description]
+**Reported**: [ISO date]
+**Source**: Slack - [username if available]
+**Component**: [component]
+**Severity**: [severity]
+**Status**: Under investigation
+
+**Description**: [full description]
+
+**Expected Behavior**: [if provided]
+
+**Steps to Reproduce**: [if provided]
+1. Step one
+2. Step two
+
+**Related**: [links to related issues/test cases if any]
+```
+
+**For Observations**:
+```markdown
+### Observation: [Brief Description]
+**Reported**: [ISO date]
+**Source**: Slack - [username if available]
+**Component**: [component]
+**Context**: [what was being done when observed]
+
+**Details**: [full observation]
+
+**Impact**: [potential impact on testing]
+```
+
+**For Test Results**:
+```markdown
+### Manual Test Result: [Test/Feature Name]
+**Reported**: [ISO date]
+**Source**: Slack - [username if available]
+**Result**: [passed/failed]
+**Component**: [component]
+
+**Details**: [what was tested, outcome]
+
+**Notes**: [any additional observations]
+```
+
+### Step 4: Determine Follow-up Actions
+
+Based on feedback type, consider additional actions:
+
+| Type | Potential Actions |
+|------|-------------------|
+| **bug_report (critical/high)** | Consider creating issue via issue-tracker if configured |
+| **bug_report (medium/low)** | Log in knowledge base, may inform future test cases |
+| **test_result** | Update relevant test case status if identifiable |
+| **observation** | May inform test plan updates |
+| **suggestion** | Log for future consideration |
+
+**Issue Tracker Integration** (if configured):
+- For critical/high severity bugs, check if issue-tracker agent is available
+- If so, create or link to an issue in the configured system
+- Reference the issue in the knowledge base entry
+
+### Step 5: Acknowledge and Confirm
+
+Respond to the user confirming:
+1. Feedback was received and understood
+2. Summary of what was captured
+3. What actions will be taken
+4. Any follow-up questions if needed
+
+## Response Guidelines
+
+**Structure**:
+```
+Thanks for reporting this. Here's what I've captured:
+
+[Summary of the feedback]
+
+I've logged this in the knowledge base under [category].
+[Any follow-up actions being taken]
+
+[Optional: Follow-up questions if clarification needed]
+```
+
+**Examples**:
+
+For bug report:
+```
+Thanks for reporting this. I've logged the following:
+
+Bug: Checkout fails when cart has more than 10 items
+- Severity: High
+- Component: Checkout
+- Status: Under investigation
+
+I've added this to the knowledge base. This may affect our checkout test coverage - I'll review TC-045 through TC-048 for related scenarios.
+
+Can you confirm which browser this occurred in?
+```
+
+For observation:
+```
+Good catch - I've noted this observation:
+
+The loading spinner on the dashboard takes longer than expected after the recent update.
+
+I've added this to the knowledge base under performance observations. This might be worth adding to our performance test suite.
+```
+
+## Context Loading Requirements
+
+Required:
+- [x] Knowledge base (`.bugzy/runtime/knowledge-base.md`) - for duplicate check and updates
+
+Conditional:
+- [ ] Test cases (`./test-cases/`) - if feedback relates to specific test
+- [ ] Test runs (`./test-runs/`) - if feedback relates to recent results
+
+## Memory Updates
+
+Required updates:
+- Knowledge base (`.bugzy/runtime/knowledge-base.md`) - add new entry or update existing
+- Optionally team communicator memory if tracking feedback sources

package/templates/init/.bugzy/runtime/handlers/messages/question.md

@@ -0,0 +1,122 @@
+# Question Message Handler
+
+Instructions for processing questions about the project, tests, coverage, or testing status.
+
+## Detection Criteria
+
+This handler applies when:
+- Message contains question words (what, how, which, where, why, when, do, does, is, are, can)
+- Question relates to tests, test plan, coverage, test results, or project artifacts
+- User is seeking information, NOT requesting an action
+- Intent field from LLM layer is `question`
+
+## Processing Steps
+
+### Step 1: Classify Question Type
+
+Analyze the question to determine the primary type:
+
+| Type | Indicators | Primary Context Sources |
+|------|------------|------------------------|
+| **Coverage** | "what tests", "do we have", "is there a test for", "covered" | test-cases/, test-plan.md |
+| **Results** | "did tests pass", "what failed", "test results", "how many" | test-runs/ |
+| **Knowledge** | "how does", "what is", "explain", feature/component questions | knowledge-base.md |
+| **Plan** | "what's in scope", "test plan", "testing strategy", "priorities" | test-plan.md |
+| **Process** | "how do I", "when should", "what's the workflow" | project-context.md |
+
+### Step 2: Load Relevant Context
+
+Based on question type, load the appropriate files:
+
+**For Coverage questions**:
+1. Read `test-plan.md` for overall test strategy
+2. List files in `./test-cases/` directory
+3. Search test case files for relevant keywords
+
+**For Results questions**:
+1. List directories in `./test-runs/` (sorted by date, newest first)
+2. Read `summary.json` from relevant test run directories
+3. Extract pass/fail counts, failure reasons
+
+**For Knowledge questions**:
+1. Read `.bugzy/runtime/knowledge-base.md`
+2. Search for relevant entries
+3. Also check test-plan.md for feature descriptions
+
+**For Plan questions**:
+1. Read `test-plan.md`
+2. Extract relevant sections (scope, priorities, features)
+
+**For Process questions**:
+1. Read `.bugzy/runtime/project-context.md`
+2. Check for workflow documentation
+
+### Step 3: Formulate Answer
+
+Compose the answer following these guidelines:
+
+1. **Be specific**: Quote relevant sections from source files
+2. **Cite sources**: Mention which files contain the information
+3. **Structure clearly**: Use bullet points for multiple items
+4. **Quantify when possible**: "We have 12 test cases covering login..."
+5. **Acknowledge gaps**: If information is incomplete, say so
+
+### Step 4: Offer Follow-up
+
+End responses with:
+- Offer to provide more detail if needed
+- Suggest related information that might be helpful
+- For coverage gaps, offer to create test cases
+
+## Response Guidelines
+
+**Structure**:
+```
+[Direct answer to the question]
+
+[Supporting details/evidence with file references]
+
+[Optional: Related information or follow-up offer]
+```
+
+**Examples**:
+
+For "Do we have tests for login?":
+```
+Yes, we have 4 test cases covering the login feature:
+- TC-001: Successful login with valid credentials
+- TC-002: Login failure with invalid password
+- TC-003: Login with remember me option
+- TC-004: Password reset flow
+
+These are documented in ./test-cases/TC-001.md through TC-004.md.
+Would you like details on any specific test case?
+```
+
+For "How many tests passed in the last run?":
+```
+The most recent test run (2024-01-15 14:30) results:
+- Total: 24 tests
+- Passed: 21 (87.5%)
+- Failed: 3
+
+Failed tests:
+- TC-012: Checkout timeout (performance issue)
+- TC-015: Image upload failed (file size validation)
+- TC-018: Search pagination broken
+
+Results are in ./test-runs/20240115-143000/summary.json
+```
+
+## Context Loading Requirements
+
+Required (based on question type):
+- [ ] Test plan (`test-plan.md`) - for coverage, plan, knowledge questions
+- [ ] Test cases (`./test-cases/`) - for coverage questions
+- [ ] Test runs (`./test-runs/`) - for results questions
+- [ ] Knowledge base (`.bugzy/runtime/knowledge-base.md`) - for knowledge questions
+- [ ] Project context (`.bugzy/runtime/project-context.md`) - for process questions
+
+## Memory Updates
+
+None required - questions are read-only operations. No state changes needed.

package/templates/init/.bugzy/runtime/handlers/messages/status.md

@@ -0,0 +1,146 @@
+# Status Message Handler
+
+Instructions for processing status requests about tests, tasks, or executions.
+
+## Detection Criteria
+
+This handler applies when:
+- User asks about progress or status
+- Keywords present: "status", "progress", "how is", "what happened", "results", "how did", "update on"
+- Questions about test runs, task completion, or execution state
+- Intent field from LLM layer is `status`
+
+## Processing Steps
+
+### Step 1: Identify Status Scope
+
+Determine what the user is asking about:
+
+| Scope | Indicators | Data Sources |
+|-------|------------|--------------|
+| **Latest test run** | "last run", "recent tests", "how did tests go" | Most recent test-runs/ directory |
+| **Specific test** | Test ID mentioned (TC-XXX), specific feature name | test-runs/*/TC-XXX/, test-cases/TC-XXX.md |
+| **All tests / Overall** | "overall", "all tests", "test coverage", "pass rate" | All test-runs/ summaries |
+| **Specific feature** | Feature name mentioned | Filter test-runs by feature |
+| **Task progress** | "is the task done", "what's happening with" | team-communicator memory |
+
+### Step 2: Gather Status Data
+
+**For Latest Test Run**:
+1. List directories in `./test-runs/` sorted by name (newest first)
+2. Read `summary.json` from the most recent directory
+3. Extract: total tests, passed, failed, skipped, execution time
+4. For failures, extract brief failure reasons
+
+**For Specific Test**:
+1. Find test case file in `./test-cases/TC-XXX.md`
+2. Search test-runs for directories containing this test ID
+3. Get most recent result for this specific test
+4. Include: last run date, result, failure reason if failed
+
+**For Overall Status**:
+1. Read all `summary.json` files in test-runs/
+2. Calculate aggregate statistics:
+   - Total runs in period (last 7 days, 30 days, etc.)
+   - Overall pass rate
+   - Most commonly failing tests
+   - Trend (improving/declining)
+
+**For Task Progress**:
+1. Read `.bugzy/runtime/memory/team-communicator.md`
+2. Check for active tasks, blocked tasks, recently completed tasks
+3. Extract relevant task status
+
+### Step 3: Format Status Report
+
+Present status clearly and concisely:
+
+**For Latest Test Run**:
+```
+Test Run: [YYYYMMDD-HHMMSS]
+Status: [Completed/In Progress]
+
+Results:
+- Total: [N] tests
+- Passed: [N] ([%])
+- Failed: [N] ([%])
+- Skipped: [N]
+
+[If failures exist:]
+Failed Tests:
+- [TC-XXX]: [Brief failure reason]
+- [TC-YYY]: [Brief failure reason]
+
+Duration: [X minutes]
+```
+
+**For Specific Test**:
+```
+Test: [TC-XXX] - [Test Name]
+
+Latest Result: [Passed/Failed]
+Run Date: [Date/Time]
+
+[If failed:]
+Failure Reason: [reason]
+Last Successful: [date if known]
+
+[If passed:]
+Consecutive Passes: [N] (since [date])
+```
+
+**For Overall Status**:
+```
+Test Suite Overview (Last [N] Days)
+
+Total Test Runs: [N]
+Average Pass Rate: [%]
+
+Trend: [Improving/Stable/Declining]
+
+Most Reliable Tests:
+- [TC-XXX]: [100%] pass rate
+- [TC-YYY]: [100%] pass rate
+
+Flaky/Failing Tests:
+- [TC-ZZZ]: [40%] pass rate - [common failure reason]
+- [TC-AAA]: [60%] pass rate - [common failure reason]
+
+Last Run: [date/time] - [X/Y passed]
+```
+
+### Step 4: Provide Context and Recommendations
+
+Based on the status:
+
+**For failing tests**:
+- Suggest reviewing the test case
+- Mention if this is a new failure or recurring
+- Link to relevant knowledge base entries if they exist
+
+**For overall declining trends**:
+- Highlight which tests are causing the decline
+- Suggest investigation areas
+
+**For good results**:
+- Acknowledge the healthy state
+- Mention any tests that were previously failing and are now passing
+
+## Response Guidelines
+
+- Lead with the most important information (pass/fail summary)
+- Use clear formatting (bullet points, percentages)
+- Include timestamps so users know data freshness
+- Offer to drill down into specifics if summary was given
+- Keep responses scannable - use structure over paragraphs
+
+## Context Loading Requirements
+
+Required (based on scope):
+- [ ] Test runs (`./test-runs/`) - for any test status
+- [ ] Test cases (`./test-cases/`) - for specific test details
+- [ ] Team communicator memory (`.bugzy/runtime/memory/team-communicator.md`) - for task status
+
+## Memory Updates
+
+None required - status checks are read-only operations. No state changes needed.

package/templates/init/.bugzy/runtime/templates/event-examples.md

@@ -0,0 +1,195 @@
+# Event Examples Template
+
+This template provides examples of different event formats that can be processed by the `/process-event` command. Use these as references when triggering events.
+
+## Natural Language Events
+
+### Test Failures
+```bash
+/process-event "Login test failed with timeout error on Chrome"
+/process-event "The checkout process is broken - users can't complete payment"
+/process-event "TC-001 failed: Element not found after waiting 10 seconds"
+```
+
+### Discoveries
+```bash
+/process-event "Found new admin panel at /admin that's not documented"
+/process-event "Discovered that users can bypass authentication by going directly to /dashboard"
+/process-event "New feature: dark mode toggle in settings menu"
+```
+
+### User Feedback
+```bash
+/process-event "Customer complaint: checkout process too complicated, abandoned cart"
+/process-event "Support ticket: users reporting slow page loads on mobile"
+/process-event "User suggestion: add keyboard shortcuts for common actions"
+```
+
+## Structured Events (Key-Value Pairs)
+
+### Test Event
+```bash
+/process-event --type test.failed --test-id TC-001 --error "Button not clickable" --browser Chrome
+/process-event --type test.passed --test-id TC-045 --duration 45s --previously-flaky true
+```
+
+### Bug Report
+```bash
+/process-event --type bug.found --component auth --severity high --title "Login bypass vulnerability"
+/process-event --type bug.fixed --bug-id BUG-123 --resolution "Updated validation logic"
+```
+
+### Feature Event
+```bash
+/process-event --type feature.added --name "Quick Actions" --location "dashboard" --documented false
+/process-event --type requirement.changed --feature "Password Policy" --change "Minimum 12 characters"
+```
+
+## JSON Format Events
+
+### Complex Test Failure
+```bash
+/process-event '{
+  "type": "test.failed",
+  "test_id": "TC-001",
+  "title": "Login with valid credentials",
+  "error": {
+    "message": "Element not found",
+    "selector": ".login-button",
+    "timeout": 10000
+  },
+  "environment": {
+    "browser": "Chrome 120",
+    "os": "macOS",
+    "viewport": "1920x1080"
+  },
+  "timestamp": "2025-01-25T10:30:00Z"
+}'
+```
+
+### User Feedback with Context
+```bash
+/process-event '{
+  "type": "user.feedback",
+  "source": "support",
+  "ticket_id": "SUP-456",
+  "user_type": "premium",
+  "issue": {
+    "area": "checkout",
+    "description": "Payment method not saving",
+    "impact": "Cannot complete purchase",
+    "frequency": "Always"
+  }
+}'
+```
+
+### Performance Issue
+```bash
+/process-event '{
+  "type": "performance.issue",
+  "page": "/dashboard",
+  "metrics": {
+    "load_time": 8500,
+    "time_to_interactive": 12000,
+    "largest_contentful_paint": 6500
+  },
+  "threshold_exceeded": true
+}'
+```
+
+## YAML-like Format
+
+### Simple Events
+```bash
+/process-event "type: test.failed, test: TC-001, browser: Firefox"
+/process-event "type: bug.found, severity: medium, component: search"
+/process-event "type: discovery, feature: API endpoint, path: /api/v2/users"
+```
+
+## Batch Events
+
+### Multiple Related Issues
+```bash
+/process-event "Multiple login failures today: TC-001, TC-002, TC-003 all failing with similar timeout errors. Seems to be a systematic issue with the authentication service."
+```
+
+### Exploratory Testing Results
+```bash
+/process-event "Exploratory testing session results: Found 3 UI inconsistencies, 1 broken link, new feature in settings, and performance degradation on search page"
+```
+
+## Event Chains
+
+Sometimes events are related and should reference each other:
+
+### Initial Event
+```bash
+/process-event --type deployment --version 2.1.0 --environment staging
+```
+
+### Follow-up Event
+```bash
+/process-event "After deployment 2.1.0: 5 tests failing that were passing before"
+```
+
+## Special Cases
+
+### Flaky Test Pattern
+```bash
+/process-event "TC-089 failed 3 times out of 10 runs - appears to be flaky"
+```
+
+### Environment-Specific
+```bash
+/process-event "All Safari tests failing but Chrome and Firefox pass"
+```
+
+### Data-Dependent
+```bash
+/process-event "Tests pass with test data but fail with production data"
+```
+
+## Tips for Event Creation
+
+1. **Be Specific**: Include test IDs, error messages, and environment details
+2. **Add Context**: Mention if issue is new, recurring, or related to recent changes
+3. **Include Impact**: Describe how the issue affects users or testing
+4. **Provide Evidence**: Include screenshots paths, logs, or session IDs if available
+5. **Link Related Items**: Reference bug IDs, test cases, or previous events
+
+## Common Patterns to Trigger
+
+### Trigger Learning Extraction
+```bash
+/process-event "Discovered that all form validations fail when browser language is not English"
+```
+
+### Trigger Test Plan Update
+```bash
+/process-event "New payment provider integrated - Stripe checkout now available"
+```
+
+### Trigger Test Case Creation
+```bash
+/process-event "Found undocumented admin features that need test coverage"
+```
+
+### Trigger Bug Report
+```bash
+/process-event "Critical: Users lose data when session expires during form submission"
+```
+
+## Event Metadata
+
+Events can include optional metadata:
+- `priority`: high, medium, low
+- `source`: automation, manual, support, monitoring
+- `session_id`: For tracking related events
+- `user`: Who reported or discovered
+- `environment`: staging, production, development
+- `tags`: Categories for filtering
+
+Example with metadata:
+```bash
+/process-event --type issue --priority high --source monitoring --environment production --message "Memory leak detected in checkout service"
+```

package/templates/init/.claude/settings.json

@@ -0,0 +1,28 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(jq:*)",
+      "mcp__notion__API-post-database-query",
+      "mcp__notion__API-retrieve-a-database",
+      "Bash(mkdir:*)",
+      "Bash(playwright-cli:*)",
+      "Bash(git grep:*)",
+      "mcp__slack__slack_list_channels",
+      "mcp__slack__slack_post_rich_message",
+      "Bash(git init:*)",
+      "Bash(git --no-pager status --porcelain)",
+      "Bash(git --no-pager diff --stat HEAD)",
+      "Bash(git --no-pager log --oneline -5)",
+      "Bash(git --no-pager status)",
+      "Bash(git --no-pager diff HEAD)"
+    ],
+    "deny": [
+      "Read(.env)"
+    ],
+    "ask": []
+  },
+  "enabledMcpjsonServers": [
+    "notion",
+    "slack"
+  ]
+}

package/templates/playwright/reporters/__tests__/bugzy-reporter-manifest-merge.test.ts

@@ -0,0 +1,329 @@
+import { test, expect } from '@playwright/test';
+import { mergeManifests } from '../bugzy-reporter';
+
+function makeExecution(overrides: Partial<{
+  number: number;
+  status: string;
+  duration: number;
+  videoFile: string | null;
+  hasTrace: boolean;
+  hasScreenshots: boolean;
+  error: string | null;
+}> = {}) {
+  return {
+    number: 1,
+    status: 'passed',
+    duration: 1000,
+    videoFile: 'video.webm',
+    hasTrace: false,
+    hasScreenshots: false,
+    error: null,
+    ...overrides,
+  };
+}
+
+function makeTestCase(id: string, executions: ReturnType<typeof makeExecution>[], finalStatus?: string) {
+  const lastExec = executions[executions.length - 1];
+  return {
+    id,
+    name: id.replace(/^TC-\d+-/, '').replace(/-/g, ' '),
+    totalExecutions: executions.length,
+    finalStatus: finalStatus ?? lastExec.status,
+    executions,
+  };
+}
+
+function makeManifest(overrides: Partial<{
+  bugzyExecutionId: string;
+  timestamp: string;
+  startTime: string;
+  endTime: string;
+  status: string;
+  stats: { totalTests: number; passed: number; failed: number; totalExecutions: number };
+  testCases: ReturnType<typeof makeTestCase>[];
+}> = {}) {
+  const testCases = overrides.testCases ?? [];
+  const totalExecutions = testCases.reduce((sum, tc) => sum + tc.executions.length, 0);
+  const passed = testCases.filter(tc => tc.finalStatus === 'passed').length;
+  const failed = testCases.length - passed;
+
+  return {
+    bugzyExecutionId: 'local-20260127-060129',
+    timestamp: '20260127-060129',
+    startTime: '2026-01-27T06:01:29.000Z',
+    endTime: '2026-01-27T06:02:00.000Z',
+    status: 'passed',
+    stats: {
+      totalTests: testCases.length,
+      passed,
+      failed,
+      totalExecutions,
+      ...overrides.stats,
+    },
+    ...overrides,
+    testCases,
+  };
+}
+
+test.describe('mergeManifests', () => {
+  test('returns current manifest unchanged when existing is null', () => {
+    const current = makeManifest({
+      testCases: [makeTestCase('TC-001-login', [makeExecution()])],
+    });
+
+    const result = mergeManifests(null, current);
+
+    expect(result).toEqual(current);
+  });
+
+  test('merges test cases from both manifests', () => {
+    const existing = makeManifest({
+      testCases: [
+        makeTestCase('TC-001-login', [makeExecution({ number: 1 })]),
+      ],
+    });
+
+    const current = makeManifest({
+      startTime: '2026-01-27T06:05:00.000Z',
+      endTime: '2026-01-27T06:06:00.000Z',
+      testCases: [
+        makeTestCase('TC-002-checkout', [makeExecution({ number: 1 })]),
+      ],
+    });
+
+    const result = mergeManifests(existing, current);
+
+    expect(result.testCases).toHaveLength(2);
+    expect(result.testCases.map(tc => tc.id)).toContain('TC-001-login');
+    expect(result.testCases.map(tc => tc.id)).toContain('TC-002-checkout');
+    expect(result.stats.totalTests).toBe(2);
+    expect(result.stats.totalExecutions).toBe(2);
+  });
+
+  test('merges executions for the same test case across runs', () => {
+    const existing = makeManifest({
+      testCases: [
+        makeTestCase('TC-001-login', [
+          makeExecution({ number: 1, status: 'failed', error: 'timeout' }),
+        ], 'failed'),
+      ],
+    });
+
+    const current = makeManifest({
+      startTime: '2026-01-27T06:05:00.000Z',
+      endTime: '2026-01-27T06:06:00.000Z',
+      testCases: [
+        makeTestCase('TC-001-login', [
+          makeExecution({ number: 2, status: 'passed' }),
+        ]),
+      ],
+    });
+
+    const result = mergeManifests(existing, current);
+
+    expect(result.testCases).toHaveLength(1);
+    const tc = result.testCases[0];
+    expect(tc.executions).toHaveLength(2);
+    expect(tc.executions[0].number).toBe(1);
+    expect(tc.executions[0].status).toBe('failed');
+    expect(tc.executions[1].number).toBe(2);
+    expect(tc.executions[1].status).toBe('passed');
+    expect(tc.totalExecutions).toBe(2);
+    expect(tc.finalStatus).toBe('passed'); // Latest execution status
+  });
+
+  test('current run wins on execution number collision', () => {
+    const existing = makeManifest({
+      testCases: [
+        makeTestCase('TC-001-login', [
+          makeExecution({ number: 3, status: 'failed', duration: 500 }),
+        ], 'failed'),
+      ],
+    });
+
+    const current = makeManifest({
+      startTime: '2026-01-27T06:05:00.000Z',
+      endTime: '2026-01-27T06:06:00.000Z',
+      testCases: [
+        makeTestCase('TC-001-login', [
+          makeExecution({ number: 3, status: 'passed', duration: 1200 }),
+        ]),
+      ],
+    });
+
+    const result = mergeManifests(existing, current);
+
+    const tc = result.testCases[0];
+    expect(tc.executions).toHaveLength(1);
+    expect(tc.executions[0].status).toBe('passed');
+    expect(tc.executions[0].duration).toBe(1200);
+  });
+
+  test('preserves test cases that only exist in existing manifest', () => {
+    const existing = makeManifest({
+      testCases: [
+        makeTestCase('TC-001-login', [makeExecution({ number: 1 })]),
+        makeTestCase('TC-002-checkout', [makeExecution({ number: 1 })]),
+      ],
+    });
+
+    const current = makeManifest({
+      startTime: '2026-01-27T06:05:00.000Z',
+      endTime: '2026-01-27T06:06:00.000Z',
+      testCases: [
+        makeTestCase('TC-001-login', [makeExecution({ number: 2 })]),
+      ],
+    });
+
+    const result = mergeManifests(existing, current);
+
+    expect(result.testCases).toHaveLength(2);
+    const checkout = result.testCases.find(tc => tc.id === 'TC-002-checkout');
+    expect(checkout).toBeDefined();
+    expect(checkout!.executions).toHaveLength(1);
+    expect(checkout!.executions[0].number).toBe(1);
+  });
+
+  test('recalculates stats correctly from merged data', () => {
+    const existing = makeManifest({
+      testCases: [
+        makeTestCase('TC-001-login', [
+          makeExecution({ number: 1, status: 'failed' }),
+        ], 'failed'),
+        makeTestCase('TC-002-checkout', [
+          makeExecution({ number: 1, status: 'passed' }),
+        ]),
+      ],
+    });
+
+    const current = makeManifest({
+      startTime: '2026-01-27T06:05:00.000Z',
+      endTime: '2026-01-27T06:06:00.000Z',
+      testCases: [
+        makeTestCase('TC-001-login', [
+          makeExecution({ number: 2, status: 'passed' }),
+        ]),
+        makeTestCase('TC-003-profile', [
+          makeExecution({ number: 1, status: 'failed' }),
+        ], 'failed'),
+      ],
+    });
+
+    const result = mergeManifests(existing, current);
+
+    expect(result.stats.totalTests).toBe(3);
+    // TC-001: exec-1 (failed) + exec-2 (passed) = 2 execs, finalStatus=passed
+    // TC-002: exec-1 (passed) = 1 exec, finalStatus=passed
+    // TC-003: exec-1 (failed) = 1 exec, finalStatus=failed
+    expect(result.stats.totalExecutions).toBe(4);
+    expect(result.stats.passed).toBe(2); // TC-001 and TC-002
+    expect(result.stats.failed).toBe(1); // TC-003
+  });
+
+  test('uses earliest startTime and latest endTime', () => {
+    const existing = makeManifest({
+      startTime: '2026-01-27T06:01:00.000Z',
+      endTime: '2026-01-27T06:02:00.000Z',
+      testCases: [makeTestCase('TC-001-login', [makeExecution()])],
+    });
+
+    const current = makeManifest({
+      startTime: '2026-01-27T06:05:00.000Z',
+      endTime: '2026-01-27T06:06:00.000Z',
+      testCases: [makeTestCase('TC-001-login', [makeExecution({ number: 2 })])],
+    });
+
+    const result = mergeManifests(existing, current);
+
+    expect(result.startTime).toBe('2026-01-27T06:01:00.000Z');
+    expect(result.endTime).toBe('2026-01-27T06:06:00.000Z');
+  });
+
+  test('sets status to failed if any test case has failed finalStatus', () => {
+    const existing = makeManifest({
+      status: 'passed',
+      testCases: [
+        makeTestCase('TC-001-login', [makeExecution({ number: 1, status: 'passed' })]),
+      ],
+    });
+
+    const current = makeManifest({
+      status: 'passed',
+      startTime: '2026-01-27T06:05:00.000Z',
+      endTime: '2026-01-27T06:06:00.000Z',
+      testCases: [
+        makeTestCase('TC-002-checkout', [
+          makeExecution({ number: 1, status: 'failed' }),
+        ], 'failed'),
+      ],
+    });
+
+    const result = mergeManifests(existing, current);
+
+    expect(result.status).toBe('failed');
+  });
+
+  test('preserves original session timestamp from existing manifest', () => {
+    const existing = makeManifest({
+      timestamp: '20260127-060129',
+      testCases: [makeTestCase('TC-001-login', [makeExecution()])],
+    });
+
+    const current = makeManifest({
+      timestamp: '20260127-060500',
+      startTime: '2026-01-27T06:05:00.000Z',
+      endTime: '2026-01-27T06:06:00.000Z',
+      testCases: [makeTestCase('TC-001-login', [makeExecution({ number: 2 })])],
+    });
+
+    const result = mergeManifests(existing, current);
+
+    expect(result.timestamp).toBe('20260127-060129');
+  });
+
+  test('handles timedOut status as failure in merged status', () => {
+    const existing = makeManifest({
+      status: 'passed',
+      testCases: [
+        makeTestCase('TC-001-login', [
+          makeExecution({ number: 1, status: 'timedOut' }),
+        ], 'timedOut'),
+      ],
+    });
+
+    const current = makeManifest({
+      status: 'passed',
+      startTime: '2026-01-27T06:05:00.000Z',
+      endTime: '2026-01-27T06:06:00.000Z',
+      testCases: [
+        makeTestCase('TC-002-checkout', [makeExecution({ number: 1 })]),
+      ],
+    });
+
+    const result = mergeManifests(existing, current);
+
+    expect(result.status).toBe('failed');
+  });
+
+  test('does not mutate input manifests', () => {
+    const existingExec = makeExecution({ number: 1, status: 'failed' });
+    const existing = makeManifest({
+      testCases: [makeTestCase('TC-001-login', [existingExec], 'failed')],
+    });
+    const existingSnapshot = JSON.parse(JSON.stringify(existing));
+
+    const current = makeManifest({
+      startTime: '2026-01-27T06:05:00.000Z',
+      endTime: '2026-01-27T06:06:00.000Z',
+      testCases: [
+        makeTestCase('TC-001-login', [makeExecution({ number: 2, status: 'passed' })]),
+      ],
+    });
+    const currentSnapshot = JSON.parse(JSON.stringify(current));
+
+    mergeManifests(existing, current);
+
+    expect(existing).toEqual(existingSnapshot);
+    expect(current).toEqual(currentSnapshot);
+  });
+});

package/templates/playwright/reporters/__tests__/playwright.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  testDir: '.',
+});

package/templates/playwright/reporters/bugzy-reporter.ts

@@ -24,6 +24,142 @@ interface StepData {
   duration?: number;
 }
 
+/**
+ * Manifest execution entry
+ */
+interface ManifestExecution {
+  number: number;
+  status: string;
+  duration: number;
+  videoFile: string | null;
+  hasTrace: boolean;
+  hasScreenshots: boolean;
+  error: string | null;
+}
+
+/**
+ * Manifest test case entry
+ */
+interface ManifestTestCase {
+  id: string;
+  name: string;
+  totalExecutions: number;
+  finalStatus: string;
+  executions: ManifestExecution[];
+}
+
+/**
+ * Manifest structure for test run sessions
+ */
+interface Manifest {
+  bugzyExecutionId: string;
+  timestamp: string;
+  startTime: string;
+  endTime: string;
+  status: string;
+  stats: {
+    totalTests: number;
+    passed: number;
+    failed: number;
+    totalExecutions: number;
+  };
+  testCases: ManifestTestCase[];
+}
+
+/**
+ * Merge an existing manifest with the current run's manifest.
+ * If existing is null, returns current as-is.
+ * Deduplicates executions by number (current run wins on collision).
+ * Recalculates stats from the merged data.
+ */
+export function mergeManifests(existing: Manifest | null, current: Manifest): Manifest {
+  if (!existing) {
+    return current;
+  }
+
+  // Build map of test cases by id from existing manifest
+  const testCaseMap = new Map<string, ManifestTestCase>();
+  for (const tc of existing.testCases) {
+    testCaseMap.set(tc.id, { ...tc, executions: [...tc.executions] });
+  }
+
+  // Merge current run's test cases
+  for (const tc of current.testCases) {
+    const existingTc = testCaseMap.get(tc.id);
+    if (existingTc) {
+      // Merge executions: build a map keyed by execution number
+      const execMap = new Map<number, ManifestExecution>();
+      for (const exec of existingTc.executions) {
+        execMap.set(exec.number, exec);
+      }
+      // Current run's executions overwrite on collision
+      for (const exec of tc.executions) {
+        execMap.set(exec.number, exec);
+      }
+      // Sort by execution number
+      const mergedExecs = Array.from(execMap.values()).sort((a, b) => a.number - b.number);
+      const finalStatus = mergedExecs[mergedExecs.length - 1].status;
+
+      testCaseMap.set(tc.id, {
+        id: tc.id,
+        name: tc.name,
+        totalExecutions: mergedExecs.length,
+        finalStatus,
+        executions: mergedExecs,
+      });
+    } else {
+      // New test case from current run
+      testCaseMap.set(tc.id, { ...tc, executions: [...tc.executions] });
+    }
+  }
+
+  // Build merged test cases array
+  const mergedTestCases = Array.from(testCaseMap.values());
+
+  // Recalculate stats
+  let totalTests = 0;
+  let totalExecutions = 0;
+  let passedTests = 0;
+  let failedTests = 0;
+
+  for (const tc of mergedTestCases) {
+    totalTests++;
+    totalExecutions += tc.executions.length;
+    if (tc.finalStatus === 'passed') {
+      passedTests++;
+    } else {
+      failedTests++;
+    }
+  }
+
+  // Use earliest startTime, latest endTime
+  const startTime = new Date(existing.startTime) < new Date(current.startTime)
+    ? existing.startTime
+    : current.startTime;
+  const endTime = new Date(existing.endTime) > new Date(current.endTime)
+    ? existing.endTime
+    : current.endTime;
+
+  // Status: if any test case failed, overall is failed
+  const hasFailure = mergedTestCases.some(tc => tc.finalStatus === 'failed' || tc.finalStatus === 'timedOut');
+  const status = hasFailure ? 'failed' : current.status;
+
+  return {
+    bugzyExecutionId: current.bugzyExecutionId,
+    timestamp: existing.timestamp, // Keep original session timestamp
+    startTime,
+    endTime,
+    status,
+    stats: {
+      totalTests,
+      passed: passedTests,
+      failed: failedTests,
+      totalExecutions,
+    },
+    testCases: mergedTestCases,
+  };
+}
+
 /**
  * Bugzy Custom Playwright Reporter
  *
@@ -393,8 +529,8 @@ class BugzyReporter implements Reporter {
       });
     }
 
-    // Generate manifest.json
-    const manifest = {
+    // Build current run's manifest
+    const currentManifest: Manifest = {
       bugzyExecutionId: this.bugzyExecutionId,
       timestamp: this.timestamp,
       startTime: this.startTime.toISOString(),
@@ -409,14 +545,37 @@ class BugzyReporter implements Reporter {
       testCases,
     };
 
+    // Read existing manifest for merge (if session is being reused)
     const manifestPath = path.join(this.testRunDir, 'manifest.json');
-    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    let existingManifest: Manifest | null = null;
+    if (fs.existsSync(manifestPath)) {
+      try {
+        existingManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+      } catch (err) {
+        console.warn(`⚠️ Could not parse existing manifest, will overwrite: ${err}`);
+      }
+    }
 
-    console.log(`\n📊 Test Run Summary:`);
+    // Merge with existing manifest data
+    const merged = mergeManifests(existingManifest, currentManifest);
+
+    // Write atomically (temp file + rename)
+    const tmpPath = manifestPath + '.tmp';
+    fs.writeFileSync(tmpPath, JSON.stringify(merged, null, 2));
+    fs.renameSync(tmpPath, manifestPath);
+
+    console.log(`\n📊 Test Run Summary (this run):`);
     console.log(`   Total tests: ${totalTests}`);
     console.log(`   Passed: ${passedTests}`);
     console.log(`   Failed: ${failedTests}`);
     console.log(`   Total executions: ${totalExecutions}`);
+
+    if (existingManifest) {
+      console.log(`\n🔗 Merged with previous session data:`);
+      console.log(`   Session total tests: ${merged.stats.totalTests}`);
+      console.log(`   Session total executions: ${merged.stats.totalExecutions}`);
+    }
+
     console.log(`   Manifest: ${manifestPath}\n`);
   }