@rigstate/rules-engine 0.6.0

package/README.md

@@ -0,0 +1,38 @@
+# @rigstate/rules-engine
+
+The universal rules generation engine for Rigstate. This package centralizes the logic for creating context-aware rules for various AI-powered IDEs (Cursor, Windsurf, VS Code, etc.).
+
+## 🚀 Features
+
+- **Multi-Agent Identity**: Generates instructions for specialized AI agents (The Nordic Trinity).
+- **Guardian Rules**: Enforces architectural constraints like file size limits and type safety.
+- **Roadmap Injection**: Dynamically injects the current active roadmap step into rules.
+- **Stack DNA**: Applies tech-stack specific constraints.
+- **Multi-IDE Support**: Supports different rule formats and filenames (.cursorrules, .windsurfrules, etc.).
+- **Strict Tool Ownership**: Binds MCP tools to specific Agent IDs for persona consistency.
+
+## 📦 Usage
+
+```typescript
+import { generateRuleContent, fetchLegacyStats, fetchActiveAgents } from '@rigstate/rules-engine';
+
+const rules = generateRuleContent(
+    project,
+    techStackList, 
+    roadmapChunks,
+    'cursor', // preference
+    legacyStats,
+    activeAgents
+);
+```
+
+## 🏗️ Architecture
+
+This package is designed to be environment-agnostic. It can be used in:
+1. **Next.js Web App**: For rule previews and GitHub synchronization.
+2. **MCP Server**: For real-time rule delivery directly to the IDE.
+3. **CLI**: for local rule validation.
+
+## 🛡️ License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+import { RuleGenerationContext, IDEProvider, MultiFileRuleResult, TableMetadata } from './types';
+export type { RuleGenerationContext, IDEProvider, ProjectSettings, RuleFile, MultiFileRuleResult, AgentSkill } from './types';
+export { IDE_FILE_NAMES } from './types';
+export { generateAvailableSkillsSection, generateSkillFileContent, getRigstateStandardSkills } from './sections/skills';
+/**
+ * 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 declare function generateRuleContent(project: RuleGenerationContext["project"], stack: string[], roadmap: RuleGenerationContext["roadmap"], ide?: IDEProvider, legacyStats?: RuleGenerationContext["legacyStats"], activeAgents?: RuleGenerationContext["activeAgents"], lean?: boolean): string;
+/**
+ * Generate multiple modular rule files optimized for modern Cursor (.mdc)
+ * and universal AGENTS.md format.
+ */
+export declare function generateRuleFiles(project: RuleGenerationContext["project"], stack: string[], roadmap: RuleGenerationContext["roadmap"], ide?: IDEProvider, legacyStats?: RuleGenerationContext["legacyStats"], activeAgents?: RuleGenerationContext["activeAgents"], databaseMetadata?: TableMetadata[]): MultiFileRuleResult;
+export declare function fetchLegacyStats(supabase: any, projectId: string): Promise<RuleGenerationContext["legacyStats"]>;
+/**
+ * Fetch active agents sorted by authority level
+ * Note: Pass in a SupabaseClient instance (browser or server)
+ */
+export declare function fetchActiveAgents(supabase: any): Promise<RuleGenerationContext["activeAgents"]>;
+export declare function mergeRuleContent(existingContent: string, newRules: string): string;
+/**
+ * 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 declare function fetchProjectTechStack(supabase: any, projectId: string, fallbackStack?: string[]): Promise<string[]>;
+/**
+ * Get the appropriate filename for a given IDE provider.
+ * Convenience wrapper around IDE_FILE_NAMES constant.
+ */
+export declare function getFileNameForIDE(ide: IDEProvider): string;

