prjct-cli 1.14.0 → 1.15.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## [1.15.0] - 2026-02-09
+
+### Features
+
+- replace hardcoded memory domain tags with semantic matching (PRJ-300) (#157)
+
+
+## [1.14.1] - 2026-02-09
+
+### Improved
+- **Semantic memory domain matching** (PRJ-300): Memory retrieval now uses two-pass scoring (exact MEMORY_TAG match + semantic keyword match) instead of exact-only tag matching. Unknown domains like "uxui" are resolved to canonical domains ("frontend") via SEMANTIC_DOMAIN_KEYWORDS map.
+- **Tech stack normalizer**: New `tech-normalizer.ts` module handles framework name normalization, compound names ("React + TypeScript"), framework families (Next.js → React), and alias resolution (nextjs → next.js).
+- **Anti-hallucination dedup**: Tech stack entries in the anti-hallucination block are now deduplicated using normalized matching, preventing duplicates like "React" and "react" or "Next.js" and "nextjs".
+- **Sealed analysis priority**: Prompt builder now uses sealed analysis frameworks as primary tech stack source, falling back to repo conventions.
+
+### Implementation Details
+- Expanded `TaskDomain` type from fixed union to `KnownDomain | (string & {})` for forward compatibility while preserving autocomplete
+- `DOMAIN_TAG_MAP` now includes TECH_STACK for frontend/database domains (previously missing)
+- `SEMANTIC_DOMAIN_KEYWORDS` maps 80+ keywords across 7 domains for fuzzy domain resolution
+- `resolveCanonicalDomains()` exported for testability — resolves arbitrary strings to known domains
+- `normalizeFrameworkName()` handles 15 aliases; `FRAMEWORK_FAMILIES` maps 12 meta-frameworks to base frameworks
+- `extractTechNames()` splits compound tech strings on +, /, commas, parentheses, "with", "and"
+
+### Learnings
+- Two-pass scoring (exact 10pts + semantic 5pts) gives gradual relevance instead of binary match/no-match
+- TypeScript's `KnownDomain | (string & {})` pattern preserves autocomplete for known values while accepting any string
+- Parentheses in compound names need comma replacement (not space) — otherwise adjacent words merge into a single token
+
+### Test Plan
+
+#### For QA
+1. `bun test core/__tests__/agentic/semantic-matching.test.ts` — domain resolution (uxui→frontend, api→backend, infra→devops)
+2. `bun test core/__tests__/agentic/tech-normalizer.test.ts` — normalization, compound names, framework families, dedup
+3. `bun test core/__tests__/agentic/prompt-assembly.test.ts` — anti-hallucination block still renders correctly
+4. `bun test` — 848 tests pass, 0 fail
+
+#### For Users
+- Memory retrieval automatically surfaces related memories across domains
+- No user action needed — improvements are automatic
+- No breaking changes
+
 ## [1.14.0] - 2026-02-09
 
 ### Features

package/core/__tests__/agentic/semantic-matching.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, it } from 'bun:test'
+import {
+  DOMAIN_TAG_MAP,
+  resolveCanonicalDomains,
+  SEMANTIC_DOMAIN_KEYWORDS,
+} from '../../agentic/memory-system'
+import { KNOWN_DOMAINS, MEMORY_TAGS } from '../../types/memory'
+
+describe('semantic domain matching (PRJ-300)', () => {
+  describe('resolveCanonicalDomains', () => {
+    it('should pass through known domains unchanged', () => {
+      expect(resolveCanonicalDomains('frontend')).toEqual(['frontend'])
+      expect(resolveCanonicalDomains('backend')).toEqual(['backend'])
+      expect(resolveCanonicalDomains('devops')).toEqual(['devops'])
+      expect(resolveCanonicalDomains('testing')).toEqual(['testing'])
+      expect(resolveCanonicalDomains('database')).toEqual(['database'])
+      expect(resolveCanonicalDomains('general')).toEqual(['general'])
+    })
+
+    it('should resolve "uxui" to frontend', () => {
+      const result = resolveCanonicalDomains('uxui')
+      expect(result).toContain('frontend')
+    })
+
+    it('should resolve "ui" to frontend', () => {
+      const result = resolveCanonicalDomains('ui')
+      expect(result).toContain('frontend')
+    })
+
+    it('should resolve "api" to backend', () => {
+      const result = resolveCanonicalDomains('api')
+      expect(result).toContain('backend')
+    })
+
+    it('should resolve "ml-pipeline" to backend', () => {
+      const result = resolveCanonicalDomains('ml-pipeline')
+      // "pipeline" matches devops, so it should at least resolve
+      expect(result.length).toBeGreaterThan(0)
+      expect(result).not.toEqual(['general'])
+    })
+
+    it('should resolve "infra" to devops', () => {
+      const result = resolveCanonicalDomains('infra')
+      expect(result).toContain('devops')
+    })
+
+    it('should resolve "docker" to devops', () => {
+      const result = resolveCanonicalDomains('docker')
+      expect(result).toContain('devops')
+    })
+
+    it('should resolve "schema" to database', () => {
+      const result = resolveCanonicalDomains('schema')
+      expect(result).toContain('database')
+    })
+
+    it('should resolve "css" to frontend', () => {
+      const result = resolveCanonicalDomains('css')
+      expect(result).toContain('frontend')
+    })
+
+    it('should resolve "e2e" to testing', () => {
+      const result = resolveCanonicalDomains('e2e')
+      expect(result).toContain('testing')
+    })
+
+    it('should fallback to general for truly unknown domains', () => {
+      expect(resolveCanonicalDomains('quantum-computing')).toEqual(['general'])
+      expect(resolveCanonicalDomains('astrology')).toEqual(['general'])
+    })
+
+    it('should handle case-insensitive and separator-insensitive', () => {
+      expect(resolveCanonicalDomains('UI')).toContain('frontend')
+      expect(resolveCanonicalDomains('API')).toContain('backend')
+      expect(resolveCanonicalDomains('e_2_e')).toContain('testing')
+    })
+  })
+
+  describe('DOMAIN_TAG_MAP', () => {
+    it('should include TECH_STACK for frontend (improved from PRJ-107)', () => {
+      expect(DOMAIN_TAG_MAP.frontend).toContain(MEMORY_TAGS.TECH_STACK)
+    })
+
+    it('should include TECH_STACK for database', () => {
+      expect(DOMAIN_TAG_MAP.database).toContain(MEMORY_TAGS.TECH_STACK)
+    })
+
+    it('should include DEPENDENCIES for testing', () => {
+      expect(DOMAIN_TAG_MAP.testing).toContain(MEMORY_TAGS.DEPENDENCIES)
+    })
+
+    it('should include all MEMORY_TAGS for general', () => {
+      const allTags = Object.values(MEMORY_TAGS)
+      for (const tag of allTags) {
+        expect(DOMAIN_TAG_MAP.general).toContain(tag)
+      }
+    })
+
+    it('should have mappings for all known domains', () => {
+      for (const domain of KNOWN_DOMAINS) {
+        expect(DOMAIN_TAG_MAP[domain]).toBeDefined()
+        expect(DOMAIN_TAG_MAP[domain].length).toBeGreaterThan(0)
+      }
+    })
+  })
+
+  describe('SEMANTIC_DOMAIN_KEYWORDS', () => {
+    it('should map uxui-related keywords to frontend', () => {
+      expect(SEMANTIC_DOMAIN_KEYWORDS.frontend).toContain('uxui')
+      expect(SEMANTIC_DOMAIN_KEYWORDS.frontend).toContain('ui')
+      expect(SEMANTIC_DOMAIN_KEYWORDS.frontend).toContain('ux')
+      expect(SEMANTIC_DOMAIN_KEYWORDS.frontend).toContain('css')
+    })
+
+    it('should map CI/CD keywords to devops', () => {
+      expect(SEMANTIC_DOMAIN_KEYWORDS.devops).toContain('ci')
+      expect(SEMANTIC_DOMAIN_KEYWORDS.devops).toContain('cd')
+      expect(SEMANTIC_DOMAIN_KEYWORDS.devops).toContain('docker')
+      expect(SEMANTIC_DOMAIN_KEYWORDS.devops).toContain('kubernetes')
+    })
+
+    it('should have keywords for all known domains except general', () => {
+      for (const domain of KNOWN_DOMAINS) {
+        expect(SEMANTIC_DOMAIN_KEYWORDS[domain]).toBeDefined()
+        if (domain !== 'general') {
+          expect(SEMANTIC_DOMAIN_KEYWORDS[domain].length).toBeGreaterThan(0)
+        }
+      }
+    })
+  })
+})

