forge-server 0.1.0

package/src/context/injector.ts

@@ -0,0 +1,797 @@
+// ContextInjector — B6
+//
+// The central orchestrator for phase-start context assembly.
+// Called by every forge.start_* tool handler before returning to the agent.
+//
+// For each phase, the injector:
+//   1. Looks up the project and its repo from SQLite
+//   2. Reads the repo's stack tags
+//   3. Searches knowledge relevant to this phase
+//   4. Gets codebase context when architecturally useful (architecture, implementation)
+//   5. Gets memories from recent sessions when relevant
+//   6. Reads previous phase outputs from SQLite
+//   7. Assembles and returns the typed context object
+//
+// Every method handles unavailable backends gracefully and NEVER throws —
+// a missing Qdrant or FalkorDB must not block a phase from starting.
+
+import type { PipelineDB } from '../storage/sqlite.js';
+import type { KnowledgeSearch } from '../knowledge/search.js';
+import type { CodebaseContext } from './codebase.js';
+import type { MemoryBridge } from './memory.js';
+import type { ConfidenceManager } from '../learning/confidence.js';
+import type { QdrantVectorStore } from '../storage/qdrant-store.js';
+import type {
+  ProjectRow,
+  RepoRow,
+  PhaseOutputRow,
+  Phase,
+} from '../util/types.js';
+import { logger } from '../util/logger.js';
+
+// ---------------------------------------------------------------------------
+// Interview context
+// ---------------------------------------------------------------------------
+
+export interface InterviewContext {
+  similarProjects: Array<{
+    name: string;
+    repo: string;
+    relevance: number;
+    outcome: string;
+  }>;
+  relevantGotchas: Array<{
+    title: string;
+    content: string;
+    confidence: number;
+    sourceRepo: string;
+  }>;
+  interviewTemplate: string;
+}
+
+// ---------------------------------------------------------------------------
+// Architecture context
+// ---------------------------------------------------------------------------
+
+export interface ArchitectureContextModules {
+  name: string;
+  path: string;
+  purpose: string;
+}
+
+export interface ArchitectureCodebaseContext {
+  modules: ArchitectureContextModules[];
+  patterns: string[];
+  dependencies: string[];
+  fileCount: number;
+}
+
+export interface ArchitectureContext {
+  codebaseContext: ArchitectureCodebaseContext;
+  relevantDecisions: Array<{
+    title: string;
+    content: string;
+    confidence: number;
+    sourceRepo: string;
+  }>;
+  relevantGotchas: Array<{
+    title: string;
+    content: string;
+    stackTags: string[];
+    confidence: number;
+  }>;
+  stackConstraints: string[];
+}
+
+// ---------------------------------------------------------------------------
+// Implementation context (per module)
+// ---------------------------------------------------------------------------
+
+export interface ModuleContext {
+  // Stable (cacheable across module dispatches)
+  conventions: Array<{ title: string; content: string }>;
+  gotchas: Array<{ title: string; content: string }>;
+  siblingModules: Array<{ name: string; agentType: string; description?: string }>;
+  advisory: AdvisoryContext;
+  // Volatile (per-module, changes each dispatch)
+  relevantCode: string;
+  recalledContext: string[];
+  recentBroadcasts: Array<{ content: string; severity: string; created_at: number }>;
+}
+
+// ---------------------------------------------------------------------------
+// Inspection context
+// ---------------------------------------------------------------------------
+
+export interface InspectionContext {
+  checklist: string;
+  pastFindings: Array<{
+    description: string;
+    severity: string;
+    resolution: string;
+    sourceRepo: string;
+  }>;
+  antiStubPatterns: string[];
+  cycleCount: number;
+  maxCycles: number;
+  broadcasts: Array<{ content: string; severity: string; created_at: number }>;
+  advisory: AdvisoryContext;
+}
+
+// ---------------------------------------------------------------------------
+// Advisory context (injected into implementation + inspection phases)
+// ---------------------------------------------------------------------------
+
+export interface AdvisoryContext {
+  visionSummary: string;
+  architectureSummary: string;
+  designSummary: string;
+  activeDirectives: Array<{ content: string; from: string; created_at: number }>;
+}
+
+// ---------------------------------------------------------------------------
+// Generic phase context
+// ---------------------------------------------------------------------------
+
+export interface PhaseContext {
+  relevantKnowledge: Array<{
+    title: string;
+    content: string;
+    category: string;
+    confidence: number;
+  }>;
+  previousOutputs: Array<{
+    phase: string;
+    type: string;
+    preview: string;
+  }>;
+  warnings: string[];
+  recentBroadcasts: Array<{
+    content: string;
+    severity: string;
+    created_at: number;
+  }>;
+}
+
+// ---------------------------------------------------------------------------
+// ContextInjector
+// ---------------------------------------------------------------------------
+
+export class ContextInjector {
+  // CACHE-FRIENDLY ORDERING PRINCIPLE:
+  // All context injection methods emit fields from MOST STABLE to MOST VOLATILE.
+  // This maximizes Anthropic's automatic prompt caching — cached prefix tokens
+  // get a 90% input cost discount. Stable content (conventions, gotchas, advisory
+  // summaries) comes first and stays cached across agent dispatches. Volatile
+  // content (broadcasts, per-module code) comes last.
+
+  private readonly confidenceManager?: ConfidenceManager;
+  private readonly vectorStore?: QdrantVectorStore;
+
+  constructor(
+    private readonly knowledgeSearch: KnowledgeSearch,
+    private readonly codebaseContext: CodebaseContext,
+    private readonly memoryBridge: MemoryBridge,
+    private readonly db: PipelineDB,
+    confidenceManager?: ConfidenceManager,
+    vectorStore?: QdrantVectorStore,
+  ) {
+    this.confidenceManager = confidenceManager;
+    this.vectorStore = vectorStore;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Fire-and-forget confidence boost for knowledge items returned by searches.
+  // NEVER blocks the caller — errors are logged and swallowed.
+  // ---------------------------------------------------------------------------
+
+  private boostKnowledgeResults(
+    results: Array<{ id: string }>,
+  ): void {
+    if (!this.confidenceManager || !this.vectorStore) return;
+    const cm = this.confidenceManager;
+    const vs = this.vectorStore;
+    for (const result of results) {
+      cm.boost(vs, result.id).catch((err) => {
+        logger.debug('ContextInjector.boostKnowledgeResults: boost failed (non-fatal)', {
+          id: result.id,
+          error: String(err),
+        });
+      });
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Broadcast injection helper.
+  // Retrieves recent agent broadcasts for a project from observations.
+  // Used to enrich phase context with cross-agent findings.
+  // ---------------------------------------------------------------------------
+
+  private async getRecentBroadcasts(
+    projectId: string,
+    limit: number = 5,
+  ): Promise<Array<{ content: string; severity: string; created_at: number }>> {
+    if (!this.vectorStore) return [];
+    try {
+      const filter: Record<string, unknown> = {
+        must: [
+          { key: 'category', match: { value: 'agent_broadcast' } },
+          { key: 'tags', match: { value: projectId } },
+        ],
+      };
+      const results = await this.vectorStore.filterObservations(filter, limit);
+      return results.map((r) => {
+        const payload = r.payload as unknown as Record<string, unknown>;
+        return {
+          content: (payload['content'] as string) ?? '',
+          severity: (payload['importance'] as number) >= 0.7 ? 'critical' : (payload['importance'] as number) >= 0.5 ? 'warning' : 'info',
+          created_at: (payload['created_at'] as number) ?? 0,
+        };
+      });
+    } catch (err) {
+      logger.debug('ContextInjector.getRecentBroadcasts: failed (non-fatal)', { error: String(err) });
+      return [];
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Advisory context (shared across implementation + inspection phases)
+  // ---------------------------------------------------------------------------
+
+  async injectAdvisoryContext(projectId: string): Promise<AdvisoryContext> {
+    const defaultCtx: AdvisoryContext = {
+      visionSummary: '',
+      architectureSummary: '',
+      designSummary: '',
+      activeDirectives: [],
+    };
+    try {
+      // Get phase outputs for vision, architecture, design
+      const phases = ['interview', 'architecture', 'design'] as const;
+      const summaries: Record<string, string> = {};
+      for (const phase of phases) {
+        const row = this.db.get<PhaseOutputRow>(
+          `SELECT content FROM phase_outputs WHERE project_id = ? AND phase = ? ORDER BY created_at DESC LIMIT 1`,
+          [projectId, phase],
+        );
+        summaries[phase] = row ? row.content.slice(0, 1500) : '';
+      }
+
+      // Get active advisory directives from observations
+      let activeDirectives: AdvisoryContext['activeDirectives'] = [];
+      if (this.vectorStore) {
+        try {
+          const filter = {
+            must: [
+              { key: 'category', match: { value: 'advisory_checkpoint' } },
+              { key: 'tags', match: { value: projectId } },
+            ],
+          };
+          const results = await this.vectorStore.filterObservations(filter, 10);
+          activeDirectives = results.map((r) => {
+            const payload = r.payload as unknown as Record<string, unknown>;
+            return {
+              content: (payload['content'] as string) ?? '',
+              from: ((payload['tags'] as string[]) ?? []).find(t => t !== projectId && t !== 'advisory_checkpoint') ?? 'unknown',
+              created_at: (payload['created_at'] as number) ?? 0,
+            };
+          });
+        } catch (err) {
+          logger.debug('injectAdvisoryContext: directive search failed (non-fatal)', { error: String(err) });
+        }
+      }
+
+      return {
+        visionSummary: summaries['interview'] ?? '',
+        architectureSummary: summaries['architecture'] ?? '',
+        designSummary: summaries['design'] ?? '',
+        activeDirectives,
+      };
+    } catch (err) {
+      logger.debug('injectAdvisoryContext: failed (non-fatal)', { error: String(err) });
+      return defaultCtx;
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Interview phase
+  // ---------------------------------------------------------------------------
+
+  async injectInterviewContext(
+    projectId: string,
+    initialRequest?: string,
+  ): Promise<InterviewContext> {
+    const { project, repo } = this.loadProjectAndRepo(projectId);
+    const stackTags = repo ? parseStack(repo.stack) : [];
+    const query = initialRequest ?? project?.name ?? 'project';
+
+    // Search for relevant gotchas related to the request
+    const gotchas = await this.knowledgeSearch.searchGotchas(query, {
+      stackTags,
+      limit: 5,
+      minConfidence: 0.4,
+    });
+
+    // Fire-and-forget confidence boost for consumed knowledge
+    this.boostKnowledgeResults(gotchas);
+
+    // Search memories for similar past projects
+    const memories = await this.memoryBridge.searchMemories(
+      `project similar to: ${query}`,
+      { repoId: repo?.id, limit: 5 },
+    );
+
+    // Derive similar projects from memories that look like project summaries
+    const similarProjects = memories
+      .filter((m) => m.content.length > 30)
+      .slice(0, 3)
+      .map((m, i) => ({
+        name: `Past project ${i + 1}`,
+        repo: repo?.name ?? 'unknown',
+        relevance: m.relevanceScore,
+        outcome: m.content.slice(0, 120),
+      }));
+
+    return {
+      similarProjects,
+      relevantGotchas: gotchas.map((g) => ({
+        title: g.title,
+        content: g.content,
+        confidence: g.confidence,
+        sourceRepo: g.source_repo,
+      })),
+      interviewTemplate: buildInterviewTemplate(stackTags),
+    };
+  }
+
+  // ---------------------------------------------------------------------------
+  // Architecture phase
+  // ---------------------------------------------------------------------------
+
+  async injectArchitectureContext(
+    projectId: string,
+    visionSummary?: string,
+  ): Promise<ArchitectureContext> {
+    const { project, repo } = this.loadProjectAndRepo(projectId);
+    const stackTags = repo ? parseStack(repo.stack) : [];
+    const query = visionSummary ?? project?.name ?? 'architecture';
+
+    // Run knowledge search and codebase context in parallel
+    const [decisions, gotchas, codebaseResult] = await Promise.all([
+      this.knowledgeSearch.searchDecisions(query, {
+        stackTags,
+        limit: 5,
+        minConfidence: 0.4,
+      }),
+      this.knowledgeSearch.searchGotchas(query, {
+        stackTags,
+        limit: 5,
+        minConfidence: 0.4,
+      }),
+      repo
+        ? this.codebaseContext.getContext(query, {
+            repoId: repo.id,
+            detail: 'skeleton',
+            maxResults: 8,
+            maxTokens: 3000,
+          })
+        : Promise.resolve(null),
+    ]);
+
+    // Fire-and-forget confidence boost for consumed knowledge
+    this.boostKnowledgeResults(decisions);
+    this.boostKnowledgeResults(gotchas);
+
+    // Build a coarse module list from skeleton file paths
+    const modules = (codebaseResult?.pivotFiles ?? []).map((f) => ({
+      name: basename(f.filePath),
+      path: f.filePath,
+      purpose: f.matchReason,
+    }));
+
+    // Derive patterns and dependencies from skeleton content
+    const skeletonContent = (codebaseResult?.supportingSkeletons ?? [])
+      .map((s) => s.skeleton)
+      .join('\n');
+
+    const patterns = extractPatterns(skeletonContent, stackTags);
+    const dependencies = extractDependencies(skeletonContent);
+
+    // Stack constraints come from the manifest stack tags
+    const stackConstraints = stackTags.map(
+      (tag) => `Stack: ${tag} — apply ${tag}-specific patterns and gotchas`,
+    );
+
+    return {
+      codebaseContext: {
+        modules,
+        patterns,
+        dependencies,
+        fileCount: codebaseResult?.pivotFiles.length ?? 0,
+      },
+      relevantDecisions: decisions.map((d) => ({
+        title: d.title,
+        content: d.content,
+        confidence: d.confidence,
+        sourceRepo: d.source_repo,
+      })),
+      relevantGotchas: gotchas.map((g) => ({
+        title: g.title,
+        content: g.content,
+        stackTags: g.stack_tags,
+        confidence: g.confidence,
+      })),
+      stackConstraints,
+    };
+  }
+
+  // ---------------------------------------------------------------------------
+  // Implementation phase (per-module)
+  // ---------------------------------------------------------------------------
+
+  async injectImplementationContext(
+    projectId: string,
+    modules: Array<{ name: string; agentType: string; description?: string }>,
+  ): Promise<Record<string, ModuleContext>> {
+    const { repo } = this.loadProjectAndRepo(projectId);
+    const stackTags = repo ? parseStack(repo.stack) : [];
+
+    // Fetch project-wide broadcasts once (shared across all modules)
+    const recentBroadcasts = await this.getRecentBroadcasts(projectId, 15);
+
+    // Fetch advisory context once (shared across all modules)
+    const advisory = await this.injectAdvisoryContext(projectId);
+
+    const result: Record<string, ModuleContext> = {};
+
+    // Process each module, fanning out searches in parallel
+    await Promise.all(
+      modules.map(async (mod) => {
+        const query = `${mod.agentType} ${mod.name}`;
+
+        const [gotchas, conventions, code] = await Promise.all([
+          this.knowledgeSearch.searchGotchas(query, {
+            stackTags,
+            limit: 4,
+            minConfidence: 0.4,
+          }),
+          this.knowledgeSearch.searchConventions(query, {
+            stackTags,
+            limit: 3,
+            minConfidence: 0.3,
+          }),
+          repo
+            ? this.codebaseContext.getContext(query, {
+                repoId: repo.id,
+                detail: 'full',
+                maxResults: 4,
+                maxTokens: 4000,
+              })
+            : Promise.resolve(null),
+        ]);
+
+        // Fire-and-forget confidence boost for consumed knowledge
+        this.boostKnowledgeResults(gotchas);
+        this.boostKnowledgeResults(conventions);
+
+        const relevantCode = code
+          ? code.pivotFiles
+              .map((f) => `// ${f.filePath}\n${f.content}`)
+              .join('\n\n')
+          : '';
+
+        // Build sibling list: all modules EXCEPT this one
+        const siblingModules = modules
+          .filter((m) => m.name !== mod.name)
+          .map((m) => ({
+            name: m.name,
+            agentType: m.agentType,
+            description: m.description,
+          }));
+
+        result[mod.name] = {
+          // Stable (cacheable)
+          conventions: conventions.map((c) => ({
+            title: c.title,
+            content: c.content,
+          } satisfies { title: string; content: string })),
+          gotchas: gotchas.map((g) => ({
+            title: g.title,
+            content: g.content,
+          } satisfies { title: string; content: string })),
+          siblingModules,
+          advisory,
+          // Volatile
+          relevantCode,
+          recalledContext: [],  // populated by session index when available
+          recentBroadcasts,
+        };
+      }),
+    );
+
+    return result;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Inspection phase
+  // ---------------------------------------------------------------------------
+
+  async injectInspectionContext(projectId: string): Promise<InspectionContext> {
+    const { repo } = this.loadProjectAndRepo(projectId);
+    const stackTags = repo ? parseStack(repo.stack) : [];
+
+    // Look up how many inspection cycles have occurred for this project
+    const cycleCount = this.countInspectionCycles(projectId);
+
+    const gotchas = await this.knowledgeSearch.searchGotchas(
+      'code quality anti-patterns stubs incomplete implementation',
+      { stackTags, limit: 6, minConfidence: 0.35 },
+    );
+
+    // Fire-and-forget confidence boost for consumed knowledge
+    this.boostKnowledgeResults(gotchas);
+
+    // Past findings from inspection outputs stored in phase_outputs
+    const pastOutputRows = this.db.all<PhaseOutputRow>(
+      `SELECT * FROM phase_outputs WHERE project_id = ? AND phase = ? ORDER BY created_at DESC LIMIT 5`,
+      [projectId, 'inspection'],
+    );
+
+    const pastFindings = pastOutputRows.map((row) => ({
+      description: row.content.slice(0, 200),
+      severity: 'unknown',
+      resolution: '',
+      sourceRepo: repo?.name ?? 'current',
+    }));
+
+    // Fetch all broadcasts from this project for interface compatibility checks
+    const broadcasts = await this.getRecentBroadcasts(projectId, 30);
+
+    const advisory = await this.injectAdvisoryContext(projectId);
+
+    return {
+      checklist: buildInspectionChecklist(stackTags),
+      pastFindings,
+      antiStubPatterns: ANTI_STUB_PATTERNS,
+      cycleCount,
+      maxCycles: 3,
+      broadcasts,
+      advisory,
+    };
+  }
+
+  // ---------------------------------------------------------------------------
+  // Generic phase context
+  // ---------------------------------------------------------------------------
+
+  async injectPhaseContext(
+    projectId: string,
+    phase: Phase,
+    query?: string,
+  ): Promise<PhaseContext> {
+    const { project, repo } = this.loadProjectAndRepo(projectId);
+    const stackTags = repo ? parseStack(repo.stack) : [];
+    const effectiveQuery =
+      query ?? PHASE_QUERY_HINTS[phase] ?? project?.name ?? phase;
+
+    const warnings: string[] = [];
+
+    // Generic knowledge search
+    const knowledge = await this.knowledgeSearch.search(effectiveQuery, {
+      stack_tags: stackTags,
+      limit: 6,
+      min_confidence: 0.3,
+    });
+
+    // Fire-and-forget confidence boost for consumed knowledge
+    this.boostKnowledgeResults(knowledge);
+
+    if (knowledge.length === 0) {
+      warnings.push('No relevant knowledge found — knowledge base may be empty');
+    }
+
+    // Previous phase outputs for this project
+    const outputRows = this.db.all<PhaseOutputRow>(
+      `SELECT phase, output_type, content FROM phase_outputs
+       WHERE project_id = ? ORDER BY created_at DESC LIMIT 10`,
+      [projectId],
+    );
+
+    const previousOutputs = outputRows.map((row) => ({
+      phase: row.phase,
+      type: row.output_type,
+      preview: row.content.slice(0, 300),
+    }));
+
+    // Fetch recent agent broadcasts for this project
+    const recentBroadcasts = await this.getRecentBroadcasts(projectId);
+
+    return {
+      relevantKnowledge: knowledge.map((k) => ({
+        title: k.title,
+        content: k.content,
+        category: k.category,
+        confidence: k.confidence,
+      } satisfies { title: string; content: string; category: string; confidence: number })),
+      previousOutputs,
+      warnings,
+      recentBroadcasts,
+    };
+  }
+
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+
+  private loadProjectAndRepo(projectId: string): {
+    project: ProjectRow | undefined;
+    repo: RepoRow | undefined;
+  } {
+    const project = this.db.get<ProjectRow>(
+      `SELECT * FROM projects WHERE id = ?`,
+      [projectId],
+    );
+    const repo = project
+      ? this.db.get<RepoRow>(`SELECT * FROM repos WHERE id = ?`, [
+          project.repo_id,
+        ])
+      : undefined;
+    return { project, repo };
+  }
+
+  /**
+   * Count how many times this project has had an inspection -> implementation
+   * cycle (i.e., how many times inspection produced a "fail" verdict).
+   */
+  private countInspectionCycles(projectId: string): number {
+    const row = this.db.get<{ cnt: number }>(
+      `SELECT COUNT(*) as cnt FROM pipeline_events
+       WHERE project_id = ? AND from_phase = 'inspection' AND to_phase = 'implementation'`,
+      [projectId],
+    );
+    return row?.cnt ?? 0;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Utilities
+// ---------------------------------------------------------------------------
+
+function parseStack(stackJson: string): string[] {
+  try {
+    const parsed = JSON.parse(stackJson);
+    return Array.isArray(parsed) ? (parsed as string[]) : [];
+  } catch {
+    return [];
+  }
+}
+
+function basename(filePath: string): string {
+  const parts = filePath.replace(/\\/g, '/').split('/');
+  return parts[parts.length - 1] ?? filePath;
+}
+
+function extractPatterns(content: string, stackTags: string[]): string[] {
+  const patterns: string[] = [];
+  if (content.includes('Module') && stackTags.includes('nestjs')) {
+    patterns.push('NestJS module pattern detected');
+  }
+  if (content.includes('Drizzle') || content.includes('drizzle')) {
+    patterns.push('Drizzle ORM pattern detected');
+  }
+  if (content.includes('interface ') || content.includes('type ')) {
+    patterns.push('TypeScript interface-driven design');
+  }
+  if (content.includes('export class')) {
+    patterns.push('Class-based service pattern');
+  }
+  return patterns;
+}
+
+function extractDependencies(content: string): string[] {
+  const deps: string[] = [];
+  const importRegex = /from ['"](@?[^'"./][^'"]*)['"]/g;
+  let match: RegExpExecArray | null;
+  const seen = new Set<string>();
+  while ((match = importRegex.exec(content)) !== null) {
+    const dep = match[1];
+    if (dep && !seen.has(dep)) {
+      seen.add(dep);
+      deps.push(dep);
+    }
+  }
+  return deps.slice(0, 10);
+}
+
+function buildInterviewTemplate(stackTags: string[]): string {
+  const stackList = stackTags.length > 0 ? stackTags.join(', ') : 'unspecified';
+  return `## Strategist Interview Template
+
+**Tech Stack**: ${stackList}
+
+### Questions to ask:
+1. What is the core problem this feature solves?
+2. Who are the primary users and what is their workflow?
+3. What are the success criteria? How will we know it is done?
+4. What are the constraints (timeline, performance, compatibility)?
+5. Are there existing patterns or modules in the codebase we should follow?
+6. What are the out-of-scope items for this iteration?
+
+### Vision document to produce:
+- Problem statement (1 paragraph)
+- User stories (numbered list)
+- Success criteria (measurable)
+- Out of scope (explicit list)
+- Known risks or dependencies`;
+}
+
+function buildInspectionChecklist(stackTags: string[]): string {
+  const lines = [
+    '## Inspector Checklist',
+    '',
+    '### Build',
+    '- [ ] TypeScript compiles without errors',
+    '- [ ] No missing imports or unresolved modules',
+    '- [ ] No dangling providers or unregistered services',
+    '',
+    '### Anti-Stub',
+    '- [ ] No TODO comments left in implementation',
+    '- [ ] No hardcoded return values (stub responses)',
+    '- [ ] Every service method performs real work',
+    '- [ ] Every guard performs real auth checks',
+    '',
+    '### Wiring',
+    '- [ ] HTTP request traces end-to-end through controller -> service -> DB',
+    '- [ ] All error cases handled (not just happy path)',
+    '- [ ] Response shapes match specified interfaces',
+    '',
+    '### Quality',
+    '- [ ] Input validation on all endpoints',
+    '- [ ] Appropriate HTTP status codes',
+    '- [ ] No bare catch blocks that swallow errors',
+  ];
+
+  if (stackTags.includes('nestjs')) {
+    lines.push(
+      '',
+      '### NestJS-specific',
+      '- [ ] All providers registered in their module',
+      '- [ ] All module imports declared',
+      '- [ ] DTOs have class-validator decorators',
+      '- [ ] Guards are applied with @UseGuards()',
+    );
+  }
+
+  if (stackTags.includes('drizzle')) {
+    lines.push(
+      '',
+      '### Drizzle-specific',
+      '- [ ] Migrations generated and applied (db:generate then db:migrate)',
+      '- [ ] No raw SQL where Drizzle query builder is appropriate',
+      '- [ ] Exported interfaces for service return types (TS4053 prevention)',
+    );
+  }
+
+  return lines.join('\n');
+}
+
+const ANTI_STUB_PATTERNS = [
+  'return { success: true } without side effects',
+  '// TODO: implement later',
+  '// TODO: add real logic',
+  'throw new Error("Not implemented")',
+  'return null // placeholder',
+  'console.log("implement me")',
+  'return [] // stub',
+  'return {} // placeholder',
+];
+
+const PHASE_QUERY_HINTS: Partial<Record<Phase, string>> = {
+  interview: 'project scoping vision requirements user stories',
+  architecture: 'module design service boundaries database schema API contracts',
+  design: 'UI design component hierarchy user experience layout',
+  qa_strategy: 'test plan testing strategy coverage integration tests',
+  implementation: 'implementation code services controllers database',
+  inspection: 'code review quality check anti-patterns stubs completeness',
+  knowledge_collection: 'learnings gotchas patterns decisions retrospective',
+};