prjct-cli 1.9.0 → 1.11.0

package/core/__tests__/agentic/token-budget.test.ts

@@ -0,0 +1,294 @@
+/**
+ * Token Budget Coordinator Tests
+ *
+ * Tests for:
+ * - Budget calculation from model context windows
+ * - Priority-based allocation (state > injection > files)
+ * - Token request/record tracking
+ * - Overflow detection and prevention
+ * - Different model allocations
+ *
+ * @see PRJ-266
+ */
+
+import { describe, expect, it } from 'bun:test'
+import { budgetsFromCoordinator } from '../../agentic/injection-validator'
+import {
+  calculateInputBudget,
+  calculateOutputReserve,
+  getContextWindow,
+  INPUT_RATIO,
+  MODEL_CONTEXT_WINDOWS,
+  TokenBudgetCoordinator,
+} from '../../agentic/token-budget'
+
+// =============================================================================
+// getContextWindow
+// =============================================================================
+
+describe('getContextWindow', () => {
+  it('should return 200K for Claude models', () => {
+    expect(getContextWindow('opus')).toBe(200_000)
+    expect(getContextWindow('sonnet')).toBe(200_000)
+    expect(getContextWindow('haiku')).toBe(200_000)
+  })
+
+  it('should return 1M for Gemini models', () => {
+    expect(getContextWindow('2.5-pro')).toBe(1_000_000)
+    expect(getContextWindow('2.5-flash')).toBe(1_000_000)
+  })
+
+  it('should return default for unknown models', () => {
+    expect(getContextWindow('unknown-model')).toBe(MODEL_CONTEXT_WINDOWS.default)
+  })
+
+  it('should return default when no model specified', () => {
+    expect(getContextWindow()).toBe(MODEL_CONTEXT_WINDOWS.default)
+    expect(getContextWindow(undefined)).toBe(MODEL_CONTEXT_WINDOWS.default)
+  })
+
+  it('should support full model IDs', () => {
+    expect(getContextWindow('claude-opus-4-6')).toBe(200_000)
+    expect(getContextWindow('claude-sonnet-4.5')).toBe(200_000)
+  })
+})
+
+// =============================================================================
+// calculateInputBudget / calculateOutputReserve
+// =============================================================================
+
+describe('calculateInputBudget', () => {
+  it('should return 65% of context window', () => {
+    const budget = calculateInputBudget('sonnet')
+    expect(budget).toBe(Math.floor(200_000 * INPUT_RATIO))
+    expect(budget).toBe(130_000)
+  })
+
+  it('should return larger budget for Gemini models', () => {
+    const budget = calculateInputBudget('2.5-pro')
+    expect(budget).toBe(Math.floor(1_000_000 * INPUT_RATIO))
+    expect(budget).toBe(650_000)
+  })
+})
+
+describe('calculateOutputReserve', () => {
+  it('should reserve 35% for output', () => {
+    const reserve = calculateOutputReserve('sonnet')
+    expect(reserve).toBe(200_000 - 130_000)
+    expect(reserve).toBe(70_000)
+  })
+})
+
+// =============================================================================
+// TokenBudgetCoordinator — Allocation
+// =============================================================================
+
+describe('TokenBudgetCoordinator allocation', () => {
+  it('should create coordinator with default model', () => {
+    const coordinator = new TokenBudgetCoordinator()
+    const allocation = coordinator.getAllocation()
+
+    expect(allocation.contextWindow).toBe(200_000)
+    expect(allocation.inputBudget).toBe(130_000)
+    expect(allocation.outputReserve).toBe(70_000)
+  })
+
+  it('should distribute budget across three categories', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+    const allocation = coordinator.getAllocation()
+
+    expect(allocation.state).toBeGreaterThan(0)
+    expect(allocation.injection).toBeGreaterThan(0)
+    expect(allocation.files).toBeGreaterThan(0)
+  })
+
+  it('should allocate all input budget (no waste)', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+    const allocation = coordinator.getAllocation()
+
+    const totalAllocated = allocation.state + allocation.injection + allocation.files
+    expect(totalAllocated).toBe(allocation.inputBudget)
+  })
+
+  it('should give files the largest allocation', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+    const allocation = coordinator.getAllocation()
+
+    expect(allocation.files).toBeGreaterThan(allocation.state)
+    expect(allocation.files).toBeGreaterThan(allocation.injection)
+  })
+
+  it('should give state minimum 1500 tokens', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+    const allocation = coordinator.getAllocation()
+
+    expect(allocation.state).toBeGreaterThanOrEqual(1_500)
+  })
+
+  it('should give injection minimum 8000 tokens', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+    const allocation = coordinator.getAllocation()
+
+    expect(allocation.injection).toBeGreaterThanOrEqual(8_000)
+  })
+
+  it('should give larger allocations for Gemini models', () => {
+    const claudeCoord = new TokenBudgetCoordinator('sonnet')
+    const geminiCoord = new TokenBudgetCoordinator('2.5-pro')
+
+    const claudeAlloc = claudeCoord.getAllocation()
+    const geminiAlloc = geminiCoord.getAllocation()
+
+    expect(geminiAlloc.files).toBeGreaterThan(claudeAlloc.files)
+    expect(geminiAlloc.inputBudget).toBeGreaterThan(claudeAlloc.inputBudget)
+  })
+})
+
+// =============================================================================
+// TokenBudgetCoordinator — Request/Record
+// =============================================================================
+
+describe('TokenBudgetCoordinator request/record', () => {
+  it('should grant tokens up to allocation', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+    const stateAlloc = coordinator.getAllocationFor('state')
+
+    const granted = coordinator.request('state', 500)
+    expect(granted).toBe(500)
+
+    const usage = coordinator.getUsage('state')
+    expect(usage.used).toBe(500)
+    expect(usage.remaining).toBe(stateAlloc - 500)
+  })
+
+  it('should cap grants at available budget', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+    const stateAlloc = coordinator.getAllocationFor('state')
+
+    // Request more than allocated
+    const granted = coordinator.request('state', stateAlloc + 1000)
+    expect(granted).toBe(stateAlloc)
+  })
+
+  it('should track cumulative usage', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+
+    coordinator.request('state', 500)
+    coordinator.request('state', 300)
+
+    const usage = coordinator.getUsage('state')
+    expect(usage.used).toBe(800)
+  })
+
+  it('should return 0 when budget exhausted', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+    const stateAlloc = coordinator.getAllocationFor('state')
+
+    coordinator.request('state', stateAlloc)
+    const granted = coordinator.request('state', 100)
+    expect(granted).toBe(0)
+  })
+
+  it('should record usage independently', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+
+    coordinator.record('files', 5000)
+    const usage = coordinator.getUsage('files')
+    expect(usage.used).toBe(5000)
+  })
+
+  it('should track total remaining across categories', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+    const inputBudget = coordinator.inputBudget
+
+    coordinator.request('state', 500)
+    coordinator.request('injection', 2000)
+    coordinator.request('files', 10000)
+
+    expect(coordinator.totalRemaining).toBe(inputBudget - 500 - 2000 - 10000)
+  })
+})
+
+// =============================================================================
+// TokenBudgetCoordinator — Overflow Detection
+// =============================================================================
+
+describe('TokenBudgetCoordinator overflow detection', () => {
+  it('should not be over budget initially', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+    expect(coordinator.isOverBudget).toBe(false)
+  })
+
+  it('should detect overflow when usage exceeds input budget', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+    const inputBudget = coordinator.inputBudget
+
+    // Force overflow via record (bypasses allocation cap)
+    coordinator.record('files', inputBudget + 1)
+    expect(coordinator.isOverBudget).toBe(true)
+  })
+
+  it('should prevent overflow via request mechanism', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+
+    // Exhaust state budget
+    const stateAlloc = coordinator.getAllocationFor('state')
+    const granted = coordinator.request('state', stateAlloc + 50000)
+
+    // Should only get what was allocated
+    expect(granted).toBe(stateAlloc)
+    expect(coordinator.isOverBudget).toBe(false)
+  })
+})
+
+// =============================================================================
+// budgetsFromCoordinator integration
+// =============================================================================
+
+describe('budgetsFromCoordinator', () => {
+  it('should create injection budgets from coordinator', () => {
+    const coordinator = new TokenBudgetCoordinator('sonnet')
+    const budgets = budgetsFromCoordinator(coordinator)
+
+    expect(budgets.totalPrompt).toBe(coordinator.getAllocationFor('injection'))
+    // Per-section budgets remain at defaults
+    expect(budgets.autoContext).toBe(500)
+    expect(budgets.agentContent).toBe(400)
+    expect(budgets.skillContent).toBe(500)
+    expect(budgets.stateData).toBe(1000)
+    expect(budgets.memories).toBe(600)
+  })
+
+  it('should give larger injection budget for Gemini models', () => {
+    const claudeBudgets = budgetsFromCoordinator(new TokenBudgetCoordinator('sonnet'))
+    const geminiBudgets = budgetsFromCoordinator(new TokenBudgetCoordinator('2.5-pro'))
+
+    expect(geminiBudgets.totalPrompt).toBeGreaterThan(claudeBudgets.totalPrompt)
+  })
+})
+
+// =============================================================================
+// Different models get different allocations
+// =============================================================================
+
+describe('model-specific allocations', () => {
+  it('should give Gemini 5x the file budget of Claude', () => {
+    const claude = new TokenBudgetCoordinator('sonnet')
+    const gemini = new TokenBudgetCoordinator('2.5-pro')
+
+    const claudeFiles = claude.getAllocationFor('files')
+    const geminiFiles = gemini.getAllocationFor('files')
+
+    // Gemini has 1M context vs Claude 200K = 5x
+    expect(geminiFiles / claudeFiles).toBeCloseTo(5, 0)
+  })
+
+  it('should maintain 65/35 split across all models', () => {
+    for (const model of ['opus', 'sonnet', 'haiku', '2.5-pro', '2.5-flash']) {
+      const coordinator = new TokenBudgetCoordinator(model)
+      const allocation = coordinator.getAllocation()
+      const ratio = allocation.inputBudget / allocation.contextWindow
+      expect(ratio).toBeCloseTo(INPUT_RATIO, 2)
+    }
+  })
+})

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

