prjct-cli 1.20.0 → 1.22.0

package/CHANGELOG.md

@@ -1,5 +1,109 @@
 # 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
 
 ### Features
@@ -11,6 +115,16 @@
 
 ### Features
 
+- **Semantic verification for analysis results** (PRJ-270): Validate analysis consistency before sealing
+  - Framework verification: checks frameworks exist in package.json dependencies (case-insensitive matching)
+  - Language verification: validates languages match actual file extensions (.ts → TypeScript)
+  - Pattern location verification: confirms pattern files exist in project
+  - File count verification: validates count accuracy (within 10% tolerance)
+  - Anti-pattern file verification: ensures anti-pattern files exist when referenced
+  - CLI command: `prjct verify --semantic` with human-readable and JSON output
+  - Parallel execution of all 5 checks using Promise.all() (~100-200ms for typical projects)
+  - Comprehensive test suite with 10 new test cases covering all scenarios (28 tests total, 63 assertions)
+
 - **Retry with exponential backoff for agent and tool operations** (PRJ-271): Comprehensive retry infrastructure with error classification and circuit breaker
   - RetryPolicy utility with configurable attempts, delays, and exponential backoff (1s→2s→4s)
   - Automatic error classification: transient (EBUSY, EAGAIN, ETIMEDOUT) vs permanent (ENOENT, EPERM)
@@ -21,6 +135,41 @@
 
 ### Implementation Details
 
+#### Semantic Verification (PRJ-270)
+
+Added semantic verification functions to validate analysis results match actual project state. The verification system runs 5 parallel checks to detect logical inconsistencies before sealing analysis data.
+
+**Modified modules:**
+- `core/schemas/analysis.ts` — Added 5 verification functions, 1 orchestrator, 2 helpers, and 2 interfaces (SemanticCheckResult, SemanticVerificationReport)
+- `core/storage/analysis-storage.ts` — Added semanticVerify() method to AnalysisStorage class
+- `core/commands/analysis.ts` — Extended verify() with --semantic flag and added semanticVerify() helper
+- `core/commands/commands.ts` — Updated verify() signature to include semantic?: boolean
+- `core/index.ts` — Updated verify command handler to pass semantic flag
+- `core/__tests__/storage/analysis-storage.test.ts` — Added 10 comprehensive test cases (+345 lines)
+- `README.md` — Added analysis verification documentation section
+- `CHANGELOG.md` — Documented semantic verification feature
+
+**Verification functions:**
+1. `verifyFrameworks()` — Checks frameworks exist in package.json (case-insensitive partial matching)
+2. `verifyLanguages()` — Validates languages match file extensions (.ts → TypeScript)
+3. `verifyPatternLocations()` — Confirms pattern files exist in project
+4. `verifyFileCount()` — Validates count accuracy (10% tolerance for temporary files/caches)
+5. `verifyAntiPatternFiles()` — Ensures anti-pattern files exist when referenced
+
+**Helper functions:**
+- `getProjectExtensions()` — Recursively scans project for file extensions (ignores node_modules, .git, dist, build, .next, .turbo, coverage)
+- `countProjectFiles()` — Counts all files in project with same ignore patterns
+
+**Key features:**
+- Parallel execution using Promise.all() for performance (~100-200ms typical)
+- Skip conditions for null/undefined/empty arrays (prevents false failures)
+- 10% tolerance for file count (accounts for temporary files, caches)
+- Case-insensitive partial matching for frameworks
+- Returns SemanticVerificationReport following VerificationReport pattern from sync-verifier
+- Zero breaking changes: all 18 existing tests pass
+
+#### Retry Infrastructure (PRJ-271)
+
 Built RetryPolicy utility with exponential backoff, error classification, and circuit breaker. Integrated across agent initialization, tool operations, and parallel agent generation. The system now automatically retries transient failures while failing fast on permanent errors.
 
 **New modules:**

package/README.md

@@ -123,15 +123,105 @@ 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
 prjct start          # First-time setup (Claude/Gemini)
 prjct init           # Initialize project (+ Cursor setup)
