prjct-cli 1.12.0 → 1.13.0

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## [1.13.0] - 2026-02-09
+
+### Features
+
+- inject sealed analysis into task prompt context (PRJ-260) (#155)
+
+
+## [1.13.0] - 2026-02-09
+
+### Features
+- **Analysis Injection**: Sealed analysis (languages, frameworks, patterns, anti-patterns) now automatically injected into LLM prompt context (PRJ-260)
+- **Enriched Ground Truth**: Prompt section 3 renders full analysis data — languages, frameworks, package manager, source/test dirs, code patterns, and anti-patterns
+- **Enhanced Anti-Hallucination**: AVAILABLE tech list enriched with analysis data (case-insensitive dedup), package manager constraint added
+
+### Implementation Details
+
+**PRJ-260 — Inject Sync Analysis into Task Context**
+Connected the analysis pipeline (from PRJ-263) to the prompt assembly pipeline (from PRJ-301). `analysisStorage.getActive()` returns sealed analysis (or draft fallback), loaded in parallel with real codebase context for zero latency impact.
+
+Key changes:
+- `core/types/agentic.ts` — New `SealedAnalysisContext` interface, extended `OrchestratorContext` with `sealedAnalysis` field
+- `core/agentic/orchestrator-executor.ts` — Added `loadSealedAnalysis()`, loads in parallel with `gatherRealContext()`
+- `core/agentic/prompt-builder.ts` — Section 3 (ground truth) renders analysis data, Section 5 passes analysis to anti-hallucination
+- `core/agentic/anti-hallucination.ts` — Extended `ProjectGroundTruth` with `analysisLanguages`, `analysisFrameworks`, `analysisPackageManager`
+- `core/__tests__/agentic/analysis-injection.test.ts` — 14 new tests
+
+### Test Plan
+
+#### For QA
+1. Run `prjct sync` on a project with sealed analysis — verify prompt contains Languages, Frameworks, Patterns sections
+2. Run `prjct sync` on a project WITHOUT sealed analysis — verify no crash, fallback rules still present
+3. Check anti-hallucination block — verify AVAILABLE list includes analysis languages/frameworks (deduped)
+4. Run `bun test core/__tests__/agentic/analysis-injection.test.ts` — 14 tests pass
+5. Run `bun test` — all 770 tests pass
+
+#### For Users
+- **What changed:** AI prompts now include your project's detected languages, frameworks, code patterns, and anti-patterns from sealed analysis
+- **How to use:** Run `prjct sync` then `prjct seal` — improvements are automatic in subsequent task prompts
+- **Breaking changes:** None
+
 ## [1.12.0] - 2026-02-09
 
 ### Features

package/core/__tests__/agentic/analysis-injection.test.ts

@@ -0,0 +1,377 @@
+/**
+ * Analysis Injection Tests (PRJ-260)
+ *
+ * Tests for injecting sealed analysis data into task context:
+ * - Prompt builder renders analysis in ground_truth section
+ * - Anti-hallucination block enriched with analysis data
+ * - Graceful degradation when no analysis available
+ */
+
+import { beforeEach, describe, expect, it } from 'bun:test'
+import {
+  buildAntiHallucinationBlock,
+  type ProjectGroundTruth,
+} from '../../agentic/anti-hallucination'
+import promptBuilder from '../../agentic/prompt-builder'
+import type { OrchestratorContext, SealedAnalysisContext } from '../../types'
+
+// =============================================================================
+// Test Fixtures
+// =============================================================================
+
+const mockSealedAnalysis: SealedAnalysisContext = {
+  languages: ['TypeScript', 'JavaScript'],
+  frameworks: ['Hono', 'Zod'],
+  packageManager: 'bun',
+  sourceDir: 'core/',
+  testDir: 'core/__tests__/',
+  fileCount: 295,
+  patterns: [
+    {
+      name: 'StorageManager pattern',
+      description: 'All storage uses StorageManager base class with read/write/update',
+      location: 'core/storage/',
+    },
+    {
+      name: 'Zod schemas',
+      description: 'Runtime validation with Zod for all data structures',
+    },
+  ],
+  antiPatterns: [
+    {
+      issue: 'Direct fs.writeFile without StorageManager',
+      file: 'core/storage/legacy.ts',
+      suggestion: 'Use StorageManager.write() instead',
+    },
+  ],
+  status: 'sealed',
+  commitHash: 'abc123def456',
+}
+
+function makeOrchestratorContext(
+  sealedAnalysis: SealedAnalysisContext | null = mockSealedAnalysis
+): OrchestratorContext {
+  return {
+    detectedDomains: ['backend', 'testing'],
+    primaryDomain: 'backend',
+    agents: [],
+    skills: [],
+    requiresFragmentation: false,
+    subtasks: null,
+    project: {
+      id: 'test-project',
+      ecosystem: 'TypeScript',
+      conventions: ['Hono', 'Zod'],
+    },
+    sealedAnalysis,
+  }
+}
+
+// =============================================================================
+// Prompt Builder — Ground Truth Section
+// =============================================================================
+
+describe('Analysis Injection in Prompt Builder (PRJ-260)', () => {
+  beforeEach(() => {
+    promptBuilder.resetContext()
+  })
+
+  it('should render sealed analysis in ground truth section', async () => {
+    const template = {
+      frontmatter: { description: 'Test task' },
+      content: '## Instructions\nDo the work',
+    }
+    const context = { projectPath: '/test/project', files: ['a.ts'] }
+    const orcCtx = makeOrchestratorContext()
+
+    const prompt = await promptBuilder.build(
+      template,
+      context,
+      {},
+      null,
+      null,
+      null,
+      null,
+      null,
+      orcCtx
+    )
+
+    // Should contain analysis data
+    expect(prompt).toContain('Languages**: TypeScript, JavaScript')
+    expect(prompt).toContain('Frameworks**: Hono, Zod')
+    expect(prompt).toContain('Package Manager**: bun')
+    expect(prompt).toContain('Source Dir**: core/')
+    expect(prompt).toContain('Test Dir**: core/__tests__/')
+    expect(prompt).toContain('Files Analyzed**: 295')
+    expect(prompt).toContain('Analysis Status**: sealed')
+    expect(prompt).toContain('abc123de') // truncated commit hash
+  })
+
+  it('should render code patterns from sealed analysis', async () => {
+    const template = {
+      frontmatter: { description: 'Test' },
+      content: '## Do',
+    }
+    const context = { projectPath: '/test', files: [] }
+    const orcCtx = makeOrchestratorContext()
+
+    const prompt = await promptBuilder.build(
+      template,
+      context,
+      {},
+      null,
+      null,
+      null,
+      null,
+      null,
+      orcCtx
+    )
+
+    expect(prompt).toContain('Code Patterns (Follow These)')
+    expect(prompt).toContain('StorageManager pattern')
+    expect(prompt).toContain('All storage uses StorageManager base class')
+    expect(prompt).toContain('core/storage/')
+    expect(prompt).toContain('Zod schemas')
+  })
+
+  it('should render anti-patterns from sealed analysis', async () => {
+    const template = {
+      frontmatter: { description: 'Test' },
+      content: '## Do',
+    }
+    const context = { projectPath: '/test', files: [] }
+    const orcCtx = makeOrchestratorContext()
+
+    const prompt = await promptBuilder.build(
+      template,
+      context,
+      {},
+      null,
+      null,
+      null,
+      null,
+      null,
+      orcCtx
+    )
+
+    expect(prompt).toContain('Anti-Patterns (Avoid These)')
+    expect(prompt).toContain('Direct fs.writeFile without StorageManager')
+    expect(prompt).toContain('core/storage/legacy.ts')
+    expect(prompt).toContain('Use StorageManager.write() instead')
+  })
+
+  it('should gracefully handle null sealed analysis', async () => {
+    const template = {
+      frontmatter: { description: 'Test' },
+      content: '## Do',
+    }
+    const context = { projectPath: '/test', files: [] }
+    const orcCtx = makeOrchestratorContext(null)
+
+    const prompt = await promptBuilder.build(
+      template,
+      context,
+      {},
+      null,
+      null,
+      null,
+      null,
+      null,
+      orcCtx
+    )
+
+    // Should still have basic project analysis
+    expect(prompt).toContain('PROJECT ANALYSIS')
+    expect(prompt).toContain('Ecosystem**: TypeScript')
+    // Should NOT have analysis-specific fields
+    expect(prompt).not.toContain('Languages**:')
+    expect(prompt).not.toContain('Code Patterns (Follow These)')
+    expect(prompt).not.toContain('Anti-Patterns (Avoid These)')
+  })
+
+  it('should handle empty patterns and anti-patterns', async () => {
+    const template = {
+      frontmatter: { description: 'Test' },
+      content: '## Do',
+    }
+    const context = { projectPath: '/test', files: [] }
+    const emptyAnalysis: SealedAnalysisContext = {
+      ...mockSealedAnalysis,
+      patterns: [],
+      antiPatterns: [],
+    }
+    const orcCtx = makeOrchestratorContext(emptyAnalysis)
+
+    const prompt = await promptBuilder.build(
+      template,
+      context,
+      {},
+      null,
+      null,
+      null,
+      null,
+      null,
+      orcCtx
+    )
+
+    expect(prompt).toContain('Languages**: TypeScript, JavaScript')
+    expect(prompt).not.toContain('Code Patterns (Follow These)')
+    expect(prompt).not.toContain('Anti-Patterns (Avoid These)')
+  })
+
+  it('should handle no orchestrator context at all', async () => {
+    const template = {
+      frontmatter: { description: 'Test' },
+      content: '## Do',
+    }
+    const context = { projectPath: '/test', files: [] }
+
+    const prompt = await promptBuilder.build(
+      template,
+      context,
+      {},
+      null,
+      null,
+      null,
+      null,
+      null,
+      null
+    )
+
+    // Should not crash, should have fallback rules
+    expect(prompt).toContain('CONSTRAINTS')
+    expect(prompt).not.toContain('PROJECT ANALYSIS')
+  })
+})
+
+// =============================================================================
+// Anti-Hallucination Block — Analysis Enrichment
+// =============================================================================
+
+describe('Anti-Hallucination Block with Analysis (PRJ-260)', () => {
+  it('should include analysis languages in AVAILABLE list', () => {
+    const truth: ProjectGroundTruth = {
+      projectPath: '/test',
+      language: 'TypeScript',
+      techStack: ['Hono'],
+      analysisLanguages: ['TypeScript', 'JavaScript', 'Shell'],
+      analysisFrameworks: ['Hono', 'Vitest'],
+    }
+
+    const block = buildAntiHallucinationBlock(truth)
+
+    expect(block).toContain('AVAILABLE in this project:')
+    // TypeScript and Hono should not be duplicated
+    expect(block).toContain('JavaScript')
+    expect(block).toContain('Shell')
+    expect(block).toContain('Vitest')
+  })
+
+  it('should deduplicate analysis data with existing tech stack (case-insensitive)', () => {
+    const truth: ProjectGroundTruth = {
+      projectPath: '/test',
+      language: 'TypeScript',
+      framework: 'Hono',
+      techStack: ['Zod'],
+      analysisLanguages: ['typescript'], // lowercase duplicate
+      analysisFrameworks: ['hono', 'Zod'], // lowercase duplicates
+    }
+
+    const block = buildAntiHallucinationBlock(truth)
+
+    // Count occurrences — each should appear exactly once
+    const typescriptMatches = block.match(/typescript/gi)
+    expect(typescriptMatches?.length).toBe(1)
+
+    const honoMatches = block.match(/hono/gi)
+    expect(honoMatches?.length).toBe(1)
+  })
+
+  it('should show package manager from analysis', () => {
+    const truth: ProjectGroundTruth = {
+      projectPath: '/test',
+      analysisPackageManager: 'bun',
+    }
+
+    const block = buildAntiHallucinationBlock(truth)
+
+    expect(block).toContain('PACKAGE MANAGER: bun')
+  })
+
+  it('should work without any analysis data', () => {
+    const truth: ProjectGroundTruth = {
+      projectPath: '/test',
+      language: 'Python',
+    }
+
+    const block = buildAntiHallucinationBlock(truth)
+
+    expect(block).toContain('AVAILABLE in this project: Python')
+    expect(block).not.toContain('PACKAGE MANAGER:')
+  })
+
+  it('should handle empty analysis arrays gracefully', () => {
+    const truth: ProjectGroundTruth = {
+      projectPath: '/test',
+      analysisLanguages: [],
+      analysisFrameworks: [],
+    }
+
+    const block = buildAntiHallucinationBlock(truth)
+
+    // Should not contain AVAILABLE line (no tech to show)
+    expect(block).not.toContain('AVAILABLE in this project:')
+    expect(block).toContain('CONSTRAINTS')
+  })
+})
+
+// =============================================================================
+// SealedAnalysisContext Type
+// =============================================================================
+
+describe('SealedAnalysisContext type (PRJ-260)', () => {
+  it('should accept valid sealed analysis data', () => {
+    const analysis: SealedAnalysisContext = {
+      languages: ['TypeScript'],
+      frameworks: ['Hono'],
+      fileCount: 100,
+      patterns: [{ name: 'test', description: 'test pattern' }],
+      antiPatterns: [{ issue: 'test', file: 'test.ts', suggestion: 'fix it' }],
+      status: 'sealed',
+    }
+
+    expect(analysis.languages).toEqual(['TypeScript'])
+    expect(analysis.status).toBe('sealed')
+  })
+
+  it('should accept draft status', () => {
+    const analysis: SealedAnalysisContext = {
+      languages: [],
+      frameworks: [],
+      fileCount: 0,
+      patterns: [],
+      antiPatterns: [],
+      status: 'draft',
+    }
+
+    expect(analysis.status).toBe('draft')
+  })
+
+  it('should accept optional fields', () => {
+    const analysis: SealedAnalysisContext = {
+      languages: ['Python'],
+      frameworks: [],
+      fileCount: 50,
+      patterns: [],
+      antiPatterns: [],
+      status: 'sealed',
+      packageManager: 'pip',
+      sourceDir: 'src/',
+      testDir: 'tests/',
+      commitHash: 'abc123',
+    }
+
+    expect(analysis.packageManager).toBe('pip')
+    expect(analysis.commitHash).toBe('abc123')
+  })
+})

package/core/agentic/anti-hallucination.ts

@@ -47,6 +47,12 @@ export const ProjectGroundTruthSchema = z.object({
   fileCount: z.number().optional(),
   /** Available agent names (e.g., ['backend', 'testing']) */
   availableAgents: z.array(z.string()).default([]),
+  /** Sealed analysis languages — used to ground available tech (PRJ-260) */
+  analysisLanguages: z.array(z.string()).default([]),
+  /** Sealed analysis frameworks — used to ground available tech (PRJ-260) */
+  analysisFrameworks: z.array(z.string()).default([]),
+  /** Package manager from sealed analysis (PRJ-260) */
+  analysisPackageManager: z.string().optional(),
 })
 
 export type ProjectGroundTruth = z.input<typeof ProjectGroundTruthSchema>
@@ -79,16 +85,32 @@ export function buildAntiHallucinationBlock(truth: ProjectGroundTruth): string {
 
   parts.push('## CONSTRAINTS (Read Before Acting)\n')
 
-  // 1. Explicit availability
+  // 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)
   const techStack = truth.techStack ?? []
   available.push(...techStack.filter((t) => t !== truth.framework))
+  // Merge languages/frameworks from sealed analysis (deduped)
+  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)
+    }
+  }
 
   if (available.length > 0) {
     parts.push(`AVAILABLE in this project: ${available.join(', ')}`)
   }
