@magic-ingredients/tiny-brain-local 0.16.0 → 0.17.0

package/dist/services/repo-service.js

@@ -1,161 +1,49 @@
 /**
  * Repository Context Service
  *
- * Manages the tiny-brain section of the context file (CLAUDE.md, etc.)
- * Responsible for formatting and storing repository analysis and agent usage.
+ * Service for repository context operations including:
+ * - Writing workflow sections to CLAUDE.md (commit format, TDD, progress tracking)
+ * - Tech context now managed by TechContextService (.tiny-brain/analysis.json, .tiny-brain/tech/*.md)
  */
 import * as fs from 'fs/promises';
 import { existsSync, readFileSync } from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
-import { detectTechStackChanges, ConfigService } from '@magic-ingredients/tiny-brain-core';
 import { getRepoRoot } from '../utils/repo-utils.js';
+import { ConfigService } from '@magic-ingredients/tiny-brain-core';
 /**
- * Service for managing repository context in the context file
- * Handles the tiny-brain section with analysis and agent usage
+ * Service for repository context operations
+ * Tech context is now managed by TechContextService
+ * Workflow sections are written to CLAUDE.md based on config flags
  */
 export class RepoService {
     context;
     static REPO_BLOCK_START = '## tiny-brain - start';
     static REPO_BLOCK_END = '## tiny-brain - end';
-    static ANALYSIS_MARKER_PREFIX = '<!-- TB_ANALYSIS:';
-    static ANALYSIS_MARKER_SUFFIX = ' -->';
-    // New constants for subagent context protocol
-    static SUBAGENT_PROTOCOL_HEADER = '## Subagent Context Protocol';
-    static AGENT_USAGE_HEADER = '### When to Use Agents';
-    static REPO_CONTEXT_HEADER = '### Repository Context';
-    static USAGE_TEMPLATE_HEADER = '### Usage Template';
-    static EXAMPLE_HEADER = '### Example';
-    static ANALYSIS_IGNORE_PREFIX = '<!-- TB_ANALYSIS-IGNORE:';
-    static ANALYSIS_IGNORE_SUFFIX = ' -->';
-    static STATUS_IGNORE_PREFIX = '<!-- TB-STATUS-IGNORE:';
-    static STATUS_IGNORE_SUFFIX = ' -->';
     configService;
-    constructor(context, configService) {
+    constructor(context) {
         this.context = context;
-        this.configService = configService || new ConfigService(context);
-    }
-    /**
-     * Write the repository block to context file with phase-based agent structure
-     */
-    async writeRepoBlockWithPhases(analysis, agentResponse, contextFilePath = 'CLAUDE.md', version) {
-        const repoRoot = getRepoRoot();
-        const fullPath = path.join(repoRoot, contextFilePath);
-        this.context.logger.debug('[RepoService] Writing repo block with phases to context file:', {
-            repoRoot,
-            contextFilePath,
-            fullPath,
-            agentCount: agentResponse?.agents?.length || 0
-        });
-        // Build the complete repo block with phase-based formatting
-        const repoBlock = await this.formatRepoBlockWithPhases(analysis, agentResponse, version);
-        // Read existing content
-        let existingContent = '';
-        try {
-            existingContent = await fs.readFile(fullPath, 'utf-8');
-        }
-        catch {
-            // File doesn't exist, that's ok
-        }
-        // Update or append tiny-brain section
-        const startMarker = RepoService.REPO_BLOCK_START;
-        const endMarker = RepoService.REPO_BLOCK_END;
-        if (existingContent.includes(startMarker)) {
-            // Replace existing tiny-brain section
-            const startIndex = existingContent.indexOf(startMarker);
-            const endIndex = existingContent.indexOf(endMarker);
-            if (endIndex > -1) {
-                // Replace from start to end marker (inclusive)
-                const afterEnd = existingContent.substring(endIndex + endMarker.length);
-                existingContent = existingContent.substring(0, startIndex) +
-                    repoBlock +
-                    afterEnd;
-            }
-            else {
-                // No end marker found, replace to next section or end of file
-                const nextSectionIndex = existingContent.indexOf('\n## ', startIndex + 1);
-                if (nextSectionIndex > -1) {
-                    existingContent = existingContent.substring(0, startIndex) +
-                        repoBlock +
-                        existingContent.substring(nextSectionIndex);
-                }
-                else {
-                    existingContent = existingContent.substring(0, startIndex) + repoBlock;
-                }
-            }
-        }
-        else {
-            // Append tiny-brain section
-            existingContent = existingContent.trimEnd() + '\n\n' + repoBlock;
-        }
-        // Ensure directory exists and write file
-        await fs.mkdir(path.dirname(fullPath), { recursive: true });
-        await fs.writeFile(fullPath, existingContent, 'utf-8');
-        this.context.logger.info(`Updated repo block with ${agentResponse?.agents?.length || 0} agents in phase structure`);
-        // Return the formatted block (without the extra newline at the end)
-        return repoBlock.trimEnd();
+        // Ensure repositoryRoot is set for ConfigService to load repo config
+        const contextWithRepo = {
+            ...context,
+            repositoryRoot: context.repositoryRoot || this.getRepositoryRoot(),
+        };
+        this.configService = new ConfigService(contextWithRepo);
     }
     /**
-     * Write the repository block to context file and return the formatted block (legacy compact format)
+     * Get repository root using the repo-utils helper
+     * This is used as fallback when context.repositoryRoot is not set
      */
-    async writeRepoBlockToContextFile(analysis, agents, contextFilePath = 'CLAUDE.md', version) {
-        const repoRoot = getRepoRoot();
-        const fullPath = path.join(repoRoot, contextFilePath);
-        this.context.logger.debug('[RepoService] Writing repo block to context file:', {
-            repoRoot,
-            contextFilePath,
-            fullPath
-        });
-        // Build the complete repo block
-        const repoBlock = await this.formatRepoBlock(analysis, agents, version);
-        // Read existing content
-        let existingContent = '';
+    getRepositoryRoot() {
         try {
-            existingContent = await fs.readFile(fullPath, 'utf-8');
+            return getRepoRoot();
         }
         catch {
-            // File doesn't exist, that's ok
-        }
-        // Update or append tiny-brain section
-        const startMarker = RepoService.REPO_BLOCK_START;
-        const endMarker = RepoService.REPO_BLOCK_END;
-        if (existingContent.includes(startMarker)) {
-            // Replace existing tiny-brain section
-            const startIndex = existingContent.indexOf(startMarker);
-            const endIndex = existingContent.indexOf(endMarker);
-            if (endIndex > -1) {
-                // Replace from start to end marker (inclusive)
-                const afterEnd = existingContent.substring(endIndex + endMarker.length);
-                existingContent = existingContent.substring(0, startIndex) +
-                    repoBlock +
-                    afterEnd;
-            }
-            else {
-                // No end marker found, replace to next section or end of file
-                const nextSectionIndex = existingContent.indexOf('\n## ', startIndex + 1);
-                if (nextSectionIndex > -1) {
-                    existingContent = existingContent.substring(0, startIndex) +
-                        repoBlock +
-                        existingContent.substring(nextSectionIndex);
-                }
-                else {
-                    existingContent = existingContent.substring(0, startIndex) + repoBlock;
-                }
-            }
+            return undefined;
         }
-        else {
-            // Append tiny-brain section
-            existingContent = existingContent.trimEnd() + '\n\n' + repoBlock;
-        }
-        // Ensure directory exists and write file
-        await fs.mkdir(path.dirname(fullPath), { recursive: true });
-        await fs.writeFile(fullPath, existingContent, 'utf-8');
-        this.context.logger.info(`Updated repo block with ${agents.length} agents`);
-        // Return the formatted block (without the extra newline at the end)
-        return repoBlock.trimEnd();
     }
     /**
-     * Read the repository block from context file
+     * Read the repository block from context file (for legacy migration)
      */
     async readRepoBlockFromContextFile(contextFilePath = 'CLAUDE.md') {
         try {
@@ -188,342 +76,6 @@ export class RepoService {
             throw error;
         }
     }
-    /**
-     * Format the repository block with phase-based agent structure
-     */
-    async formatRepoBlockWithPhases(analysis, agentResponse, version) {
-        let block = `${RepoService.REPO_BLOCK_START}\n`;
-        // Add YAML frontmatter with version if provided
-        if (version) {
-            block += '---\n';
-            block += `version: ${version}\n`;
-            block += `updated: ${new Date().toISOString()}\n`;
-            block += '---\n\n';
-        }
-        // PRD Workflow section (appears FIRST if PRD exists)
-        const prdWorkflow = await this.formatPRDWorkflowSection();
-        if (prdWorkflow) {
-            block += prdWorkflow;
-        }
-        // ADR section (if exists)
-        const adrSection = this.formatADRSection();
-        if (adrSection) {
-            block += adrSection;
-        }
-        block += `${RepoService.SUBAGENT_PROTOCOL_HEADER}\n\n`;
-        // When to use agents - phase-based format
-        block += `${RepoService.AGENT_USAGE_HEADER}\n\n`;
-        block += this.formatAgentsWithPhases(agentResponse);
-        // Repository context - YAML format
-        block += `${RepoService.REPO_CONTEXT_HEADER}\n`;
-        block += this.formatRepositoryContextYaml(analysis);
-        // Documentation templates section (conditional)
-        const docTemplatesSection = this.formatDocumentationTemplatesSection();
-        if (docTemplatesSection) {
-            block += docTemplatesSection;
-        }
-        // Usage template
-        block += `\n${RepoService.USAGE_TEMPLATE_HEADER}\n\n`;
-        block += '```\n';
-        block += 'Repository Context: [paste the yaml above]\n\n';
-        block += 'AGENT: [choose from list above]\n';
-        block += 'TASK: [specific task description]\n';
-        block += 'CONSTRAINTS: [requirements/limitations]\n';
-        block += 'EXPECTED OUTPUT: [what you need back]\n';
-        block += '```\n';
-        // Example
-        block += `\n${RepoService.EXAMPLE_HEADER}\n`;
-        block += '```\n';
-        block += 'Repository Context: [repo context yaml]\n\n';
-        block += 'AGENT: component-developer\n';
-        block += 'TASK: Create a UserProfile component with avatar, name, and email\n';
-        block += 'CONSTRAINTS: Must be accessible, use TypeScript, follow TDD\n';
-        block += 'EXPECTED OUTPUT: Component file with tests and usage example\n';
-        block += '```\n';
-        // TB_ANALYSIS at the end with IGNORE suffix for clarity
-        block += `\n${RepoService.ANALYSIS_IGNORE_PREFIX}${JSON.stringify(analysis)}${RepoService.ANALYSIS_IGNORE_SUFFIX}\n`;
-        block += `${RepoService.REPO_BLOCK_END}\n`;
-        return block;
-    }
-    /**
-     * Format the complete repository block with simplified structure
-     */
-    async formatRepoBlock(analysis, agents, version) {
-        let block = `${RepoService.REPO_BLOCK_START}\n`;
-        // Add YAML frontmatter with version if provided
-        if (version) {
-            block += '---\n';
-            block += `version: ${version}\n`;
-            block += `updated: ${new Date().toISOString()}\n`;
-            block += '---\n\n';
-        }
-        // PRD Workflow section (includes commit format, TDD workflow if enabled)
-        const prdWorkflow = await this.formatPRDWorkflowSection();
-        if (prdWorkflow) {
-            block += prdWorkflow;
-        }
-        // Tech Stack & Agents section (simplified table format)
-        block += '## Tech Stack & Agents\n\n';
-        block += this.formatAgentTable(agents, analysis);
-        // Repository context - YAML format
-        block += '\n## Repository Context\n';
-        block += this.formatRepositoryContextYaml(analysis);
-        // Documentation templates section (conditional)
-        const docTemplatesSection = this.formatDocumentationTemplatesSection();
-        if (docTemplatesSection) {
-            block += docTemplatesSection;
-        }
-        // TB_ANALYSIS at the end with IGNORE suffix for clarity
-        block += `\n${RepoService.ANALYSIS_IGNORE_PREFIX}${JSON.stringify(analysis)}${RepoService.ANALYSIS_IGNORE_SUFFIX}\n`;
-        block += `${RepoService.REPO_BLOCK_END}\n`;
-        return block;
-    }
-    /**
-     * Parse the repository block from context file into structured data
-     */
-    async parseRepoBlock(contextFilePath = 'CLAUDE.md') {
-        const repoBlockMarkdown = await this.readRepoBlockFromContextFile(contextFilePath);
-        if (!repoBlockMarkdown)
-            return null;
-        // Extract JSON from comment
-        const analysisRegex = new RegExp(`${RepoService.ANALYSIS_MARKER_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(.*?)${RepoService.ANALYSIS_MARKER_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
-        const jsonMatch = repoBlockMarkdown.match(analysisRegex);
-        const rawAnalysis = jsonMatch ? JSON.parse(jsonMatch[1]) : null;
-        // Extract analysis section
-        const analysisMatch = repoBlockMarkdown.match(/### repo analysis\n([\s\S]*?)(?=\n###|\n##|$)/);
-        const analysis = analysisMatch ? analysisMatch[1].trim() : '';
-        // Extract documentation section (optional)
-        const docMatch = repoBlockMarkdown.match(/#### documentation\n([\s\S]*?)(?=\n###|\n##|$)/);
-        const documentation = docMatch ? docMatch[1].trim() : null;
-        // Extract agent usage section
-        const agentMatch = repoBlockMarkdown.match(/### agent usage\n([\s\S]*?)(?=\n##|$)/);
-        const agentUsage = agentMatch ? agentMatch[1].trim() : 'No agents available for this repository.';
-        return { rawAnalysis, analysis, documentation, agentUsage };
-    }
-    /**
-     * Format agents with phase-based structure
-     */
-    formatAgentsWithPhases(agentResponse) {
-        // Handle empty response
-        if (!agentResponse?.agentUsage?.phases || Object.keys(agentResponse.agentUsage.phases).length === 0) {
-            return 'No agents available for this repository.\n';
-        }
-        let output = '';
-        const phases = agentResponse.agentUsage.phases;
-        const phaseOrder = ['ideation', 'development', 'testing', 'operations'];
-        const phaseNames = {
-            ideation: 'Phase 1: Ideation',
-            development: 'Phase 2: Development',
-            testing: 'Phase 3: Testing & Quality',
-            operations: 'Phase 4: Operations & Analysis'
-        };
-        // Format each phase
-        phaseOrder.forEach((phaseKey) => {
-            const phase = phases[phaseKey];
-            if (!phase)
-                return;
-            output += `#### ${phaseNames[phaseKey]}\n`;
-            // List agents
-            if (phase.agents && phase.agents.length > 0) {
-                phase.agents.forEach((agentName) => {
-                    const agent = agentResponse.agents?.find((a) => a.name === agentName);
-                    if (agent) {
-                        output += `- \`${agent.name}\` - ${agent.details.description}\n`;
-                    }
-                    else {
-                        output += `- \`${agentName}\`\n`;
-                    }
-                });
-                output += '\n';
-            }
-            // Phase handoffs
-            if (phase.handoffs && phase.handoffs.length > 0) {
-                const phaseName = phaseNames[phaseKey] || phaseKey;
-                const phaseTitle = phaseName.includes(':') ? phaseName.split(':')[0] : phaseName;
-                output += `**${phaseTitle} Handoffs:**\n`;
-                phase.handoffs.forEach((handoff) => {
-                    if (typeof handoff === 'string') {
-                        // Handle string format: "from → to: description"
-                        output += `- \`${handoff.replace(' → ', '` → `').replace(': ', '`: ')}\n`;
-                    }
-                    else {
-                        // Handle object format
-                        output += `- \`${handoff.from}\` → \`${handoff.to}\``;
-                        if (handoff.description) {
-                            output += `: ${handoff.description}`;
-                        }
-                        output += '\n';
-                    }
-                });
-                output += '\n';
-            }
-        });
-        // Cross-phase handoffs
-        if (agentResponse.agentUsage.crossPhaseHandoffs && agentResponse.agentUsage.crossPhaseHandoffs.length > 0) {
-            output += '### Cross-Phase Handoffs\n';
-            agentResponse.agentUsage.crossPhaseHandoffs.forEach((handoff) => {
-                const fromPhaseName = phaseNames[handoff.from] || handoff.from;
-                const toPhaseName = phaseNames[handoff.to] || handoff.to;
-                const fromName = fromPhaseName.includes(':') ? fromPhaseName.split(':')[1]?.trim() : fromPhaseName;
-                const toName = toPhaseName.includes(':') ? toPhaseName.split(':')[1]?.trim() : toPhaseName;
-                output += `**${fromName.charAt(0).toUpperCase() + fromName.slice(1)} → ${toName.charAt(0).toUpperCase() + toName.slice(1)}:**\n`;
-                output += `- ${handoff.description}\n\n`;
-            });
-        }
-        // Prerequisites
-        if (agentResponse.agentUsage.prerequisites && Object.keys(agentResponse.agentUsage.prerequisites).length > 0) {
-            output += '### Agent Prerequisites\n';
-            Object.entries(agentResponse.agentUsage.prerequisites).forEach(([agent, prerequisites]) => {
-                // Prerequisites can be either a string or array of strings
-                if (Array.isArray(prerequisites)) {
-                    if (prerequisites.length > 0) {
-                        const formattedPrereqs = prerequisites.map(prereq => `\`${prereq}\``).join(', ');
-                        output += `- \`${agent}\`: ${formattedPrereqs}\n`;
-                    }
-                }
-                else if (typeof prerequisites === 'string' && prerequisites.trim()) {
-                    // Prerequisites is a string description - wrap agent names in backticks
-                    const formattedPrerequisites = prerequisites.replace(/([a-z-]+(?:-[a-z]+)*)/g, (match) => {
-                        // Only wrap strings that look like agent names (hyphenated words)
-                        if (match.includes('-') || ['system', 'feature', 'component', 'functional', 'tdd', 'refactoring', 'metrics', 'root'].some(word => match.includes(word))) {
-                            return `\`${match}\``;
-                        }
-                        return match;
-                    });
-                    output += `- \`${agent}\`: ${formattedPrerequisites}\n`;
-                }
-            });
-            output += '\n';
-        }
-        // Invocation template
-        if (agentResponse.agentUsage.invocationTemplate?.structure) {
-            output += '### Agent Invocation Template\n';
-            output += '```\n';
-            output += agentResponse.agentUsage.invocationTemplate.structure.replace(/\\n/g, '\n');
-            output += '\n```\n';
-        }
-        return output;
-    }
-    /**
-     * Format agents as a simple table with tech-stack specific "Use for" descriptions
-     */
-    formatAgentTable(agents, analysis) {
-        if (agents.length === 0) {
-            return 'No agents installed for this repository.\n';
-        }
-        // Generate tech stack summary
-        const techParts = [];
-        if (analysis.languages.length > 0) {
-            techParts.push(analysis.languages.join('/'));
-        }
-        if (analysis.frameworks.length > 0) {
-            techParts.push(analysis.frameworks.join(', '));
-        }
-        const testingTool = analysis.testingTools[0];
-        if (testingTool) {
-            techParts.push(`${testingTool} testing`);
-        }
-        let output = '';
-        if (techParts.length > 0) {
-            output += `${techParts.join(' repository with ')}.\n\n`;
-        }
-        // Build agent table
-        output += '| Agent | Use for |\n';
-        output += '|-------|--------|\n';
-        agents.forEach(agent => {
-            // Use TBR-provided usage if available, otherwise generic fallback
-            const useCase = agent.usage || this.generateAgentUseCase(agent);
-            output += `| \`${agent.name}\` | ${useCase} |\n`;
-        });
-        output += '\nSkills automatically select appropriate agents. Use Task tool for direct invocation.\n';
-        return output;
-    }
-    /**
-     * Generate generic "Use for" description based on agent name
-     * This is a fallback when TBR doesn't provide contextual usage
-     */
-    generateAgentUseCase(agent) {
-        const name = agent.name.toLowerCase();
-        // Generic fallback based on agent name
-        if (name.includes('typescript'))
-            return 'TypeScript files';
-        if (name.includes('react'))
-            return 'React components';
-        if (name.includes('component'))
-            return 'UI components';
-        if (name.includes('tdd') || name.includes('test'))
-            return 'Test files';
-        if (name.includes('backend'))
-            return 'Backend code';
-        if (name.includes('frontend'))
-            return 'Frontend code';
-        if (name.includes('architect'))
-            return 'Architecture decisions';
-        if (name.includes('refactor'))
-            return 'Refactoring';
-        if (name.includes('security'))
-            return 'Security';
-        if (name.includes('performance'))
-            return 'Performance';
-        if (name.includes('quality'))
-            return 'Code review';
-        if (name.includes('validator'))
-            return 'Validation';
-        // Fallback to cleaned-up agent name
-        return agent.name.replace(/-/g, ' ');
-    }
-    /**
-     * Format repository context as clean YAML
-     */
-    formatRepositoryContextYaml(analysis) {
-        const repoRoot = getRepoRoot();
-        let yaml = '```yaml\n';
-        // Analysis metadata
-        yaml += `Analysis Date: ${new Date().toISOString()}\n`;
-        yaml += `Analysis Version: ${this.getAnalysisVersion()}\n`;
-        yaml += `Languages: ${analysis.languages.join(', ')}\n`;
-        yaml += `Frameworks: ${analysis.frameworks.join(', ')}\n`;
-        yaml += `Build Tools: ${analysis.buildTools.join(', ')}\n`;
-        yaml += `Testing Tools: ${analysis.testingTools.join(', ')}\n`;
-        if (analysis.hasTests) {
-            yaml += `Tests: ${analysis.testFileCount} files (patterns: ${analysis.testPatterns.join(', ')})\n`;
-        }
-        if (analysis.isPolyglot) {
-            yaml += `Polyglot: Yes (primary: ${analysis.primaryLanguage})\n`;
-        }
-        yaml += `Documentation Pattern: ${analysis.documentationPattern}\n`;
-        // Build documentation locations including PRD and ADR paths if they exist
-        const docLocations = analysis.documentationLocations?.map(loc => path.isAbsolute(loc) ? loc : path.join(repoRoot, loc)) || [];
-        // Add PRD path if it exists
-        const prdPath = path.join(repoRoot, 'docs', 'prd');
-        if (existsSync(prdPath) && !docLocations.includes(prdPath)) {
-            docLocations.push(prdPath);
-        }
-        // Add ADR path if it exists
-        const adrPath = path.join(repoRoot, 'docs', 'adr');
-        if (existsSync(adrPath) && !docLocations.includes(adrPath)) {
-            docLocations.push(adrPath);
-        }
-        yaml += `Documentation Locations: ${docLocations.join(', ')}\n`;
-        yaml += '```\n';
-        return yaml;
-    }
-    /**
-     * Get the analysis version from package.json
-     */
-    getAnalysisVersion() {
-        try {
-            // Read package.json from the tiny-brain-local package
-            const currentFilePath = fileURLToPath(import.meta.url);
-            const packageJsonPath = path.join(path.dirname(currentFilePath), '../../package.json');
-            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            return packageJson.version || '0.0.0';
-        }
-        catch (error) {
-            this.context.logger.warn('Failed to read package version:', error);
-            return '0.0.0';
-        }
-    }
     /**
      * Extract version from tiny-brain block frontmatter
      * @param content - The content containing the tiny-brain block
@@ -535,106 +87,6 @@ export class RepoService {
         const match = content.match(versionRegex);
         return match ? match[1] : null;
     }
-    /**
-     * Format documentation templates section for PRDs and ADRs
-     * Only includes sections for directories that exist
-     */
-    formatDocumentationTemplatesSection() {
-        const repoRoot = getRepoRoot();
-        const prdPath = path.join(repoRoot, 'docs', 'prd');
-        const adrPath = path.join(repoRoot, 'docs', 'adr');
-        const hasPRD = existsSync(prdPath);
-        const hasADR = existsSync(adrPath);
-        // If neither exists, return empty string
-        if (!hasPRD && !hasADR) {
-            return '';
-        }
-        let section = '\n### Documentation Templates\n\n';
-        const skillsPath = path.join(repoRoot, '.claude', 'skills');
-        // Add PRD instructions if directory exists
-        if (hasPRD) {
-            section += '**PRD & Feature Creation (Model-Invoked Skills):**\n';
-            section += `- Skills are automatically triggered based on your intent - describe what you want to do\n`;
-            section += `- "I want to plan a new feature" → triggers plan skill\n`;
-            section += `- "I want to add a feature to the PRD" → triggers feature skill\n`;
-            section += `- "I want to track a bug fix" → triggers fix skill\n`;
-            section += `- Skills: \`.claude/skills/plan/\`, \`.claude/skills/feature/\`, \`.claude/skills/fix/\`\n`;
-            section += `- Check available skills: ask "What Skills are available?"\n\n`;
-        }
-        // Add ADR instructions if directory exists
-        if (hasADR) {
-            const adrSkillPath = path.join(skillsPath, 'adr');
-            section += '**ADR Creation:**\n';
-            section += `- Use \`/adr\` skill to create Architecture Decision Records\n`;
-            section += `- Skill located at \`${adrSkillPath}/\`\n`;
-            section += `- Template at \`${adrSkillPath}/templates/adr-template.md\`\n`;
-        }
-        return section;
-    }
-    /**
-     * Extract TB_ANALYSIS from content with new IGNORE format
-     */
-    extractTBAnalysis(content) {
-        const regex = new RegExp(`${RepoService.ANALYSIS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(.*?)${RepoService.ANALYSIS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
-        const match = content.match(regex);
-        if (match && match[1]) {
-            try {
-                return JSON.parse(match[1]);
-            }
-            catch {
-                return null;
-            }
-        }
-        return null;
-    }
-    /**
-     * Extract TB-STATUS from content with backwards compatibility for TB_ANALYSIS-IGNORE
-     */
-    extractTBStatus(content) {
-        // First try TB-STATUS-IGNORE (new format)
-        const statusRegex = new RegExp(`${RepoService.STATUS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(.*?)${RepoService.STATUS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
-        const statusMatch = content.match(statusRegex);
-        if (statusMatch && statusMatch[1]) {
-            try {
-                return JSON.parse(statusMatch[1]);
-            }
-            catch {
-                return null;
-            }
-        }
-        // Fall back to TB_ANALYSIS-IGNORE (legacy format)
-        const analysisRegex = new RegExp(`${RepoService.ANALYSIS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(.*?)${RepoService.ANALYSIS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
-        const analysisMatch = content.match(analysisRegex);
-        if (analysisMatch && analysisMatch[1]) {
-            try {
-                const analysis = JSON.parse(analysisMatch[1]);
-                // Convert RepoAnalysis to TBStatus format (no additional fields for legacy)
-                return analysis;
-            }
-            catch {
-                return null;
-            }
-        }
-        return null;
-    }
-    /**
-     * Generate TB-STATUS-IGNORE format string with current timestamp
-     */
-    updateTBStatus(analysis, installedAgents) {
-        const tbStatus = {
-            ...analysis,
-            lastUpdated: new Date().toISOString(),
-            ...(installedAgents && { installedAgents })
-        };
-        return `${RepoService.STATUS_IGNORE_PREFIX}${JSON.stringify(tbStatus)}${RepoService.STATUS_IGNORE_SUFFIX}`;
-    }
-    /**
-     * Check if repository is initialized (has TB-STATUS-IGNORE or TB_ANALYSIS-IGNORE)
-     */
-    isRepoInitialized(content) {
-        const tbStatus = this.extractTBStatus(content);
-        return tbStatus !== null;
-    }
     /**
      * Check if we're in a repository context
      */
@@ -649,562 +101,373 @@ export class RepoService {
         }
     }
     /**
-     * Check if repository is initialized (has TB block in context file)
+     * Check if repository is initialized (has .tiny-brain/analysis.json)
+     * This is the new initialization check - no longer checks CLAUDE.md
      */
     async isRepositoryInitialized() {
         if (!this.isInRepository()) {
-            return false; // Not in repo, so not initialized
+            return false;
         }
         try {
-            const content = await this.readRepoBlockFromContextFile();
-            return content ? this.isRepoInitialized(content) : false;
+            const repoRoot = getRepoRoot();
+            const analysisPath = path.join(repoRoot, '.tiny-brain', 'analysis.json');
+            return existsSync(analysisPath);
         }
         catch {
             return false;
         }
     }
     /**
-     * Compare two tech stacks and return differences
-     */
-    compareTechStack(previousAnalysis, currentAnalysis) {
-        return detectTechStackChanges({
-            languages: previousAnalysis.languages || [],
-            frameworks: previousAnalysis.frameworks || [],
-            buildTools: previousAnalysis.buildTools || [],
-            testingTools: previousAnalysis.testingTools || []
-        }, {
-            languages: currentAnalysis.languages || [],
-            frameworks: currentAnalysis.frameworks || [],
-            buildTools: currentAnalysis.buildTools || [],
-            testingTools: currentAnalysis.testingTools || []
-        });
-    }
-    /**
-     * Migrate legacy TB_ANALYSIS-IGNORE format to new TB-STATUS-IGNORE format
-     */
-    migrateToNewFormat(existingContent, newAnalysis) {
-        // Generate new TB-STATUS-IGNORE format
-        const newStatusIgnore = this.updateTBStatus(newAnalysis);
-        // Replace TB_ANALYSIS-IGNORE with TB-STATUS-IGNORE
-        if (existingContent.includes(RepoService.ANALYSIS_IGNORE_PREFIX)) {
-            const analysisRegex = new RegExp(`${RepoService.ANALYSIS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*?${RepoService.ANALYSIS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
-            return existingContent.replace(analysisRegex, newStatusIgnore);
-        }
-        // Replace existing TB-STATUS-IGNORE with updated version
-        if (existingContent.includes(RepoService.STATUS_IGNORE_PREFIX)) {
-            const statusRegex = new RegExp(`${RepoService.STATUS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*?${RepoService.STATUS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
-            return existingContent.replace(statusRegex, newStatusIgnore);
-        }
-        // No existing format found, return original content
-        return existingContent;
-    }
-    /**
-     * Update agent usage section in CLAUDE.md with phase-based structure
+     * Get the analysis version from package.json
      */
-    async updateAgentUsageSection(installedAgents, phaseStructure, contextFilePath = 'CLAUDE.md') {
+    getAnalysisVersion() {
         try {
-            const repoRoot = getRepoRoot();
-            const fullPath = path.join(repoRoot, contextFilePath);
-            // Read existing content or create new
-            let existingContent = '';
-            try {
-                existingContent = await fs.readFile(fullPath, 'utf-8');
-            }
-            catch {
-                // File doesn't exist, create with just the tiny-brain section
-                existingContent = '';
-            }
-            // Generate the agent usage content
-            const agentUsageContent = this.formatPhaseBasedAgentUsage(installedAgents, phaseStructure);
-            // Update or create the tiny-brain section
-            const updatedContent = this.updateTinyBrainSection(existingContent, agentUsageContent);
-            // Ensure directory exists and write file
-            await fs.mkdir(path.dirname(fullPath), { recursive: true });
-            await fs.writeFile(fullPath, updatedContent, 'utf-8');
-            this.context.logger.info(`Updated ${contextFilePath} with ${installedAgents.length} agents in phase structure`);
+            // Read package.json from the tiny-brain-local package
+            const currentFilePath = fileURLToPath(import.meta.url);
+            const packageJsonPath = path.join(path.dirname(currentFilePath), '../../package.json');
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+            return packageJson.version || '0.0.0';
         }
         catch (error) {
-            this.context.logger.error(`Failed to update agent usage section in ${contextFilePath}:`, error);
-            throw error;
-        }
-    }
-    /**
-     * Generate phase structure from installed agents
-     */
-    generatePhaseStructure(installedAgents) {
-        const structure = {
-            phases: {},
-            crossPhaseHandoffs: [],
-            prerequisites: {}
-        };
-        // Agent categorization
-        const ideationAgents = [];
-        const developmentAgents = [];
-        const testingAgents = [];
-        const operationsAgents = [];
-        // Categorize agents
-        installedAgents.forEach(agent => {
-            const name = agent.name.toLowerCase();
-            if (name.includes('prd') || name.includes('researcher') ||
-                name.includes('architect') || name.includes('planner')) {
-                ideationAgents.push(agent.name);
-            }
-            else if (name.includes('test') || name.includes('validator') ||
-                name.includes('tdd') || name.includes('refactor')) {
-                testingAgents.push(agent.name);
-            }
-            else if (name.includes('metrics') || name.includes('analyst') ||
-                name.includes('collector') || name.includes('monitor')) {
-                operationsAgents.push(agent.name);
-            }
-            else {
-                // Default to development
-                developmentAgents.push(agent.name);
-            }
-        });
-        // Build phase structure
-        if (ideationAgents.length > 0) {
-            structure.phases.ideation = {
-                agents: ideationAgents,
-                handoffs: this.generatePhaseHandoffs(ideationAgents)
-            };
-        }
-        if (developmentAgents.length > 0) {
-            structure.phases.development = {
-                agents: developmentAgents,
-                handoffs: this.generatePhaseHandoffs(developmentAgents)
-            };
-        }
-        if (testingAgents.length > 0) {
-            structure.phases.testing = {
-                agents: testingAgents,
-                handoffs: this.generatePhaseHandoffs(testingAgents)
-            };
-        }
-        if (operationsAgents.length > 0) {
-            structure.phases.operations = {
-                agents: operationsAgents,
-                handoffs: this.generatePhaseHandoffs(operationsAgents)
-            };
+            this.context.logger.warn('Failed to read package version:', error);
+            return '0.0.0';
         }
-        // Generate cross-phase handoffs
-        structure.crossPhaseHandoffs = this.generateCrossPhaseHandoffs(structure.phases);
-        // Generate prerequisites
-        structure.prerequisites = this.generatePrerequisites(installedAgents);
-        return structure;
     }
     /**
-     * Create or update TB-STATUS-IGNORE with analysis and installed agents
+     * Write workflow sections to CLAUDE.md based on config flags
+     *
+     * Writes the following sections when their respective flags are enabled:
+     * - Commit Message Format (when SDD enabled)
+     * - TDD Workflow (when TDD enabled)
+     * - Progress Tracking Auto-Commit Configuration (when SDD enabled)
+     * - Operational Tracking Directory (when SDD enabled)
      */
-    async createOrUpdateTBStatus(analysis, installedAgents, contextFilePath = 'CLAUDE.md') {
-        try {
-            const repoRoot = getRepoRoot();
-            const fullPath = path.join(repoRoot, contextFilePath);
-            // Read existing content
-            let existingContent = '';
-            try {
-                existingContent = await fs.readFile(fullPath, 'utf-8');
-            }
-            catch {
-                // File doesn't exist
-            }
-            // Create TB status data
-            const tbStatus = {
-                ...analysis,
-                lastUpdated: new Date().toISOString(),
-                installedAgents
-            };
-            // Generate TB-STATUS-IGNORE format
-            const statusIgnore = `${RepoService.STATUS_IGNORE_PREFIX}${JSON.stringify(tbStatus)}${RepoService.STATUS_IGNORE_SUFFIX}`;
-            // Update the status in the content
-            let updatedContent = existingContent;
-            // Replace existing TB-STATUS-IGNORE or TB_ANALYSIS-IGNORE
-            if (existingContent.includes(RepoService.STATUS_IGNORE_PREFIX)) {
-                const statusRegex = new RegExp(`${RepoService.STATUS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*?${RepoService.STATUS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
-                updatedContent = existingContent.replace(statusRegex, statusIgnore);
-            }
-            else if (existingContent.includes(RepoService.ANALYSIS_IGNORE_PREFIX)) {
-                const analysisRegex = new RegExp(`${RepoService.ANALYSIS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*?${RepoService.ANALYSIS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
-                updatedContent = existingContent.replace(analysisRegex, statusIgnore);
-            }
-            else {
-                // Add to tiny-brain section or create it
-                updatedContent = this.addStatusToContent(existingContent, statusIgnore);
-            }
-            // Write updated content
-            await fs.mkdir(path.dirname(fullPath), { recursive: true });
-            await fs.writeFile(fullPath, updatedContent, 'utf-8');
-            this.context.logger.info(`Updated TB-STATUS-IGNORE with ${installedAgents.length} agents`);
-        }
-        catch (error) {
-            this.context.logger.error('Failed to create or update TB-STATUS-IGNORE:', error);
-            throw error;
+    async writeWorkflowSections(options = {}) {
+        const { contextPath = 'CLAUDE.md' } = options;
+        // Check config flags
+        const enableSDD = await this.configService.isSDDEnabled();
+        const enableTDD = await this.configService.isTDDEnabled();
+        // If nothing is enabled, don't write anything
+        if (!enableSDD && !enableTDD) {
+            return;
         }
-    }
-    /**
-     * Migrate legacy TB_ANALYSIS-IGNORE to TB-STATUS-IGNORE format
-     */
-    async migrateTBAnalysisToTBStatus(existingContent, installedAgents, contextFilePath = 'CLAUDE.md') {
-        try {
-            // Extract existing analysis data
-            const existingAnalysis = this.extractTBAnalysis(existingContent);
-            if (!existingAnalysis) {
-                this.context.logger.warn('No TB_ANALYSIS-IGNORE found to migrate');
-                return;
-            }
-            // Create TB status with preserved analysis data and new agents
-            const tbStatus = {
-                ...existingAnalysis,
-                lastUpdated: new Date().toISOString(),
-                installedAgents
-            };
-            // Generate new TB-STATUS-IGNORE
-            const statusIgnore = `${RepoService.STATUS_IGNORE_PREFIX}${JSON.stringify(tbStatus)}${RepoService.STATUS_IGNORE_SUFFIX}`;
-            // Replace TB_ANALYSIS-IGNORE with TB-STATUS-IGNORE
-            const analysisRegex = new RegExp(`${RepoService.ANALYSIS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*?${RepoService.ANALYSIS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
-            const updatedContent = existingContent.replace(analysisRegex, statusIgnore);
-            // Write migrated content
-            const repoRoot = getRepoRoot();
-            const fullPath = path.join(repoRoot, contextFilePath);
-            await fs.writeFile(fullPath, updatedContent, 'utf-8');
-            this.context.logger.info('Successfully migrated TB_ANALYSIS-IGNORE to TB-STATUS-IGNORE format');
+        // Build the workflow sections content
+        let workflowContent = '';
+        // Commit Message Format (when SDD enabled)
+        if (enableSDD) {
+            workflowContent += this.formatCommitMessageSection();
         }
-        catch (error) {
-            this.context.logger.error('Failed to migrate TB_ANALYSIS-IGNORE:', error);
-            throw error;
+        // TDD Workflow (when TDD enabled)
+        if (enableTDD) {
+            workflowContent += this.formatTDDWorkflowSection();
         }
-    }
-    /**
-     * Get TB status from CLAUDE.md with fallback to legacy format
-     */
-    async getTBStatus(contextFilePath = 'CLAUDE.md') {
-        try {
-            const repoRoot = getRepoRoot();
-            const fullPath = path.join(repoRoot, contextFilePath);
-            const content = await fs.readFile(fullPath, 'utf-8');
-            // Try to extract TB status using existing method
-            const tbStatus = this.extractTBStatus(content);
-            if (tbStatus && !tbStatus.installedAgents) {
-                // Legacy format detected, recommend migration
-                this.context.logger.info('Legacy TB_ANALYSIS-IGNORE format detected. Consider migrating to TB-STATUS-IGNORE.');
-            }
-            return tbStatus;
+        // Progress Tracking Auto-Commit Configuration (when SDD enabled)
+        if (enableSDD) {
+            workflowContent += this.formatProgressTrackingSection();
         }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                // File doesn't exist
-                return null;
-            }
-            this.context.logger.warn('Failed to parse TB status:', error);
-            return null;
+        // Operational Tracking Directory (when SDD enabled)
+        if (enableSDD) {
+            workflowContent += this.formatOperationalTrackingSection();
         }
-    }
-    /**
-     * Update repository context YAML section with current analysis
-     */
-    async updateRepositoryContext(analysis, contextFilePath = 'CLAUDE.md') {
+        // Build the complete tiny-brain block
+        const repoBlock = `${RepoService.REPO_BLOCK_START}\n\n${workflowContent}${RepoService.REPO_BLOCK_END}\n`;
+        // Get full path
+        const repoRoot = getRepoRoot();
+        const fullPath = path.join(repoRoot, contextPath);
+        // Read existing content
+        let existingContent = '';
         try {
-            const repoRoot = getRepoRoot();
-            const fullPath = path.join(repoRoot, contextFilePath);
-            // Read existing content
-            let existingContent = '';
-            try {
-                existingContent = await fs.readFile(fullPath, 'utf-8');
-            }
-            catch {
-                // File doesn't exist
-                return;
-            }
-            // Generate new YAML content
-            const newYamlContent = this.formatRepositoryContextYaml(analysis);
-            // Find and replace the Repository Context section
-            const contextHeaderRegex = /### Repository Context\n```yaml\n.*?\n```/s;
-            const updatedContent = existingContent.replace(contextHeaderRegex, `### Repository Context\n${newYamlContent}`);
-            // Write updated content
-            await fs.writeFile(fullPath, updatedContent, 'utf-8');
-            this.context.logger.info('Updated repository context YAML section');
-        }
-        catch (error) {
-            this.context.logger.error('Failed to update repository context:', error);
-            throw error;
-        }
-    }
-    /**
-     * Format phase-based agent usage content
-     */
-    formatPhaseBasedAgentUsage(installedAgents, phaseStructure) {
-        // Suppress unused parameter warning - installedAgents used implicitly through phaseStructure
-        void installedAgents;
-        let content = '### When to Use Agents\n\n';
-        const phaseNames = {
-            ideation: 'Phase 1: Ideation',
-            development: 'Phase 2: Development',
-            testing: 'Phase 3: Testing & Quality',
-            operations: 'Phase 4: Operations & Analysis'
-        };
-        // Generate phase sections
-        Object.entries(phaseStructure.phases).forEach(([phaseKey, phase]) => {
-            const phaseName = phaseNames[phaseKey] || phaseKey;
-            content += `#### ${phaseName}\n`;
-            // List agents
-            phase.agents.forEach(agentName => {
-                const description = this.getAgentDescription(agentName);
-                content += `- \`${agentName}\` - ${description}\n`;
-            });
-            // Add handoffs if any
-            if (phase.handoffs.length > 0) {
-                content += `\n**${phaseName.split(':')[0]} Handoffs:**\n`;
-                phase.handoffs.forEach(handoff => {
-                    content += `- ${handoff.replace(/(\w+)/g, '`$1`')}\n`;
-                });
-            }
-            content += '\n';
-        });
-        // Add cross-phase handoffs
-        if (phaseStructure.crossPhaseHandoffs.length > 0) {
-            content += '### Cross-Phase Handoffs\n';
-            phaseStructure.crossPhaseHandoffs.forEach(handoff => {
-                const fromPhase = phaseNames[handoff.from] || handoff.from;
-                const toPhase = phaseNames[handoff.to] || handoff.to;
-                content += `**${fromPhase.split(':')[1]?.trim()} → ${toPhase.split(':')[1]?.trim()}:**\n`;
-                content += `- ${handoff.description}\n\n`;
-            });
+            existingContent = await fs.readFile(fullPath, 'utf-8');
         }
-        // Add prerequisites
-        if (Object.keys(phaseStructure.prerequisites).length > 0) {
-            content += '### Agent Prerequisites\n';
-            Object.entries(phaseStructure.prerequisites).forEach(([agent, prereqs]) => {
-                if (Array.isArray(prereqs)) {
-                    const formattedPrereqs = prereqs.map(p => `\`${p}\``).join(', ');
-                    content += `- \`${agent}\`: ${formattedPrereqs}\n`;
-                }
-                else if (typeof prereqs === 'string') {
-                    content += `- \`${agent}\`: ${prereqs}\n`;
-                }
-            });
+        catch {
+            // File doesn't exist, that's ok
         }
-        return content;
-    }
-    /**
-     * Update tiny-brain section in content with new agent usage
-     */
-    updateTinyBrainSection(existingContent, agentUsageContent) {
+        // Update or append tiny-brain section
         const startMarker = RepoService.REPO_BLOCK_START;
         const endMarker = RepoService.REPO_BLOCK_END;
         if (existingContent.includes(startMarker)) {
             // Replace existing tiny-brain section
             const startIndex = existingContent.indexOf(startMarker);
-            const endIndex = existingContent.indexOf(endMarker);
+            const endIndex = existingContent.indexOf(endMarker, startIndex);
             if (endIndex > -1) {
-                // Replace content between markers
-                const beforeSection = existingContent.substring(0, startIndex);
-                const afterSection = existingContent.substring(endIndex + endMarker.length);
-                return beforeSection + this.buildTinyBrainSection(agentUsageContent) + afterSection;
-            }
-        }
-        // Add new tiny-brain section
-        return existingContent.trimEnd() + '\n\n' + this.buildTinyBrainSection(agentUsageContent);
-    }
-    /**
-     * Build complete tiny-brain section
-     */
-    buildTinyBrainSection(agentUsageContent) {
-        return `${RepoService.REPO_BLOCK_START}\n` +
-            `${RepoService.SUBAGENT_PROTOCOL_HEADER}\n\n` +
-            agentUsageContent + '\n' +
-            `${RepoService.REPO_BLOCK_END}`;
-    }
-    /**
-     * Add TB status to content (create tiny-brain section if needed)
-     */
-    addStatusToContent(existingContent, statusIgnore) {
-        const startMarker = RepoService.REPO_BLOCK_START;
-        const endMarker = RepoService.REPO_BLOCK_END;
-        if (existingContent.includes(startMarker) && existingContent.includes(endMarker)) {
-            // Add before end marker
-            const endIndex = existingContent.indexOf(endMarker);
-            return existingContent.substring(0, endIndex) +
-                statusIgnore + '\n' +
-                existingContent.substring(endIndex);
-        }
-        else {
-            // Create minimal tiny-brain section
-            return existingContent.trimEnd() + '\n\n' +
-                `${startMarker}\n${statusIgnore}\n${endMarker}\n`;
-        }
-    }
-    /**
-     * Generate handoffs for agents within a phase
-     */
-    generatePhaseHandoffs(agents) {
-        const handoffs = [];
-        // Generate common handoff patterns
-        if (agents.includes('prd-researcher') && agents.includes('system-architect')) {
-            handoffs.push('prd-researcher → system-architect: Requirements analysis to system design');
-        }
-        if (agents.includes('system-architect') && agents.includes('backend-architect')) {
-            handoffs.push('system-architect → backend-architect: System design to backend architecture');
-        }
-        if (agents.includes('feature-developer') && agents.includes('component-developer')) {
-            handoffs.push('feature-developer → component-developer: Feature specs to UI implementation');
-        }
-        if (agents.includes('feature-developer') && agents.includes('typescript-developer')) {
-            handoffs.push('feature-developer → typescript-developer: Feature specs to type-safe implementation');
-        }
-        return handoffs;
-    }
-    /**
-     * Generate cross-phase handoffs based on available phases
-     */
-    generateCrossPhaseHandoffs(phases) {
-        const handoffs = [];
-        if (phases.ideation && phases.development) {
-            handoffs.push({
-                from: 'ideation',
-                to: 'development',
-                description: 'Architecture outputs → Development agents'
-            });
-        }
-        if (phases.development && phases.testing) {
-            handoffs.push({
-                from: 'development',
-                to: 'testing',
-                description: 'Implementation outputs → Testing agents'
-            });
-        }
-        if (phases.testing && phases.operations) {
-            handoffs.push({
-                from: 'testing',
-                to: 'operations',
-                description: 'Quality metrics → Operational monitoring'
-            });
-        }
-        return handoffs;
-    }
-    /**
-     * Generate prerequisites for agents
-     */
-    generatePrerequisites(installedAgents) {
-        const prerequisites = {};
-        const agentNames = installedAgents.map(a => a.name);
-        agentNames.forEach(agent => {
-            if (agent === 'feature-developer' && agentNames.includes('system-architect')) {
-                prerequisites[agent] = ['system-architect'];
-            }
-            if (agent === 'component-developer' && agentNames.includes('system-architect')) {
-                prerequisites[agent] = ['system-architect'];
-            }
-            if (agent === 'typescript-developer' &&
-                (agentNames.includes('backend-architect') || agentNames.includes('system-architect'))) {
-                prerequisites[agent] = agentNames.includes('backend-architect') ?
-                    ['backend-architect', 'system-architect'] : ['system-architect'];
-            }
-            if (agent === 'tdd-validator' && agentNames.some(a => a.includes('developer'))) {
-                prerequisites[agent] = agentNames.filter(a => a.includes('developer'));
+                // Replace from start to end marker (inclusive)
+                const afterEnd = existingContent.substring(endIndex + endMarker.length);
+                existingContent = existingContent.substring(0, startIndex) +
+                    repoBlock +
+                    afterEnd;
             }
-        });
-        return prerequisites;
-    }
-    /**
-     * Get description for an agent (placeholder - could be enhanced)
-     */
-    getAgentDescription(agentName) {
-        const descriptions = {
-            'prd-researcher': 'Research and analyze Product Requirements Documents to generate comprehensive technical tasks and implementation strategies',
-            'system-architect': 'Design comprehensive system architectures that integrate frontend, backend, and infrastructure components',
-            'backend-architect': 'Design and architect reliable backend systems with focus on data integrity, security, and fault tolerance',
-            'feature-developer': 'Feature implementation specialist who transforms requirements into working functionality',
-            'component-developer': 'UI component development specialist focused on building reusable, accessible, and well-tested components',
-            'typescript-developer': 'TypeScript development specialist focused on type-safe, maintainable code following modern JavaScript/TypeScript best practices',
-            'tdd-validator': 'Test-Driven Development methodology validator ensuring rigorous TDD compliance and quality gates',
-            'functional-tester': 'Functional testing specialist who validates software functionality against requirements',
-            'refactoring-expert': 'Code refactoring specialist focused on improving code quality, maintainability, and performance without changing functionality',
-            'metrics-collector': 'Metrics and observability specialist who gathers, analyzes, and reports on system and business metrics',
-            'root-cause-analyst': 'Incident investigation specialist who diagnoses system issues and identifies root causes'
-        };
-        return descriptions[agentName] || `${agentName.replace(/-/g, ' ')} specialist`;
-    }
-    /**
-     * Format workflow sections for CLAUDE.md
-     * Each section is independent - enabled features appear regardless of other settings
-     */
-    async formatPRDWorkflowSection() {
-        let section = '';
-        const repoRoot = getRepoRoot();
-        const prdPath = path.join(repoRoot, 'docs', 'prd');
-        const adrPath = path.join(repoRoot, 'docs', 'adr');
-        const hasPRD = existsSync(prdPath);
-        const hasADR = existsSync(adrPath);
-        // Check all feature flags
-        const enableSDD = await this.configService.isSDDEnabled();
-        const enableADR = await this.configService.isADREnabled();
-        const enableQuality = await this.configService.isQualityEnabled();
-        const enableTDD = await this.configService.isTDDEnabled();
-        // PRD Workflow section (requires SDD enabled AND docs/prd exists)
-        if (enableSDD && hasPRD) {
-            section += '## PRD Workflow\n\n';
-            section += 'IMPORTANT: Skills at `.claude/skills/` are **model-invoked** - describe your intent and Claude will use them automatically.\n';
-            section += 'Examples: "I want to plan a new feature", "track this bug fix", "add a feature to the PRD"\n\n';
-            section += '**Product Requirements Documents (PRDs):**\n';
-            section += `- Location: \`docs/prd/{prd-id}/prd.md\`\n`;
-            section += `- Features: \`docs/prd/{prd-id}/features/{feature-id}.md\`\n`;
-            section += `- Skills: plan (create PRDs), feature (add features), fix (track fixes)\n\n`;
-            // Commit Message Format (part of SDD)
-            section += '## Commit Message Format\n\n';
-            section += 'This project uses **Conventional Commits** for PRD-tracked tasks.\n\n';
-            section += '**Format:**\n';
-            section += '```\n';
-            section += '{type}({scope}): commit title\n\n';
-            section += 'PRD: {prd-id}\n';
-            section += 'Feature: {feature-id}\n';
-            section += 'Task: {exact-task-description}\n\n';
-            section += 'Description of changes...\n\n';
-            section += '🤖 Generated with [Claude Code](https://claude.com/claude-code)\n';
-            section += '```\n\n';
-            section += '**Quick Reference:**\n';
-            section += '- PRD ID = directory name in `docs/prd/`\n';
-            section += '- Feature ID = feature\'s `id` field\n';
-            section += '- Task = EXACT description from progress.json\n';
-            section += '- Type = `test`, `feat`, or `refactor` (for TDD tracking)\n\n';
-        }
-        // ADR section (independent - requires ADR enabled)
-        if (enableADR && hasADR) {
-            section += '## Architecture Decision Records\n\n';
-            section += `- Location: \`docs/adr/NNNN-decision-title.md\`\n`;
-            section += `- Use \`/adr\` skill to create ADRs\n\n`;
-            if (enableSDD && hasPRD) {
-                section += '**ADR Suggestions:** After PRD commits, check for ADR suggestions with `plan operation=check-adrs`\n\n';
+            else {
+                // No end marker found, replace to next section or end of file
+                const nextSectionIndex = existingContent.indexOf('\n## ', startIndex + 1);
+                if (nextSectionIndex > -1) {
+                    existingContent = existingContent.substring(0, startIndex) +
+                        repoBlock +
+                        existingContent.substring(nextSectionIndex);
+                }
+                else {
+                    existingContent = existingContent.substring(0, startIndex) + repoBlock;
+                }
             }
         }
-        // Quality section (independent - requires Quality enabled)
-        if (enableQuality) {
-            section += '## Code Quality Analysis\n\n';
-            section += `- Use \`/quality\` skill to run comprehensive quality analysis\n`;
-            section += `- Categories: Security, Reliability, Performance, Maintainability, Testing, Architecture, Documentation, Operations\n`;
-            section += `- Grades: A (90-100), B (80-89), C (70-79), D (60-69), F (<60)\n\n`;
-        }
-        // TDD Workflow section (independent - requires TDD enabled)
-        if (enableTDD) {
-            section += '## TDD Workflow\n\n';
-            section += '**MANDATORY:** This repository follows strict Test-Driven Development (TDD).\n\n';
-            section += '**Red → Green → Refactor Cycle:**\n\n';
-            section += '| Phase | Commit Type | What to Commit | Tests Must |\n';
-            section += '|-------|-------------|----------------|------------|\n';
-            section += '| RED | `test:` | Test files only | FAIL |\n';
-            section += '| GREEN | `feat:` or `fix:` | Implementation only | PASS |\n';
-            section += '| REFACTOR | `refactor:` | Any (optional) | PASS |\n\n';
-            section += '**Critical Rules:**\n';
-            section += '- NEVER commit test + implementation files together\n';
-            section += '- One task = one complete TDD cycle\n';
-            section += '- Git hooks enforce: `test:` skips test run, `feat:`/`fix:` runs full checks\n\n';
+        else {
+            // Append tiny-brain section
+            existingContent = existingContent.trimEnd() + '\n\n' + repoBlock;
         }
-        return section;
-    }
-    /**
-     * Format ADR section (currently empty as ADR info is part of PRD workflow)
-     */
-    formatADRSection() {
-        // ADR information is now included in PRD workflow section
-        return '';
+        // Ensure directory exists and write file
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, existingContent, 'utf-8');
+        this.context.logger.info(`Updated workflow sections in ${contextPath}`);
+    }
+    /**
+     * Format the Commit Message Format section
+     */
+    formatCommitMessageSection() {
+        return `## Commit Message Format
+
+### CRITICAL: Commit Header Requirements
+
+**BEFORE EVERY COMMIT**, check if you're working on tracked work:
+
+1. **Active PRDs?** Check \`.tiny-brain/progress/\` for \`in_progress\` status
+2. **Open Fixes?** Check \`.tiny-brain/fixes/progress.json\` for \`investigating\` or \`in_progress\` status
+
+**If YES, you MUST include tracking headers or the commit will be REJECTED.**
+
+### For PRD-tracked work:
+\`\`\`
+feat(scope): description
+
+PRD: {prd-id}
+Feature: {feature-id}
+Task: {exact task description from progress.json}
+
+Description of changes...
+\`\`\`
+
+### For Fix-tracked work:
+\`\`\`
+feat(scope): description
+
+Fix: {fix-id}
+Task: {exact task description from fix document}
+
+Description of changes...
+\`\`\`
+
+### Commit Types
+| Type | When | Headers Required? |
+|------|------|-------------------|
+| \`test:\` | Writing failing tests (TDD RED) | Yes |
+| \`feat:\` | Implementation (TDD GREEN) | Yes |
+| \`fix:\` | Bug fixes | Yes |
+| \`refactor:\` | Code improvement | Yes |
+| \`chore:\` | Maintenance (untracked) | No |
+
+**WARNING:** The commit-msg hook will reject commits missing required headers.
+
+### CRITICAL: Update Markdown After Successful Commits
+
+**IMMEDIATELY after your commit is accepted**, you MUST update the source markdown file. This is NOT optional.
+
+**For PRD tasks:**
+1. Open the feature file: \`docs/prd/{prd-id}/features/{feature-id}.md\`
+2. Find the task checkbox and update it:
+   \`\`\`
+   Before: - [ ] Task description
+   After:  - [x] Task description ({short-sha})
+   \`\`\`
+3. Add implementation notes below the task if helpful
+4. If ALL tasks in the feature are complete, mark the feature complete in the PRD file
+   - The feature file's frontmatter contains \`prd: {prd-id}\` - use this to find \`docs/prd/{prd-id}/prd.md\`
+
+**For Fix tasks:**
+1. Open the fix file: \`.tiny-brain/fixes/{fix-id}.md\`
+2. **Update EACH task** with its resolution:
+   - Set the task's \`commitSha\` field in \`.tiny-brain/fixes/progress.json\`
+   - Set the task's \`status\` to \`"completed"\`
+   - If one commit addresses multiple tasks, use the same SHA for all
+   - Mark tasks as \`(superseded)\` if no longer needed
+   - **Show the user a task status table** after updating, e.g.:
+     | Task | Description | Status | commitSha |
+     |------|-------------|--------|-----------|
+     | 1 | Write failing test | completed | abc1234 |
+     | 2 | Implement fix | completed | abc1234 |
+     | 3 | Skipped task | superseded | - |
+3. **ONLY set \`status: resolved\`** when ALL tasks are accounted for:
+   - 100% of tasks must have either a commit SHA or be marked superseded
+   - A fix with 5 tasks could be: 3 completed + 2 superseded = resolved
+   - A fix with incomplete tasks stays \`in_progress\`
+4. When fully resolved, update YAML frontmatter:
+   - Set \`status: resolved\`
+   - Set \`resolved: YYYY-MM-DDTHH:mm:ss.sssZ\` (ISO timestamp)
+   - Add \`resolution\` object with \`rootCause\`, \`fix\` (array), and \`filesModified\` (array):
+     \`\`\`yaml
+     resolution:
+       rootCause: Brief description of what caused the issue
+       fix:
+         - First fix action taken
+         - Second fix action taken
+       filesModified:
+         - path/to/file1.ts
+         - path/to/file2.ts
+     \`\`\`
+
+**The sync-progress hook will automatically sync your changes to progress.json, preserving task commit history.**
+
+**Failure to update markdown files is a workflow violation.**
+
+`;
+    }
+    /**
+     * Format the TDD Workflow section
+     */
+    formatTDDWorkflowSection() {
+        return `## TDD Workflow
+
+IMPORTANT: This repository follows strict Test-Driven Development (TDD) with a 3-phase commit workflow.
+
+**Red → Green → Refactor Cycle:**
+
+1. **Red Phase** (\`test:\` or \`test(scope):\` commits):
+   - Write failing tests first
+   - Tests SHOULD fail (that's the point!)
+   - Use: \`git commit -m "test: ..."\` or \`git commit -m "test(api): ..."\`
+   - Git hook automatically runs typecheck + lint but SKIPS tests
+   - Tracked in: \`testCommitSha\` field
+
+2. **Green Phase** (\`feat:\` or \`feat(scope):\` commits):
+   - Implement minimum code to make tests pass
+   - Use: \`git commit -m "feat: ..."\` or \`git commit -m "feat(auth): ..."\`
+   - Git hook automatically runs full checks (typecheck + lint + test)
+   - Tracked in: \`commitSha\` field
+   - **Marks task as COMPLETED**
+
+3. **Refactor Phase** (\`refactor:\` or \`refactor(scope):\` commits - optional):
+   - Improve code quality without changing behavior
+   - Use: \`git commit -m "refactor: ..."\` or \`git commit -m "refactor(plan): ..."\`
+   - Git hook automatically runs full checks (typecheck + lint + test)
+   - Tracked in: \`refactorCommitSha\` field
+
+**Why This Matters:**
+- Git hooks automatically detect commit type and run appropriate checks
+- Separate commit tracking enables Feature 9 (TDD phase tracking in dashboard)
+- Provides audit trail of development process
+- Only \`feat:\` or \`feat(scope):\` commits mark tasks as completed
+
+`;
+    }
+    /**
+     * Format the Progress Tracking Auto-Commit Configuration section
+     */
+    formatProgressTrackingSection() {
+        return `## Progress Tracking Auto-Commit Configuration
+
+By default, tiny-brain uses **manual mode** for progress.json commits. This means after tracking a task commit, you must manually stage and commit the progress.json updates. This keeps your working tree clean and gives you full control over what gets committed.
+
+### Default Behavior (Manual Mode)
+
+When you complete a task with a \`feat:\` or \`test:\` commit:
+1. The post-commit hook updates progress.json automatically
+2. You'll see a friendly message with instructions:
+   \`\`\`
+   📝 Progress tracking updated!
+
+      To commit progress.json changes, run:
+      git add .tiny-brain/progress/*.json
+      git commit -m "chore: update progress tracking"
+
+      💡 Tip: Enable auto-commit to skip this step:
+      npx tiny-brain config preferences set autoCommitProgress true
+   \`\`\`
+3. Commit the progress.json changes when you're ready
+
+### Enabling Auto-Commit
+
+Auto-commit automatically creates a second commit containing progress.json updates after each tracked task commit.
+
+**Enable globally (all repos):**
+\`\`\`bash
+npx tiny-brain config preferences set autoCommitProgress true
+\`\`\`
+
+**Enable for current repo only:**
+\`\`\`bash
+npx tiny-brain config preferences set autoCommitProgress true --repo
+\`\`\`
+
+**Disable auto-commit:**
+\`\`\`bash
+npx tiny-brain config preferences set autoCommitProgress false
+\`\`\`
+
+**Check current setting:**
+\`\`\`bash
+npx tiny-brain config preferences get autoCommitProgress
+\`\`\`
+
+### When to Use Each Mode
+
+**Use Manual Mode (default) when:**
+- Working in a team - keeps progress updates separate from feature commits
+- You want full control over what gets committed
+- You prefer to batch progress updates
+- You're concerned about commit history noise
+
+**Use Auto-Commit Mode when:**
+- Working solo or in small teams where commit noise is acceptable
+- You want progress always synced with remote
+- You frequently switch machines and need up-to-date progress
+- You forget to commit progress.json regularly
+
+### Configuration Hierarchy
+
+Settings follow this precedence (highest to lowest):
+1. Per-repository config (\`.git/tiny-brain/preferences.json\`)
+2. Global config (\`~/.tiny-brain/config/preferences.json\`)
+3. Default values (manual mode)
+
+This allows you to set a global preference but override it per repository as needed.
+
+`;
+    }
+    /**
+     * Format the Operational Tracking Directory section
+     */
+    formatOperationalTrackingSection() {
+        return `## Operational Tracking Directory (.tiny-brain/)
+
+The \`.tiny-brain/\` directory stores operational tracking data separate from documentation:
+
+\`\`\`
+.tiny-brain/
+├── progress/           # PRD progress tracking
+│   └── {prd-id}.json   # One file per PRD
+└── fixes/              # Fix progress tracking
+    └── progress.json   # Aggregated fix tracking
+\`\`\`
+
+**Key distinction:**
+- **Documentation** (in \`docs/\`) - PRD markdown, feature specs, fix analysis - permanent, reviewed
+- **Operational tracking** (in \`.tiny-brain/\`) - progress.json files - transient, auto-generated
+
+### Gitignore Options
+
+Teams can choose whether to track progress files in git:
+
+**Option 1: Track progress (default)** - Keep \`.tiny-brain/\` in git for visibility across team members.
+
+**Option 2: Ignore progress** - Add to \`.gitignore\` to reduce PR noise:
+\`\`\`gitignore
+# Ignore operational tracking (optional)
+.tiny-brain/progress/
+.tiny-brain/fixes/progress.json
+\`\`\`
+
+**Option 3: Ignore all** - Ignore entire directory:
+\`\`\`gitignore
+.tiny-brain/
+\`\`\`
+
+`;
     }
 }