+prjct sync           # Analyze project and generate context
+prjct verify         # Verify analysis integrity (cryptographic)
+prjct verify --semantic  # Verify analysis consistency (semantic)
 prjct --version      # Show version + provider status
 prjct --help         # Show help
 ```
 
+### Analysis Verification
+
+prjct provides two types of analysis verification to ensure data integrity and logical consistency:
+
+#### Cryptographic Verification (Default)
+```bash
+prjct verify [--json]
+```
+
+Verifies the integrity of sealed analysis results using cryptographic signatures. This ensures:
+- Analysis data hasn't been tampered with
+- Sealed analysis matches the original analysis
+- Hash signatures are valid
+
+**When to use:** After sealing an analysis (`prjct seal`) to confirm data integrity.
+
+#### Semantic Verification (PRJ-270)
+```bash
+prjct verify --semantic [--json]
+```
+
+Validates that analysis results match the actual project state. This checks:
+- ✓ **Frameworks** exist in `package.json` dependencies
+- ✓ **Languages** match actual file extensions (.ts → TypeScript)
+- ✓ **Pattern locations** reference real files in the project
+- ✓ **File count** is accurate (within 10% tolerance)
+- ✓ **Anti-pattern files** exist when referenced
+
+**When to use:** Before sealing an analysis to catch logical inconsistencies or after project changes to validate analysis accuracy.
+
+**Example output:**
+```
+Semantic Verification Report
+────────────────────────────
+  ✓ Framework verification: passed (2 frameworks validated)
+  ✓ Language verification: passed (1 language validated)
+  ✓ Pattern locations: passed (12 patterns verified)
+  ✓ File count verification: passed (324 files, within tolerance)
+  ✓ Anti-pattern files: passed (3 anti-patterns verified)
+
+Result: PASSED (5/5 checks)
+Total time: 145ms
+```
+
+Both verification modes support `--json` flag for programmatic use.
+
 ## Environment Variables
 
 ### Configuration

package/core/__tests__/storage/analysis-storage.test.ts

@@ -14,6 +14,7 @@ import {
   AnalysisItemSchema,
   AnalysisStatusSchema,
   parseAnalysis,
+  type SemanticCheckResult,
   safeParseAnalysis,
 } from '../../schemas/analysis'
 
@@ -275,3 +276,366 @@ describe('backward compatibility', () => {
     expect(result.modelMetadata?.provider).toBe('claude')
   })
 })
+
+// =============================================================================
+// Semantic Verification (PRJ-270)
+// =============================================================================
+
+describe('semantic verification', () => {
+  const { semanticVerify } = require('../../schemas/analysis')
+  const fs = require('node:fs/promises')
+  const path = require('node:path')
+  const os = require('node:os')
+
+  // Helper to create a temporary test project
+  async function createTestProject(options: {
+    hasPackageJson?: boolean
+    packageJsonDeps?: Record<string, string>
+    files?: { path: string; content: string }[]
+    fileCount?: number
+  }) {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'prjct-test-'))
+
+    // Create package.json if requested
+    if (options.hasPackageJson) {
+      const pkg = {
+        name: 'test-project',
+        dependencies: options.packageJsonDeps || {},
+      }
+      await fs.writeFile(path.join(tmpDir, 'package.json'), JSON.stringify(pkg, null, 2))
+    }
+
+    // Create additional files
+    if (options.files) {
+      for (const file of options.files) {
+        const filePath = path.join(tmpDir, file.path)
+        await fs.mkdir(path.dirname(filePath), { recursive: true })
+        await fs.writeFile(filePath, file.content)
+      }
+    }
+
+    return tmpDir
+  }
+
+  // Helper to cleanup test project
+  async function cleanupTestProject(tmpDir: string) {
+    try {
+      await fs.rm(tmpDir, { recursive: true, force: true })
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+
+  it('should pass all checks for valid analysis', async () => {
+    const projectPath = await createTestProject({
+      hasPackageJson: true,
+      packageJsonDeps: { hono: '^3.0.0', zod: '^3.0.0' },
+      files: [
+        { path: 'src/index.ts', content: 'export const app = {}' },
+        { path: 'src/server.ts', content: 'import { serve } from "bun"' },
+        { path: 'patterns/service.ts', content: 'export class UserService {}' },
+      ],
+    })
+
+    const analysis = {
+      projectId: 'test',
+      languages: ['TypeScript'],
+      frameworks: ['Hono'],
+      configFiles: [],
+      fileCount: 4, // package.json + 3 TypeScript files
+      patterns: [
+        { name: 'Service pattern', description: 'DI pattern', location: 'patterns/service.ts' },
+      ],
+      antiPatterns: [],
+      analyzedAt: '2026-02-10T00:00:00.000Z',
+      status: 'draft' as const,
+    }
+
+    const result = await semanticVerify(analysis, projectPath)
+
+    expect(result.passed).toBe(true)
+    expect(result.failedCount).toBe(0)
+    expect(result.passedCount).toBeGreaterThan(0)
+    expect(result.checks.every((c: SemanticCheckResult) => c.passed)).toBe(true)
+
+    await cleanupTestProject(projectPath)
+  })
+
+  it('should fail when frameworks are not in package.json', async () => {
+    const projectPath = await createTestProject({
+      hasPackageJson: true,
+      packageJsonDeps: { express: '^4.0.0' }, // Different framework
+      files: [{ path: 'src/index.ts', content: '' }],
+    })
+
+    const analysis = {
+      projectId: 'test',
+      languages: ['TypeScript'],
+      frameworks: ['Hono', 'Zod'], // These are not in dependencies
+      configFiles: [],
+      fileCount: 1,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-10T00:00:00.000Z',
+      status: 'draft' as const,
+    }
+
+    const result = await semanticVerify(analysis, projectPath)
+
+    expect(result.passed).toBe(false)
+    expect(result.failedCount).toBeGreaterThan(0)
+
+    const frameworkCheck = result.checks.find(
+      (c: SemanticCheckResult) => c.name === 'Framework verification'
+    )
+    expect(frameworkCheck?.passed).toBe(false)
+    expect(frameworkCheck?.error).toContain('not found in dependencies')
+
+    await cleanupTestProject(projectPath)
+  })
+
+  it('should fail when package.json is missing', async () => {
+    const projectPath = await createTestProject({
+      hasPackageJson: false, // No package.json
+      files: [{ path: 'src/index.ts', content: '' }],
+    })
+
+    const analysis = {
+      projectId: 'test',
+      languages: ['TypeScript'],
+      frameworks: ['Hono'],
+      configFiles: [],
+      fileCount: 1,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-10T00:00:00.000Z',
+      status: 'draft' as const,
+    }
+
+    const result = await semanticVerify(analysis, projectPath)
+
+    const frameworkCheck = result.checks.find(
+      (c: SemanticCheckResult) => c.name === 'Framework verification'
+    )
+    expect(frameworkCheck?.passed).toBe(false)
+    expect(frameworkCheck?.error).toContain('package.json not found')
+
+    await cleanupTestProject(projectPath)
+  })
+
+  it('should fail when declared languages have no matching files', async () => {
+    const projectPath = await createTestProject({
+      hasPackageJson: true,
+      files: [
+        { path: 'src/index.js', content: '' }, // Only JS files
+      ],
+    })
+
+    const analysis = {
+      projectId: 'test',
+      languages: ['TypeScript', 'Go'], // Declared but no .ts or .go files
+      frameworks: [],
+      configFiles: [],
+      fileCount: 1,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-10T00:00:00.000Z',
+      status: 'draft' as const,
+    }
+
+    const result = await semanticVerify(analysis, projectPath)
+
+    const languageCheck = result.checks.find(
+      (c: SemanticCheckResult) => c.name === 'Language verification'
+    )
+    expect(languageCheck?.passed).toBe(false)
+    expect(languageCheck?.error).toContain('without matching files')
+
+    await cleanupTestProject(projectPath)
+  })
+
+  it('should fail when pattern locations reference missing files', async () => {
+    const projectPath = await createTestProject({
+      hasPackageJson: true,
+      files: [{ path: 'src/index.ts', content: '' }],
+    })
+
+    const analysis = {
+      projectId: 'test',
+      languages: ['TypeScript'],
+      frameworks: [],
+      configFiles: [],
+      fileCount: 1,
+      patterns: [
+        { name: 'Service pattern', description: 'DI', location: 'src/service.ts' }, // Doesn't exist
+        { name: 'Repository', description: 'Data access', location: 'src/repo.ts' }, // Doesn't exist
+      ],
+      antiPatterns: [],
+      analyzedAt: '2026-02-10T00:00:00.000Z',
+      status: 'draft' as const,
+    }
+
+    const result = await semanticVerify(analysis, projectPath)
+
+    const patternCheck = result.checks.find(
+      (c: SemanticCheckResult) => c.name === 'Pattern location verification'
+    )
+    expect(patternCheck?.passed).toBe(false)
+    expect(patternCheck?.error).toContain('not found')
+
+    await cleanupTestProject(projectPath)
+  })
+
+  it('should fail when file count is inaccurate', async () => {
+    const projectPath = await createTestProject({
+      hasPackageJson: true,
+      files: [
+        { path: 'src/a.ts', content: '' },
+        { path: 'src/b.ts', content: '' },
+        { path: 'src/c.ts', content: '' },
+      ], // 4 files total (package.json + 3 .ts files)
+    })
+
+    const analysis = {
+      projectId: 'test',
+      languages: ['TypeScript'],
+      frameworks: [],
+      configFiles: [],
+      fileCount: 100, // Way off (actual is ~4)
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-10T00:00:00.000Z',
+      status: 'draft' as const,
+    }
+
+    const result = await semanticVerify(analysis, projectPath)
+
+    const fileCountCheck = result.checks.find(
+      (c: SemanticCheckResult) => c.name === 'File count verification'
+    )
+    expect(fileCountCheck?.passed).toBe(false)
+    expect(fileCountCheck?.error).toContain('mismatch')
+
+    await cleanupTestProject(projectPath)
+  })
+
+  it('should fail when anti-pattern files are missing', async () => {
+    const projectPath = await createTestProject({
+      hasPackageJson: true,
+      files: [{ path: 'src/index.ts', content: '' }],
+    })
+
+    const analysis = {
+      projectId: 'test',
+      languages: ['TypeScript'],
+      frameworks: [],
+      configFiles: [],
+      fileCount: 1,
+      patterns: [],
+      antiPatterns: [
+        { issue: 'Missing types', file: 'src/bad.ts', suggestion: 'Add types' }, // File doesn't exist
+      ],
+      analyzedAt: '2026-02-10T00:00:00.000Z',
+      status: 'draft' as const,
+    }
+
+    const result = await semanticVerify(analysis, projectPath)
+
+    const antiPatternCheck = result.checks.find(
+      (c: SemanticCheckResult) => c.name === 'Anti-pattern file verification'
+    )
+    expect(antiPatternCheck?.passed).toBe(false)
+    expect(antiPatternCheck?.error).toContain('not found')
+
+    await cleanupTestProject(projectPath)
+  })
+
+  it('should skip checks when no data to verify', async () => {
+    const projectPath = await createTestProject({
+      hasPackageJson: true,
+    })
+
+    const analysis = {
+      projectId: 'test',
+      languages: [], // No languages declared
+      frameworks: [], // No frameworks declared
+      configFiles: [],
+      fileCount: 1,
+      patterns: [], // No patterns with locations
+      antiPatterns: [], // No anti-patterns
+      analyzedAt: '2026-02-10T00:00:00.000Z',
+      status: 'draft' as const,
+    }
+
+    const result = await semanticVerify(analysis, projectPath)
+
+    expect(result.passed).toBe(true) // All checks skipped, so passes
+    expect(
+      result.checks.every((c: SemanticCheckResult) => c.output?.includes('skipped') || c.passed)
+    ).toBe(true)
+
+    await cleanupTestProject(projectPath)
+  })
+
+  it('should accept file count within tolerance (10%)', async () => {
+    const projectPath = await createTestProject({
+      hasPackageJson: true,
+      files: [
+        { path: 'src/a.ts', content: '' },
+        { path: 'src/b.ts', content: '' },
+        { path: 'src/c.ts', content: '' },
+        { path: 'src/d.ts', content: '' },
+        { path: 'src/e.ts', content: '' },
+      ], // 6 files total
+    })
+
+    const analysis = {
+      projectId: 'test',
+      languages: ['TypeScript'],
+      frameworks: [],
+      configFiles: [],
+      fileCount: 6, // Within 10% tolerance
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-10T00:00:00.000Z',
+      status: 'draft' as const,
+    }
+
+    const result = await semanticVerify(analysis, projectPath)
+
+    const fileCountCheck = result.checks.find(
+      (c: SemanticCheckResult) => c.name === 'File count verification'
+    )
+    expect(fileCountCheck?.passed).toBe(true)
+
+    await cleanupTestProject(projectPath)
+  })
+
+  it('should handle partial framework matches (case insensitive)', async () => {
+    const projectPath = await createTestProject({
+      hasPackageJson: true,
+      packageJsonDeps: { '@hono/node-server': '^1.0.0' }, // Hono as part of package name
+    })
+
+    const analysis = {
+      projectId: 'test',
+      languages: [],
+      frameworks: ['Hono'], // Should match @hono/node-server
+      configFiles: [],
+      fileCount: 1,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-10T00:00:00.000Z',
+      status: 'draft' as const,
+    }
+
+    const result = await semanticVerify(analysis, projectPath)
+
+    const frameworkCheck = result.checks.find(
+      (c: SemanticCheckResult) => c.name === 'Framework verification'
+    )
+    expect(frameworkCheck?.passed).toBe(true)
+
+    await cleanupTestProject(projectPath)
+  })
+})