package/core/__tests__/agentic/tech-normalizer.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it } from 'bun:test'
+import {
+  deduplicateTechStack,
+  extractTechNames,
+  getFrameworkFamily,
+  matchesTech,
+  normalizeFrameworkName,
+} from '../../agentic/tech-normalizer'
+
+describe('tech-normalizer', () => {
+  describe('normalizeFrameworkName', () => {
+    it('should lowercase and trim', () => {
+      expect(normalizeFrameworkName('  TypeScript ')).toBe('typescript')
+      expect(normalizeFrameworkName('React')).toBe('react')
+    })
+
+    it('should resolve aliases', () => {
+      expect(normalizeFrameworkName('NodeJS')).toBe('node')
+      expect(normalizeFrameworkName('ts')).toBe('typescript')
+      expect(normalizeFrameworkName('js')).toBe('javascript')
+      expect(normalizeFrameworkName('pg')).toBe('postgres')
+      expect(normalizeFrameworkName('postgresql')).toBe('postgres')
+    })
+
+    it('should preserve dotted names', () => {
+      expect(normalizeFrameworkName('Next.js')).toBe('next.js')
+      expect(normalizeFrameworkName('Vue.js')).toBe('vue')
+    })
+
+    it('should handle nextjs alias', () => {
+      expect(normalizeFrameworkName('nextjs')).toBe('next.js')
+      expect(normalizeFrameworkName('nuxtjs')).toBe('nuxt.js')
+    })
+  })
+
+  describe('extractTechNames', () => {
+    it('should split on + separator', () => {
+      expect(extractTechNames('React + TypeScript')).toEqual(['react', 'typescript'])
+    })
+
+    it('should extract from parentheses', () => {
+      expect(extractTechNames('Next.js (React)')).toEqual(['next.js', 'react'])
+    })
+
+    it('should split on "with"', () => {
+      expect(extractTechNames('Hono with Zod')).toEqual(['hono', 'zod'])
+    })
+
+    it('should split on commas', () => {
+      expect(extractTechNames('React, Vue, Angular')).toEqual(['react', 'vue', 'angular'])
+    })
+
+    it('should handle single name', () => {
+      expect(extractTechNames('React')).toEqual(['react'])
+    })
+  })
+
+  describe('getFrameworkFamily', () => {
+    it('should resolve meta-frameworks to base', () => {
+      expect(getFrameworkFamily('next.js')).toBe('react')
+      expect(getFrameworkFamily('Next.js')).toBe('react')
+      expect(getFrameworkFamily('Remix')).toBe('react')
+      expect(getFrameworkFamily('Gatsby')).toBe('react')
+    })
+
+    it('should resolve Vue meta-frameworks', () => {
+      expect(getFrameworkFamily('nuxt')).toBe('vue')
+      expect(getFrameworkFamily('Nuxt.js')).toBe('vue')
+    })
+
+    it('should resolve Svelte meta-framework', () => {
+      expect(getFrameworkFamily('SvelteKit')).toBe('svelte')
+    })
+
+    it('should return name itself for base frameworks', () => {
+      expect(getFrameworkFamily('React')).toBe('react')
+      expect(getFrameworkFamily('Express')).toBe('express')
+      expect(getFrameworkFamily('Hono')).toBe('hono')
+    })
+  })
+
+  describe('matchesTech', () => {
+    it('should match exact names (case-insensitive)', () => {
+      expect(matchesTech('React', 'react')).toBe(true)
+      expect(matchesTech('react', 'React')).toBe(true)
+    })
+
+    it('should match via framework family', () => {
+      expect(matchesTech('Next.js', 'react')).toBe(true)
+      expect(matchesTech('Nuxt', 'vue')).toBe(true)
+      expect(matchesTech('SvelteKit', 'svelte')).toBe(true)
+    })
+
+    it('should match compound names', () => {
+      expect(matchesTech('React + TypeScript', 'react')).toBe(true)
+      expect(matchesTech('React + TypeScript', 'typescript')).toBe(true)
+    })
+
+    it('should match parenthesized names', () => {
+      expect(matchesTech('Next.js (React)', 'react')).toBe(true)
+      expect(matchesTech('Next.js (React)', 'next.js')).toBe(true)
+    })
+
+    it('should not match unrelated frameworks', () => {
+      expect(matchesTech('Vue', 'react')).toBe(false)
+      expect(matchesTech('Angular', 'react')).toBe(false)
+    })
+  })
+
+  describe('deduplicateTechStack', () => {
+    it('should remove case-insensitive duplicates', () => {
+      expect(deduplicateTechStack(['React', 'react', 'REACT'])).toEqual(['React'])
+    })
+
+    it('should remove alias duplicates', () => {
+      expect(deduplicateTechStack(['TypeScript', 'ts'])).toEqual(['TypeScript'])
+      expect(deduplicateTechStack(['Node.js', 'nodejs'])).toEqual(['Node.js'])
+    })
+
+    it('should preserve unique entries', () => {
+      expect(deduplicateTechStack(['React', 'Next.js', 'TypeScript'])).toEqual([
+        'React',
+        'Next.js',
+        'TypeScript',
+      ])
+    })
+
+    it('should preserve first occurrence casing', () => {
+      expect(deduplicateTechStack(['Next.js', 'nextjs', 'NEXT.JS'])).toEqual(['Next.js'])
+    })
+
+    it('should handle empty array', () => {
+      expect(deduplicateTechStack([])).toEqual([])
+    })
+  })
+})