+  if (truth.analysisPackageManager) {
+    parts.push(`PACKAGE MANAGER: ${truth.analysisPackageManager}`)
+  }
 
   // 2. Explicit unavailability from domain flags
   if (truth.domains) {

package/core/agentic/orchestrator-executor.ts

@@ -23,13 +23,14 @@ import { getRecentFiles } from '../context-tools/recent-tool'
 import { extractSignatures } from '../context-tools/signatures-tool'
 import configManager from '../infrastructure/config-manager'
 import pathManager from '../infrastructure/path-manager'
-import { stateStorage } from '../storage'
+import { analysisStorage, stateStorage } from '../storage'
 import type {
   LoadedAgent,
   LoadedSkill,
   OrchestratorContext,
   OrchestratorSubtask,
   RealCodebaseContext,
+  SealedAnalysisContext,
 } from '../types'
 import { getErrorMessage, isNotFoundError } from '../types/fs'
 import domainClassifier, { type ProjectContext } from './domain-classifier'
@@ -76,8 +77,11 @@ export class OrchestratorExecutor {
     // Step 5: Load skills from agent frontmatter
     const skills = await this.loadSkills(agents)
 
-    // Step 6: Gather real codebase context proactively
-    const realContext = await this.gatherRealContext(taskDescription, projectPath)
+    // Step 6: Gather real codebase context and sealed analysis in parallel
+    const [realContext, sealedAnalysis] = await Promise.all([
+      this.gatherRealContext(taskDescription, projectPath),
+      this.loadSealedAnalysis(projectId),
+    ])
 
     // Step 7: Determine if fragmentation is needed
     const requiresFragmentation = this.shouldFragment(domains, taskDescription)
@@ -101,6 +105,7 @@ export class OrchestratorExecutor {
         conventions: repoAnalysis?.conventions || [],
       },
       realContext,
+      sealedAnalysis,
     }
   }
 
