@rigstate/rules-engine 0.6.0

package/dist/types.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Supported IDE providers for rules file generation.
+ * - cursor: .cursorrules + .cursor/rules/*.mdc
+ * - antigravity: .cursorrules + .cursor/rules/*.mdc (Cursor-compatible)
+ * - windsurf: .windsurfrules
+ * - vscode: .cursorrules + .cursor/rules/*.mdc
+ * - copilot: .github/copilot-instructions.md
+ * - generic: CONVENTIONS.md (universal markdown format)
+ */
+export type IDEProvider = 'cursor' | 'antigravity' | 'windsurf' | 'vscode' | 'copilot' | 'generic';
+/**
+ * Mapping of IDE providers to their respective rules file names.
+ * Centralized here to ensure consistency across all consumers.
+ */
+export declare const IDE_FILE_NAMES: Record<IDEProvider, string>;
+export interface ProjectSettings {
+    lmax: number;
+    lmax_ui: number;
+    security_level: string;
+}
+export interface RuleFile {
+    path: string;
+    content: string;
+    metadata?: {
+        description?: string;
+        globs?: string[];
+        alwaysApply?: boolean;
+    };
+}
+export interface MultiFileRuleResult {
+    files: RuleFile[];
+    suggestedIde: IDEProvider;
+    version: string;
+}
+export interface RuleGenerationContext {
+    project: {
+        id: string;
+        name: string;
+        description?: string;
+        functional_spec?: {
+            projectDescription?: string;
+            coreProblem?: string;
+            targetAudience?: string;
+            featureList?: Array<{
+                name: string;
+                description: string;
+                priority: string;
+            }>;
+            keyInsights?: string[];
+        };
+        ambition_level?: string;
+        tenancy?: 'SINGLE' | 'MULTI_ORG';
+        monetization?: 'FREE' | 'SAAS';
+        compliance?: 'NONE' | 'GDPR' | 'HIPAA';
+        vibe?: 'CORPORATE' | 'CREATIVE' | 'BRUTALIST';
+        settings?: ProjectSettings;
+    };
+    stack: string[];
+    roadmap: Array<{
+        step_number: number;
+        title: string;
+        status: string;
+        sprint_focus?: string;
+        prompt_content?: string;
+        is_legacy?: boolean;
+    }>;
+    ide: IDEProvider;
+    legacyStats?: {
+        total: number;
+        legacyCount: number;
+        activeCount: number;
+    };
+    activeAgents?: Array<{
+        id: string;
+        key: string;
+        name: string;
+        job_title?: string;
+        content: string;
+        authority_level: number;
+        primary_mission?: string;
+        trigger_keywords?: string;
+    }>;
+    databaseMetadata?: TableMetadata[];
+}
+export interface TableMetadata {
+    table_name: string;
+    rls_enabled: boolean;
+    policy_count: number;
+    column_count: number;
+    has_id: boolean;
+    has_created_at: boolean;
+    has_updated_at: boolean;
+    has_user_id: boolean;
+    indexed_columns: string[];
+    foreign_keys: {
+        column: string;
+        target_table: string;
+    }[];
+}
+export interface AgentSkill {
+    name: string;
+    description: string;
+    specialist: string;
+    version: string;
+    governance: 'OPEN' | 'SOFT_LOCK' | 'HARD_LOCK';
+    content: string;
+    activation?: {
+        imports?: string[];
+        content?: string[];
+        files?: string[];
+        violation_id?: string;
+        metric_threshold?: number;
+    };
+}

package/dist/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDE_FILE_NAMES = void 0;
+/**
+ * Mapping of IDE providers to their respective rules file names.
+ * Centralized here to ensure consistency across all consumers.
+ */
+exports.IDE_FILE_NAMES = {
+    cursor: '.cursorrules',
+    antigravity: '.cursorrules',
+    windsurf: '.windsurfrules',
+    vscode: '.cursorrules',
+    copilot: '.github/copilot-instructions.md',
+    generic: 'CONVENTIONS.md'
+};

package/dist/utils/mdc.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Utility to wrap markdown content with MDC (Modern Cursor) frontmatter.
+ */
+export declare function wrapMdc(content: string, metadata: {
+    description?: string;
+    globs?: string[];
+    alwaysApply?: boolean;
+}): string;