package/core/agentic/anti-hallucination.ts

@@ -19,6 +19,7 @@
  */
 
 import { z } from 'zod'
+import { deduplicateTechStack } from './tech-normalizer'
 
 // =============================================================================
 // Schema
@@ -85,25 +86,19 @@ export function buildAntiHallucinationBlock(truth: ProjectGroundTruth): string {
 
   parts.push('## CONSTRAINTS (Read Before Acting)\n')
 
-  // 1. Explicit availability (enriched by sealed analysis — PRJ-260)
-  const available: string[] = []
-  if (truth.language) available.push(truth.language)
-  if (truth.framework) available.push(truth.framework)
+  // 1. Explicit availability (enriched by sealed analysis — PRJ-260, PRJ-300)
+  // Use normalized deduplication to prevent "React" and "react" appearing twice,
+  // and to handle aliases like "Next.js" vs "nextjs".
+  const rawAvailable: string[] = []
+  if (truth.language) rawAvailable.push(truth.language)
+  if (truth.framework) rawAvailable.push(truth.framework)
   const techStack = truth.techStack ?? []
-  available.push(...techStack.filter((t) => t !== truth.framework))
-  // Merge languages/frameworks from sealed analysis (deduped)
+  rawAvailable.push(...techStack)
+  // Merge languages/frameworks from sealed analysis
   const analysisLangs = truth.analysisLanguages ?? []
   const analysisFrameworks = truth.analysisFrameworks ?? []
-  for (const lang of analysisLangs) {
-    if (!available.some((a) => a.toLowerCase() === lang.toLowerCase())) {
-      available.push(lang)
-    }
-  }
-  for (const fw of analysisFrameworks) {
-    if (!available.some((a) => a.toLowerCase() === fw.toLowerCase())) {
-      available.push(fw)
-    }
-  }
+  rawAvailable.push(...analysisLangs, ...analysisFrameworks)
+  const available = deduplicateTechStack(rawAvailable)
 
   if (available.length > 0) {
     parts.push(`AVAILABLE in this project: ${available.join(', ')}`)

package/core/agentic/memory-system.ts

@@ -26,6 +26,7 @@ export type {
   Decision,
   HistoryEntry,
   HistoryEventType,
+  KnownDomain,
   Memory,
   MemoryContext,
   MemoryContextParams,
@@ -40,11 +41,12 @@ export type {
   Workflow,
 } from '../types/memory'
 
-export { calculateConfidence, MEMORY_TAGS } from '../types/memory'
+export { calculateConfidence, KNOWN_DOMAINS, MEMORY_TAGS } from '../types/memory'
 
 import type {
   HistoryEntry,
   HistoryEventType,
+  KnownDomain,
   Memory,
   MemoryContext,
   MemoryDatabase,
@@ -58,7 +60,167 @@ import type {
   Workflow,
 } from '../types/memory'
 
-import { calculateConfidence, MEMORY_TAGS } from '../types/memory'
+import { calculateConfidence, KNOWN_DOMAINS, MEMORY_TAGS } from '../types/memory'
+
+// =============================================================================
+// Semantic Domain Mapping (PRJ-300)
+// =============================================================================
+
+/**
+ * Map each known domain to its relevant MEMORY_TAGS.
+ * More comprehensive than the previous mapping — includes TECH_STACK and
+ * DEPENDENCIES where they apply.
+ */
+export const DOMAIN_TAG_MAP: Record<string, MemoryTag[]> = {
+  frontend: [
+    MEMORY_TAGS.CODE_STYLE,
+    MEMORY_TAGS.FILE_STRUCTURE,
+    MEMORY_TAGS.ARCHITECTURE,
+    MEMORY_TAGS.TECH_STACK,
+  ],
+  backend: [
+    MEMORY_TAGS.CODE_STYLE,
+    MEMORY_TAGS.ARCHITECTURE,
+    MEMORY_TAGS.DEPENDENCIES,
+    MEMORY_TAGS.TECH_STACK,
+  ],
+  devops: [
+    MEMORY_TAGS.SHIP_WORKFLOW,
+    MEMORY_TAGS.TEST_BEHAVIOR,
+    MEMORY_TAGS.DEPENDENCIES,
+    MEMORY_TAGS.ARCHITECTURE,
+  ],
+  docs: [MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.NAMING_CONVENTION, MEMORY_TAGS.FILE_STRUCTURE],
+  testing: [MEMORY_TAGS.TEST_BEHAVIOR, MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.DEPENDENCIES],
+  database: [
+    MEMORY_TAGS.ARCHITECTURE,
+    MEMORY_TAGS.NAMING_CONVENTION,
+    MEMORY_TAGS.TECH_STACK,
+    MEMORY_TAGS.DEPENDENCIES,
+  ],
+  general: Object.values(MEMORY_TAGS) as MemoryTag[],
+}
+
+/**
+ * Semantic keywords for each domain.
+ * Used to resolve unknown domain strings (e.g., "uxui" → frontend)
+ * and for partial scoring when memory tags relate semantically.
+ * @see PRJ-300
+ */
+export const SEMANTIC_DOMAIN_KEYWORDS: Record<string, string[]> = {
+  frontend: [
+    'ui',
+    'ux',
+    'uxui',
+    'css',
+    'styling',
+    'component',
+    'layout',
+    'design',
+    'responsive',
+    'react',
+    'vue',
+    'svelte',
+    'angular',
+    'html',
+    'tailwind',
+    'sass',
+    'web',
+    'accessibility',
+    'a11y',
+  ],
+  backend: [
+    'api',
+    'server',
+    'route',
+    'endpoint',
+    'rest',
+    'graphql',
+    'middleware',
+    'worker',
+    'queue',
+    'auth',
+    'hono',
+    'express',
+    'service',
+    'microservice',
+  ],
+  devops: [
+    'ci',
+    'cd',
+    'docker',
+    'kubernetes',
+    'deploy',
+    'infra',
+    'infrastructure',
+    'monitoring',
+    'cloud',
+    'aws',
+    'gcp',
+    'azure',
+    'pipeline',
+    'helm',
+    'terraform',
+  ],
+  docs: ['documentation', 'readme', 'guide', 'tutorial', 'wiki', 'changelog', 'jsdoc', 'typedoc'],
+  testing: [
+    'test',
+    'spec',
+    'e2e',
+    'unit',
+    'integration',
+    'coverage',
+    'mock',
+    'vitest',
+    'jest',
+    'playwright',
+    'cypress',
+  ],
+  database: [
+    'db',
+    'sql',
+    'schema',
+    'migration',
+    'query',
+    'orm',
+    'prisma',
+    'mongo',
+    'postgres',
+    'redis',
+    'drizzle',
+    'sqlite',
+  ],
+  general: [],
+}
+
+/**
+ * Resolve a domain string to canonical known domain(s).
+ * Known domains pass through; unknown domains are matched via semantic keywords.
+ * Exported for testing.
+ * @see PRJ-300
+ */
+export function resolveCanonicalDomains(domain: string): KnownDomain[] {
+  // Exact match
+  if ((KNOWN_DOMAINS as readonly string[]).includes(domain)) {
+    return [domain as KnownDomain]
+  }
+
+  // Semantic resolution — find canonical domains whose keywords match
+  const normalized = domain.toLowerCase().replace(/[-_\s]/g, '')
+  const matches: KnownDomain[] = []
+
+  for (const [canonical, keywords] of Object.entries(SEMANTIC_DOMAIN_KEYWORDS)) {
+    if (canonical === 'general') continue
+    for (const kw of keywords) {
+      if (normalized.includes(kw) || kw.includes(normalized)) {
+        matches.push(canonical as KnownDomain)
+        break
+      }
+    }
+  }
+
+  return matches.length > 0 ? matches : ['general']
+}
 
 // =============================================================================
 // Base Store
@@ -858,11 +1020,9 @@ export class SemanticMemories extends CachedStore<MemoryDatabase> {
         userTriggered: 0,
       }
 
-      // Domain match scoring (0-25 points)
+      // Domain match scoring (0-25 points) — semantic matching (PRJ-300)
       if (query.taskDomain) {
-        const domainTags = this._getDomainTags(query.taskDomain)
-        const matchingTags = (memory.tags || []).filter((tag) => domainTags.includes(tag))
-        breakdown.domainMatch = Math.min(25, matchingTags.length * 10)
+        breakdown.domainMatch = this._getSemanticDomainScore(query.taskDomain, memory.tags || [])
       }
 
       // Tag match from command context (0-20 points)
@@ -943,25 +1103,66 @@ export class SemanticMemories extends CachedStore<MemoryDatabase> {
   }
 
   /**
-   * Map task domain to relevant memory tags.
-   * @see PRJ-107
+   * Compute semantic domain match score (0-25 points).
+   *
+   * Two-pass scoring:
+   * 1. Exact MEMORY_TAG match: memory tag in domain's tag list → 10 pts each
+   * 2. Semantic match: memory tag relates to domain via keywords → 5 pts each
+   *
+   * Unknown domains are resolved to canonical domain(s) via SEMANTIC_DOMAIN_KEYWORDS.
+   * @see PRJ-107, PRJ-300
    */
-  private _getDomainTags(domain: TaskDomain): MemoryTag[] {
-    const domainTagMap: Record<TaskDomain, MemoryTag[]> = {
-      frontend: [MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.FILE_STRUCTURE, MEMORY_TAGS.ARCHITECTURE],
-      backend: [
-        MEMORY_TAGS.CODE_STYLE,
-        MEMORY_TAGS.ARCHITECTURE,
-        MEMORY_TAGS.DEPENDENCIES,
-        MEMORY_TAGS.TECH_STACK,
-      ],
-      devops: [MEMORY_TAGS.SHIP_WORKFLOW, MEMORY_TAGS.TEST_BEHAVIOR, MEMORY_TAGS.DEPENDENCIES],
-      docs: [MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.NAMING_CONVENTION],
-      testing: [MEMORY_TAGS.TEST_BEHAVIOR, MEMORY_TAGS.CODE_STYLE],
-      database: [MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.NAMING_CONVENTION],
-      general: Object.values(MEMORY_TAGS) as MemoryTag[],
+  private _getSemanticDomainScore(domain: TaskDomain, memoryTags: string[]): number {
+    // Resolve to canonical domain(s)
+    const canonicals = this._resolveCanonicalDomains(domain)
+    if (canonicals.length === 0) return 0
+
+    // Collect all relevant MEMORY_TAGS for the canonical domains
+    const relevantTags = new Set<string>()
+    for (const canonical of canonicals) {
+      const tags = DOMAIN_TAG_MAP[canonical]
+      if (tags) {
+        for (const tag of tags) relevantTags.add(tag)
+      }
+    }
+
+    // Collect semantic keywords for the canonical domains
+    const domainKeywords = new Set<string>()
+    for (const canonical of canonicals) {
+      const keywords = SEMANTIC_DOMAIN_KEYWORDS[canonical]
+      if (keywords) {
+        for (const kw of keywords) domainKeywords.add(kw)
+      }
+    }
+
+    let score = 0
+
+    for (const tag of memoryTags) {
+      // Pass 1: exact MEMORY_TAG match (10 pts)
+      if (relevantTags.has(tag)) {
+        score += 10
+        continue
+      }
+      // Pass 2: semantic keyword match (5 pts)
+      const normalized = tag.toLowerCase().replace(/[-_\s]/g, '')
+      for (const kw of domainKeywords) {
+        if (normalized.includes(kw) || kw.includes(normalized)) {
+          score += 5
+          break
+        }
+      }
     }
-    return domainTagMap[domain] || []
+
+    return Math.min(25, score)
+  }
+
+  /**
+   * Resolve a domain string to canonical known domain(s).
+   * Delegates to module-level resolveCanonicalDomains().
+   * @see PRJ-300
+   */
+  private _resolveCanonicalDomains(domain: TaskDomain): KnownDomain[] {
+    return resolveCanonicalDomains(domain)
   }
 
   /**

package/core/agentic/prompt-builder.ts

@@ -39,6 +39,7 @@ import {
   InjectionBudgetTracker,
   truncateToTokenBudget,
 } from './injection-validator'
+import { deduplicateTechStack } from './tech-normalizer'
 import type { TokenBudgetCoordinator } from './token-budget'
 
 // =============================================================================
@@ -689,10 +690,17 @@ class PromptBuilder {
 
     if (projectPath) {
       const sa = orchestratorContext?.sealedAnalysis
+      // PRJ-300: prefer sealed analysis frameworks as primary tech stack,
+      // falling back to repo conventions. Deduplicate with normalized matching.
+      const rawStack = [
+        ...(sa?.frameworks || []),
+        ...(orchestratorContext?.project?.conventions || []),
+      ]
       const groundTruth: ProjectGroundTruth = {
         projectPath,
         language: orchestratorContext?.project?.ecosystem,
-        techStack: orchestratorContext?.project?.conventions || [],
+        framework: sa?.frameworks?.[0],
+        techStack: deduplicateTechStack(rawStack),
         domains: this.extractDomains(state),
         fileCount: context.files?.length || context.filteredSize || 0,
         availableAgents: orchestratorContext?.agents?.map((a) => a.name) || [],

package/core/agentic/tech-normalizer.ts

@@ -0,0 +1,167 @@
+/**
+ * Tech Normalizer (PRJ-300)
+ *
+ * Normalized matching for tech stack / framework names.
+ * Handles:
+ * - Compound names: "React + TypeScript" → ["react", "typescript"]
+ * - Framework aliases: "nextjs" → "next.js"
+ * - Framework families: "Next.js" → react family
+ * - Case-insensitive, whitespace-insensitive matching
+ */
+
+// =============================================================================
+// Framework Families
+// =============================================================================
+
+/**
+ * Map framework names to their family (meta-framework → base framework).
+ * Used to verify that "Next.js" matches expected "react".
+ */
+const FRAMEWORK_FAMILIES: Record<string, string> = {
+  'next.js': 'react',
+  nextjs: 'react',
+  remix: 'react',
+  gatsby: 'react',
+  'react native': 'react',
+  expo: 'react',
+  nuxt: 'vue',
+  'nuxt.js': 'vue',
+  nuxtjs: 'vue',
+  sveltekit: 'svelte',
+  analog: 'angular',
+  astro: 'multi',
+  vite: 'multi',
+}
+
+/**
+ * Aliases that normalize to a canonical name.
+ */
+const FRAMEWORK_ALIASES: Record<string, string> = {
+  nextjs: 'next.js',
+  nuxtjs: 'nuxt.js',
+  expressjs: 'express',
+  fastifyjs: 'fastify',
+  'react.js': 'react',
+  'vue.js': 'vue',
+  'svelte.js': 'svelte',
+  'angular.js': 'angular',
+  angularjs: 'angular',
+  'node.js': 'node',
+  nodejs: 'node',
+  ts: 'typescript',
+  js: 'javascript',
+  pg: 'postgres',
+  postgresql: 'postgres',
+  mongo: 'mongodb',
+}
+
+// =============================================================================
+// Core Functions
+// =============================================================================
+
+/**
+ * Normalize a single framework/tech name.
+ * Strips whitespace, lowercases, resolves aliases.
+ *
+ * @example
+ * normalizeFrameworkName("Next.js") → "next.js"
+ * normalizeFrameworkName("  TypeScript ") → "typescript"
+ * normalizeFrameworkName("NodeJS") → "node"
+ */
+export function normalizeFrameworkName(name: string): string {
+  const trimmed = name.trim().toLowerCase()
+
+  // Check aliases
+  const aliasKey = trimmed.replace(/[.\s-]/g, '')
+  if (FRAMEWORK_ALIASES[aliasKey]) {
+    return FRAMEWORK_ALIASES[aliasKey]
+  }
+  if (FRAMEWORK_ALIASES[trimmed]) {
+    return FRAMEWORK_ALIASES[trimmed]
+  }
+
+  return trimmed
+}
+
+/**
+ * Extract individual tech names from a compound string.
+ * Handles separators: +, /, comma, parentheses, "with", "and".
+ *
+ * @example
+ * extractTechNames("React + TypeScript") → ["react", "typescript"]
+ * extractTechNames("Next.js (React)") → ["next.js", "react"]
+ * extractTechNames("Hono with Zod") → ["hono", "zod"]
+ */
+export function extractTechNames(compound: string): string[] {
+  // Replace parentheses with comma separators to split them out
+  const parts = compound
+    .replace(/[()]/g, ',')
+    .split(/[+/,]|\bwith\b|\band\b/i)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0)
+
+  return parts.map(normalizeFrameworkName)
+}
+
+/**
+ * Get the framework family for a tech name.
+ * Returns the base framework or the name itself if no family exists.
+ *
+ * @example
+ * getFrameworkFamily("next.js") → "react"
+ * getFrameworkFamily("nuxt") → "vue"
+ * getFrameworkFamily("express") → "express"
+ */
+export function getFrameworkFamily(name: string): string {
+  const normalized = normalizeFrameworkName(name)
+  return FRAMEWORK_FAMILIES[normalized] || normalized
+}
+
+/**
+ * Check if two tech names match (direct or via family).
+ *
+ * @example
+ * matchesTech("Next.js", "react") → true (Next.js is React family)
+ * matchesTech("React + TypeScript", "react") → true (contains react)
+ * matchesTech("Vue", "react") → false
+ */
+export function matchesTech(actual: string, expected: string): boolean {
+  const expectedNorm = normalizeFrameworkName(expected)
+
+  // Extract all tech names from actual (handles compound names)
+  const actualNames = extractTechNames(actual)
+
+  for (const name of actualNames) {
+    // Direct match
+    if (name === expectedNorm) return true
+    // Family match
+    if (getFrameworkFamily(name) === expectedNorm) return true
+    // Reverse family match
+    if (getFrameworkFamily(expectedNorm) === name) return true
+  }
+
+  return false
+}
+
+/**
+ * Deduplicate a tech stack list using normalized matching.
+ * Preserves the first occurrence's original casing.
+ *
+ * @example
+ * deduplicateTechStack(["React", "react", "Next.js"]) → ["React", "Next.js"]
+ * deduplicateTechStack(["TypeScript", "ts"]) → ["TypeScript"]
+ */
+export function deduplicateTechStack(stack: string[]): string[] {
+  const seen = new Set<string>()
+  const result: string[] = []
+
+  for (const name of stack) {
+    const normalized = normalizeFrameworkName(name)
+    if (!seen.has(normalized)) {
+      seen.add(normalized)
+      result.push(name)
+    }
+  }
+
+  return result
+}

package/core/types/memory.ts

@@ -86,17 +86,27 @@ export interface MemoryQuery {
 }
 
 /**
- * Domain types for task context.
+ * Known domain types for task context.
  * @see PRJ-107
  */
-export type TaskDomain =
-  | 'frontend'
-  | 'backend'
-  | 'devops'
-  | 'docs'
-  | 'testing'
-  | 'database'
-  | 'general'
+export const KNOWN_DOMAINS = [
+  'frontend',
+  'backend',
+  'devops',
+  'docs',
+  'testing',
+  'database',
+  'general',
+] as const
+export type KnownDomain = (typeof KNOWN_DOMAINS)[number]
+
+/**
+ * Task domain — accepts known domains with autocomplete + any string for
+ * semantic resolution. Unknown domains are resolved to the closest canonical
+ * domain via SEMANTIC_DOMAIN_KEYWORDS.
+ * @see PRJ-107, PRJ-300
+ */
+export type TaskDomain = KnownDomain | (string & {})
 
 /**
  * Enhanced query parameters for selective memory retrieval.

package/dist/bin/prjct.mjs

@@ -10482,7 +10482,7 @@ function calculateConfidence(count, userConfirmed = false) {
   if (count >= 3) return "medium";
   return "low";
 }
-var MEMORY_TAGS;
+var MEMORY_TAGS, KNOWN_DOMAINS;
 var init_memory = __esm({
   "core/types/memory.ts"() {
     "use strict";
@@ -10505,6 +10505,15 @@ var init_memory = __esm({
       CONFIRMATION_LEVEL: "confirmation_level",
       AGENT_PREFERENCE: "agent_preference"
     };
+    KNOWN_DOMAINS = [
+      "frontend",
+      "backend",
+      "devops",
+      "docs",
+      "testing",
+      "database",
+      "general"
+    ];
     __name(calculateConfidence, "calculateConfidence");
   }
 });
@@ -10512,7 +10521,24 @@ var init_memory = __esm({
 // core/agentic/memory-system.ts
 import fs25 from "node:fs/promises";
 import path23 from "node:path";
-var CachedStore, SessionStore, HistoryStore, PatternStore, SemanticMemories, MemorySystem, memorySystem, memory_system_default;
+function resolveCanonicalDomains(domain) {
+  if (KNOWN_DOMAINS.includes(domain)) {
+    return [domain];
+  }
+  const normalized = domain.toLowerCase().replace(/[-_\s]/g, "");
+  const matches = [];
+  for (const [canonical, keywords] of Object.entries(SEMANTIC_DOMAIN_KEYWORDS)) {
+    if (canonical === "general") continue;
+    for (const kw of keywords) {
+      if (normalized.includes(kw) || kw.includes(normalized)) {
+        matches.push(canonical);
+        break;
+      }
+    }
+  }
+  return matches.length > 0 ? matches : ["general"];
+}
+var DOMAIN_TAG_MAP, SEMANTIC_DOMAIN_KEYWORDS, CachedStore, SessionStore, HistoryStore, PatternStore, SemanticMemories, MemorySystem, memorySystem, memory_system_default;
 var init_memory_system = __esm({
   "core/agentic/memory-system.ts"() {
     "use strict";
@@ -10524,6 +10550,121 @@ var init_memory_system = __esm({
     init_jsonl_helper();
     init_memory();
     init_memory();
+    DOMAIN_TAG_MAP = {
+      frontend: [
+        MEMORY_TAGS.CODE_STYLE,
+        MEMORY_TAGS.FILE_STRUCTURE,
+        MEMORY_TAGS.ARCHITECTURE,
+        MEMORY_TAGS.TECH_STACK
+      ],
+      backend: [
+        MEMORY_TAGS.CODE_STYLE,
+        MEMORY_TAGS.ARCHITECTURE,
+        MEMORY_TAGS.DEPENDENCIES,
+        MEMORY_TAGS.TECH_STACK
+      ],
+      devops: [
+        MEMORY_TAGS.SHIP_WORKFLOW,
+        MEMORY_TAGS.TEST_BEHAVIOR,
+        MEMORY_TAGS.DEPENDENCIES,
+        MEMORY_TAGS.ARCHITECTURE
+      ],
+      docs: [MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.NAMING_CONVENTION, MEMORY_TAGS.FILE_STRUCTURE],
+      testing: [MEMORY_TAGS.TEST_BEHAVIOR, MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.DEPENDENCIES],
+      database: [
+        MEMORY_TAGS.ARCHITECTURE,
+        MEMORY_TAGS.NAMING_CONVENTION,
+        MEMORY_TAGS.TECH_STACK,
+        MEMORY_TAGS.DEPENDENCIES
+      ],
+      general: Object.values(MEMORY_TAGS)
+    };
+    SEMANTIC_DOMAIN_KEYWORDS = {
+      frontend: [
+        "ui",
+        "ux",
+        "uxui",
+        "css",
+        "styling",
+        "component",
+        "layout",
+        "design",
+        "responsive",
+        "react",
+        "vue",
+        "svelte",
+        "angular",
+        "html",
+        "tailwind",
+        "sass",
+        "web",
+        "accessibility",
+        "a11y"
+      ],
+      backend: [
+        "api",
+        "server",
+        "route",
+        "endpoint",
+        "rest",
+        "graphql",
+        "middleware",
+        "worker",
+        "queue",
+        "auth",
+        "hono",
+        "express",
+        "service",
+        "microservice"
+      ],
+      devops: [
+        "ci",
+        "cd",
+        "docker",
+        "kubernetes",
+        "deploy",
+        "infra",
+        "infrastructure",
+        "monitoring",
+        "cloud",
+        "aws",
+        "gcp",
+        "azure",
+        "pipeline",
+        "helm",
+        "terraform"
+      ],
+      docs: ["documentation", "readme", "guide", "tutorial", "wiki", "changelog", "jsdoc", "typedoc"],
+      testing: [
+        "test",
+        "spec",
+        "e2e",
+        "unit",
+        "integration",
+        "coverage",
+        "mock",
+        "vitest",
+        "jest",
+        "playwright",
+        "cypress"
+      ],
+      database: [
+        "db",
+        "sql",
+        "schema",
+        "migration",
+        "query",
+        "orm",
+        "prisma",
+        "mongo",
+        "postgres",
+        "redis",
+        "drizzle",
+        "sqlite"
+      ],
+      general: []
+    };
+    __name(resolveCanonicalDomains, "resolveCanonicalDomains");
     CachedStore = class {
       static {
         __name(this, "CachedStore");
@@ -11101,9 +11242,7 @@ var init_memory_system = __esm({
             userTriggered: 0
           };
           if (query.taskDomain) {
-            const domainTags = this._getDomainTags(query.taskDomain);
-            const matchingTags = (memory.tags || []).filter((tag) => domainTags.includes(tag));
-            breakdown.domainMatch = Math.min(25, matchingTags.length * 10);
+            breakdown.domainMatch = this._getSemanticDomainScore(query.taskDomain, memory.tags || []);
           }
           if (query.commandName) {
             const commandTags = this._getCommandTags(query.commandName);
@@ -11153,25 +11292,55 @@ var init_memory_system = __esm({
         };
       }
       /**
-       * Map task domain to relevant memory tags.
-       * @see PRJ-107
+       * Compute semantic domain match score (0-25 points).
+       *
+       * Two-pass scoring:
+       * 1. Exact MEMORY_TAG match: memory tag in domain's tag list → 10 pts each
+       * 2. Semantic match: memory tag relates to domain via keywords → 5 pts each
+       *
+       * Unknown domains are resolved to canonical domain(s) via SEMANTIC_DOMAIN_KEYWORDS.
+       * @see PRJ-107, PRJ-300
+       */
+      _getSemanticDomainScore(domain, memoryTags) {
+        const canonicals = this._resolveCanonicalDomains(domain);
+        if (canonicals.length === 0) return 0;
+        const relevantTags = /* @__PURE__ */ new Set();
+        for (const canonical of canonicals) {
+          const tags = DOMAIN_TAG_MAP[canonical];
+          if (tags) {
+            for (const tag of tags) relevantTags.add(tag);
+          }
+        }
+        const domainKeywords = /* @__PURE__ */ new Set();
+        for (const canonical of canonicals) {
+          const keywords = SEMANTIC_DOMAIN_KEYWORDS[canonical];
+          if (keywords) {
+            for (const kw of keywords) domainKeywords.add(kw);
+          }
+        }
+        let score = 0;
+        for (const tag of memoryTags) {
+          if (relevantTags.has(tag)) {
+            score += 10;
+            continue;
+          }
+          const normalized = tag.toLowerCase().replace(/[-_\s]/g, "");
+          for (const kw of domainKeywords) {
+            if (normalized.includes(kw) || kw.includes(normalized)) {
+              score += 5;
+              break;
+            }
+          }
+        }
+        return Math.min(25, score);
+      }
+      /**
+       * Resolve a domain string to canonical known domain(s).
+       * Delegates to module-level resolveCanonicalDomains().
+       * @see PRJ-300
        */
-      _getDomainTags(domain) {
-        const domainTagMap = {
-          frontend: [MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.FILE_STRUCTURE, MEMORY_TAGS.ARCHITECTURE],
-          backend: [
-            MEMORY_TAGS.CODE_STYLE,
-            MEMORY_TAGS.ARCHITECTURE,
-            MEMORY_TAGS.DEPENDENCIES,
-            MEMORY_TAGS.TECH_STACK
-          ],
-          devops: [MEMORY_TAGS.SHIP_WORKFLOW, MEMORY_TAGS.TEST_BEHAVIOR, MEMORY_TAGS.DEPENDENCIES],
-          docs: [MEMORY_TAGS.CODE_STYLE, MEMORY_TAGS.NAMING_CONVENTION],
-          testing: [MEMORY_TAGS.TEST_BEHAVIOR, MEMORY_TAGS.CODE_STYLE],
-          database: [MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.NAMING_CONVENTION],
-          general: Object.values(MEMORY_TAGS)
-        };
-        return domainTagMap[domain] || [];
+      _resolveCanonicalDomains(domain) {
+        return resolveCanonicalDomains(domain);
       }
       /**
        * Map command to relevant memory tags.
@@ -15894,28 +16063,71 @@ var init_outcomes2 = __esm({
   }
 });
 
+// core/agentic/tech-normalizer.ts
+function normalizeFrameworkName(name) {
+  const trimmed = name.trim().toLowerCase();
+  const aliasKey = trimmed.replace(/[.\s-]/g, "");
+  if (FRAMEWORK_ALIASES[aliasKey]) {
+    return FRAMEWORK_ALIASES[aliasKey];
+  }
+  if (FRAMEWORK_ALIASES[trimmed]) {
+    return FRAMEWORK_ALIASES[trimmed];
+  }
+  return trimmed;
+}
+function deduplicateTechStack(stack) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const name of stack) {
+    const normalized = normalizeFrameworkName(name);
+    if (!seen.has(normalized)) {
+      seen.add(normalized);
+      result.push(name);
+    }
+  }
+  return result;
+}
+var FRAMEWORK_ALIASES;
+var init_tech_normalizer = __esm({
+  "core/agentic/tech-normalizer.ts"() {
+    "use strict";
+    FRAMEWORK_ALIASES = {
+      nextjs: "next.js",
+      nuxtjs: "nuxt.js",
+      expressjs: "express",
+      fastifyjs: "fastify",
+      "react.js": "react",
+      "vue.js": "vue",
+      "svelte.js": "svelte",
+      "angular.js": "angular",
+      angularjs: "angular",
+      "node.js": "node",
+      nodejs: "node",
+      ts: "typescript",
+      js: "javascript",
+      pg: "postgres",
+      postgresql: "postgres",
+      mongo: "mongodb"
+    };
+    __name(normalizeFrameworkName, "normalizeFrameworkName");
+    __name(deduplicateTechStack, "deduplicateTechStack");
+  }
+});
+
 // core/agentic/anti-hallucination.ts
 import { z as z16 } from "zod";
 function buildAntiHallucinationBlock(truth) {
   const parts = [];
   parts.push("## CONSTRAINTS (Read Before Acting)\n");
-  const available = [];
-  if (truth.language) available.push(truth.language);
-  if (truth.framework) available.push(truth.framework);
+  const rawAvailable = [];
+  if (truth.language) rawAvailable.push(truth.language);
+  if (truth.framework) rawAvailable.push(truth.framework);
   const techStack = truth.techStack ?? [];
-  available.push(...techStack.filter((t) => t !== truth.framework));
+  rawAvailable.push(...techStack);
   const analysisLangs = truth.analysisLanguages ?? [];
   const analysisFrameworks = truth.analysisFrameworks ?? [];
-  for (const lang of analysisLangs) {
-    if (!available.some((a) => a.toLowerCase() === lang.toLowerCase())) {
-      available.push(lang);
-    }
-  }
-  for (const fw of analysisFrameworks) {
-    if (!available.some((a) => a.toLowerCase() === fw.toLowerCase())) {
-      available.push(fw);
-    }
-  }
+  rawAvailable.push(...analysisLangs, ...analysisFrameworks);
+  const available = deduplicateTechStack(rawAvailable);
   if (available.length > 0) {
     parts.push(`AVAILABLE in this project: ${available.join(", ")}`);
   }
@@ -15948,6 +16160,7 @@ var ProjectGroundTruthSchema, DOMAIN_LABELS;
 var init_anti_hallucination = __esm({
   "core/agentic/anti-hallucination.ts"() {
     "use strict";
+    init_tech_normalizer();
     ProjectGroundTruthSchema = z16.object({
       /** Project root path */
       projectPath: z16.string(),
@@ -16375,6 +16588,7 @@ var init_prompt_builder = __esm({
     init_command_context2();
     init_environment_block();
     init_injection_validator();
+    init_tech_normalizer();
     PromptBuilder = class {
       static {
         __name(this, "PromptBuilder");
@@ -16870,10 +17084,15 @@ Show changes, list affected files, ask for confirmation.
         }
         if (projectPath) {
           const sa = orchestratorContext?.sealedAnalysis;
+          const rawStack = [
+            ...sa?.frameworks || [],
+            ...orchestratorContext?.project?.conventions || []
+          ];
           const groundTruth2 = {
             projectPath,
             language: orchestratorContext?.project?.ecosystem,
-            techStack: orchestratorContext?.project?.conventions || [],
+            framework: sa?.frameworks?.[0],
+            techStack: deduplicateTechStack(rawStack),
             domains: this.extractDomains(state),
             fileCount: context2.files?.length || context2.filteredSize || 0,
             availableAgents: orchestratorContext?.agents?.map((a) => a.name) || [],
@@ -31842,7 +32061,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.14.0",
+      version: "1.15.0",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "core/index.ts",
   "bin": {