prjct-cli 1.21.0 → 1.22.0

package/CHANGELOG.md

@@ -1,10 +1,107 @@
 # Changelog
 
+## [1.22.0] - 2026-02-10
+
+### Features
+
+- add task-to-analysis feedback loop (PRJ-272) (#165)
+- add task history array with FIFO eviction (PRJ-281) (#164)
+
+
+## [1.22.0] - 2026-02-10
+
+### Features
+
+- **Task-to-analysis feedback loop** (PRJ-272): Tasks report discoveries back into analysis and agent generation
+  - TaskFeedbackSchema: stackConfirmed, patternsDiscovered, agentAccuracy (with rating enum), issuesEncountered
+  - Optional `feedback` field on TaskHistoryEntry for backward compatibility
+  - `getAggregatedFeedback()` consolidates patterns, stack confirmations, and issues across task history
+  - Recurring issues (2+ occurrences) automatically promoted to "known gotchas"
+  - Sync incorporates feedback: patterns populate analysis draft, gotchas become anti-patterns
+  - Agent generator injects "Recent Learnings" section into domain agents with patterns, gotchas, and accuracy notes
+  - Workflow `done()` accepts and passes feedback through to storage
+  - 22 new tests covering schema validation, persistence, aggregation, gotcha promotion, and backward compatibility (1020 total)
+
+### Implementation Details
+
+Closes the knowledge loop between task execution and project analysis. Previously, discoveries made during tasks were lost when sessions ended. Now, structured feedback persists in task history and feeds into the next sync cycle.
+
+**Data flow:** `p. done` (feedback captured) → `taskHistory[].feedback` → `p. sync` → `analysis.patterns` + `agents/*.md` "Recent Learnings"
+
+**Modified modules:**
+- `core/schemas/state.ts` — Added TaskFeedbackSchema, extended TaskHistoryEntrySchema with optional feedback field
+- `core/storage/state-storage.ts` — completeTask() accepts feedback, createTaskHistoryEntry() attaches it, getAggregatedFeedback() provides read-side API, toMarkdown() shows feedback in context
+- `core/commands/workflow.ts` — done() passes feedback through options to completeTask()
+- `core/services/sync-service.ts` — saveDraftAnalysis() loads aggregated feedback, injectFeedbackSection() adds learnings to agents
+- `core/services/agent-generator.ts` — generate() accepts TaskFeedbackContext, injectFeedbackSection() appends learnings to domain agents
+- `core/__tests__/storage/state-storage-feedback.test.ts` — 22 comprehensive tests
+
+### Learnings
+
+- **SyncService duplicates AgentGenerator:** Both have their own `generateDomainAgent()` — feedback injection needed in both places
+- **Write-Through pattern:** All state flows JSON → MD → Event; feedback follows the same pattern
+- **Backward compatibility via optional fields:** Adding `feedback?: TaskFeedback` to existing schema requires zero migration
+
+### Test Plan
+
+#### For QA
+1. Complete a task with `p. done` — verify feedback stored in `taskHistory[0].feedback`
+2. Complete multiple tasks with same issue — verify gotcha promotion (2+ occurrences)
+3. Run `p. sync` after tasks with feedback — verify analysis draft has patterns
+4. Run `p. sync` with agent regeneration — verify "Recent Learnings" in domain agents
+5. Complete task WITHOUT feedback — verify backward compatibility
+6. Run `bun test` — all 1020 tests pass
+
+#### For Users
+**What changed:** Task discoveries now persist and improve future agent context automatically.
+**How to use:** Automatic via `p. done` template. No user action required.
+**Breaking changes:** None.
+
 ## [1.21.0] - 2026-02-10
 
 ### Features
 
 - add semantic verification for analysis results (PRJ-270) (#163)
+- **Task history array** (PRJ-281): Replace single previousTask with bounded task history for pattern learning
+  - TaskHistoryEntry schema captures completed task metadata: title, classification, timestamps, subtasks, outcome, branch, Linear IDs
+  - Automatic history push on task completion with FIFO eviction (max 20 entries)
+  - Context injection: shows 3 recent same-type tasks when active, 5 recent when idle
+  - Accessor methods: getTaskHistory(), getMostRecentTask(), getTaskHistoryByType()
+  - Backward compatible: undefined taskHistory initializes as empty array
+  - Comprehensive test suite with 20 test cases (998 tests total pass)
+
+### Implementation Details
+
+Replaced single previousTask field with bounded task history array to enable pattern learning and cross-task context for AI agents. When tasks complete, metadata is automatically captured and stored with FIFO eviction.
+
+**Modified modules:**
+- `core/schemas/state.ts` — Added TaskHistoryEntrySchema with 12 fields, updated StateJsonSchema, exported TaskHistoryEntry type, updated DEFAULT_STATE
+- `core/storage/state-storage.ts` — Updated completeTask() to push history entries, added createTaskHistoryEntry() helper, added 3 accessor methods, updated toMarkdown() for context injection, updated getDefault()
+- `core/__tests__/storage/state-storage-history.test.ts` (468 lines) — 20 comprehensive tests covering push, eviction, backward compatibility, accessors, and context injection
+- `README.md` — Added Task History section with usage documentation
+- `CHANGELOG.md` — Documented task history feature
+
+### Learnings
+
+- **Schema-first design:** Define Zod schemas before implementation ensures type safety and validation at runtime
+- **Type assertions for extended properties:** Use `taskAny = task as any` to access properties not in CurrentTask schema (type, branch, parentDescription)
+- **Context injection in toMarkdown():** The state-storage toMarkdown() method is where context is generated, not context-builder.ts
+- **pathManager mocking for test isolation:** Mock getGlobalProjectPath, getStoragePath, getFilePath to use temp directories in tests
+- **FIFO over LRU:** Simpler implementation with predictable behavior for bounded history
+
+### Test Plan
+
+#### For QA
+1. Complete a task with `p. done` — verify taskHistory entry appears in state.json with all metadata fields
+2. Complete 25+ tasks — verify only 20 entries remain (oldest dropped)
+3. Start a bug task — verify context markdown shows recent bug tasks only (not features)
+4. Test with existing state.json missing taskHistory field — verify backward compatibility
+5. Verify accessor methods return correct data: getTaskHistory(), getMostRecentTask(), getTaskHistoryByType()
+
+#### For Users
+**What changed:** Completed tasks are now tracked in a history array (max 20) instead of only storing the last paused task
+**How to use:** No action needed — task history is automatic on `p. done`
+**Breaking changes:** None — fully backward compatible
 
 
 ## [1.20.0] - 2026-02-10

package/README.md

@@ -123,6 +123,47 @@ All agents share the same project storage, so you can switch between them freely
 | `p. linear` | - | Linear integration |
 | `p. github` | - | GitHub Issues integration |
 
+## Task History
+
+prjct automatically tracks your completed tasks to help AI agents learn from patterns and make better decisions across sessions.
+
+### How It Works
+
+When you complete a task (`p. done` / `/done`), prjct stores:
+- Task description and classification (feature, bug, improvement, chore)
+- Start and completion timestamps
+- Number of subtasks and their summaries
+- Git branch name and Linear issue ID (if linked)
+- PR URL (if shipped)
+
+This history is:
+- **Bounded**: Maximum 20 entries with FIFO (First-In-First-Out) eviction
+- **Contextual**: Filtered by task type when starting similar work
+- **Persistent**: Survives across sessions and agent types
+
+### Context Injection
+
+Task history is automatically injected into the AI agent's context:
+- When **starting a task**: Shows 3 most recent tasks of the same type (e.g., recent bug fixes when starting a new bug)
+- When **idle**: Shows 5 most recent tasks across all types
+- **Purpose**: Helps agents identify patterns, avoid repeating mistakes, and build on previous solutions
+
+### Accessor Methods (for developers)
+
+```typescript
+import { stateStorage } from './storage/state-storage'
+
+// Get full task history (max 20 entries, newest first)
+const history = await stateStorage.getTaskHistory(projectId)
+
+// Get most recent completed task
+const recent = await stateStorage.getMostRecentTask(projectId)
+
+// Get tasks by classification
+const bugs = await stateStorage.getTaskHistoryByType(projectId, 'bug')
+const features = await stateStorage.getTaskHistoryByType(projectId, 'feature')
+```
+
 ## CLI Commands
 
 ```bash

package/core/__tests__/storage/state-storage-feedback.test.ts

@@ -0,0 +1,463 @@
+/**
+ * State Storage Task Feedback Tests (PRJ-272)
+ *
+ * Tests for the task-to-analysis feedback loop:
+ * - Feedback schema validation
+ * - Feedback persistence in task history
+ * - Feedback aggregation across tasks
+ * - Known gotchas promotion (2+ occurrences)
+ * - Backward compatibility (tasks without feedback)
+ * - Context injection (markdown with feedback)
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import pathManager from '../../infrastructure/path-manager'
+import type { CurrentTask, StateJson, TaskFeedback } from '../../schemas/state'
+import { TaskFeedbackSchema } from '../../schemas/state'
+import { prjctDb } from '../../storage/database'
+import { stateStorage } from '../../storage/state-storage'
+
+// =============================================================================
+// Test Setup
+// =============================================================================
+
+let tmpRoot: string | null = null
+let testProjectId: string
+
+const originalGetGlobalProjectPath = pathManager.getGlobalProjectPath.bind(pathManager)
+const originalGetStoragePath = pathManager.getStoragePath.bind(pathManager)
+const originalGetFilePath = pathManager.getFilePath.bind(pathManager)
+
+beforeEach(async () => {
+  tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'prjct-feedback-test-'))
+  testProjectId = `test-feedback-${Date.now()}`
+
+  pathManager.getGlobalProjectPath = (projectId: string) => {
+    return path.join(tmpRoot!, projectId)
+  }
+
+  pathManager.getStoragePath = (projectId: string, filename: string) => {
+    return path.join(tmpRoot!, projectId, 'storage', filename)
+  }
+
+  pathManager.getFilePath = (projectId: string, layer: string, filename: string) => {
+    return path.join(tmpRoot!, projectId, layer, filename)
+  }
+
+  const storagePath = pathManager.getStoragePath(testProjectId, '')
+  await fs.mkdir(storagePath, { recursive: true })
+
+  const syncPath = path.join(tmpRoot!, testProjectId, 'sync')
+  await fs.mkdir(syncPath, { recursive: true })
+})
+
+afterEach(async () => {
+  prjctDb.close()
+
+  pathManager.getGlobalProjectPath = originalGetGlobalProjectPath
+  pathManager.getStoragePath = originalGetStoragePath
+  pathManager.getFilePath = originalGetFilePath
+
+  if (tmpRoot) {
+    await fs.rm(tmpRoot, { recursive: true, force: true })
+    tmpRoot = null
+  }
+})
+
+// =============================================================================
+// Helper Functions
+// =============================================================================
+
+function createMockTask(
+  overrides: Partial<CurrentTask> & Record<string, unknown> = {}
+): CurrentTask {
+  return {
+    id: `task-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+    description: 'Test task',
+    startedAt: new Date().toISOString(),
+    sessionId: `session-${Date.now()}`,
+    ...overrides,
+  } as CurrentTask
+}
+
+async function startAndCompleteWithFeedback(
+  projectId: string,
+  task: CurrentTask,
+  feedback?: TaskFeedback
+): Promise<StateJson> {
+  await stateStorage.startTask(projectId, task)
+  await stateStorage.completeTask(projectId, feedback)
+  return await stateStorage.read(projectId)
+}
+
+// =============================================================================
+// Tests: TaskFeedback Schema Validation
+// =============================================================================
+
+describe('TaskFeedback Schema', () => {
+  it('should validate a complete feedback object', () => {
+    const feedback: TaskFeedback = {
+      stackConfirmed: ['React 18', 'TypeScript strict mode'],
+      patternsDiscovered: ['API routes follow /api/v1/{resource} pattern'],
+      agentAccuracy: [{ agent: 'backend.md', rating: 'helpful', note: 'Good API patterns' }],
+      issuesEncountered: ['ESLint conflicts with Prettier'],
+    }
+
+    const result = TaskFeedbackSchema.safeParse(feedback)
+    expect(result.success).toBe(true)
+  })
+
+  it('should validate an empty feedback object', () => {
+    const feedback: TaskFeedback = {}
+
+    const result = TaskFeedbackSchema.safeParse(feedback)
+    expect(result.success).toBe(true)
+  })
+
+  it('should validate feedback with only patterns', () => {
+    const feedback: TaskFeedback = {
+      patternsDiscovered: ['Components use barrel exports'],
+    }
+
+    const result = TaskFeedbackSchema.safeParse(feedback)
+    expect(result.success).toBe(true)
+  })
+
+  it('should reject invalid agent accuracy rating', () => {
+    const feedback = {
+      agentAccuracy: [{ agent: 'backend.md', rating: 'invalid_rating' }],
+    }
+
+    const result = TaskFeedbackSchema.safeParse(feedback)
+    expect(result.success).toBe(false)
+  })
+
+  it('should validate all agent accuracy rating values', () => {
+    for (const rating of ['helpful', 'neutral', 'inaccurate'] as const) {
+      const feedback: TaskFeedback = {
+        agentAccuracy: [{ agent: 'test.md', rating }],
+      }
+      const result = TaskFeedbackSchema.safeParse(feedback)
+      expect(result.success).toBe(true)
+    }
+  })
+})
+
+// =============================================================================
+// Tests: Feedback Persistence in Task History
+// =============================================================================
+
+describe('Feedback Persistence', () => {
+  it('should store feedback in task history entry', async () => {
+    const task = createMockTask({ description: 'Task with feedback' })
+    const feedback: TaskFeedback = {
+      stackConfirmed: ['TypeScript'],
+      patternsDiscovered: ['Uses Hono framework'],
+    }
+
+    const state = await startAndCompleteWithFeedback(testProjectId, task, feedback)
+
+    expect(state.taskHistory).toBeDefined()
+    expect(state.taskHistory!.length).toBe(1)
+    expect(state.taskHistory![0].feedback).toBeDefined()
+    expect(state.taskHistory![0].feedback?.stackConfirmed).toEqual(['TypeScript'])
+    expect(state.taskHistory![0].feedback?.patternsDiscovered).toEqual(['Uses Hono framework'])
+  })
+
+  it('should store task without feedback (backward compatible)', async () => {
+    const task = createMockTask({ description: 'Task without feedback' })
+
+    const state = await startAndCompleteWithFeedback(testProjectId, task)
+
+    expect(state.taskHistory).toBeDefined()
+    expect(state.taskHistory!.length).toBe(1)
+    expect(state.taskHistory![0].feedback).toBeUndefined()
+  })
+
+  it('should preserve feedback through FIFO eviction', async () => {
+    // Complete first task with feedback
+    const task1 = createMockTask({ description: 'Task 1' })
+    await stateStorage.startTask(testProjectId, task1)
+    await stateStorage.completeTask(testProjectId, {
+      patternsDiscovered: ['Pattern from task 1'],
+    })
+
+    // Complete second task with feedback
+    const task2 = createMockTask({ description: 'Task 2' })
+    await stateStorage.startTask(testProjectId, task2)
+    await stateStorage.completeTask(testProjectId, {
+      patternsDiscovered: ['Pattern from task 2'],
+    })
+
+    const state = await stateStorage.read(testProjectId)
+    expect(state.taskHistory!.length).toBe(2)
+    // Most recent first (FIFO)
+    expect(state.taskHistory![0].feedback?.patternsDiscovered).toEqual(['Pattern from task 2'])
+    expect(state.taskHistory![1].feedback?.patternsDiscovered).toEqual(['Pattern from task 1'])
+  })
+
+  it('should store full feedback with all fields', async () => {
+    const task = createMockTask({ description: 'Full feedback task' })
+    const feedback: TaskFeedback = {
+      stackConfirmed: ['React 18', 'TypeScript'],
+      patternsDiscovered: ['API routes use /api/v1/{resource}', 'Barrel exports'],
+      agentAccuracy: [
+        { agent: 'backend.md', rating: 'helpful', note: 'Good patterns' },
+        { agent: 'frontend.md', rating: 'inaccurate', note: 'Missing Tailwind' },
+      ],
+      issuesEncountered: ['ESLint conflicts with Prettier'],
+    }
+
+    const state = await startAndCompleteWithFeedback(testProjectId, task, feedback)
+
+    const stored = state.taskHistory![0].feedback!
+    expect(stored.stackConfirmed).toEqual(['React 18', 'TypeScript'])
+    expect(stored.patternsDiscovered).toEqual([
+      'API routes use /api/v1/{resource}',
+      'Barrel exports',
+    ])
+    expect(stored.agentAccuracy).toHaveLength(2)
+    expect(stored.agentAccuracy![0].rating).toBe('helpful')
+    expect(stored.agentAccuracy![1].rating).toBe('inaccurate')
+    expect(stored.issuesEncountered).toEqual(['ESLint conflicts with Prettier'])
+  })
+})
+
+// =============================================================================
+// Tests: Feedback Aggregation
+// =============================================================================
+
+describe('Feedback Aggregation', () => {
+  it('should aggregate patterns from multiple tasks', async () => {
+    // Task 1
+    const task1 = createMockTask({ description: 'Task 1' })
+    await stateStorage.startTask(testProjectId, task1)
+    await stateStorage.completeTask(testProjectId, {
+      patternsDiscovered: ['Pattern A'],
+    })
+
+    // Task 2
+    const task2 = createMockTask({ description: 'Task 2' })
+    await stateStorage.startTask(testProjectId, task2)
+    await stateStorage.completeTask(testProjectId, {
+      patternsDiscovered: ['Pattern B'],
+    })
+
+    const aggregated = await stateStorage.getAggregatedFeedback(testProjectId)
+    expect(aggregated.patternsDiscovered).toContain('Pattern A')
+    expect(aggregated.patternsDiscovered).toContain('Pattern B')
+  })
+
+  it('should deduplicate patterns', async () => {
+    // Both tasks discover the same pattern
+    const task1 = createMockTask({ description: 'Task 1' })
+    await stateStorage.startTask(testProjectId, task1)
+    await stateStorage.completeTask(testProjectId, {
+      patternsDiscovered: ['Same pattern'],
+    })
+
+    const task2 = createMockTask({ description: 'Task 2' })
+    await stateStorage.startTask(testProjectId, task2)
+    await stateStorage.completeTask(testProjectId, {
+      patternsDiscovered: ['Same pattern'],
+    })
+
+    const aggregated = await stateStorage.getAggregatedFeedback(testProjectId)
+    expect(aggregated.patternsDiscovered).toEqual(['Same pattern'])
+  })
+
+  it('should deduplicate stack confirmations', async () => {
+    const task1 = createMockTask({ description: 'Task 1' })
+    await stateStorage.startTask(testProjectId, task1)
+    await stateStorage.completeTask(testProjectId, {
+      stackConfirmed: ['TypeScript', 'React'],
+    })
+
+    const task2 = createMockTask({ description: 'Task 2' })
+    await stateStorage.startTask(testProjectId, task2)
+    await stateStorage.completeTask(testProjectId, {
+      stackConfirmed: ['TypeScript', 'Next.js'],
+    })
+
+    const aggregated = await stateStorage.getAggregatedFeedback(testProjectId)
+    expect(aggregated.stackConfirmed).toContain('TypeScript')
+    expect(aggregated.stackConfirmed).toContain('React')
+    expect(aggregated.stackConfirmed).toContain('Next.js')
+    // TypeScript should not be duplicated
+    expect(aggregated.stackConfirmed.filter((s) => s === 'TypeScript')).toHaveLength(1)
+  })
+
+  it('should promote recurring issues to known gotchas', async () => {
+    // Same issue encountered twice
+    const task1 = createMockTask({ description: 'Task 1' })
+    await stateStorage.startTask(testProjectId, task1)
+    await stateStorage.completeTask(testProjectId, {
+      issuesEncountered: ['ESLint conflicts with Prettier'],
+    })
+
+    const task2 = createMockTask({ description: 'Task 2' })
+    await stateStorage.startTask(testProjectId, task2)
+    await stateStorage.completeTask(testProjectId, {
+      issuesEncountered: ['ESLint conflicts with Prettier'],
+    })
+
+    const aggregated = await stateStorage.getAggregatedFeedback(testProjectId)
+    expect(aggregated.knownGotchas).toContain('ESLint conflicts with Prettier')
+  })
+
+  it('should NOT promote single-occurrence issues to gotchas', async () => {
+    const task1 = createMockTask({ description: 'Task 1' })
+    await stateStorage.startTask(testProjectId, task1)
+    await stateStorage.completeTask(testProjectId, {
+      issuesEncountered: ['One-time issue'],
+    })
+
+    const aggregated = await stateStorage.getAggregatedFeedback(testProjectId)
+    expect(aggregated.issuesEncountered).toContain('One-time issue')
+    expect(aggregated.knownGotchas).not.toContain('One-time issue')
+  })
+
+  it('should aggregate agent accuracy across tasks', async () => {
+    const task1 = createMockTask({ description: 'Task 1' })
+    await stateStorage.startTask(testProjectId, task1)
+    await stateStorage.completeTask(testProjectId, {
+      agentAccuracy: [{ agent: 'backend.md', rating: 'helpful' }],
+    })
+
+    const task2 = createMockTask({ description: 'Task 2' })
+    await stateStorage.startTask(testProjectId, task2)
+    await stateStorage.completeTask(testProjectId, {
+      agentAccuracy: [{ agent: 'backend.md', rating: 'inaccurate', note: 'Missing Hono context' }],
+    })
+
+    const aggregated = await stateStorage.getAggregatedFeedback(testProjectId)
+    expect(aggregated.agentAccuracy).toHaveLength(2)
+    expect(aggregated.agentAccuracy[0].agent).toBe('backend.md')
+    expect(aggregated.agentAccuracy[1].agent).toBe('backend.md')
+  })
+
+  it('should return empty aggregation when no feedback exists', async () => {
+    // Complete task without feedback
+    const task = createMockTask({ description: 'No feedback' })
+    await stateStorage.startTask(testProjectId, task)
+    await stateStorage.completeTask(testProjectId)
+
+    const aggregated = await stateStorage.getAggregatedFeedback(testProjectId)
+    expect(aggregated.stackConfirmed).toEqual([])
+    expect(aggregated.patternsDiscovered).toEqual([])
+    expect(aggregated.agentAccuracy).toEqual([])
+    expect(aggregated.issuesEncountered).toEqual([])
+    expect(aggregated.knownGotchas).toEqual([])
+  })
+
+  it('should return empty aggregation when no tasks exist', async () => {
+    const aggregated = await stateStorage.getAggregatedFeedback(testProjectId)
+    expect(aggregated.stackConfirmed).toEqual([])
+    expect(aggregated.patternsDiscovered).toEqual([])
+    expect(aggregated.knownGotchas).toEqual([])
+  })
+})
+
+// =============================================================================
+// Tests: Context Injection (Markdown Generation)
+// =============================================================================
+
+describe('Feedback in Markdown Context', () => {
+  it('should include patterns in task history markdown', async () => {
+    const task = createMockTask({ description: 'Task with patterns' })
+    await stateStorage.startTask(testProjectId, task)
+    await stateStorage.completeTask(testProjectId, {
+      patternsDiscovered: ['Uses barrel exports'],
+    })
+
+    const state = await stateStorage.read(testProjectId)
+    // Access the private toMarkdown via the generated context
+    const md = (stateStorage as any).toMarkdown(state)
+
+    expect(md).toContain('Patterns: Uses barrel exports')
+  })
+
+  it('should include gotchas in task history markdown', async () => {
+    const task = createMockTask({ description: 'Task with gotchas' })
+    await stateStorage.startTask(testProjectId, task)
+    await stateStorage.completeTask(testProjectId, {
+      issuesEncountered: ['Port 3000 already in use'],
+    })
+
+    const state = await stateStorage.read(testProjectId)
+    const md = (stateStorage as any).toMarkdown(state)
+
+    expect(md).toContain('Gotchas: Port 3000 already in use')
+  })
+
+  it('should NOT show feedback section when feedback is empty', async () => {
+    const task = createMockTask({ description: 'Task without feedback' })
+    await stateStorage.startTask(testProjectId, task)
+    await stateStorage.completeTask(testProjectId)
+
+    const state = await stateStorage.read(testProjectId)
+    const md = (stateStorage as any).toMarkdown(state)
+
+    expect(md).not.toContain('Patterns:')
+    expect(md).not.toContain('Gotchas:')
+  })
+})
+
+// =============================================================================
+// Tests: Mixed Feedback and Non-Feedback Tasks
+// =============================================================================
+
+describe('Mixed Tasks (with and without feedback)', () => {
+  it('should handle mix of tasks with and without feedback', async () => {
+    // Task 1: with feedback
+    const task1 = createMockTask({ description: 'With feedback' })
+    await stateStorage.startTask(testProjectId, task1)
+    await stateStorage.completeTask(testProjectId, {
+      patternsDiscovered: ['Pattern from task 1'],
+    })
+
+    // Task 2: without feedback
+    const task2 = createMockTask({ description: 'Without feedback' })
+    await stateStorage.startTask(testProjectId, task2)
+    await stateStorage.completeTask(testProjectId)
+
+    // Task 3: with feedback
+    const task3 = createMockTask({ description: 'With feedback again' })
+    await stateStorage.startTask(testProjectId, task3)
+    await stateStorage.completeTask(testProjectId, {
+      patternsDiscovered: ['Pattern from task 3'],
+    })
+
+    const aggregated = await stateStorage.getAggregatedFeedback(testProjectId)
+    expect(aggregated.patternsDiscovered).toContain('Pattern from task 1')
+    expect(aggregated.patternsDiscovered).toContain('Pattern from task 3')
+    expect(aggregated.patternsDiscovered).toHaveLength(2)
+  })
+
+  it('should correctly count occurrences for gotcha promotion with mixed tasks', async () => {
+    // Task 1: encounters issue
+    const task1 = createMockTask({ description: 'Task 1' })
+    await stateStorage.startTask(testProjectId, task1)
+    await stateStorage.completeTask(testProjectId, {
+      issuesEncountered: ['Build fails on M1'],
+    })
+
+    // Task 2: no feedback
+    const task2 = createMockTask({ description: 'Task 2' })
+    await stateStorage.startTask(testProjectId, task2)
+    await stateStorage.completeTask(testProjectId)
+
+    // Task 3: encounters same issue
+    const task3 = createMockTask({ description: 'Task 3' })
+    await stateStorage.startTask(testProjectId, task3)
+    await stateStorage.completeTask(testProjectId, {
+      issuesEncountered: ['Build fails on M1'],
+    })
+
+    const aggregated = await stateStorage.getAggregatedFeedback(testProjectId)
+    expect(aggregated.knownGotchas).toContain('Build fails on M1')
+  })
+})