@@ -0,0 +1,277 @@
+/**
+ * Analysis Storage Tests (PRJ-263)
+ *
+ * Tests for sealable analysis lifecycle:
+ * - Schema validation (draft/verified/sealed)
+ * - Signature computation and verification
+ * - Staleness detection
+ * - Draft preservation on re-sync
+ * - Backward compatibility
+ */
+
+import { describe, expect, it } from 'bun:test'
+import {
+  AnalysisItemSchema,
+  AnalysisStatusSchema,
+  parseAnalysis,
+  safeParseAnalysis,
+} from '../../schemas/analysis'
+
+// =============================================================================
+// Schema Validation
+// =============================================================================
+
+describe('AnalysisStatusSchema', () => {
+  it('should accept valid statuses', () => {
+    expect(AnalysisStatusSchema.parse('draft')).toBe('draft')
+    expect(AnalysisStatusSchema.parse('verified')).toBe('verified')
+    expect(AnalysisStatusSchema.parse('sealed')).toBe('sealed')
+  })
+
+  it('should reject invalid statuses', () => {
+    expect(() => AnalysisStatusSchema.parse('pending')).toThrow()
+    expect(() => AnalysisStatusSchema.parse('active')).toThrow()
+    expect(() => AnalysisStatusSchema.parse('')).toThrow()
+  })
+})
+
+describe('AnalysisItemSchema', () => {
+  const validDraft = {
+    projectId: 'test-project-123',
+    languages: ['TypeScript'],
+    frameworks: ['Hono'],
+    configFiles: ['tsconfig.json'],
+    fileCount: 295,
+    patterns: [{ name: 'Service pattern', description: 'Classes with dependency injection' }],
+    antiPatterns: [],
+    analyzedAt: '2026-02-08T20:00:00.000Z',
+    status: 'draft' as const,
+    commitHash: 'abc1234',
+  }
+
+  it('should parse a valid draft analysis', () => {
+    const result = AnalysisItemSchema.parse(validDraft)
+    expect(result.status).toBe('draft')
+    expect(result.commitHash).toBe('abc1234')
+    expect(result.projectId).toBe('test-project-123')
+  })
+
+  it('should default status to draft when not provided', () => {
+    const { status, ...withoutStatus } = validDraft
+    const result = AnalysisItemSchema.parse(withoutStatus)
+    expect(result.status).toBe('draft')
+  })
+
+  it('should parse a sealed analysis with signature', () => {
+    const sealed = {
+      ...validDraft,
+      status: 'sealed' as const,
+      signature: 'sha256-abc123def456',
+      sealedAt: '2026-02-08T21:00:00.000Z',
+    }
+    const result = AnalysisItemSchema.parse(sealed)
+    expect(result.status).toBe('sealed')
+    expect(result.signature).toBe('sha256-abc123def456')
+    expect(result.sealedAt).toBe('2026-02-08T21:00:00.000Z')
+  })
+
+  it('should accept optional fields as undefined', () => {
+    const minimal = {
+      projectId: 'test',
+      languages: [],
+      frameworks: [],
+      configFiles: [],
+      fileCount: 0,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-08T20:00:00.000Z',
+    }
+    const result = AnalysisItemSchema.parse(minimal)
+    expect(result.status).toBe('draft')
+    expect(result.commitHash).toBeUndefined()
+    expect(result.signature).toBeUndefined()
+    expect(result.sealedAt).toBeUndefined()
+    expect(result.modelMetadata).toBeUndefined()
+  })
+
+  it('should reject missing required fields', () => {
+    expect(() => AnalysisItemSchema.parse({})).toThrow()
+    expect(() => AnalysisItemSchema.parse({ projectId: 'test' })).toThrow()
+  })
+})
+
+describe('parseAnalysis / safeParseAnalysis', () => {
+  it('should parse valid data', () => {
+    const data = {
+      projectId: 'test',
+      languages: ['TypeScript'],
+      frameworks: [],
+      configFiles: [],
+      fileCount: 10,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-08T20:00:00.000Z',
+    }
+    const result = parseAnalysis(data)
+    expect(result.projectId).toBe('test')
+    expect(result.status).toBe('draft')
+  })
+
+  it('should return success for safeParseAnalysis with valid data', () => {
+    const data = {
+      projectId: 'test',
+      languages: [],
+      frameworks: [],
+      configFiles: [],
+      fileCount: 0,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-08T20:00:00.000Z',
+    }
+    const result = safeParseAnalysis(data)
+    expect(result.success).toBe(true)
+  })
+
+  it('should return failure for safeParseAnalysis with invalid data', () => {
+    const result = safeParseAnalysis({ invalid: true })
+    expect(result.success).toBe(false)
+  })
+})
+
+// =============================================================================
+// Staleness Detection (pure function tests)
+// =============================================================================
+
+describe('staleness detection', () => {
+  // Test checkStaleness method from AnalysisStorage
+  it('should detect stale analysis when commits differ', () => {
+    const { analysisStorage } = require('../../storage/analysis-storage')
+    const result = analysisStorage.checkStaleness('abc1234', 'def5678')
+    expect(result.isStale).toBe(true)
+    expect(result.sealedCommit).toBe('abc1234')
+    expect(result.currentCommit).toBe('def5678')
+  })
+
+  it('should detect fresh analysis when commits match', () => {
+    const { analysisStorage } = require('../../storage/analysis-storage')
+    const result = analysisStorage.checkStaleness('abc1234', 'abc1234')
+    expect(result.isStale).toBe(false)
+  })
+
+  it('should handle null sealed commit', () => {
+    const { analysisStorage } = require('../../storage/analysis-storage')
+    const result = analysisStorage.checkStaleness(null, 'abc1234')
+    expect(result.isStale).toBe(false)
+    expect(result.message).toContain('No sealed analysis')
+  })
+
+  it('should handle null current commit', () => {
+    const { analysisStorage } = require('../../storage/analysis-storage')
+    const result = analysisStorage.checkStaleness('abc1234', null)
+    expect(result.isStale).toBe(true)
+    expect(result.message).toContain('Cannot determine')
+  })
+})
+
+// =============================================================================
+// Signature Computation (determinism test)
+// =============================================================================
+
+describe('signature computation', () => {
+  it('should produce deterministic signatures for same input', () => {
+    const { createHash } = require('node:crypto')
+
+    const analysis = {
+      projectId: 'test',
+      languages: ['TypeScript'],
+      frameworks: ['Hono'],
+      configFiles: [],
+      fileCount: 100,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-08T20:00:00.000Z',
+      commitHash: 'abc1234',
+    }
+
+    const canonical = {
+      projectId: analysis.projectId,
+      languages: analysis.languages,
+      frameworks: analysis.frameworks,
+      packageManager: undefined,
+      sourceDir: undefined,
+      testDir: undefined,
+      configFiles: analysis.configFiles,
+      fileCount: analysis.fileCount,
+      patterns: analysis.patterns,
+      antiPatterns: analysis.antiPatterns,
+      analyzedAt: analysis.analyzedAt,
+      commitHash: analysis.commitHash,
+    }
+
+    const sig1 = createHash('sha256').update(JSON.stringify(canonical)).digest('hex')
+    const sig2 = createHash('sha256').update(JSON.stringify(canonical)).digest('hex')
+
+    expect(sig1).toBe(sig2)
+    expect(sig1).toHaveLength(64) // SHA-256 hex = 64 chars
+  })
+
+  it('should produce different signatures for different inputs', () => {
+    const { createHash } = require('node:crypto')
+
+    const data1 = JSON.stringify({ projectId: 'a', fileCount: 1 })
+    const data2 = JSON.stringify({ projectId: 'b', fileCount: 2 })
+
+    const sig1 = createHash('sha256').update(data1).digest('hex')
+    const sig2 = createHash('sha256').update(data2).digest('hex')
+
+    expect(sig1).not.toBe(sig2)
+  })
+})
+
+// =============================================================================
+// Backward Compatibility
+// =============================================================================
+
+describe('backward compatibility', () => {
+  it('should parse old analysis.json without seal fields', () => {
+    const oldFormat = {
+      projectId: 'old-project',
+      languages: ['JavaScript'],
+      frameworks: ['Express'],
+      configFiles: ['package.json'],
+      fileCount: 50,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2025-12-01T00:00:00.000Z',
+      // No status, commitHash, signature, sealedAt
+    }
+
+    const result = AnalysisItemSchema.parse(oldFormat)
+    expect(result.status).toBe('draft') // Default
+    expect(result.commitHash).toBeUndefined()
+    expect(result.signature).toBeUndefined()
+    expect(result.sealedAt).toBeUndefined()
+  })
+
+  it('should parse old analysis with modelMetadata but no seal fields', () => {
+    const oldWithModel = {
+      projectId: 'old-project',
+      languages: ['TypeScript'],
+      frameworks: [],
+      configFiles: [],
+      fileCount: 10,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-01-15T00:00:00.000Z',
+      modelMetadata: {
+        provider: 'claude',
+        model: 'sonnet',
+        recordedAt: '2026-01-15T00:00:00.000Z',
+      },
+    }
+
+    const result = AnalysisItemSchema.parse(oldWithModel)
+    expect(result.status).toBe('draft')
+    expect(result.modelMetadata?.provider).toBe('claude')
+  })
+})