package/dist/index.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRigstateStandardSkills = exports.generateSkillFileContent = exports.generateAvailableSkillsSection = exports.IDE_FILE_NAMES = void 0;
+exports.generateRuleContent = generateRuleContent;
+exports.generateRuleFiles = generateRuleFiles;
+exports.fetchLegacyStats = fetchLegacyStats;
+exports.fetchActiveAgents = fetchActiveAgents;
+exports.mergeRuleContent = mergeRuleContent;
+exports.fetchProjectTechStack = fetchProjectTechStack;
+exports.getFileNameForIDE = getFileNameForIDE;
+const types_1 = require("./types");
+const identity_1 = require("./sections/identity");
+const stack_dna_1 = require("./sections/stack-dna");
+const current_step_1 = require("./sections/current-step");
+const workflow_1 = require("./sections/workflow");
+const tooling_1 = require("./sections/tooling");
+const skills_1 = require("./sections/skills");
+const mdc_1 = require("./utils/mdc");
+var types_2 = require("./types");
+Object.defineProperty(exports, "IDE_FILE_NAMES", { enumerable: true, get: function () { return types_2.IDE_FILE_NAMES; } });
+var skills_2 = require("./sections/skills");
+Object.defineProperty(exports, "generateAvailableSkillsSection", { enumerable: true, get: function () { return skills_2.generateAvailableSkillsSection; } });
+Object.defineProperty(exports, "generateSkillFileContent", { enumerable: true, get: function () { return skills_2.generateSkillFileContent; } });
+Object.defineProperty(exports, "getRigstateStandardSkills", { enumerable: true, get: function () { return skills_2.getRigstateStandardSkills; } });
+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).
+ */
+function generateRuleContent(project, stack, roadmap, ide = 'cursor', legacyStats, activeAgents, lean = false) {
+    const sections = [];
+    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 = (0, identity_1.generateIdentitySection)(project, ide, activeAgents);
+    sections.push(identitySection);
+    // SECTION 1.5: SKILLS (Discovery Layer)
+    const skills = (0, skills_1.getRigstateStandardSkills)();
+    const skillsSection = (0, skills_1.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 = (0, stack_dna_1.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 = (0, current_step_1.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 = (0, workflow_1.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 = (0, tooling_1.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 = {
+        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.
+ */
+function generateRuleFiles(project, stack, roadmap, ide = 'cursor', legacyStats, activeAgents, databaseMetadata) {
+    const files = [];
+    // 1. GENERATE AGENTS.MD (Universal Root File - Context Reference)
+    const agentTable = activeAgents?.map((a) => `| **${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: (0, mdc_1.wrapMdc)((0, identity_1.generateIdentitySection)(project, ide, activeAgents), {
+                description: "Project context and specialist personas",
+                alwaysApply: true
+            })
+        });
+        // Guardian & Stack DNA
+        files.push({
+            path: '.cursor/rules/rigstate-guardian.mdc',
+            content: (0, mdc_1.wrapMdc)((0, stack_dna_1.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 = (0, current_step_1.generateCurrentStepSection)(roadmap);
+        if (currentStep) {
+            files.push({
+                path: '.cursor/rules/rigstate-roadmap.mdc',
+                content: (0, mdc_1.wrapMdc)(currentStep, {
+                    description: "Active sprint focus and current roadmap step details",
+                    alwaysApply: true
+                })
+            });
+        }
+        // Workflow & Tooling
+        files.push({
+            path: '.cursor/rules/rigstate-workflow.mdc',
+            content: (0, mdc_1.wrapMdc)((0, workflow_1.generateWorkflowSection)(ide) + '\n\n' + (0, tooling_1.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: (0, mdc_1.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 = (0, skills_1.getRigstateStandardSkills)();
+        for (const skill of rigstateSkills) {
+            files.push({
+                path: `.agent/skills/${skill.name}/SKILL.md`,
+                content: (0, skills_1.generateSkillFileContent)(skill),
+                metadata: { description: skill.description }
+            });
+        }
+    }
+    return {
+        files,
+        suggestedIde: ide,
+        version: ENGINE_VERSION
+    };
+}
+async function fetchLegacyStats(supabase, projectId) {
+    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) => c.is_legacy === true).length;
+    const activeCount = (chunks || []).filter((c) => 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)
+ */
+async function fetchActiveAgents(supabase) {
+    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) => ({
+        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
+    }));
+}
+function mergeRuleContent(existingContent, newRules) {
+    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)
+ */
+async function fetchProjectTechStack(supabase, projectId, fallbackStack = ['Next.js', 'TypeScript', 'Supabase', 'Tailwind CSS']) {
+    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) => 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.
+ */
+function getFileNameForIDE(ide) {
+    return types_1.IDE_FILE_NAMES[ide] || types_1.IDE_FILE_NAMES.cursor;
+}

package/dist/sections/current-step.d.ts

@@ -0,0 +1,2 @@
+import { RuleGenerationContext } from '../types';
+export declare function generateCurrentStepSection(roadmap: RuleGenerationContext["roadmap"]): string | null;

package/dist/sections/current-step.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCurrentStepSection = generateCurrentStepSection;
+function generateCurrentStepSection(roadmap) {
+    const activeRoadmap = roadmap.filter((r) => r.is_legacy !== true);
+    const activeSteps = activeRoadmap
+        .filter((r) => r.status === 'ACTIVE')
+        .sort((a, b) => a.step_number - b.step_number);
+    if (activeSteps.length === 0) {
+        const nextSteps = activeRoadmap
+            .filter((r) => r.status === 'LOCKED')
+            .sort((a, b) => 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;
+}

package/dist/sections/identity.d.ts

@@ -0,0 +1,2 @@
+import { RuleGenerationContext, IDEProvider } from '../types';
+export declare function generateIdentitySection(project: RuleGenerationContext["project"], ide: IDEProvider, activeAgents?: RuleGenerationContext["activeAgents"]): string;

package/dist/sections/identity.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateIdentitySection = generateIdentitySection;
+function generateIdentitySection(project, ide, activeAgents) {
+    const mission = project.functional_spec?.projectDescription
+        || project.description
+        || `Build a ${project.ambition_level || 'professional'} application.`;
+    const audienceInfo = project.functional_spec?.targetAudience
+        ? `\n- **Target Users:** ${project.functional_spec.targetAudience}`
+        : '';
+    const problemInfo = project.functional_spec?.coreProblem
+        ? `\n- **Problem Being Solved:** ${project.functional_spec.coreProblem}`
+        : '';
+    // Build specialist context list
+    const specialistList = activeAgents?.map((a) => `- **${a.name}** (\`${a.key}\`, Lvl ${a.authority_level}): ${a.primary_mission || extractFirstSentence(a.content)}`).join('\n') || '- No specialists configured.';
+    return `## 🧠 PROJECT CONTEXT
+
+**Project:** ${project.name}  
+**ID:** \`${project.id}\`  
+**Mission:** ${mission}${audienceInfo}${problemInfo}
+
+---
+
+## 🤖 SPECIALIST PERSONAS
+
+The following personas represent areas of expertise. Reference their guidelines when working in their domain.
+
+${specialistList}
+
+### How to Use Specialists
+1. **Architecture & Governance** → Follow Frank's guidelines for code structure and security.
+2. **Documentation & Reports** → Use The Scribe's patterns for markdown and PDFs.
+3. **Historical Context** → Consult The Librarian for legacy feature discovery.
+
+> **Note:** These are informational contexts, not active agents. You (the IDE agent) execute all code.
+
+---
+
+## 🎯 CODING PRINCIPLES
+- **CONCISE:** No filler words. Get to the point.
+- **PRECISE:** Give specific answers with file paths and code.
+- **PRACTICAL:** Focus on what ships, not theory.
+- **GUARDIAN-AWARE:** Respect architectural constraints in the Guardian rules.`;
+}
+function extractFirstSentence(text) {
+    const match = text.match(/^[^.!?]*[.!?]/);
+    return match ? match[0].trim() : text.slice(0, 100) + '...';
+}

package/dist/sections/skills.d.ts

@@ -0,0 +1,13 @@
+import { AgentSkill } from '../types';
+/**
+ * Generate the <available_skills> XML block for the root .cursorrules file.
+ */
+export declare function generateAvailableSkillsSection(skills: AgentSkill[]): string;
+/**
+ * Generate the content for a specific SKILL.md file.
+ */
+export declare function generateSkillFileContent(skill: AgentSkill): string;
+/**
+ * Get the standard Rigstate library of skills.
+ */
+export declare function getRigstateStandardSkills(): AgentSkill[];