package/dist/utils/mdc.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapMdc = wrapMdc;
+/**
+ * Utility to wrap markdown content with MDC (Modern Cursor) frontmatter.
+ */
+function wrapMdc(content, metadata) {
+    const yaml = ['---'];
+    if (metadata.description) {
+        yaml.push(`description: "${metadata.description.replace(/"/g, '\\"')}"`);
+    }
+    if (metadata.globs && metadata.globs.length > 0) {
+        yaml.push('globs:');
+        for (const glob of metadata.globs) {
+            yaml.push(`  - "${glob}"`);
+        }
+    }
+    if (metadata.alwaysApply !== undefined) {
+        yaml.push(`alwaysApply: ${metadata.alwaysApply}`);
+    }
+    yaml.push('---');
+    return `${yaml.join('\n')}\n${content}`;
+}

package/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "@rigstate/rules-engine",
+    "version": "0.6.0",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsc -w"
+    },
+    "dependencies": {
+        "zod": "^3.22.4"
+    },
+    "devDependencies": {
+        "typescript": "^5.3.3"
+    }
+}

package/src/index.ts

@@ -0,0 +1,416 @@
+import {
+    RuleGenerationContext,
+    IDEProvider,
+    IDE_FILE_NAMES,
+    RuleFile,
+    MultiFileRuleResult,
+    TableMetadata
+} from './types';
+import { generateIdentitySection } from './sections/identity';
+import { generateStackDnaSection } from './sections/stack-dna';
+import { generateCurrentStepSection } from './sections/current-step';
+import { generateWorkflowSection } from './sections/workflow';
+import { generateToolingSection } from './sections/tooling';
+import { generateAvailableSkillsSection, generateSkillFileContent, getRigstateStandardSkills } from './sections/skills';
+import { wrapMdc } from './utils/mdc';
+
+// Re-export types and constants for consumers
+export type {
+    RuleGenerationContext,
+    IDEProvider,
+    ProjectSettings,
+    RuleFile,
+    MultiFileRuleResult,
+    AgentSkill
+} from './types';
+export { IDE_FILE_NAMES } from './types';
+export { generateAvailableSkillsSection, generateSkillFileContent, getRigstateStandardSkills } from './sections/skills';
+
+const RIGSTATE_START = "RIGSTATE_START";
+const RIGSTATE_END = "RIGSTATE_END";
+const ENGINE_VERSION = "3.0.0";
+
+/**
+ * Generate modular IDE rule content optimized for AI coding assistants.
+ * v2.4.0: Added Agent IDs, Tool Binding, and Strict Ownership.
+ * Refactored into sub-modules for Guardian Compliance (400-line limit).
+ */
+/**
+ * Generate modular IDE rule content optimized for AI coding assistants.
+ * v2.4.0: Added Agent IDs, Tool Binding, and Strict Ownership.
+ * Refactored into sub-modules for Guardian Compliance (400-line limit).
+ */
+export function generateRuleContent(
+    project: RuleGenerationContext["project"],
+    stack: string[],
+    roadmap: RuleGenerationContext["roadmap"],
+    ide: IDEProvider = 'cursor',
+    legacyStats?: RuleGenerationContext["legacyStats"],
+    activeAgents?: RuleGenerationContext["activeAgents"],
+    lean: boolean = false
+): string {
+    const sections: string[] = [];
+    sections.push('# 🚀 Rigstate Supervisor v2.4 (Context-Aware)');
+
+    // SECTION 0: HIERARCHY (Top Priority)
+    sections.push(`IMPORTANT: Internal agent coordination must always use the provided Agent IDs. Display names are for user-facing chat only. When invoking tools or referencing hierarchy, use the ID as the primary key.
+
+## ⚖️ AGENT HIERARCHY & AUTHORITY
+You must defer to the instructions of agents with higher Authority Levels (10 being highest).
+Security and Architecture (Levels 8-10) always override creative or implementation suggestions (Levels 1-5).`);
+
+    // SECTION 1: IDENTITY (Multi-Agent Ecosystem)
+    // Always keep Identity in root for instant persona recognition
+    const identitySection = generateIdentitySection(project, ide, activeAgents);
+    sections.push(identitySection);
+
+    // SECTION 1.5: SKILLS (Discovery Layer)
+    const skills = getRigstateStandardSkills();
+    const skillsSection = generateAvailableSkillsSection(skills);
+    if (skillsSection) {
+        sections.push(skillsSection);
+    }
+
+    // SECTION 2: STACK DNA + GUARDIAN RULES
+    // In Lean mode (Cursor context), we trust rigstate-guardian.mdc to handle this.
+    if (!lean) {
+        const stackDnaSection = generateStackDnaSection(project, stack, legacyStats);
+        sections.push(stackDnaSection);
+    }
+
+    // SECTION 3: CURRENT STEP (Active Focus Injection)
+    // In Lean mode, rigstate-roadmap.mdc handles this dynamically.
+    if (!lean) {
+        const currentStepSection = generateCurrentStepSection(roadmap);
+        if (currentStepSection) {
+            sections.push(currentStepSection);
+        }
+    }
+
+    // SECTION 4: WORKFLOW (How to Parse Roadmap Steps)
+    // Frank's "Supervisor Mode" logic.
+    // We KEEP this in Lean mode because it defines the core behavior of the agent globally.
+    // However, if it's identical to rigstate-workflow.mdc, we might consider linking.
+    // But Frank's protocol is the "Operating System" of the session.
+    const workflowSection = generateWorkflowSection(ide);
+    sections.push(workflowSection);
+
+    // SECTION 5: TOOLING (CLI + MCP Integration)
+    // In Lean mode, rigstate-workflow.mdc has the specific CLI commands and tools.
+    if (!lean) {
+        const toolingSection = generateToolingSection(activeAgents);
+        sections.push(toolingSection);
+    } else {
+        // Add a pointer in Lean mode
+        sections.push(`## 🔧 TOOLING & SPECIFIC RULES
+> **OPTIMIZED MODE:** Detailed technical rules, CLI commands, and tech stack constraints are loaded dynamically from \`.cursor/rules/*.mdc\` based on the files you interact with.
+> - **Stack & Guardian:** See \`rigstate-guardian.mdc\`
+> - **Roadmap & Tasks:** See \`rigstate-roadmap.mdc\`
+> - **Tools & Workflow:** See \`rigstate-workflow.mdc\``);
+    }
+
+    // Generate IDE-specific header
+    const headerMap: Record<IDEProvider, string> = {
+        cursor: `# Cursor Project Rules: ${project.name}`,
+        antigravity: `# Antigravity Project Rules: ${project.name}`,
+        windsurf: `# Windsurf Project Rules: ${project.name}`,
+        vscode: `# VS Code Project Rules: ${project.name}`,
+        copilot: `# GitHub Copilot Instructions: ${project.name}`,
+        generic: `# Project Conventions: ${project.name}`
+    };
+    const header = headerMap[ide] || `# Project Rules: ${project.name}`;
+
+    return `${RIGSTATE_START}
+${header}
+> Generated by Rigstate v2.5.0 | Project ID: ${project.id} | Last synced: ${new Date().toISOString()}
+> ${lean ? '⚡ LEAN MODE ACTIVE: Redundant context offloaded to .cursor/rules/*.mdc' : '📦 FULL MODE ACTIVE'}
+
+⚠️ **SYSTEM NOTE:** Changes made to this Guardian template propagate to ALL Rigstate projects on next sync.
+🛡️ **Guardian v2.5 Upgrade Applied:** IMPACT_GUARD + BUILD_INTEGRITY now active globally.
+
+${sections.join('\n\n---\n\n')}
+${RIGSTATE_END}`;
+}
+
+/**
+ * Generate multiple modular rule files optimized for modern Cursor (.mdc) 
+ * and universal AGENTS.md format.
+ */
+export function generateRuleFiles(
+    project: RuleGenerationContext["project"],
+    stack: string[],
+    roadmap: RuleGenerationContext["roadmap"],
+    ide: IDEProvider = 'cursor',
+    legacyStats?: RuleGenerationContext["legacyStats"],
+    activeAgents?: RuleGenerationContext["activeAgents"],
+    databaseMetadata?: TableMetadata[]
+): MultiFileRuleResult {
+    const files: RuleFile[] = [];
+
+    // 1. GENERATE AGENTS.MD (Universal Root File - Context Reference)
+    const agentTable = activeAgents?.map((a: any) =>
+        `| **${a.name}** | \`${a.key}\` | ${a.job_title} | ${a.primary_mission || 'Specialist'} |`
+    ).join('\n') || '| - | - | - | No agents configured |';
+
+    const agentsMdContent = `# 🤖 AI Agent Context: ${project.name}
+> **Rigstate v${ENGINE_VERSION}** | Project ID: \`${project.id}\`
+
+This file describes the **specialist personas** available in this project.  
+These are **context providers**, not active controllers. The IDE agent (you) remains in full control of code execution.
+
+## 📋 Available Specialists
+| Name | Key | Role | Specialty |
+|:--- |:--- |:--- |:--- |
+${agentTable}
+
+## 🔍 How to Use This Context
+1.  **Read their expertise**: Each specialist has a defined area of knowledge (architecture, documentation, history).
+2.  **Adopt their perspective**: When working in their domain, consider their guidelines.
+3.  **Call MCP tools if needed**: Some specialists have associated tools (e.g., \`generate_professional_pdf\` for The Scribe).
+
+## ⚠️ Important
+- These personas do **NOT** execute code or override your decisions.
+- They provide **context and guidelines** that you apply at your discretion.
+- Authority levels indicate priority of guidelines when they conflict (higher = stronger recommendation).
+
+---
+*Generated by Rigstate. Run \`rigstate sync\` to refresh.*`;
+
+
+    files.push({
+        path: 'AGENTS.md',
+        content: agentsMdContent,
+        metadata: { description: "Project hierarchy and agent identities" }
+    });
+
+    // 2. GENERATE SYSTEM-SPECIFIC MONO-FILE (Fallback/Baseline)
+    // If IDE is Cursor, we use LEAN mode for the root .cursorrules file
+    // because we are generating specific .mdc files below that cover the details.
+    const isLean = ide === 'cursor';
+    const masterFileName = getFileNameForIDE(ide);
+    const monoContent = generateRuleContent(project, stack, roadmap, ide, legacyStats, activeAgents, isLean);
+
+    files.push({
+        path: masterFileName,
+        content: monoContent,
+        metadata: { description: `Master rules file for ${ide}` }
+    });
+
+
+    // 3. GENERATE MODULAR (.mdc) RULES (Cursor, Antigravity, VS Code)
+    if (ide === 'cursor' || ide === 'antigravity' || ide === 'vscode') {
+
+
+        // Identity & Context
+        files.push({
+            path: '.cursor/rules/rigstate-identity.mdc',
+            content: wrapMdc(generateIdentitySection(project, ide, activeAgents), {
+                description: "Project context and specialist personas",
+                alwaysApply: true
+            })
+        });
+
+
+
+        // Guardian & Stack DNA
+        files.push({
+            path: '.cursor/rules/rigstate-guardian.mdc',
+            content: wrapMdc(generateStackDnaSection(project, stack, legacyStats), {
+                description: "Governance rules, tech stack constraints, and file size limits",
+                globs: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.sql"],
+                alwaysApply: true
+            })
+        });
+
+        // Current Focus (Roadmap)
+        const currentStep = generateCurrentStepSection(roadmap);
+        if (currentStep) {
+            files.push({
+                path: '.cursor/rules/rigstate-roadmap.mdc',
+                content: wrapMdc(currentStep, {
+                    description: "Active sprint focus and current roadmap step details",
+                    alwaysApply: true
+                })
+            });
+        }
+
+        // Workflow & Tooling
+        files.push({
+            path: '.cursor/rules/rigstate-workflow.mdc',
+            content: wrapMdc(generateWorkflowSection(ide) + '\n\n' + generateToolingSection(activeAgents), {
+                description: "Coding workflows, CLI usage, and tool binding rules",
+                alwaysApply: true
+            })
+        });
+
+        // Database Specific (scoped)
+        let dbContent = "## 🗄️ Database Standards\n- Always verify RLS policies for new tables.\n- Use `supabase/migrations` for DDL changes.\n- Reference `types/supabase.ts` for strictly typed queries.";
+
+        if (databaseMetadata && databaseMetadata.length > 0) {
+            const securedCount = databaseMetadata.filter(t => t.rls_enabled).length;
+            const unsecuredCount = databaseMetadata.length - securedCount;
+            const unsecuredTables = databaseMetadata.filter(t => !t.rls_enabled).map(t => t.table_name);
+
+            dbContent = `## 🗄️ Database Context: ${databaseMetadata.length} Tables
+> **Security Check:** ${securedCount} Secured | ${unsecuredCount} Unsecured
+
+### ⚠️ Security Attention Required
+${unsecuredTables.length > 0
+                    ? unsecuredTables.map(t => `- 🔴 **${t}**: RLS Disabled`).join('\n')
+                    : "- ✅ All tables have Row Level Security enabled."}
+
+### 📋 Schema Reference
+| Table | RLS | Policies | Cols | Key Features |
+| :--- | :---: | :---: | :---: | :--- |
+${databaseMetadata.map(t => {
+                        const features = [];
+                        if (t.has_user_id) features.push('User-Scoped');
+                        if (t.has_created_at) features.push('Timestamps');
+                        return `| \`${t.table_name}\` | ${t.rls_enabled ? '✅' : '❌'} | ${t.policy_count} | ${t.column_count} | ${features.join(', ') || '-'} |`;
+                    }).join('\n')}
+
+### 🛡️ Development Rules
+1.  **RLS is MANDATORY:** All tables containing user data must have RLS enabled.
+2.  **Use RPCs for Complex Logic:** Do not put complex business logic in client-side queries.
+3.  **Migrations:** Always use \`supabase/migrations\` for schema changes.`;
+        }
+
+        files.push({
+            path: '.cursor/rules/rigstate-database.mdc',
+            content: wrapMdc(dbContent, {
+                description: "Live database schema, RLS status, and table metadata",
+                globs: ["supabase/**/*", "**/*.sql", "**/lib/supabase/**"],
+                alwaysApply: databaseMetadata && databaseMetadata.length > 0 ? true : false
+            })
+        });
+
+        // 4. GENERATE AGENT SKILLS (.agent/skills/<name>/SKILL.md)
+        const rigstateSkills = getRigstateStandardSkills();
+        for (const skill of rigstateSkills) {
+            files.push({
+                path: `.agent/skills/${skill.name}/SKILL.md`,
+                content: generateSkillFileContent(skill),
+                metadata: { description: skill.description }
+            });
+        }
+    }
+
+
+
+    return {
+        files,
+        suggestedIde: ide,
+        version: ENGINE_VERSION
+    };
+}
+
+export async function fetchLegacyStats(supabase: any, projectId: string): Promise<RuleGenerationContext["legacyStats"]> {
+    const { data: chunks } = await supabase
+        .from('roadmap_chunks')
+        .select('is_legacy')
+        .eq('project_id', projectId);
+
+    if (!chunks) return { total: 0, legacyCount: 0, activeCount: 0 };
+
+    const legacyCount = (chunks || []).filter((c: any) => c.is_legacy === true).length;
+    const activeCount = (chunks || []).filter((c: any) => c.is_legacy !== true).length;
+
+    return {
+        total: (chunks || []).length,
+        legacyCount,
+        activeCount
+    };
+}
+
+/**
+ * Fetch active agents sorted by authority level
+ * Note: Pass in a SupabaseClient instance (browser or server)
+ */
+export async function fetchActiveAgents(supabase: any): Promise<RuleGenerationContext["activeAgents"]> {
+    const { data: prompts } = await supabase
+        .from('system_prompts')
+        .select('id, key, content, name, display_name, job_title, authority_level, primary_mission, trigger_keywords')
+        .eq('include_in_rules', true)
+        .eq('is_active', true)
+        .order('authority_level', { ascending: false });
+
+    if (!prompts) return [];
+
+    return (prompts || []).map((p: any) => ({
+        id: p.id,
+        key: p.key,
+        name: p.display_name || p.name || p.key,
+        job_title: p.job_title || 'Specialist Agent',
+        content: p.content,
+        authority_level: (() => {
+            if (p.authority_level === null || p.authority_level === undefined) {
+                throw new Error(`Agent ${p.key} is missing authority_level. Update via CMS.`);
+            }
+            return p.authority_level;
+        })(),
+        primary_mission: p.primary_mission || undefined,
+        trigger_keywords: p.trigger_keywords || undefined
+    }));
+}
+
+export function mergeRuleContent(existingContent: string, newRules: string): string {
+    const startIndex = existingContent.indexOf(RIGSTATE_START);
+    const endIndex = existingContent.indexOf(RIGSTATE_END);
+
+    if (startIndex !== -1 && endIndex !== -1) {
+        const before = existingContent.substring(0, startIndex);
+        const after = existingContent.substring(endIndex + RIGSTATE_END.length);
+        return before + newRules + after;
+    } else {
+        return existingContent + "\n\n" + newRules;
+    }
+}
+
+/**
+ * Fetch project tech stack from database.
+ * Falls back to common defaults if no tags are defined.
+ * Note: Pass in a SupabaseClient instance (browser or server)
+ */
+export async function fetchProjectTechStack(
+    supabase: any,
+    projectId: string,
+    fallbackStack: string[] = ['Next.js', 'TypeScript', 'Supabase', 'Tailwind CSS']
+): Promise<string[]> {
+    try {
+        // Try to fetch from project_tech_tags table
+        const { data: tags, error } = await supabase
+            .from('project_tech_tags')
+            .select('name')
+            .eq('project_id', projectId);
+
+        if (error || !tags || tags.length === 0) {
+            // Fallback: Check project metadata for stack info
+            const { data: project } = await supabase
+                .from('projects')
+                .select('functional_spec')
+                .eq('id', projectId)
+                .single();
+
+            // Extract tech from functional_spec if available
+            if (project?.functional_spec?.techStack) {
+                return project.functional_spec.techStack;
+            }
+
+            return fallbackStack;
+        }
+
+        return tags.map((t: any) => t.name);
+    } catch (error) {
+        console.warn('fetchProjectTechStack: Failed to fetch, using fallback', error);
+        return fallbackStack;
+    }
+}
+
+/**
+ * Get the appropriate filename for a given IDE provider.
+ * Convenience wrapper around IDE_FILE_NAMES constant.
+ */
+export function getFileNameForIDE(ide: IDEProvider): string {
+    return IDE_FILE_NAMES[ide] || IDE_FILE_NAMES.cursor;
+}
+