package/core/agentic/anti-hallucination.ts

@@ -0,0 +1,124 @@
+/**
+ * Anti-Hallucination Block Generator
+ *
+ * Generates constraint blocks that ground the LLM in project reality.
+ * Based on research of 25+ system prompts (Claude Code, Gemini, ChatGPT),
+ * the following techniques reduce hallucinations 25-40%:
+ *
+ * 1. Explicit availability — what IS in the project
+ * 2. Explicit unavailability — what is NOT in the project
+ * 3. Visibility grounding — only use paths shown in context
+ * 4. Library verification — check package.json before assuming
+ * 5. Scope clarification — limit to project directory
+ *
+ * This block should be injected BEFORE task context (position 5 in prompt order)
+ * so the LLM has constraints loaded before reading code.
+ *
+ * @module agentic/anti-hallucination
+ * @see PRJ-301
+ */
+
+import { z } from 'zod'
+
+// =============================================================================
+// Schema
+// =============================================================================
+
+export const ProjectGroundTruthSchema = z.object({
+  /** Project root path */
+  projectPath: z.string(),
+  /** Programming language (e.g., 'TypeScript', 'JavaScript', 'Python') */
+  language: z.string().optional(),
+  /** Primary framework (e.g., 'Hono', 'Next.js', 'Express') */
+  framework: z.string().optional(),
+  /** Technology stack items (e.g., ['Hono', 'Zod', 'Vitest']) */
+  techStack: z.array(z.string()).default([]),
+  /** Domain flags from sealed analysis */
+  domains: z
+    .object({
+      hasFrontend: z.boolean().default(false),
+      hasBackend: z.boolean().default(false),
+      hasDatabase: z.boolean().default(false),
+      hasTesting: z.boolean().default(false),
+      hasDocker: z.boolean().default(false),
+    })
+    .optional(),
+  /** Total files in project */
+  fileCount: z.number().optional(),
+  /** Available agent names (e.g., ['backend', 'testing']) */
+  availableAgents: z.array(z.string()).default([]),
+})
+
+export type ProjectGroundTruth = z.input<typeof ProjectGroundTruthSchema>
+
+// =============================================================================
+// Domain Mapping
+// =============================================================================
+
+/** Map domain flags to human-readable technology categories */
+const DOMAIN_LABELS: Record<string, string> = {
+  hasFrontend: 'Frontend (UI/components)',
+  hasBackend: 'Backend (APIs/servers)',
+  hasDatabase: 'Database (SQL/ORM)',
+  hasTesting: 'Testing (unit/integration)',
+  hasDocker: 'Docker/containers',
+}
+
+// =============================================================================
+// Generator
+// =============================================================================
+
+/**
+ * Build the anti-hallucination constraints block.
+ *
+ * Returns a markdown section with explicit availability statements,
+ * visibility grounding rules, and library verification directives.
+ */
+export function buildAntiHallucinationBlock(truth: ProjectGroundTruth): string {
+  const parts: string[] = []
+
+  parts.push('## CONSTRAINTS (Read Before Acting)\n')
+
+  // 1. Explicit availability
+  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))
+
+  if (available.length > 0) {
+    parts.push(`AVAILABLE in this project: ${available.join(', ')}`)
+  }
+
+  // 2. Explicit unavailability from domain flags
+  if (truth.domains) {
+    const absent = Object.entries(truth.domains)
+      .filter(([, hasIt]) => !hasIt)
+      .map(([key]) => DOMAIN_LABELS[key])
+      .filter(Boolean)
+
+    if (absent.length > 0) {
+      parts.push(`NOT PRESENT: ${absent.join(', ')}`)
+    }
+  }
+
+  // 3. Available agents
+  const availableAgents = truth.availableAgents ?? []
+  if (availableAgents.length > 0) {
+    parts.push(`AGENTS: ${availableAgents.join(', ')}`)
+  }
+
+  // 4. Scope and grounding rules
+  parts.push('')
+  parts.push(`SCOPE: Only files in \`${truth.projectPath}\` are accessible.`)
+  parts.push('RULE: Use ONLY file paths explicitly shown in context. Do NOT infer or guess paths.')
+  parts.push('RULE: NEVER assume a library is available. Check package.json/imports first.')
+  parts.push('RULE: If previous context contradicts this section, trust this section.')
+  parts.push('RULE: Read files BEFORE modifying. Never assume code structure.')
+
+  if (truth.fileCount) {
+    parts.push(`\nContext: ${truth.fileCount} files in project.`)
+  }
+
+  return parts.join('\n')
+}