@@ -197,6 +202,34 @@ export class OrchestratorExecutor {
     }
   }
 
+  /**
+   * Load sealed/active analysis from analysis storage (PRJ-260).
+   * Returns sealed if available, otherwise draft as fallback.
+   * Returns null if no analysis exists (graceful degradation).
+   */
+  private async loadSealedAnalysis(projectId: string): Promise<SealedAnalysisContext | null> {
+    try {
+      const analysis = await analysisStorage.getActive(projectId)
+      if (!analysis) return null
+
+      return {
+        languages: analysis.languages,
+        frameworks: analysis.frameworks,
+        packageManager: analysis.packageManager,
+        sourceDir: analysis.sourceDir,
+        testDir: analysis.testDir,
+        fileCount: analysis.fileCount,
+        patterns: analysis.patterns,
+        antiPatterns: analysis.antiPatterns,
+        status: analysis.status ?? 'draft',
+        commitHash: analysis.commitHash,
+      }
+    } catch {
+      // Graceful degradation — analysis is optional enhancement
+      return null
+    }
+  }
+
   /**
    * Load repo-analysis.json for project context
    */

package/core/agentic/prompt-builder.ts

@@ -542,10 +542,50 @@ class PromptBuilder {
     // =========================================================================
 
     if (orchestratorContext) {
+      const sa = orchestratorContext.sealedAnalysis
       parts.push('\n## PROJECT ANALYSIS (Sealed)\n')
       parts.push(`**Ecosystem**: ${orchestratorContext.project.ecosystem}\n`)
       parts.push(`**Primary Domain**: ${orchestratorContext.primaryDomain}\n`)
-      parts.push(`**Domains**: ${orchestratorContext.detectedDomains.join(', ')}\n\n`)
+      parts.push(`**Domains**: ${orchestratorContext.detectedDomains.join(', ')}\n`)
+
+      // Inject sealed analysis data (PRJ-260)
+      if (sa) {
+        if (sa.languages.length > 0) {
+          parts.push(`**Languages**: ${sa.languages.join(', ')}\n`)
+        }
+        if (sa.frameworks.length > 0) {
+          parts.push(`**Frameworks**: ${sa.frameworks.join(', ')}\n`)
+        }
+        if (sa.packageManager) {
+          parts.push(`**Package Manager**: ${sa.packageManager}\n`)
+        }
+        if (sa.sourceDir) {
+          parts.push(`**Source Dir**: ${sa.sourceDir}\n`)
+        }
+        if (sa.testDir) {
+          parts.push(`**Test Dir**: ${sa.testDir}\n`)
+        }
+        parts.push(`**Files Analyzed**: ${sa.fileCount}\n`)
+        parts.push(
+          `**Analysis Status**: ${sa.status}${sa.commitHash ? ` (commit: ${sa.commitHash.slice(0, 8)})` : ''}\n`
+        )
+
+        if (sa.patterns.length > 0) {
+          parts.push('\n### Code Patterns (Follow These)\n')
+          for (const p of sa.patterns) {
+            parts.push(`- **${p.name}**: ${p.description}${p.location ? ` (${p.location})` : ''}\n`)
+          }
+        }
+
+        if (sa.antiPatterns.length > 0) {
+          parts.push('\n### Anti-Patterns (Avoid These)\n')
+          for (const ap of sa.antiPatterns) {
+            parts.push(`- **${ap.issue}** in \`${ap.file}\` — ${ap.suggestion}\n`)
+          }
+        }
+      }
+
+      parts.push('\n')
     }
 
     const needsPatterns = commandContext.patterns
@@ -648,6 +688,7 @@ class PromptBuilder {
     // =========================================================================
 
     if (projectPath) {
+      const sa = orchestratorContext?.sealedAnalysis
       const groundTruth: ProjectGroundTruth = {
         projectPath,
         language: orchestratorContext?.project?.ecosystem,
@@ -655,6 +696,10 @@ class PromptBuilder {
         domains: this.extractDomains(state),
         fileCount: context.files?.length || context.filteredSize || 0,
         availableAgents: orchestratorContext?.agents?.map((a) => a.name) || [],
+        // Inject sealed analysis data for enriched grounding (PRJ-260)
+        analysisLanguages: sa?.languages || [],
+        analysisFrameworks: sa?.frameworks || [],
+        analysisPackageManager: sa?.packageManager,
       }
       parts.push(`\n${buildAntiHallucinationBlock(groundTruth)}\n`)
     } else {

package/core/types/agentic.ts

@@ -724,4 +724,35 @@ export interface OrchestratorContext {
   }
   /** Real codebase context gathered proactively */
   realContext?: RealCodebaseContext
+  /** Sealed/active analysis from PRJ-263 storage — injected into prompt context (PRJ-260) */
+  sealedAnalysis?: SealedAnalysisContext | null
+}
+
+/**
+ * Subset of analysis data injected into prompt context.
+ * Extracted from AnalysisSchema to avoid coupling types to storage schema.
+ *
+ * @see PRJ-260
+ */
+export interface SealedAnalysisContext {
+  /** Programming languages detected */
+  languages: string[]
+  /** Frameworks detected */
+  frameworks: string[]
+  /** Package manager (e.g., 'bun', 'npm', 'pnpm') */
+  packageManager?: string
+  /** Source directory */
+  sourceDir?: string
+  /** Test directory */
+  testDir?: string
+  /** Total files analyzed */
+  fileCount: number
+  /** Code patterns found */
+  patterns: Array<{ name: string; description: string; location?: string }>
+  /** Anti-patterns found */
+  antiPatterns: Array<{ issue: string; file: string; suggestion: string }>
+  /** Lifecycle status */
+  status: 'draft' | 'verified' | 'sealed'
+  /** Git commit hash when analysis was performed */
+  commitHash?: string
 }

package/core/types/index.ts

@@ -81,6 +81,8 @@ export type {
   RealCodebaseContext,
   ReasoningResult,
   ReasoningStep,
+  // Sealed analysis context (PRJ-260)
+  SealedAnalysisContext,
   SimpleExecutionResult,
   SkillContext,
   SmartContextProjectState,

package/dist/bin/prjct.mjs

@@ -14203,7 +14203,10 @@ var init_orchestrator_executor = __esm({
         const { domains, primary } = await this.detectDomains(taskDescription, projectId, repoAnalysis);
         const agents = await this.loadAgents(domains, projectId);
         const skills = await this.loadSkills(agents);
-        const realContext = await this.gatherRealContext(taskDescription, projectPath);
+        const [realContext, sealedAnalysis] = await Promise.all([
+          this.gatherRealContext(taskDescription, projectPath),
+          this.loadSealedAnalysis(projectId)
+        ]);
         const requiresFragmentation = this.shouldFragment(domains, taskDescription);
         let subtasks = null;
         if (requiresFragmentation && command === "task") {
@@ -14221,7 +14224,8 @@ var init_orchestrator_executor = __esm({
             ecosystem: repoAnalysis?.ecosystem || "unknown",
             conventions: repoAnalysis?.conventions || []
           },
-          realContext
+          realContext,
+          sealedAnalysis
         };
       }
       /**
@@ -14301,6 +14305,31 @@ var init_orchestrator_executor = __esm({
           return { branch: "unknown", status: "git unavailable" };
         }
       }
+      /**
+       * Load sealed/active analysis from analysis storage (PRJ-260).
+       * Returns sealed if available, otherwise draft as fallback.
+       * Returns null if no analysis exists (graceful degradation).
+       */
+      async loadSealedAnalysis(projectId) {
+        try {
+          const analysis2 = await analysisStorage.getActive(projectId);
+          if (!analysis2) return null;
+          return {
+            languages: analysis2.languages,
+            frameworks: analysis2.frameworks,
+            packageManager: analysis2.packageManager,
+            sourceDir: analysis2.sourceDir,
+            testDir: analysis2.testDir,
+            fileCount: analysis2.fileCount,
+            patterns: analysis2.patterns,
+            antiPatterns: analysis2.antiPatterns,
+            status: analysis2.status ?? "draft",
+            commitHash: analysis2.commitHash
+          };
+        } catch {
+          return null;
+        }
+      }
       /**
        * Load repo-analysis.json for project context
        */
@@ -15381,9 +15410,24 @@ function buildAntiHallucinationBlock(truth) {
   if (truth.framework) available.push(truth.framework);
   const techStack = truth.techStack ?? [];
   available.push(...techStack.filter((t) => t !== truth.framework));
+  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);
+    }
+  }
   if (available.length > 0) {
     parts.push(`AVAILABLE in this project: ${available.join(", ")}`);
   }
+  if (truth.analysisPackageManager) {
+    parts.push(`PACKAGE MANAGER: ${truth.analysisPackageManager}`);
+  }
   if (truth.domains) {
     const absent = Object.entries(truth.domains).filter(([, hasIt]) => !hasIt).map(([key]) => DOMAIN_LABELS[key]).filter(Boolean);
     if (absent.length > 0) {
@@ -15430,7 +15474,13 @@ var init_anti_hallucination = __esm({
       /** Total files in project */
       fileCount: z15.number().optional(),
       /** Available agent names (e.g., ['backend', 'testing']) */
-      availableAgents: z15.array(z15.string()).default([])
+      availableAgents: z15.array(z15.string()).default([]),
+      /** Sealed analysis languages — used to ground available tech (PRJ-260) */
+      analysisLanguages: z15.array(z15.string()).default([]),
+      /** Sealed analysis frameworks — used to ground available tech (PRJ-260) */
+      analysisFrameworks: z15.array(z15.string()).default([]),
+      /** Package manager from sealed analysis (PRJ-260) */
+      analysisPackageManager: z15.string().optional()
     });
     DOMAIN_LABELS = {
       hasFrontend: "Frontend (UI/components)",
@@ -16174,14 +16224,57 @@ ${envBlock}
 `);
         }
         if (orchestratorContext) {
+          const sa = orchestratorContext.sealedAnalysis;
           parts.push("\n## PROJECT ANALYSIS (Sealed)\n");
           parts.push(`**Ecosystem**: ${orchestratorContext.project.ecosystem}
 `);
           parts.push(`**Primary Domain**: ${orchestratorContext.primaryDomain}
 `);
           parts.push(`**Domains**: ${orchestratorContext.detectedDomains.join(", ")}
-
 `);
+          if (sa) {
+            if (sa.languages.length > 0) {
+              parts.push(`**Languages**: ${sa.languages.join(", ")}
+`);
+            }
+            if (sa.frameworks.length > 0) {
+              parts.push(`**Frameworks**: ${sa.frameworks.join(", ")}
+`);
+            }
+            if (sa.packageManager) {
+              parts.push(`**Package Manager**: ${sa.packageManager}
+`);
+            }
+            if (sa.sourceDir) {
+              parts.push(`**Source Dir**: ${sa.sourceDir}
+`);
+            }
+            if (sa.testDir) {
+              parts.push(`**Test Dir**: ${sa.testDir}
+`);
+            }
+            parts.push(`**Files Analyzed**: ${sa.fileCount}
+`);
+            parts.push(
+              `**Analysis Status**: ${sa.status}${sa.commitHash ? ` (commit: ${sa.commitHash.slice(0, 8)})` : ""}
+`
+            );
+            if (sa.patterns.length > 0) {
+              parts.push("\n### Code Patterns (Follow These)\n");
+              for (const p of sa.patterns) {
+                parts.push(`- **${p.name}**: ${p.description}${p.location ? ` (${p.location})` : ""}
+`);
+              }
+            }
+            if (sa.antiPatterns.length > 0) {
+              parts.push("\n### Anti-Patterns (Avoid These)\n");
+              for (const ap of sa.antiPatterns) {
+                parts.push(`- **${ap.issue}** in \`${ap.file}\` \u2014 ${ap.suggestion}
+`);
+              }
+            }
+          }
+          parts.push("\n");
         }
         const needsPatterns = commandContext.patterns;
         const codePatternsContent = state?.codePatterns || "";
@@ -16282,13 +16375,18 @@ Show changes, list affected files, ask for confirmation.
           );
         }
         if (projectPath) {
+          const sa = orchestratorContext?.sealedAnalysis;
           const groundTruth2 = {
             projectPath,
             language: orchestratorContext?.project?.ecosystem,
             techStack: orchestratorContext?.project?.conventions || [],
             domains: this.extractDomains(state),
             fileCount: context2.files?.length || context2.filteredSize || 0,
-            availableAgents: orchestratorContext?.agents?.map((a) => a.name) || []
+            availableAgents: orchestratorContext?.agents?.map((a) => a.name) || [],
+            // Inject sealed analysis data for enriched grounding (PRJ-260)
+            analysisLanguages: sa?.languages || [],
+            analysisFrameworks: sa?.frameworks || [],
+            analysisPackageManager: sa?.packageManager
           };
           parts.push(`
 ${buildAntiHallucinationBlock(groundTruth2)}
@@ -31102,7 +31200,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.12.0",
+      version: "1.13.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.12.0",
+  "version": "1.13.0",
   "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "core/index.ts",
   "bin": {