package/src/sections/current-step.ts

@@ -0,0 +1,62 @@
+import { RuleGenerationContext } from '../types';
+
+export function generateCurrentStepSection(
+    roadmap: RuleGenerationContext["roadmap"]
+): string | null {
+    const activeRoadmap = roadmap.filter((r: any) => r.is_legacy !== true);
+
+    const activeSteps = activeRoadmap
+        .filter((r: any) => r.status === 'ACTIVE')
+        .sort((a: any, b: any) => a.step_number - b.step_number);
+
+    if (activeSteps.length === 0) {
+        const nextSteps = activeRoadmap
+            .filter((r: any) => r.status === 'LOCKED')
+            .sort((a: any, b: any) => a.step_number - b.step_number)
+            .slice(0, 1);
+
+        if (nextSteps.length === 0) return null;
+
+        return `## 🎯 CURRENT FOCUS
+
+> **No active task.** The next step in the backlog is:
+> 
+> **Step ${nextSteps[0].step_number}: ${nextSteps[0].title}**`;
+    }
+
+    const currentStep = activeSteps[0];
+    let objectiveText = currentStep.title;
+    let constraintsText = '';
+    let dodText = '';
+
+    if (currentStep.prompt_content) {
+        const content = currentStep.prompt_content;
+
+        const objectiveMatch = content.match(/###\s*🎯\s*Objective\s*\n([\s\S]*?)(?=###|$)/i);
+        if (objectiveMatch) objectiveText = objectiveMatch[1].trim();
+
+        const constraintsMatch = content.match(/###\s*⚠️\s*Constraints\s*\n([\s\S]*?)(?=###|$)/i);
+        if (constraintsMatch) constraintsText = constraintsMatch[1].trim();
+
+        const dodMatch = content.match(/###\s*✅\s*Definition of Done\s*\n([\s\S]*?)(?=###|$)/i);
+        if (dodMatch) dodText = dodMatch[1].trim();
+    }
+
+    let section = `## 🎯 CURRENT FOCUS
+
+**Active Step ${currentStep.step_number}: ${currentStep.title}**
+${currentStep.sprint_focus ? `*Sprint: ${currentStep.sprint_focus}*` : ''}
+
+### Objective
+${objectiveText}`;
+
+    if (constraintsText) {
+        section += `\n\n### Task-Specific Constraints\n${constraintsText}`;
+    }
+
+    if (dodText) {
+        section += `\n\n### Definition of Done\n${dodText}`;
+    }
+
+    return section;
+}